multi-llm

799 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

• skills/multi-llm/SKILL.md17 KB0e7e8de21f3cupstream ↗

  ---
  name: multi-llm
  description: "Orchestrate code plan reviews, task generation, implementation, code reviews and commit reviews using multiple LLM providers in parallel, or ask each model a free-text question about a plan. Use this skill whenever the user wants to review a plan with multiple models, generate implementation tasks, implement tasks with subagent delegation, review code changes against a plan, review or fix the commits they made, ask the models a question about a plan, or run any multi-model workflow. Triggers on: 'review my plan', 'multi-llm', 'run code review', 'generate tasks from plan', 'implement this plan', 'use multiple models to review', 'ask the models about my plan', 'ask a question about this plan', '--ask', 'improve my plan', 'review and apply the suggestions', 'improve the code', 'review and fix the code', 'review my last commit', 'review the last N commits', 'review this branch's commits', 'fix the issues in my last commit'."
  allowed-tools:
    - Bash(uv:*)
    - Bash(PYTHONUNBUFFERED=1 uv:*)
    - Bash(command -v uv)
    - Bash(ls:*)
    - Bash(grep:*)
    - Bash(diff:*)
    - Bash(tail:*)
    - Bash(dirname:*)
    - Bash(test -x:*)
    - Bash(git rev-parse:*)
    - Read
    - Edit
    - Write
    - Task
    - AskUserQuestion
    - Glob
    - Grep
  argument-hint: [--review-plan|--apply-suggestions|--improve-plan|--generate-tasks|--review-tasks|--apply-task-suggestions|--implement|--review-code|--apply-code-fixes|--improve-code|--review-commits|--apply-commit-fixes|--improve-commits|--full|--ask|--status|--init] <plan_path>|[<range>] (<range>: --*-commits only) ["<question>" (required for --ask)] [--models provider:model ...] [--interactive] [--quick] [--yes] [--force] [--scope-policy expand|preserve] [--focus "<text>"|--context-plan PATH (--*-commits only)] [--dir PATH|--gitignore|--template-only (--init only)]
  ---
  
  # Multi-LLM — Claude Code entry shim
  
  This file carries the facts true of Claude Code and nothing else; the workflow
  lives in the shared host-neutral core, loaded in step 4 — never re-derived here.
  
  ## 1. Skill directory
  
  Claude Code expands `${CLAUDE_SKILL_DIR}` to this skill's absolute path inside *this* file before you read it, so every command below is already resolved: run
  them as written, and **keep the double quotes** (the path may contain spaces, e.g. `C:\Users\John Smith\...`, and an unquoted expansion word-splits).
  
  ## 2. Check `uv`, before the first `uv run`
  
  Run `command -v uv` exactly as written — standalone, never chained (chaining loses the permission allow rule). A path means proceed; otherwise check the locations a
  fresh shell may not have on `PATH` yet, reading **stdout, not the exit status** (this `ls` exits non-zero whenever any candidate is missing, the normal case):
  
  ```bash
  ls "$HOME/.local/bin/uv" "$HOME/.local/bin/uv.exe" "$HOME/.cargo/bin/uv" "$HOME/.cargo/bin/uv.exe" /opt/homebrew/bin/uv /usr/local/bin/uv /opt/local/bin/uv 2>/dev/null
  ```
  
  If uv is genuinely absent, print `${CLAUDE_SKILL_DIR}/hosts/uv-missing.txt`
  verbatim and **stop with exit 3** — never install it, never ask, never fall back
  to bare `python`.
  
  ## 3. Map the user's flag to a mode word
  
  Flags are position-independent, and the mode flag is the mode word without its
  `--` (`--review-code` → `review-code`, `--full` → `full`, and so on for every flag
  in `argument-hint`). **No mode flag means `review-plan`.** Everything else the user
  typed passes through verbatim — never add a flag they did not type.
  
  The first positional is the **plan path**; for `--ask` the next single quoted argument is the **question**. Never re-join an unquoted multi-word question, never
  re-type a path you could copy, never infer a plan path from the conversation. A missing plan path, or an empty or unquoted question, is an error: show the
  usage hint from `argument-hint` and stop. `--init` takes no plan path.
  
  **The three commit modes** (`--review-commits`, `--apply-commit-fixes`, `--improve-commits`) take an optional **range**, not a plan path: the bare words right after the mode flag, none meaning `HEAD`. Bare words are joined into one range (`--review-commits last 2 commits` needs no quotes, unlike `--ask`'s question), and a `-N` there is a range (`-2`, the last 2 commits).
  Pass them right after the mode word, before any flag, as typed: range words after a flag are refused with `[RANGE_AFTER_FLAGS]`, and a run takes one range. A plan goes in `--context-plan <path>`, never in the range; after the launch, every command you spell takes the brief `[COMMIT_BRIEF]` names as its plan path, as the mode's core says, and a command the run prints keeps the pinned range it prints.
  
  ## 4. Load the mode's core instructions, then execute them step by step
  
  ```bash
  uv run --frozen --no-dev --project "${CLAUDE_SKILL_DIR}" -- python "${CLAUDE_SKILL_DIR}/multi_llm.py" util instructions <mode>
  ```
  
  This prints the core with every skill-dir placeholder already substituted — but most cores exceed this host's Bash-result cap, and what comes back is then a
  `<persisted-output>` stub: a file path plus the output's first 2 KB. **That stub is not the core**: it keeps what the mode is and how it is invoked, which reads like a finished
  overview, and drops the end, where the steps that do the work are. So first find, in the result, the line its opening lines say the core ends with; if it is missing, `Read` the
  path the stub names, in full, before your next tool call, and treat that file as the core. Never run a mode command from a core you have not seen the end of — the usage line in the
  surviving 2 KB runs cleanly, reports success, and applies nothing. The documented fallback, `${CLAUDE_SKILL_DIR}/instructions/<mode>.md`, leaves its path placeholder for you to fill.
  
  ## 5. Capability verbs — how this host answers each one
  
  The core names three capability verbs and never a tool. These are their one concrete resolution here, so nothing is left to decide mid-run:
  
  - **Spawn subagents** — call your host's own subagent tool `Task`: when the task carries `task.prompt_path`, tell the subagent to read that file in full — through line `task.prompt_lines`, paging if one read returns fewer — and follow it verbatim, printing only what it asks; if the file is absent, or the task has no `prompt_path`, pass `task.prompt` verbatim. Take the role from `task.subagent_type` when your tool needs one, and write the JSON it returns to `task.output_path`. Never pass `--exec-subagents` on this host.
  - **Ask the user** — call your host's own structured question tool `AskUserQuestion`, then copy the selected option's command verbatim. Never compose a flag from the user's words.
  - **Run detached** — use your host's own background mechanism `run_in_background`, redirecting stdout and stderr to the phase dir's `orchestrator-run.log` (`> … 2>&1`, the one dispatcher command that takes a redirect: every foreground call runs bare), and give that launch call a timeout of its own, the longest the parameter takes: 7200000 here, in milliseconds (2 hours; a session whose maximum is lower clamps it rather than refusing it). Without one the mechanism stops the command at its default deadline, as short as ten minutes, and a fan-out still running then dies mid-run (exit `143`, `next` `null`). Never pass `--detach` on this host. Then make one **non-waiting** `status <plan> <selector> --host <this host's id> --view run --exit-zero` call — no `--wait`, no `--timeout`, so it answers in well under a second — and relay its `progress:` line and `models:` table once: the count is on the one, and the other's rows are the only thing that says which CLI and model each of them runs. The run writes that roster a few seconds after launch, so repeat that one call once if no table printed yet, adding `--wait --timeout 10` as the wait (never `sleep` before a call: a call that does not start with `uv` loses its permission rule) — and a table that *does* print can still be the previous run's, because the phase dir is re-used and the write that claims it for this fan-out drops the predecessor's `progress` only about 0.2 s in: a table under a `progress:` step that is not `fanout` is the last run's, so make that call again rather than relaying it. That step is the whole test — a head line reading `finished in foreground (…)` rather than `running` is what a re-used dir prints all run long once an earlier `--detach` run left its own terminal `run` record in it, so the tense names no run. Then poll while it runs, one foreground `status <plan> <selector> --host <this host's id> --view run --wait --timeout <interval> --exit-zero` call per turn at a 120-300 s interval, relaying the rendered `progress:` line and, whenever one prints, the `just finished:` line that names the model that turned terminal during that wait — verbatim. Its absence claims nothing: that line is a difference between two readings taken inside one wait, so a model that finished in the gap between polls is already terminal when the next poll takes its baseline — so every poll compares its `models:` table with the previous poll's and names every newly terminal row that line did not name, copying its spec and state word out of the row — a copy, never a recount. Nothing else from the view is relayed mid-run. Spell `--host` out yourself — no launcher printed a command to copy it from, and without it the wait is clamped under the tightest ceiling on record — and give the call itself a timeout of at least the interval plus 30 s, in that parameter's own unit — milliseconds here, so 330000 for a 300 s interval, not 330, which is a third of a second — because this host's default per-call cap is shorter than the interval and would otherwise kill every poll from the first. No exit code from that poll ends the loop except `1`, the unreadable one: nothing on this host names one invocation, so without `--exit-zero` `2` is the steady state and a `0` or a `3` belongs to an earlier run in the same dir and names no verdict for this one: read the exit code as nothing, relay the rendered line exactly as on a `2`, and keep polling. Both calls carry `--exit-zero` so every answer that was read exits `0` and none shows as an error. The loop ends when the background mechanism reports the process exited; read the markers and output paths from `orchestrator-run.log` then, and report a non-zero exit status with that path rather than retrying. A stop at the mechanism's time limit (exit `143`, `next` `null`, `status` still reading `running in foreground`) names no way forward of its own, so offer the user each of these and run none yourself: the launch, made again the same way with `--force` added, which resumes, keeping each model whose result file is in the phase dir (`[SKIP]`) and running the rest (without it, review-code and the commit modes refuse a dir holding results, exit `3`; never `--rerun-all`); and, on a review mode with at least one such file, its `--reaggregate`, which reports with those and lists the rest as failed. Say which models have a file: a `done` row can have none, its result held in memory for the fan-out's end. Where the mode instruction names a continuation for a stopped run (a composite's `[IMPROVE_RERUN]`), offer that instead. The mode instruction names the selector and the rest of the loop.
  
  While a phase runs, wait in this session for what it started: each subagent's, and each background command's, completion notification arrives on its own, and ending your turn while they run is how you wait. Never call `ScheduleWakeup`, `CronCreate` or `/loop` to come back later, and never schedule a phase command to run again: a scheduled prompt keeps a headless session open after its last reply and, when it fires, runs the phase a second time (the plugin's hook refuses both while a phase runs). When a batch's edits need more work, send the batch back to the subagent that ran it (`SendMessage`) and verify it again; never edit a batch's files yourself, since its diff, its record and its summary all count every change as its subagent's.
  
  ## 6. The one dispatcher command
  
  Every mode is this single command, with `--host claude-code` baked in, and every `util` command a core names starts the same way. Run each one from the directory this session started in (normally the repository root), and never `cd` in a Bash call: this host's Bash keeps the new directory for every later call, so a relative plan path then names a file that is not there. Run each one alone in its Bash call and spelled exactly as written here, the skill directory as printed: nothing chained before or after it (no probe, no `cd`, no other command) and no shell variable standing in for it, since a call that does not start with `uv` loses this skill's allow rule:
  
  ```bash
  uv run --frozen --no-dev --project "${CLAUDE_SKILL_DIR}" -- python "${CLAUDE_SKILL_DIR}/multi_llm.py" <mode> "<plan-path>" --host claude-code [flags…]
  ```
  
  Exit codes are uniform (`0` done, `1` error, `2` nothing to do / already complete, `3` needs a human) and the
  last stdout line is always `MULTI_LLM_RESULT: {…}`: read `state`, `artifacts` and `next` from it rather than
  mining the transcript, and report what its `notice` says, when it has one, every part of it, as plain text. Put it above the closing section, and repeat nothing that section says. Run `next` verbatim when it is not `null` on `0` and `2`. On `3` stop: report to the
  user which phase stopped, on which plan or commit range, the last error line it printed, whole (on a stop it says what stopped, what it
  reported, what did not run and whether anything ran the repository's tests), and the options its output names (`next` included);
  do not run a different mode. Do not perform the work this run was going to review, plan, or implement: doing
  it yourself is never a substitute for a failed run. Run an option only after the user has picked it. Never edit `driver.write_paths`, or any other multi-llm setting in `.multi-llm/providers.yaml`, yourself. At a stop, offer only the ways forward the stop itself names, as it words them: when it names a change to `driver.write_paths` that lets a refused file be written (adding it to `allow`, or removing or narrowing a deny rule that covers it), that is one of them and the user's call; add no advice about the write policy of your own. Run `next` as printed, never re-typed: its plan path as printed, no flag added or dropped (no re-spelled plan flag, no lost `--quick --yes`). Run every foreground dispatcher call bare: no pipe (not even `| tail`), no `2>&1`, no `sleep` before it — a pipe reports `tail`'s exit code (a `3` reads as `0`), a trim drops the marker lines above the result line, and a command that does not start with `uv` loses this skill's allow rule. A long output is saved to a file: read it. Run the repository's own test or check command (implement's regression step) the same way: bare, its whole output read. The detached launch (*Run detached*, section 5) is the one exception: it redirects stdout and stderr into the phase dir's `orchestrator-run.log` (`> … 2>&1`).
  A stop at the background mechanism's time limit is the one stop whose ways forward are not its own to name: it names none, so offer the ones *Run detached* (section 5) lists for it, as it words them.
  `user_next_step` is the phase after this one, for the user to type: never run it yourself; end your report
  with the section the lookup prints between its `[NEXT_STEP_MARKDOWN]` and `[NEXT_STEP_MARKDOWN_END]` lines (its `markdown`), copied as it is (its words and order, each command alone in its fenced block, each why and note plain text, the manual tasks it lists included, no caption of your own). Only that section says "Workflow complete.": never write those words yourself. Copy it word for word, never wrapped in a fenced block of your own (its commands are fenced already), and say none of it twice: its whys, notes, manual tasks and "Workflow complete." appear only in it, never above it. After a workflow phase exits `0` or `2` with `next` `null` (never after `status`, `ask`, `init`), get it as the report's first step, after every command the core names: the command above
  with `util next-command "<plan-path>" --after <mode>` replacing `<mode> "<plan-path>"`, no `[flags…]`, the plan path as the user typed it — even when a `[NEXT_COMMAND]` line is already on screen (a `next` run can name it absolutely). After
  `1` or `3` look nothing up: a failed run has no next command. A native `implement` that stopped part-way exited `0`, so look it up: its section is the resume and each answer the stop offers, each with its why: copy it as given, whys included, in place of any list, recap or summary of the ways forward of your own; when the plugin ran no tests, the lookup also prints a `[TESTS_NOT_RUN]` line: give the text after the tag in the report, verbatim, as plain text. A lookup that prints no `[NEXT_COMMAND]` or `[WORKFLOW_COMPLETE]` line means there is none: write no command and never fill the gap (not from `suggested next:`, a plan path or a default).
  
  ## 7. Examples
  
  ```bash
  /multi-llm:multi-llm plans/my-feature.md                 # review-plan (the default)
  /multi-llm:multi-llm --full plans/my-feature.md --yes    # fully unattended
  /multi-llm:multi-llm --ask "plans/my plan.md" "Is the rollback strategy sufficient?"
  /multi-llm:multi-llm --review-commits                    # review the last commit (HEAD)
  /multi-llm:multi-llm --review-commits last 2 commits     # a range: bare words, no quotes
  /multi-llm:multi-llm --improve-commits this branch       # review, then fix, this branch's commits
  ```
  
  Providers and models live in `${CLAUDE_SKILL_DIR}/providers.yaml` (per-repository override via `--init`); `docs/providers.md` in the repository has the rest.
  

• skills/multi-llm/legacy/README.md3.2 KB4372a0db8051upstream ↗

  # `legacy/` — the pre-refactor instruction tree
  
  This directory holds the **host-coupled instruction core exactly as it was before
  the host-neutral rewrite**: the same 11 `instructions/*.md` and 5
  `references/*.md` files, byte-for-byte, still naming `Task` /
  `AskUserQuestion` / `run_in_background` / `${CLAUDE_SKILL_DIR}` and each
  `*_orchestrator.py` directly.
  
  It exists because the rewrite touched ~5k lines of battle-tested markdown, and the
  golden regression guard (`tests/test_instruction_refactor_guard.py`) is necessary
  but not sufficient: it proves the modes the guard fixture exercises, not the
  interactive corners a real user hits on day two. So there is **a way back that does
  not undo the Python work** — reverting the rewrite commit would also give back
  every `${CLAUDE_SKILL_DIR}` site the dispatcher was built to delete.
  
  ## Using it
  
  ```bash
  MULTI_LLM_LEGACY_INSTRUCTIONS=1 <your usual invocation>
  ```
  
  With that variable set to `1`, `multi_llm.py util instructions <mode>` serves the
  file from `legacy/instructions/` instead of `instructions/`, renders it against the
  running skill dir exactly as it renders the current core (the renderer substitutes
  every spelling of the placeholder, `${CLAUDE_SKILL_DIR}` included), and prints a
  one-line notice to **stderr** so a transcript records which core was read.
  
  Nothing else changes: same dispatcher, same modes, same exit codes, same
  `MULTI_LLM_RESULT` line. The escape hatch is a *read-path* switch, not a second
  implementation.
  
  `improve-plan`, `improve-code`, `review-commits`, `apply-commit-fixes` and
  `improve-commits` postdate the rewrite and have no frozen copy here: with the
  variable set they serve the current core, exactly as without it, and print no
  notice.
  
  ## Boundaries
  
  - **Claude Code only.** The legacy text names Claude Code's tools, so it is a
    fallback for the reference host and for nothing else. A non-Claude host that sets
    the variable gets instructions naming tools it does not have.
  - **Not maintained.** These files are frozen at the pre-refactor state. Fixes land
    in `instructions/`; nothing is back-ported here. One exception, forced by a
    Python change rather than a markdown one (2026-10-05): the write phases'
    orchestrators now record a phase *started* at emit and leave completion to the
    host's closing step, so `instructions/apply-suggestions.md` gained a closing
    `apply_suggestions_orchestrator.py --plan-file … --mark-completed` step (§8) and
    `instructions/implement.md`'s step 10 a closing
    `finalize_tracking.py --state-file … --mark-completed` call. Without them this
    core could no longer complete either phase; a write-path branch on the
    environment variable would have broken the "read path only" rule above
    instead. `tests/test_legacy_instructions.py` pins both.
  - **Not linted, not counted.** The host-neutrality lint, the `${CLAUDE_SKILL_DIR}`
    manifest and the `{SKILL_DIR}` site inventory all scan `instructions/` and
    `references/` and deliberately skip this directory — a frozen copy that had to
    pass the new rules would not be a copy.
  - **Expected lifetime: one release.** Once the reference host has run the rewritten
    core through the interactive corners the guard cannot reach, this directory and
    the environment variable go away together.
  

• skills/multi-llm/tests/container/home_seed/README.md2.7 KBff43608fd36eupstream ↗

  # `home_seed/<id>/` — minimum synthesized config, value-free and tracked
  
  Every container row starts each identity at its **first-run posture** in a fresh
  tmpfs `$HOME`, which is the point: it is the state a real user's machine is never
  in, and therefore the one nothing else tests. These templates are the measured
  minimum that lets each CLI start non-interactively, pass the executor's own
  credential probe, and run without stopping to ask for approval.
  
  **They contain no values.** Every credential field is an empty string or a
  `{{placeholder}}` the entrypoint or the PATH wrapper substitutes at row start —
  with the *fake* per-exec stub session key on the provider lane, and on the host
  lane with whatever `creds.yaml` resolved. That is why `.gitignore` anchors its
  credential rules by path (`**/.codex/auth.json`) and then negates this whole
  directory back in: a bare `*auth.json` would silently untrack these files —
  `git add` appears to succeed, `git ls-files` never lists them, the committed-secret
  scanner never walks them, and the build context ships without them — surfacing
  three phases later as an opencode row that dies on `not_authenticated`.
  
  ## Measured, not assumed (Phase 1)
  
  | id | file | why it is needed |
  | --- | --- | --- |
  | `codex` | `.codex/config.toml` | selects the stub provider; **`$CODEX_HOME` must also point here and the directory must exist** — codex exits 1 with "CODEX_HOME points to … but that path does not exist", and a *relative* `$HOME` makes it resolve `~/.codex` against nothing and fall straight through to `api.openai.com` |
  | `codex` | `.codex/auth.json` | `codex login status` prints "Not logged in" and exits **1** without it, and `classify_auth_probe` reads that as `False` — so `install-host codex` fails row 5 and `preflight_runner` refuses the batch before the first stub call |
  | `opencode` | `.local/share/opencode/auth.json` | where `opencode auth list` reads credentials from |
  | `claude-code` | `.claude.json` | onboarding + a trust entry for `/work/sample-project`; the real `~/.claude.json` is deny-listed (87 KB of per-project history and MCP definitions that routinely embed third-party keys), so this is synthesized instead of mounted |
  
  **One measured surprise worth knowing before you trust an opencode row:** a
  logged-out `opencode auth list` prints "0 credentials" and exits **0**, which
  matches none of the adapter's `auth_error_patterns` — so `classify_auth_probe`
  returns `True` and the executor preflight admits the batch. Unlike codex, opencode
  does *not* fail closed on a missing credential; its `install-host` row 5 reports
  `auth=ok` on a completely fresh `$HOME`. A negative auth row on opencode therefore
  cannot expect a `not_authenticated` refusal.
  

• skills/multi-llm/tests/container/README.md70 KB104b39f5274aupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/runs/README.md4.9 KBe969b52ddf43upstream ↗

  # `runs/` — raw evidence bundles (ephemeral, gitignored)
  
  Each container row binds `/work/out` here, at `runs/<utc>/<row-id>/`, and leaves:
  
  - `stub.jsonl` — every request the stub server received, including the ones it
    could not answer (`unhandled: true`) and the ones no pattern matched
    (`unmatched: true`);
  - `calls.jsonl` — the PATH wrapper's call log: one redacted argv per real CLI
    invocation, plus the scrub receipt (child environment variable *names*, never
    values, and the config root);
  - `receipts/<row-id>/NNN.receipt.json` — one per dispatcher invocation, written by
    the `uv` wrapper: the parsed `MULTI_LLM_RESULT` payload, the run-id-correlated
    worker record, exit code and wall clock;
  - `artifacts/` — the plan's output directory, copied out by the entrypoint's
    `finally` step so a failed row still leaves its phase dirs, `state.json` and
    `.status.json` files behind.
  
  ## This directory is not provenance
  
  **Nothing in the repo may cite a path under `runs/` as evidence** — not
  `hosts/capabilities.yaml`, not a commit message, not a README. It is gitignored,
  `make e2e-clean` prunes it, and a fresh clone does not have it. A dangling pointer
  into a deleted directory is exactly the failure mode the split exists to prevent,
  and a test asserts no tracked file contains a `runs/` path outside the two places
  that describe the directory itself.
  
  The longer-lived half is the sibling **`records/`**: a sanitized, schema-pinned
  summary the host-side driver derives from these bundles — host id, CLI version,
  image digest, row outcomes, the credential census, cost actuals, and the sha256 of
  every file here. Records are **local too**: every harness run writes fresh ones, so
  `records/` is gitignored except for `record.schema.json` and the codex release
  network-check records (`*-codex-release-network-check*.json`), which the publish
  workflow reads from the default branch. `make e2e-prune` and `make e2e-clean` never
  touch it.
  
  If you still have a bundle, `make e2e-verify-record REC=records/<utc>-<host>.json`
  re-hashes it and says whether it is the one the promotion cited. If you deleted it,
  the record still stands on its own and the tool reports the bundle as *missing*
  rather than as *mismatched* — which is the honest answer, since deleting this
  directory is a supported thing to do.
  
  ## Capped, and safe to delete
  
  The lane prunes itself: `harness.prune_runs` runs as each bundle directory is
  created and keeps the newest **8**, plus bundles leased by active drivers.
  Leases last until the driver exits, so concurrent runs cannot prune evidence
  that session-scoped graders still need. Process exit (including a crash)
  releases the lease. Zero-byte files in `.run-locks/` keep lock identities stable
  without entering bundle digests. Platforms without POSIX locks skip pruning.
  `MLLM_E2E_RUNS_KEEP` overrides the number and `0` turns the sweep off.
  `make e2e-prune KEEP=n` is the same sweep on demand, for a checkout that predates
  it. Both are shape-aware: only `<utc>[-<suffix>]/` directories are candidates, so
  this README, `lock-update/` and `surface/` stay. `make e2e-clean` is still the
  blunt instrument — `rm -rf runs/*/`, which takes those with it — and both leave
  `records/` untouched.
  
  **Why a cap and not just an ignore rule.** `runs/` is gitignored, and that was
  treated as the whole answer until it wasn't: nothing that copies a *working tree*
  consults `.gitignore`. `codex plugin add` against a local-path marketplace and a
  local-path plugin install both take the directory as it stands, so an uncapped
  `runs/` is a distribution problem before it is a disk one — it reached **1.2 GB
  here, in a repo with 18 MB of tracked files**, and the advertised install would
  have copied every byte of it. The build context is a separate defence and already
  holds (`.dockerignore` re-excludes `runs/**` from inside an allowlisted tree);
  the cap is what protects the routes that have no context file to read.
  
  A pruned bundle costs nothing a record needed: `make e2e-verify-record` reports
  **MISSING** and exits 0, saying the record stands on its own, rather than reading
  the absence as a mismatch.
  
  One consequence worth knowing: **`test_container_argv.py` grades what is in here**.
  It grades the bundles *its own invocation* produced — the run roots
  `harness.MATRIX` recorded, filtered to the rows whose `row-result.json` says
  `lane: provider`, because a discovery-only or host-only bundle dispatches no argv
  this table describes and would starve every entry. Reading a bundle back from disk
  survives only as the fallback for running that module alone, and only when the
  bundle is newer than every input the comparison depends on (`expected_argv.yaml`,
  `normalize_argv.py`, the provider adapters, the subagent executor and the write
  scheduler); otherwise it skips, naming the command to re-run, rather than passing
  on stale evidence. So a clean disarms it until the next lane run, and editing a
  `build_command()` — or the table itself — cannot be graded against yesterday's
  argv.
  

• skills/multi-llm/tests/golden/README.md3.9 KB75e800d8a13aupstream ↗

  # Golden Baseline Snapshots
  
  Pre-refactor baseline snapshots for the three apply orchestrators, captured
  for artifact parity validation during and after the ApplyOrchestratorBase
  refactor.
  
  ## Capture Details
  
  - **Capture date**: 2026-03-14
  - **Commit hash**: `b50260c71d204c9f67a948168f78cb8591f18879`
  - **Branch**: `master` (pre-refactor state)
  
  ## Orchestrators Covered
  
  1. `apply_suggestions_orchestrator.py` — applies validated plan review suggestions
  2. `apply_code_fixes_orchestrator.py` — applies validated code review fixes
  3. `apply_task_suggestions_orchestrator.py` — applies validated task review suggestions
  
  ## Artifact Types
  
  ### `--help` output
  CLI argument parser output for each orchestrator. Verifies that CLI interfaces
  remain identical after refactor.
  
  - `apply_suggestions_help.txt`
  - `apply_code_fixes_help.txt`
  - `apply_task_suggestions_help.txt`
  
  **These are normalized, not raw captures.** Since D1 each parser's `epilog`
  prints its example commands with the skill dir *resolved from `__file__`* (no
  `${CLAUDE_SKILL_DIR}` — no shell but Claude Code's expands it, so on Codex or
  OpenCode a copied example would die before Python started). A raw capture would
  therefore bake the capturing machine's absolute path into a checked-in fixture,
  so `capture_baselines.normalize_skill_dir` rewrites it back to the `{SKILL_DIR}`
  template token. Compare against live `--help` by rendering the fixture forward
  with the skill's own renderer — one round-trip, no second normalization rule:
  
  ```python
  cli_common.render_instruction_text(golden_text, cli_common.skill_dir())
  ```
  
  ### `--dry-run` output
  Console output (stdout + stderr) from running each orchestrator with `--dry-run`
  against representative test fixtures. Captures batch summaries, filtering
  decisions, and item counts.
  
  - `apply_suggestions_dry_run_stdout.txt` / `_stderr.txt` / `_exit_code.txt`
  - `apply_code_fixes_dry_run_stdout.txt` / `_stderr.txt` / `_exit_code.txt`
  - `apply_task_suggestions_dry_run_stdout.txt` / `_stderr.txt` / `_exit_code.txt`
  
  ### JSON output (`orchestrator_output.json`)
  Full output JSON from each orchestrator run, capturing schema structure, keys,
  value types, nesting, batch count, batch contents, and ordering.
  
  - `apply_suggestions_output.json` — stdout JSON from `--output-format json`
  - `apply_suggestions_orchestrator_output.json` — file written to disk
  - `apply_code_fixes_output.json` — stdout JSON from `--output-format json`
  - `apply_code_fixes_orchestrator_output.json` — file written to disk
  - `apply_task_suggestions_orchestrator_output.json` — file written to disk
  - `apply_task_suggestions_stdout.txt` — stdout from normal run
  
  ### Report-parsing intermediates
  Parsed user edits, skips, and validation overrides from report.md for each
  orchestrator, serialized as JSON snapshots.
  
  - `apply_suggestions_report_parsing.json`
  - `apply_code_fixes_report_parsing.json`
  - `apply_task_suggestions_report_parsing.json`
  
  ### Metadata
  - `capture_metadata.json` — capture date, commit hash, file manifest
  
  ## Regenerating Baselines
  
  To regenerate all golden files from the current code state:
  
  ```bash
  uv run --project skills/multi-llm -- python \
      skills/multi-llm/tests/golden/capture_baselines.py
  ```
  
  The script is idempotent and will overwrite existing golden files.
  
  ## Usage in Parity Validation
  
  During the refactor, compare post-refactor outputs against these golden files
  to ensure behavioral parity:
  
  1. **CLI interface**: Diff `--help` output against golden help files
  2. **Dry-run output**: Compare stderr markers, counts, and batch summaries
  3. **JSON schema**: Validate that output JSON has identical keys, types, and nesting
  4. **Report parsing**: Ensure skipped items, overrides, and edits are parsed identically
  
  Note: Some fields in the JSON outputs are environment-specific (e.g., `plan_file`
  paths contain `/tmp/` prefixes, `timestamp` values). Parity checks should
  normalize or ignore these fields.
  

• skills/multi-llm/tests/README.md5.4 KBbda1f2ff3f3dupstream ↗

  # Test Suite Documentation
  
  This directory contains unit tests and integration tests for the multi-llm skill.
  
  ## Quick Start
  
  ```bash
  # Run all tests
  uv run -- pytest
  
  # Run with verbose output
  uv run -- pytest -v
  
  # Run a specific test file
  uv run -- pytest tests/test_filtering.py -v
  
  # Run a specific test class
  uv run -- pytest tests/test_filtering.py::TestFilterItems -v
  
  # Run a specific test
  uv run -- pytest tests/test_filtering.py::TestFilterItems::test_filter_valid_items -v
  ```
  
  ## Test Categories
  
  ### Unit Tests
  
  These test individual functions and classes in isolation:
  
  | File | Module Tested | Description |
  |------|---------------|-------------|
  | `test_importance.py` | `utils/importance.py` | Importance level calculations and comparisons |
  | `test_filtering.py` | `utils/filtering.py` | Bulk approval conflict resolution, item filtering |
  | `test_validation_recovery.py` | `utils/validation.py` | Error classification, validation result loading/saving |
  | `test_state_manager_decisions.py` | `utils/state_manager.py` | Group ID generation, human decision tracking, resume state |
  | `test_schema_validator.py` | `utils/schema_validator.py` | JSON schema validation |
  | `test_json_extractor.py` | `utils/json_extractor.py` | JSON extraction from LLM responses |
  | `test_output_handler.py` | `utils/output_handler.py` | Output file path handling |
  | `test_provider_registry.py` | `utils/provider_registry.py` | LLM provider configuration |
  
  ### Integration Tests
  
  These test the orchestrators end-to-end using subprocess calls:
  
  | File | Description |
  |------|-------------|
  | `test_apply_suggestions_integration.py` | Tests `apply_suggestions_orchestrator.py` with various CLI options |
  
  ## Running Integration Tests
  
  Integration tests use mock data in `plans/test-plan/` to avoid calling real LLMs.
  
  ```bash
  # Run integration tests
  uv run -- pytest tests/test_apply_suggestions_integration.py -v
  
  # Regenerate test fixtures if they become stale
  uv run -- python tests/test_apply_suggestions_integration.py --setup-fixtures
  ```
  
  ### Integration Test Fixtures
  
  The integration tests use a self-contained test plan at `plans/test-plan/`:
  
  ```
  plans/
  ├── test-plan.md                    # Mock plan file
  └── test-plan/
      ├── state.json                  # Session state (for resume tests)
      └── review-plan/
          ├── backup.md               # Original plan backup
          ├── grouped.json            # 10 suggestion groups
          └── validation.json         # Validation results (v2 format)
  ```
  
  The fixtures include:
  - **10 suggestion groups** with varying importance (HIGH, MEDIUM, LOW)
  - **Validation results** covering all statuses:
    - 4 `valid`
    - 2 `needs-human-decision` (real ambiguity)
    - 3 `validation_failed` (parsing_error, timeout, rate_limited)
    - 1 `invalid`
  - **State file** with:
    - 1 previously processed item
    - 1 previous human decision (approved)
  
  ## Test Patterns
  
  ### Import Pattern
  
  All test files use this import pattern to access the skill modules:
  
  ```python
  import sys
  from pathlib import Path
  
  sys.path.insert(0, str(Path(__file__).parent.parent))
  
  from utils.filtering import filter_items
  ```
  
  ### Fixture Pattern
  
  Common fixtures are defined in `conftest.py`:
  
  ```python
  @pytest.fixture
  def temp_dir():
      with tempfile.TemporaryDirectory() as d:
          yield Path(d)
  
  @pytest.fixture
  def sample_plan(temp_dir):
      plan_file = temp_dir / "test-plan.md"
      plan_file.write_text("# Test Plan\n...")
      return plan_file
  ```
  
  ### Class-Based Test Organization
  
  Tests are organized into classes by feature:
  
  ```python
  class TestFilterItems:
      """Tests for filter_items() function."""
  
      def test_filter_valid_items(self):
          ...
  
      def test_filter_with_bulk_approval(self):
          ...
  ```
  
  ## Coverage Report
  
  To generate a coverage report:
  
  ```bash
  # Run with coverage
  uv run -- pytest --cov=. --cov-report=html
  
  # Open the report
  open htmlcov/index.html
  ```
  
  ## Troubleshooting
  
  ### Import Errors
  
  If you see `ModuleNotFoundError`, ensure you're running from the skill directory:
  
  ```bash
  cd skills/multi-llm
  uv run -- pytest
  ```
  
  ### Stale Fixtures
  
  If integration tests fail unexpectedly, regenerate the fixtures:
  
  ```bash
  uv run -- python tests/test_apply_suggestions_integration.py --setup-fixtures
  ```
  
  ### Plan Hash Mismatch
  
  The state file includes a `plan_hash` that must match the actual plan content. If you modify `plans/test-plan.md`, regenerate fixtures to update the hash.
  
  ## Adding New Tests
  
  1. **Unit tests**: Add to the appropriate `test_*.py` file or create a new one
  2. **Integration tests**: Add to `test_apply_suggestions_integration.py` or create a new integration test file
  3. **Fixtures**: Add common fixtures to `conftest.py`
  
  ### Example: Adding a Unit Test
  
  ```python
  # tests/test_my_module.py
  import sys
  from pathlib import Path
  
  import pytest
  
  sys.path.insert(0, str(Path(__file__).parent.parent))
  
  from utils.my_module import my_function
  
  
  class TestMyFunction:
      def test_basic_case(self):
          result = my_function("input")
          assert result == "expected"
  
      def test_edge_case(self):
          with pytest.raises(ValueError):
              my_function(None)
  ```
  
  ### Example: Adding an Integration Test
  
  ```python
  # In test_apply_suggestions_integration.py
  
  class TestNewFeature:
      def test_new_option_works(self):
          result = run_orchestrator("--new-option", "--dry-run")
          assert result.returncode == 0
          assert "expected output" in result.stderr
  ```
  

• skills/multi-llm/references/host-capabilities.md14 KBfb87a4e5bbd0upstream ↗

  <!-- GENERATED FILE — DO NOT EDIT.
       Rendered from hosts/capabilities.yaml by hosts/render_capabilities.py.
       Edit the YAML and re-render; CI fails if this file differs from a fresh
       render, so a hand-edit cannot ship. -->
  
  # Host capabilities
  
  Human-readable view of `hosts/capabilities.yaml`. **Nothing reads this file at run
  time** — not an orchestrator, not a shim, and above all not a driving agent. The
  YAML is consumed by `multi_llm.py`, by `install-host` and by the tests; this
  document exists for people reading the repo.
  
  Every value carries a **provenance**: `verified` means a recorded live smoke run
  observed it, `documented` means host docs only, `unknown` is the shipping default.
  A `documented`-only value never selects the non-conservative path — which is why
  hosts whose native subagent dispatch is merely documented ship as
  `subagents: executor`, and why a documented command-timeout ceiling is worked
  around with `--detach` rather than trusted.
  
  The three **capability verbs** are the spine of each entry. The host-neutral
  instruction core says *spawn subagents* / *ask the user* / *run detached*; the
  columns below say what each resolves to, and a shim bakes that resolution in as a
  sentence when it is installed.
  
  
  | Host | Shim (repo → installed) | `arguments` | *spawn subagents* | *ask the user* | *run detached* | Default runner | `nested_exec` (spawn/network/creds) | Max subagents | Timeout ceiling | Verified |
  |---|---|---|---|---|---|---|---|---|---|---|
  | `claude-code` | *not rendered* → `SKILL.md` | `placeholder` | `native` (`Task`) — verified | `structured` (`AskUserQuestion`) — verified | `native` (`run_in_background`) — verified | `claude-code:sonnet` | allowed/allowed/allowed | 10 | 600 s (not raisable) | `arguments`, `ask`, `default_subagent_runner`, `detach`, `installable`, `multi_turn`, `native_tool`, `next_command.skill`, `shim_max_lines`, `subagent_tiers`, `subagents` |
  | `codex` | `hosts/codex/shim.md.tmpl` → `SKILL.md` | `placeholder` | `executor` (`agent`) — documented | `free-text` — documented | `python` — documented | `codex:gpt-6-astra` | unknown/unknown/unknown | 4 | none documented | `invocation`, `next_command.default`, `next_command.package`, `package`, `session_runner_provider` |
  | `opencode` | `hosts/opencode/shim.md.tmpl` → `commands/multi-llm.md` | `placeholder` | `executor` (`task`) — documented | `free-text` — documented | `required` — verified | `opencode:opencode/big-pickle` | unknown/unknown/unknown | 4 | 120 s (raise via env: `unknown`, config: `unknown`) | `arguments`, `detach`, `headless_invocation`, `install_paths`, `installable`, `invocation`, `multi_turn`, `next_command.default`, `next_command.package`, `package`, `reload`, `shim` |
  
  ## Per-host notes and stripped variables
  
  ### `claude-code`
  
  - Installable: `false`; reload after install: `none`
  - Invocation (documented): invoke it as `/multi-llm:multi-llm <mode-flag> <plan-path> [options]`, or as `/multi-llm <mode-flag> <plan-path> [options]` when the skill is installed as a plain skill under one of `install_paths`.
  - Driving agent gets a turn after a command returns (`multi_turn`): `true` — verified. A `false` here is what addresses a failed batch's retry instruction to the human rather than to an agent that will never read it.
  - Subagent tiers: full `sonnet`, cheap `haiku`
  - Verb sentences a rendered shim carries:
    - **Spawn subagents** — call your host's own subagent tool `Task`: when the task carries `task.prompt_path`, tell the subagent to read that file in full — through line `task.prompt_lines`, paging if one read returns fewer — and follow it verbatim, printing only what it asks; if the file is absent, or the task has no `prompt_path`, pass `task.prompt` verbatim. Take the role from `task.subagent_type` when your tool needs one, and write the JSON it returns to `task.output_path`. Never pass `--exec-subagents` on this host.
    - **Ask the user** — call your host's own structured question tool `AskUserQuestion`, then copy the selected option's command verbatim. Never compose a flag from the user's words.
    - **Run detached** — use your host's own background mechanism `run_in_background`, redirecting stdout and stderr to the phase dir's `orchestrator-run.log` (`> … 2>&1`, the one dispatcher command that takes a redirect: every foreground call runs bare), and give that launch call a timeout of its own, the longest the parameter takes: 7200000 here, in milliseconds (2 hours; a session whose maximum is lower clamps it rather than refusing it). Without one the mechanism stops the command at its default deadline, as short as ten minutes, and a fan-out still running then dies mid-run (exit `143`, `next` `null`). Never pass `--detach` on this host. Then make one **non-waiting** `status <plan> <selector> --host <this host's id> --view run --exit-zero` call — no `--wait`, no `--timeout`, so it answers in well under a second — and relay its `progress:` line and `models:` table once: the count is on the one, and the other's rows are the only thing that says which CLI and model each of them runs. The run writes that roster a few seconds after launch, so repeat that one call once if no table printed yet, adding `--wait --timeout 10` as the wait (never `sleep` before a call: a call that does not start with `uv` loses its permission rule) — and a table that *does* print can still be the previous run's, because the phase dir is re-used and the write that claims it for this fan-out drops the predecessor's `progress` only about 0.2 s in: a table under a `progress:` step that is not `fanout` is the last run's, so make that call again rather than relaying it. That step is the whole test — a head line reading `finished in foreground (…)` rather than `running` is what a re-used dir prints all run long once an earlier `--detach` run left its own terminal `run` record in it, so the tense names no run. Then poll while it runs, one foreground `status <plan> <selector> --host <this host's id> --view run --wait --timeout <interval> --exit-zero` call per turn at a 120-300 s interval, relaying the rendered `progress:` line and, whenever one prints, the `just finished:` line that names the model that turned terminal during that wait — verbatim. Its absence claims nothing: that line is a difference between two readings taken inside one wait, so a model that finished in the gap between polls is already terminal when the next poll takes its baseline — so every poll compares its `models:` table with the previous poll's and names every newly terminal row that line did not name, copying its spec and state word out of the row — a copy, never a recount. Nothing else from the view is relayed mid-run. Spell `--host` out yourself — no launcher printed a command to copy it from, and without it the wait is clamped under the tightest ceiling on record — and give the call itself a timeout of at least the interval plus 30 s, in that parameter's own unit — milliseconds here, so 330000 for a 300 s interval, not 330, which is a third of a second — because this host's default per-call cap is shorter than the interval and would otherwise kill every poll from the first. No exit code from that poll ends the loop except `1`, the unreadable one: nothing on this host names one invocation, so without `--exit-zero` `2` is the steady state and a `0` or a `3` belongs to an earlier run in the same dir and names no verdict for this one: read the exit code as nothing, relay the rendered line exactly as on a `2`, and keep polling. Both calls carry `--exit-zero` so every answer that was read exits `0` and none shows as an error. The loop ends when the background mechanism reports the process exited; read the markers and output paths from `orchestrator-run.log` then, and report a non-zero exit status with that path rather than retrying. A stop at the mechanism's time limit (exit `143`, `next` `null`, `status` still reading `running in foreground`) names no way forward of its own, so offer the user each of these and run none yourself: the launch, made again the same way with `--force` added, which resumes, keeping each model whose result file is in the phase dir (`[SKIP]`) and running the rest (without it, review-code and the commit modes refuse a dir holding results, exit `3`; never `--rerun-all`); and, on a review mode with at least one such file, its `--reaggregate`, which reports with those and lists the rest as failed. Say which models have a file: a `done` row can have none, its result held in memory for the fan-out's end. Where the mode instruction names a continuation for a stopped run (a composite's `[IMPROVE_RERUN]`), offer that instead. The mode instruction names the selector and the rest of the loop.
  - Install paths (project): `.claude/skills/multi-llm`
  - Install paths (global): `$HOME/.claude/skills/multi-llm`
  - Install paths (legacy): *none*
  - Runners:
    - `claude-code`: bundled=`true`, needs_auth=`false`, profiles=[generate, agent-readonly, agent-write], usage=`full`
    - `cursor-agent`: bundled=`false`, needs_auth=`true` (`cursor-agent login`), profiles=[generate], usage=`partial`
  - Refuse-to-start guards stripped from a dispatched runner: `CLAUDECODE`, `CLAUDE_CODE_ENTRYPOINT`
  - Session-scoping variables stripped: `CLAUDE_SESSION_ID`, `CLAUDE_SKILL_DIR`
  - Sanctioned exceptions that survive stripping: *none recorded* — audited, found nothing
  - Nested-exec notes: Native subagents run in-session; the executor is not on the default path for this host.
  
  ### `codex`
  
  - Installable: `true`; reload after install: `new-session`
  - Invocation (verified): invoke it by name rather than as a slash command — `Use the multi-llm skill with exactly these arguments: <the same arguments the Claude Code skill takes>`. Codex installs this shim as a **skill**, which is model-invoked rather than typed: its composer answers `/multi-llm` with `Unrecognized command`.
  - Driving agent gets a turn after a command returns (`multi_turn`): `true` — documented. A `false` here is what addresses a failed batch's retry instruction to the human rather than to an agent that will never read it.
  - Subagent tiers: resolved from `providers.yaml` `driver.subagent_runner{,_cheap}` (this host does not dispatch subagents natively)
  - Verb sentences a rendered shim carries:
    - **Spawn subagents** — run the dispatcher with `--exec-subagents`: it dispatches every materialized task itself and continues past each marker in the same process. Never spawn a subagent by hand on this host.
    - **Ask the user** — print the numbered option block exactly as the dispatcher rendered it and copy the selected option's command verbatim, and only under `--interactive`. Otherwise the documented `--yes` default applies and nothing is asked.
    - **Run detached** — pass `--detach` (which implies `--yes`) on every fan-out mode, and on every apply mode and `implement`, whose write batches the executor runs inside that one command, then poll `status <plan> --view run`. Do this even when you expect the run to be quick: a run started in the foreground cannot be handed back to once your turn ends. Only a single-model call that applies no batch may stay in the foreground. Never combine `--detach` with a host background mechanism — pick one.
  - Install paths (project): `.codex/skills/multi-llm`
  - Install paths (global): `$HOME/.codex/skills/multi-llm`
  - Install paths (legacy): `$HOME/.codex/prompts/multi-llm.md`
  - Runners:
    - `claude-code`: bundled=`false`, needs_auth=`true` (`claude login`), profiles=[generate, agent-readonly, agent-write], usage=`full`
    - `codex`: bundled=`true`, needs_auth=`false`, profiles=[generate, agent-readonly, agent-write], usage=`full`
  - Refuse-to-start guards stripped from a dispatched runner: *none recorded* — the env diff has not run yet
  - Session-scoping variables stripped: *none recorded* — the env diff has not run yet
  - Sanctioned exceptions that survive stripping: *none recorded* — the env diff has not run yet
  - Nested-exec notes: Filled by the Phase 2 nested-exec smoke: --exec-subagents launched from inside `codex exec`'s own sandboxed shell, for both the same-host runner and a third-party one.
  
  ### `opencode`
  
  - Installable: `true`; reload after install: `new-session`
  - Invocation (verified): invoke it as `/multi-llm <the same arguments the Claude Code skill takes>`.
  - Driving agent gets a turn after a command returns (`multi_turn`): `true` — verified. A `false` here is what addresses a failed batch's retry instruction to the human rather than to an agent that will never read it.
  - Subagent tiers: resolved from `providers.yaml` `driver.subagent_runner{,_cheap}` (this host does not dispatch subagents natively)
  - Verb sentences a rendered shim carries:
    - **Spawn subagents** — run the dispatcher with `--exec-subagents`: it dispatches every materialized task itself and continues past each marker in the same process. Never spawn a subagent by hand on this host.
    - **Ask the user** — print the numbered option block exactly as the dispatcher rendered it and copy the selected option's command verbatim, and only under `--interactive`. Otherwise the documented `--yes` default applies and nothing is asked.
    - **Run detached** — pass `--detach` (which implies `--yes`) on every fan-out mode, and on every apply mode and `implement`, whose write batches the executor runs inside that one command, and poll `status <plan> --view run`. This host caps a single shell command below the runtime of either, so no foreground path is offered for them.
  - Install paths (project): `.opencode/commands`
  - Install paths (global): `$XDG_CONFIG_HOME/opencode/commands`, `$HOME/.config/opencode/commands`
  - Install paths (legacy): *none*
  - Runners:
    - `claude-code`: bundled=`false`, needs_auth=`true` (`claude login`), profiles=[generate, agent-readonly, agent-write], usage=`full`
    - `opencode`: bundled=`true`, needs_auth=`false`, profiles=[generate, agent-readonly, agent-write], usage=`full`
  - Refuse-to-start guards stripped from a dispatched runner: *none recorded* — the env diff has not run yet
  - Session-scoping variables stripped: *none recorded* — the env diff has not run yet
  - Sanctioned exceptions that survive stripping: *none recorded* — the env diff has not run yet
  - Nested-exec notes: Filled by the Phase 3 nested-exec smoke from inside `opencode run`.
  

• skills/multi-llm/references/human-decision-batch.md17 KB69baf1c52485upstream ↗

  # Human Decision Batch Mode
  
  When the orchestrator output includes `human_review_config`, use batch mode for efficient review of `needs-human-decision` items.
  
  **Under `--yes` (or `--non-interactive`) nothing in this file renders.** `--yes`
  implies `--agent-decide`, so `decision_mode` is always `"judge_auto_decide"` and
  the guard below routes every item to the judge — no batch summary, no per-item
  prompt, no 4-option cap to work around (D6 row 10). The batching described here
  exists only for the attended path.
  
  ## Batch Mode Guard (Required)
  
  Before prompting for ANY needs-human-decision item, check:
  
  0. Read `human_review_config.decision_mode` from orchestrator output.
     If it is `"judge_auto_decide"` (set by the `--agent-decide` flag, which
     **`--yes` sets for you** — D6 row 10, so an unattended run always lands here):
     - Do NOT prompt the user at all — skip the batch summary AND any
       per-item question.
     - Go directly to the **"Let the Agent Decide" Mode** section below and
       evaluate every item autonomously.
     - This takes precedence over `batch_enabled` and `mode`.
  0a. **Partition `needs_human_review` before doing anything else.** Split the items
      into two sets:
      - **Pre-marked judge set** — every item whose `group_id` appears in
        `human_review_config.judge_decide_item_ids`, **OR** that carries a per-item
        `decision_mode == "judge_auto_decide"` field. (The id list is a convenience
        index; the authoritative per-item signal is the `decision_mode` field — fall
        back to scanning that flag if an item has no stable id.)
      - **Interactive set** — all remaining items.
      Then:
      1. **Process the pre-marked judge set first, without prompting.** Run the
         **"Let the Agent Decide" Mode** section below scoped to exactly those items
         (per-item trigger — one judging subagent, or the haiku coordinator fan-out
         if >4). Do NOT ask the user about these items, and do NOT
         include them in any batch summary.
      2. **Then continue the steps below for the interactive set only** — the normal
         batch summary / individual prompts. (If the global
         `decision_mode == "judge_auto_decide"` from step 0, every item is already
         in the pre-marked set by construction, so the interactive set is empty.)
      3. This per-item path is independent of `batch_enabled` / `mode`; it is the
         per-item analogue of the global `judge_auto_decide` mode.
  1. Otherwise, for the **interactive set** read `human_review_config.batch_enabled`
     from orchestrator output
  2. If `batch_enabled == true`:
     - Do NOT ask the user once per item
     - Present the batch summary prompt ONCE
     - Record all decisions with the same batch context
  3. If `batch_enabled == false` OR `human_review_config` is missing:
     - Fall back to asking the user once per item
  
  ## Batch Approval Flow
  
  When there are multiple `needs-human-decision` items, present them in batches organized by importance level.
  
  **Ask the user**:
  - Question: "There are {N} items requiring human review ({X} HIGH, {Y} MEDIUM, {Z} LOW). How would you like to proceed?"
  - Header: "Batch review"
  - Options:
    - label: "Review each individually", description: "Traditional one-by-one flow"
    - label: "Let the agent decide", description: "The judge agent evaluates each item using its judgment"
    - label: "Approve all LOW, review others", description: "Auto-approve LOW importance, ask about rest"
    - label: "Approve all MEDIUM and LOW", description: "Auto-approve MEDIUM/LOW, ask about HIGH only"
    (A host whose ask mechanism caps the option count renders "Approve all" and "Skip all" through its overflow channel)
  
  ## "Let the Agent Decide" Mode
  
  Trigger this mode when **any** of the following hold:
  - the user selects "Let the agent decide" in the batch-approval prompt — scope: **all** `needs-human-decision` items, **or**
  - the user selects "Let the agent decide" for a single item in an individual / legacy per-item prompt — scope: **just that one item**, **or**
  - `human_review_config.decision_mode == "judge_auto_decide"` (the user passed
    `--agent-decide` on the command line, so no prompt is shown) — scope: **all** `needs-human-decision` items, **or**
  - **reviewer pre-marked items via report override** — every item whose `group_id`
    is in `human_review_config.judge_decide_item_ids`, **or** that carries a per-item
    `decision_mode == "judge_auto_decide"` field (set via the report's "Let the agent
    decide" dropdown/checkbox) — scope: **exactly those items**. This is **distinct
    from** the global `--agent-decide` trigger above: that flag targets **all**
    needs-human items, whereas this per-item trigger targets only the items the
    reviewer pre-marked in the report. See **Batch Mode Guard** step 0a for how this
    pre-marked set is gathered and processed (partition-then-process) before the
    interactive set.
  
  The evaluation is identical in every case; only the *set of items* it runs on differs. The per-item trigger exists so a user who is unsure about one specific item can offload just that decision to the judge agent — exactly as `--agent-decide` would have handled it — without touching the other items.
  
  ### Who owns the prompt, and where the verdict goes
  
  **Python owns the prompt; this section is narrative, not a template.** The apply orchestrator materializes one judging task per in-scope item into `{phase}/human_decision_tasks.json` (`utils/human_decisions.py`). **For each task in that file, run `task.prompt` as a subagent, then write the JSON it returns to `task.output_path`** — the same print/persist contract every other materialized task uses, and the reason no invoker needs to assemble a judging prompt.
  
  Always judge in a **subagent**, never inline in the main conversation — the reasoning is token-heavy and would crowd the main agent's context. The main agent stays responsible for *applying* and *recording*. Judging is complex reasoning: use the **full model**, never a cheap tier. Only a pure-orchestration fan-out coordinator (which writes no verdict) may be downgraded.
  
  **The judge is not necessarily Claude.** It is whichever agent runs the judging tasks: the host's own agent (through its native subagent tool) on a host that has one, or the runner `driver.subagent_runner` resolves to under `--exec-subagents` — the session model on Codex when available, with `codex:gpt-6-astra` as the host fallback. An explicit `driver.subagent_runner` takes precedence. **Do not choose the judge's name yourself.** The apply orchestrator settles it when it ingests the verdicts and records it on every decision as `batch_context.judge`: the runner spec the executor's provenance proves wrote the verdict file, `<host> host agent` (e.g. `claude-code host agent`) for a verdict the host's own agent wrote, or `executor (runner unrecorded)` when neither can be established. Wherever this file writes `{judge}`, it means that recorded value — read it from `state.json`'s `human_decisions_{phase}` entries, the same records the decisions come from, and copy it verbatim (several distinct values: list each once, comma-separated, in first-seen order). Never replace it with a name of your own, such as your model id or "Claude": the console block, `summary.md` and the HTML report badge all read that field, and this summary must name the same judge they do. Never tell the user "Claude is deciding" unless Claude actually is the judge.
  
  The rules below travel **inside** `task.prompt`, not as a pointer to this file: a headless runner may have no way to open it. They are rendered from `HUMAN_DECISION_JUDGE_RULES` in `utils/subagent_prompts.py`, which is the single source of truth — a test fails when this block and that constant diverge.
  
  **The verdict is a file with a schema, not a shape everyone remembers.** `human_decision_batch_<n>.json` is `{"schema_version": "1.0", "judge": "<the model the judge says it is>", "verdicts": [...]}` (`judge` optional: it is what names a host-native judge's model in the report instead of "claude-code host agent"), each verdict `{group_id, decision, reason, salvaged_description, dropped}` with `decision ∈ approve|salvage|skip` and `salvaged_description`/`dropped` non-null iff `decision == "salvage"` — pinned by `schemas/human_decision_verdicts.schema.json`. The wrapper object (rather than a bare array) is what lets the ingest distinguish a truncated write from a legitimately empty verdict set. Verdicts are never returned as chat text: one that never touches disk is unrecoverable after a crash, invisible to `--resume`, and meaningless under `--detach`.
  
  Re-invoking the apply orchestrator once the verdict files exist ingests them: each verdict is schema-validated (naming the offending file and index), mapped by stable `group_id` — never by batch or list position — recorded via `record_human_decision`, and the work set is rebuilt from the recorded decisions, with `salvaged_description` substituted into the suggestion before batching. A group with no verdict stays `needs-human-decision`; it is never silently approved or dropped. Duplicate `group_id`s are an error unless the objects are identical, in which case the first wins.
  
  <!-- BEGIN GENERATED: judge-rules — rendered from utils/subagent_prompts.py HUMAN_DECISION_JUDGE_RULES. Edit the constant, not this block. -->
  
  ### Three outcomes
  
  - **Approve (as-is)** — the suggestion is sound; apply it unchanged.
  - **Salvage (partial)** — only *part* of the suggestion is valid or worthwhile; rewrite it down to that defensible core and apply the rewritten version. **This is the default whenever an item is partially valid — never skip a whole suggestion just because part of it is wrong.**
  - **Skip** — there is nothing worthwhile to keep; drop the item entirely.
  
  ### Evaluation Criteria
  
  Read each item's details (title, description, importance, validation_reason, confidence) and decide based on:
  
  1. **Clear improvement vs. subjective preference**: Approve items that address genuine bugs, security issues, or correctness problems. Be cautious with purely stylistic or preference-based items.
  2. **Validation reason signals**: If the validation reason indicates genuine ambiguity ("could go either way", "trade-off", "matter of preference"), lean toward skipping. If it indicates implementation uncertainty ("not sure about scope", "might affect other files"), lean toward approving.
  3. **Importance as risk signal**: Be more conservative (lean skip) with HIGH importance items — they have bigger impact if wrong. Be more permissive (lean approve) with LOW importance items.
  4. **Security items lean approve**: Security-type items (XSS, injection, auth bypass, data exposure) should lean toward approval.
  5. **Deletion caution**: For items that involve removing code/content, require stronger confidence before approving. Deletions are harder to reverse.
  6. **Model consensus**: If the `models` array shows multiple models flagged this as `needs-human-decision`, be more cautious. If only one model flagged it while others said `valid`, lean toward approving.
  
  ### Deciding Approve vs. Salvage vs. Skip
  
  Apply the criteria above to each **distinct claim inside the suggestion**, not just the suggestion as a whole. Many `needs-human-decision` items are a mix — one solid point bundled with an overreach, a speculative extra, or an out-of-scope aside. Salvaging the worthwhile part is the **default** for such items.
  
  1. **Identify the worthwhile core**: Which specific part(s) address a genuine bug, correctness, security, or clarity issue and survive the criteria above?
  2. **Whole thing is sound** -> **Approve** as-is.
  3. **Part is worthwhile, the rest is questionable / speculative / out-of-scope / low-confidence** -> **Salvage**: rewrite the description to keep only the worthwhile core and drop the rest. Salvage only ever **narrows** a suggestion — never add anything that was not in the original. The existing criteria still govern the kept part (e.g. deletion caution, security lean-approve).
  4. **Nothing survives** — the item is purely subjective, speculative, redundant, or wrong -> **Skip**. Salvage only when a concrete, defensible improvement remains; do **not** manufacture value or apply a watered-down change just to avoid skipping. If there is nothing worthwhile, skip it entirely.
  
  A salvaged item is applied like an approval, except the **rewritten** description is what gets applied — never the original.
  
  <!-- END GENERATED: judge-rules -->
  
  ### Process
  
  1. Run the judging tasks from `human_decision_tasks.json` as described above for the item(s) in scope (all `needs-human-decision` items for a batch/`--agent-decide` trigger; just the one selected item for a per-item trigger), writing each reply to its `task.output_path`, then re-invoke the apply orchestrator so it ingests the verdicts.
  2. Present an informational summary (not a prompt — do not ask for confirmation):
  
  ```
  Judge agent ({judge}) decisions for {N} needs-human-decision items:
  
  Approved ({A}):
    - [Title] ({importance}) — {brief reason}
  
  Salvaged ({V}):
    - [Title] ({importance}) — kept: {what was kept}; dropped: {what was dropped}
  
  Skipped ({S}):
    - [Title] ({importance}) — {brief reason nothing was worth keeping}
  ```
  
  3. Proceed directly:
     - **Approved** items → apply the original suggestion.
     - **Salvaged** items → apply the **rewritten** description (substitute it for the original when building the apply prompt / batch).
     - **Skipped** items → take no action.
  
  ### State Recording
  
  Record each decision using the existing `record_human_decision` mechanism. A salvaged item is recorded as an **`approved`** decision (it is an approval of the rewritten suggestion) carrying a salvage marker — this keeps `--resume` and any report consumer treating it as an applied approval, while the `batch_action` / `decision_source` distinguish it.
  
  The markers below are **identical regardless of what triggered the evaluation** — `--agent-decide`, the batch "Let the agent decide" option, or a single-item per-item "Let the agent decide" selection. Recording them the same way means `--resume`, the Markdown apply summary, and the HTML report all surface an agent-decided / salvaged item the same way, with no per-trigger special-casing.
  
  Approve / skip:
  
  ```json
  {
    "decision": "approved" or "skipped",
    "reason": "Agent decide [{judge}]: {brief reason}",
    "timestamp": "...",
    "batch_context": {
      "batch_id": "{generated}",
      "judge": "{judge}",
      "batch_action": "judge_auto_decide",
      "decision_source": "judge_auto_decide",
      "importance_at_decision": "{importance}"
    }
  }
  ```
  
  Salvage (note `decision` stays `"approved"`):
  
  ```json
  {
    "decision": "approved",
    "reason": "Agent decide [{judge}] (salvaged): kept {what}; dropped {what}",
    "timestamp": "...",
    "batch_context": {
      "batch_id": "{generated}",
      "judge": "{judge}",
      "batch_action": "judge_auto_decide_salvage",
      "decision_source": "judge_auto_decide_salvage",
      "importance_at_decision": "{importance}",
      "salvaged_description": "{the rewritten description that was applied}",
      "dropped": "{brief note on what was intentionally left out}"
    }
  }
  ```
  
  ## Individual Review Mode
  
  For "Review each individually" mode, group items by importance and ask the user once per level.
  
  For each importance level, first display the items as an informational list:
  
  ```
  == {IMPORTANCE} IMPORTANCE ({count} items) ==
  
  1. [Title]: [Brief reason for needs-human-decision]
     {context line}
  
  2. [Title]: [Brief reason]
     {context line}
  ```
  
  Then **ask the user** once per importance level:
  - Question: "{IMPORTANCE} IMPORTANCE ({count} items): [{comma-separated titles}]. How would you like to handle these?"
  - Header: "{IMPORTANCE} items"
  - Options:
    - label: "Approve all {IMPORTANCE}", description: "Apply all {count} items at this level"
    - label: "Skip all {IMPORTANCE}", description: "Skip all {count} items at this level"
    - label: "Review individually", description: "Review each item one by one"
    - label: "Next importance level", description: "Skip to the next group"
  
  When the user picks **Review individually**, present each item in turn using the per-item prompt in **Legacy Individual Mode** below — which includes a **Let the agent decide** option so the user can offload any single item they are unsure about to the judge agent.
  
  ## Legacy Individual Mode
  
  For single items, when `batch_enabled == false`, or when the user chose **Review individually** above.
  
  For each item, **ask the user**:
  - Question: "How should we handle this item?"
  - Header: "Review needed"
  - Options:
    - "Apply/Fix this item" -> Process it (apply as-is)
    - "Skip this item" -> Skip and continue
    - "Let the agent decide" -> Offload just this item to the judge agent: run **"Let the Agent Decide" Mode** scoped to this single item (spawn one judging subagent per **Delegate the judgment to a subagent**), then apply the original (approve), apply the rewritten description (salvage), or skip per the subagent's verdict, and continue to the next item
    - "Skip all remaining" -> Exit early
  
  The **Let the agent decide** option lets a user who is unsure about a specific item hand that one decision to the judge agent; it behaves exactly like `--agent-decide` would for that item (Approve / Salvage / Skip, with salvage preferred over skipping a partially-valid item). Record its outcome with the same `judge_auto_decide` / `judge_auto_decide_salvage` markers shown under **State Recording** so reports and `--resume` treat it identically to a flag-driven auto-decision.
  

• skills/multi-llm/references/own-check.md4.3 KB7c637ad6efe5upstream ↗

  # Recording a code batch's own check
  
  A subagent that edited code — an implement task that declares files, or an apply-code-fixes batch — ends its reply with a `check` object saying which checks it ran on its edits. Record it on that batch's `util batch-done` call with `--own-check`, by the first rule below that fits the object. The `--exec-subagents` leg reads the same object by the same rules (`subagent_executor.batch_check_findings`), so both legs record the same result.
  
  ## Words the rules use
  
  - **A finding**: an entry of its `findings` (a bare string or object is one entry) that is not empty. Beside a `passed` that is true, an entry that only says nothing was found (`"none"`, `"n/a"`, `"no problems found"`, `0`) is no finding either.
  - **`passed` is true** when it reads `true`, `"true"`, `"yes"`, `"pass"`, `"passed"` or `1`; **false** when it reads `false`, `"false"`, `"no"`, `"fail"`, `"failed"` or `0`; anything else (missing, `null`, `"maybe"`) is **neither**.
  - **`ran` maps a command to failed** when that command's outcome reads `"failed"`, `"fail"`, `"fails"`, `"failing"` or `false`; to **passed** for `"passed"`, `"pass"`, `"ok"`, `"success"` or `true`; to **not run** for `"not run"`, `"skipped"` or `"could not run"`. A list of `"<command>: <outcome>"` strings, or of `{"command": …, "outcome": …}` objects, is read the same way.
  - **It ran nothing** when its `ran` is there and names no command it ran: `ran` is empty (`{}` or `[]`), or each entry is not run or the result shape's placeholder `<each check command you ran>` copied as it is (as a key, a string, or an object's `command`); or it has no `ran` at all but gives a `not_run` reason (a non-blank string).
  
  ## The rules
  
  1. **No `check` object** (none at all, `null`, or not an object): leave `--own-check` out.
  2. **`could_not_run` is true**: `--own-check findings --finding "its check could not run: <its findings, joined with "; ">"` (just `--finding "its check could not run"` when it names none).
  3. **It ran nothing** — its `passed: true` is then a pass of nothing, never a pass:
     - it names a finding: `--own-check findings` and one `--finding` per finding, whatever `passed` says;
     - else, `passed` is false: `--own-check findings` with no `--finding` (it said its check failed and named nothing);
     - else: `--own-check none` — it ran no check, which is never a pass.
  4. **Otherwise** — its `ran` names a command it ran, or its `check` has neither `ran` nor a `not_run` reason (an older reply):
     - `passed` is true: `--own-check passed` (what it lists beside a pass, such as `npm test: 12 passed`, is not a failing check), unless `ran` maps a command to failed: then `--own-check findings` and one `--finding "<command>: failed"` per such command;
     - `passed` is false: `--own-check findings` and one `--finding` per finding, plus one `--finding "<command>: failed"` per command `ran` maps to failed that no finding names (no `--finding` at all when there is neither);
     - `passed` is neither: as for false when it names a finding or `ran` maps a command to failed; else `--own-check passed` when `ran` maps a command to passed; else `--own-check none`.
  
  Each `--finding` is a finding as the reply wrote it, character for character, with no words of yours added: a finding that repeats one the user accepted for a check counts as accepted only when it says nothing more. A `note` in the `check` (the subagent's own words about its checks, such as that a failure is the accepted one) is recorded with `--note "<its note>"` beside `--own-check`, never as a `--finding`; the `--exec-subagents` leg records the same note, and neither leg reads it as a finding. A note is a comment, never a failure: every failure the check printed stays a `--finding`, so a `[FINDING_RESTATE]` call is run only when the words it moves to `--note` are a comment, never when they report something the check printed beyond the accepted finding (another value, test or line).
  
  `--own-check findings` is recorded with `--status completed`: the edits are kept and the check is reported as failing. An apply-code-fixes batch's `listed` is recorded beside it, one `--listed-check "{command}={outcome}"` per entry (step 6 of its runbook): a command it lists as failed is a failing check whatever the rules above gave, and a `passed: false` that names no finding beside a `listed` naming no failure is read as no failing check.
  

• skills/multi-llm/references/resume-detection.md2.2 KB922ef8d3dfdbupstream ↗

  # Resume Detection
  
  Check for existing output BEFORE running the orchestrator to avoid expensive duplicate runs.
  
  ## Detection Cases
  
  Check in this order:
  
  a. If `{plan}/{phase}/validation.json` exists:
     -> Phase is complete. Report results from `{plan}/{phase}/report.md` (or `report.html`) and skip.
  
  b. If `{plan}/{phase}/validation_tasks.json` exists AND `validation_batch_*.json` files exist:
     -> Validation ran partially or fully. Check if all batches complete.
     If all complete: run `--reaggregate` to finalize.
     If partial: re-run only missing validation batches, then reaggregate.
  
  c. If `{plan}/{phase}/validation_tasks.json` exists but NO `validation_batch_*.json`:
     -> Orchestrator completed but validation was interrupted. Skip to Validation Handling.
  
  d. If per-model `*.json` files exist in `{plan}/{phase}/` but no `grouped.json`:
     -> The fan-out stopped before grouping. Compare the files with `models_requested` in
     `{plan}/{phase}/.status.json`.
     If every requested model has its file: run `--reaggregate`.
     If some have none: run the orchestrator again with the same models. It keeps each
     file (`[SKIP]`) and runs only the missing ones; a `--reaggregate` would report
     without them. On review-code add `--force`, which a dir holding results needs
     (exit 3 otherwise); a composite's flags line already carries it. Never `--rerun-all`.
     Left out, `--scope-policy` stays the one the kept files were requested under (one
     `Scope policy notice:` line says so); a different one typed stops at exit 3 with
     `[SCOPE_POLICY_CONFLICT]`.
  
  e. If none of the above: proceed to run the orchestrator.
  
  f. If `.status.json` exists with `state: "validation_pending"`: equivalent to case (c) — skip to Validation Handling.
  
  ## Orchestrator Guards
  
  The orchestrator has its own re-run protection as defense-in-depth:
  - **Primary**: Exits with code 2 if phase is already marked complete in state.json. Use `--force` to override.
  - **Secondary** (code-review only): Exits with code 3 if partial completion artifacts exist without the phase being complete.
  
  This instruction-level resume detection is the FIRST line of defense; the orchestrator guards are backup protection.
  

• skills/multi-llm/references/salvage-handling.md12 KBdb096e8f5c5dupstream ↗

  # Salvage Handling
  
  When a model's review output cannot be parsed as JSON, the orchestrator writes a
  salvage *request* (`salvage_{model}.json`) and, beside it, a **materialized
  salvage task** (`salvage_task_{model}.json`) — printing
  `[SALVAGE_NEEDED] {request_path}` and `[SALVAGE_TASK] {task_path}`.
  
  **For each task in the task file, run `task.prompt` as a subagent, then write the
  JSON it returns to `task.output_path`.** That is the whole contract; the prompt
  is assembled in Python (`utils/subagent_prompts.build_salvage_prompt`) and
  carries the request's `raw_output`, `expected_type` and `expected_schema` inline,
  so a runner with no workspace access can serve it.
  
  **Run the pair this run advertised, and leave the retired ones where they lie.**
  A phase dir is stable per plan and `--force` clears the state file's completion
  marker without deleting a byte from it, so a salvage pair outlives the attempt
  that produced it. Every *fresh* attempt for a model therefore retires that
  model's pair before the provider is invoked — both files, renamed to
  `retired_salvage_{model}.superseded.{stamp}.json` and
  `retired_salvage_task_{model}.superseded.{stamp}.json`
  (`utils/review_orchestrator_base.retire_salvage_artifacts`, called from
  `code_review_orchestrator.run_single_review` and from `run_all_models`'s
  `per_model`). It is a rename and never a delete, because the request holds the
  raw output the model actually produced and that is the evidence an operator
  needs to tell a truncated answer from a dead account; and it is quiet, so what
  tells you it happened is the phase dir, not a marker. Three rules follow:
  
  - **Run the task files this run printed `[SALVAGE_TASK]` for.** If you find them
    by listing the directory instead, match `salvage_task_*.json` and take the
    prefix literally — a `retired_salvage_task_…` file is a previous attempt's,
    and its `output_path` is a result file this run has already written.
  - **Never rename a retired file back, re-materialize a task from one, or write
    a document recovered from one to its `output_path`.** Do not delete one
    either: it is the evidence, and it is nobody's outstanding work.
  - **A request you found by listing is only yours if this run ran that model.**
    Check the request's `model` field against the models this run actually
    dispatched. A model *skipped as already complete* on a resumed run begins no
    attempt, so it keeps its pair and that pair is genuinely outstanding. A model
    *dropped from the selection* between runs also begins no attempt, so nothing
    retires its pair either — it is stale in exactly the way its `{model}.json` is
    stale, and running it would write last run's answer over this run's file.
  
  Neither of the two rules below can catch that one: they judge the reply in front
  of them, and a superseded request arrives from an attempt that already ended —
  the phantom participant walking in through the one door the gate cannot watch.
  
  **`raw_output` is the text the salvage gate judged, and it is bounded.** It is
  chosen by one rule, `utils/review_orchestrator_base.salvage_source`, on all three
  losing paths — a non-zero exit, a timeout kill, and a zero exit whose output
  would not parse — because a provider can write a truncated array and *then* die:
  
  - **When the adapter reduces its stream, `raw_output` is `salvage_text`**: the
    assistant's answer text and nothing else (for an event-stream CLI, the text of
    its last assistant message — never its tool calls, its reasoning, or the event
    framing around them). The adapter reads its whole stdout to produce it, and
    the harness then redacts it and bounds it **from the answer's opening
    bracket**: text that fits the 45 KB cap is kept whole, and longer text is
    windowed forward from the `[` or `{` the answer opened, so a cut falls at the
    end, never at the start. An empty `salvage_text` is the adapter's verdict that
    there is no answer text at all, and then no salvage is requested — stderr is
    never consulted in its place, because a stream CLI's stderr holds only
    diagnostics.
  - **Only when no reducer applies is it still the raw excerpt**:
    `details["stdout_excerpt"]` ahead of `details["stderr"]`, the last 20 lines of
    the stream, each line cut at 64 KB and the whole at 45 KB.
  
  Two consequences when you read a request:
  
  - **Judge the answer text, not the transport stream.** A document is not more
    likely to be the model's answer because of the channel it arrived on — stdout
    is precisely where a CLI's own error event appears — so both rules below apply
    to it unchanged. And when `raw_output` still holds an event stream, only the
    assistant's own text parts can hold the answer: an event's `content` array of
    `thinking`/`toolCall` parts, a tool call's arguments, or a tool's result is
    transport data, however array-shaped it looks.
  - **An elision in `raw_output` is the harness's, not the model's.** Every cut
    leaves its own marker in the text, and credential-shaped values are replaced
    with `<redacted:{name}>`. So a document that stops mid-token may have been cut
    by the bound rather than by the provider, and a raw excerpt that starts
    mid-sentence may simply be missing its earlier lines. Recover what is present
    and no more: do not reconstruct a tail you cannot see, and never carry a
    `<redacted:…>` marker into the result as though it were the model's own text.
  
  **One reply is not a result.** When the raw output holds nothing recoverable —
  an authentication error, a stack trace, an empty stream — the prompt tells the
  subagent to print `{"salvage_failed": true, "reason": "..."}` instead of a
  document. **Do not write that object to `task.output_path`, and do not write an
  empty array in its place.** That path is the model's *own* result file, so
  whatever lands there is read back as that model's review: an empty array would
  make a model that never produced a parseable word count as one that reviewed the
  input and found nothing — and finding priority is scored partly by how many
  models flagged something. Leave the file untouched, so the model stays failed,
  which is the true outcome; report the subagent's `reason` beside it. An empty
  array that the subagent really did recover from the raw output is a result like
  any other and is written normally — **unless the request records
  `"failure": "timeout"`**. A run killed at its deadline never said "I found
  nothing", so an empty array recovered from it is a non-result: write nothing,
  leave the model failed, and report that the run timed out before it wrote an
  answer. A timed-out run's recovered findings are still written as usual.
  
  **Not every non-result announces itself.** A stream that was cut off mid-answer
  often still carries a relayed provider error — `{"error": {"code": 401,
  "message": "User not found"}}`, or the `{"type": "error", "message": "..."}`
  record an `opencode`/`codex` run prints as an event — and a subagent can recover
  that object perfectly faithfully, report success, and never print the sentinel,
  because as far as it can tell it found something. It is still not this model's
  review. So before writing: if what came back is neither an array, nor an object
  wrapping one, nor an object carrying the answer's own fields (`title`, `desc`,
  `importance`, …), treat it exactly as `salvage_failed` — write nothing, leave the
  model failed, and report that the raw output held a provider error rather than a
  document, which points at the provider's login instead of at a JSON repair.
  
  The same holds for a reply recovered out of an event stream's transport data.
  An array a subagent lifted from an event's `content` field — `thinking` and
  `toolCall` parts, a tool call's arguments, a tool's output — passes the shape
  test, because it *is* an array, but it is not findings the model wrote. It is a
  non-result, like a relayed provider error: write nothing, leave the model
  failed, and report it as `salvage_failed`, naming it as transport data.
  
  **On this lane both checks are yours, and the second one is the write itself.**
  Nothing stands between the subagent's reply and `task.output_path` except you:
  under `--exec-subagents` that position is held by
  `utils/subagent_executor._salvage_gave_up`, and here there is no such reader. So
  apply them in the prompt's own order — the sentinel first, because a subagent
  that read the raw output and named what was in it gives a better diagnostic than
  anything the shape test can reconstruct from the reply alone; then the shape
  test. Decide **before** you back up, not after: a
  `{filename}-BEFORE-SALVAGE-{timestamp}.json` sitting beside an unchanged result
  file records a salvage that never happened. A near-miss is not a non-result —
  a single record where an array was asked for names the answer's own fields, so
  it passes the shape test and is a mis-packaged recovery to repackage, not a
  provider error to report.
  
  `--exec-subagents` applies both rules on its own lane: the task is recorded in
  `subagent_batch_report.json` as `salvage_unrecoverable`, carrying that `reason`,
  with nothing written and no retry. The second rule is one shared predicate,
  `json_extractor.is_answer_shaped` — the same one that decides whether a salvage
  is worth dispatching at all, asked again of what came back. What it buys *there*
  is the diagnostic rather than the write: the salvage result shape
  (`subagent_executor._salvage_result_errors`) already refuses a top-level object
  for not being an array, so an error envelope never reached disk on that lane —
  it was reported as `schema_invalid`, "expected a JSON array of suggestions, got
  dict", which reads as a botched repair pass and invites another one when the fix
  is the provider's login. On *this* lane the same rule stops the write, because an invoker
  following the paragraph above it would faithfully persist the envelope. Same
  predicate, two different failures prevented.
  
  **A salvage that recovered nothing is finished, and re-running it is the loop to
  avoid.** The same raw output through the same prompt has the same answer, which
  is why `salvage_unrecoverable` sits in none of the executor's retry sets. Under
  `--exec-subagents` the run closes the case for you: the pair is retired as
  `retired_salvage_{model}.unrecoverable.{stamp}.json`, and
  `[SALVAGE_UNRECOVERABLE] {model}: {reason}` prints on stdout in the place the
  `[SALVAGE_NEEDED]` marker would have held — so there is no `SALVAGE NEEDED`
  block, no `[REAGGREGATE_AFTER_SALVAGE]` line and nothing recorded as the run's
  next command, because the artifacts those blocks look for are gone, not because
  a second reporting site re-derived the verdict. Only the terminal verdict is
  retired this way; every other salvage failure has a retry rung, stays on disk,
  and goes on being advertised precisely so it can be re-run.
  
  **Without `--exec-subagents` none of that fires, and the flow above is unchanged
  byte for byte** — this is your lane and it keeps working exactly as documented:
  the two markers print, you run each task, you write what is recoverable, you run
  the reaggregation the run prints. What is yours by hand is the ending. When a
  salvage recovered nothing, write nothing, report the `reason` (or your own
  finding from the shape test), and do **not** dispatch that request again. Then
  finish the run anyway: reaggregation is still mandatory, because the models that
  *did* parse depend on it, and the unrecovered model simply stays failed in the
  result. That request is still listed under `SALVAGE NEEDED` in the run output
  you are working from — the block was printed by the fan-out, before anyone knew
  what the salvage would find, so answering it does not remove it. Treating a
  request you have already answered as work still outstanding is what turns a dead
  provider account into an endless salvage-and-reaggregate loop.
  
  Two steps that used to live in this prompt are the invoker's, not the subagent's:
  
  1. **Back up before overwriting.** Immediately before writing `task.output_path`,
     run `utils/backup.py` on it; an existing file is copied to
     `{filename}-BEFORE-SALVAGE-{timestamp}.json`.
  2. **Delete the salvage request** after reaggregation, not after extraction — the
     request is what the task's `inputs.salvage_request_sha256` binds to. Delete
     only the request you actually consumed: a `retired_salvage_…` file is not
     yours to remove, and deleting one destroys the raw output that says why that
     model failed.
  
  After ALL salvage tasks complete, run reaggregation. The orchestrator prints a
  `[REAGGREGATE_AFTER_SALVAGE]` marker with the exact command — copy and run it.
  This is mandatory: reaggregation regenerates grouped.json, validation.json and
  the report files to include the salvaged data. Do NOT report results to the user
  until reaggregation is complete.
  

• skills/multi-llm/references/summary-format.md9.6 KB1311cba4ec28upstream ↗

  # Standard Summary Format
  
  The shape of the report a mode ends with. It moved out of the Claude Code shim in
  the D5c cutover: what a run reports is *workflow* prose, identical on every host,
  so it belongs in the core rather than in one host's entry file.
  
  After any mode completes, report:
  
  ```
  ## [Mode] Complete
  
  **Plan**: /path/to/plan.md
  
  ### Results
  - [Mode-specific statistics]
  
  ### Output Files
  - [Every generated file, with its full path]
  
  ### State
  - State file: [path, if the mode has one]
  
  ### Next Steps
  - Start the next phase in a fresh context (recommended, for best performance) —
    use whatever context-reset command your host provides, and omit this line if it
    has none
  - [The next step, copied from `user_next_step` as the next-step rule below says:
    its `command` alone in a fenced block, then any optional commands under
    "Optional, before that:" — or "Workflow complete." and any manual tasks still
    owed — or nothing]
  ```
  
  Every mode ends with this report. Four rules, and a fifth for `ask`:
  
  - **Paths come from the run, never from memory.** Take them from the orchestrator's
    own output — the `[OUTPUT_FILE]` lines, the paths a phase printed, and
    `MULTI_LLM_RESULT`'s `artifacts` array. Do not reconstruct a path from a pattern.
  - **Report the one follow-up the run owes, verbatim — and tell `next` from
    `user_next_step`.** They are two different things. `MULTI_LLM_RESULT.next`,
    when it is not `null`, *continues this phase*: the phase has not finished (a
    `--reaggregate` or a `status` poll is still owed), so copy it exactly, and
    report nothing as a next step that the run did not name. Copy it character
    for character, never re-typed: its plan path as printed, no flag added or
    dropped (not a `--plan-file` spelling, not without the `--quick --yes` it
    carries), and read a foreground call's output whole (only a detached launch
    redirects its output, into the phase dir's `orchestrator-run.log`): a pipe,
    even through `tail`, hands you the pipe's exit code instead of the
    dispatcher's and drops the marker lines above the `MULTI_LLM_RESULT` line you
    must read.
    `user_next_step`
    *starts the next phase*: it is the user's to type, never yours to run, and it
    ends the report as the next rule says.
  - **End the report with the next phase's command — copied, never composed.**
    Python builds it as `user_next_step`; your part is to fetch it and copy it.
    - *Where it comes from.* While the last result's `next` is not `null`, the
      phase is unfinished: report that follow-up under the rule above and look
      nothing up. A phase whose run exited `1` or `3` failed and has no next
      step either: report the failure, and look nothing up. Otherwise take
      `user_next_step` from the last result (its `MULTI_LLM_RESULT` line, or the
      tool result that relays it) when that result carries the key. When it does
      not, the host decides:
      - *On Codex and OpenCode* (file shim and tool alike), the key arrives in
        the phase's own result, so a result without it means there is no next
        step — the phase stopped short (at a `[…_PENDING]` marker, say), or the
        run is not one that names a next phase. Look nothing up, and write
        nothing under `### Next Steps`. `--after` does not check that the phase
        finished, so a lookup here could name the successor of a phase that
        never did.
      - *On Claude Code* only, the phase's last call is often a `util` step that
        cannot know the phase, so the report's first step is one read-only
        lookup, run after every command the core told you to run — the phase's
        own completion write included, because run earlier it answers from a
        phase not yet recorded: the dispatcher's
        `util next-command "<plan-path>" --after <the mode you ran>`, behind the
        same `uv run … multi_llm.py` prefix as every command in the core, with the
        plan path as the user typed it. Run it even when a `[NEXT_COMMAND]` line
        is already on screen: a `--reaggregate` (or any other `next`) run can name
        the plan by its absolute path, and the command is printed with the path
        the user typed. Its `MULTI_LLM_RESULT` line carries `user_next_step`, and
        the `[NEXT_COMMAND]` lines above it hold the same strings.
      - *When a lookup answers nothing.* A lookup whose output has no
        `[NEXT_COMMAND]` or `[WORKFLOW_COMPLETE]` line, and whose result line has
        no `user_next_step`, found no next command: that is its whole answer.
        Write nothing under `### Next Steps` for it, and do not fill the gap: not
        with a status view's `suggested next:` (a phase name, not a command), not
        with a default, and never with a command assembled from the plan path.
        (2026-10-02: a Claude Code `--status` ran the lookup, got nothing, and
        the report invented a command from the plan path.)
  
      `ask`, `init` and `status` are not workflow phases: on every host they run
      no lookup and end with no command.
    - *What to write under `### Next Steps`.* `user_next_step.markdown`, copied
      as it is (on Claude Code the lookup prints it between `[NEXT_STEP_MARKDOWN]`
      and `[NEXT_STEP_MARKDOWN_END]`): it is this section already written, as the
      rest of this rule describes it. Copy it word for word, never wrapped in a
      fenced block of your own (its commands are fenced already), and say none of
      it twice: its whys, notes, manual tasks and "Workflow complete." appear only
      in it, never above it. A notice you report goes above it and repeats none
      of it. Without it, `user_next_step.command` alone in a
      fenced block, copied character for character, and never "Workflow
      complete." beside it, however much of the work is done: while there is a
      command, the workflow goes on (its `why`, the `[NEXT_COMMAND_WHY]` line,
      goes above it as plain text). Any `optional_before`
      entries follow it, never precede it: the line "Optional, before that:",
      then each entry in the order the key lists them — its `why` as plain text
      outside the fence, then its `command` alone in its own fenced block. When
      the lookup also printed `[NEXT_COMMAND_ANSWERS_WHY]` /
      `[NEXT_COMMAND_ANSWERS]` pairs (`user_next_step.answers`: a stopped
      implement's `--human-task` answers, the one command carrying every answer
      first when more than one task waits, then each answer alone), write every
      pair, in the order printed,
      last: its why as plain text, then its command alone in its own fenced
      block. A stopped implement's lookup can also print a `[TESTS_NOT_RUN]`
      line above them, saying what ran the repository's tests: give the text
      after its tag verbatim in the report, above `### Next Steps`; it is never a command. When
      `complete` is `true` (its `command` is then `null`), write
      "Workflow complete." instead, and when it carries `manual_tasks`, list
      each one under it, its `id` and `title`, as the user's to do: implement
      deferred them to the user, and one with `waits_on` is a task skipped with
      that manual task, which implement runs once that one is recorded done (the
      `[MANUAL_TASK]` lines below `[WORKFLOW_COMPLETE]` are the same tasks, and
      such a line says what it waits on), then its `manual_tasks_note`
      (the `[MANUAL_TASK_NOTE]` line) verbatim as plain text and its
      `manual_tasks_command` (the `[MANUAL_TASK_COMMAND]` line) alone in its own
      fenced block: they say how to record them done.
      A `user_next_step` that names a `command` can carry `manual_tasks` and
      `manual_tasks_note` too, while the run's manual tasks are still owed (on
      Claude Code the same lines follow the `[NEXT_COMMAND]` block): list them
      after the commands the same way, with the note and its command, but never
      write "Workflow complete." for it. When there is no `user_next_step` at all,
      write neither a command nor "Workflow complete.": an absent key is not a
      completion.
    - *A failed lookup prints no command.* When `util next-command` exits
      non-zero, write no fenced command and no "Workflow complete.": write one
      line under `### Next Steps` saying the next-step lookup failed, quoting the
      stderr line it printed.
    - Never build, shorten, recall or rephrase a command yourself — not from a
      phase name, a mode flag, a usage line or an earlier report. A paraphrased
      command is the failure this rule exists to remove.
  - **Name every model that produced nothing, with its reason.** A review
    phase's `report.md` lists them on its `**Models failed:** N of M requested — …`
    line, directly under `**Models:**`, on the fan-out and after `--reaggregate`
    alike; a `--reaggregate` also prints one `[MODEL_FAILED] <model>: <reason>`
    line per requested model that still has no result. When
    `MULTI_LLM_RESULT.state` is `"partial"`, the same models and reasons are the
    `failed` rows of `progress.models` (a `status` poll carries them). List each
    one under Results with its reason; never report the run as if only the models
    that answered had been requested. **In `ask` mode** they are the
    `## Failed Models` section of `answers.md`. A failed model whose run left some
    text has it kept in a `partial_<model>.md` that its line names; say so, since
    a partial is not counted and a resume re-asks the model. You may offer
    `--accept-partial <model>` for a partial the user has read and judged whole —
    never run it unasked.
  - **In `ask` mode, say how the answers were obtained.** Report the run's
    `answered: …` counts line verbatim, and the `[WARN]` it prints when every
    model asked to write an answer file answered on stdout instead. A host that
    reads only the result line takes both from `MULTI_LLM_RESULT.answer_origins`
    (its integers are the counts line's; `warn_all_fallback` is the warning).
  

• skills/multi-llm/references/uv-check.md5.7 KB4274922c4fc1upstream ↗

  # uv Preflight (D6 row 1)
  
  **Audience: maintainers.** No agent opens this file at run time — every shim
  carries its own inlined copy of the step below. This document is the one
  written contract that copy, `install-host --check`'s row-3 shape lint and the
  shim tests are authored against, so an edit here is an edit to what every shim
  has to say.
  
  Every orchestrator and helper in this skill runs through `uv run`, so when `uv`
  is genuinely absent the shell fails with `uv: command not found` (exit 127)
  *before* any Python that could explain it runs. Row 1 therefore cannot own its own detection, and
  ownership is split across three layers with three different lifetimes:
  
  | Layer | When | Owner |
  |---|---|---|
  | 1 | install time | `multi_llm.py install-host --check` resolves `uv` and reports a miss as a prerequisite failure |
  | 2 | invocation time | **the shim's uv step, placed before its first `uv run`** — the inlined copy of the procedure below, and the only part of this that cannot be Python |
  | 3 | run time | the Python backstop, `utils/unattended.require_uv()` — uv removed after install, a host invoking `multi_llm.py` directly, or a shim edited by hand |
  
  **The message text lives in exactly one place: `hosts/uv-missing.txt`.** The shim
  interpolates it, `install-host --check` prints it and the Python backstop reads
  it, so no two layers can disagree about how to install uv. Never paraphrase it
  here or in a shim.
  
  ## The probe (layer 2 — run this once, before the first `uv run`)
  
  Run detection as a **single standalone command** — do NOT chain it with `||`,
  `&&`, `;`, or a pipe. The permission allowlist contains the exact-match rule
  `Bash(command -v uv)`, and exact-match rules only apply when the command is run
  exactly as written; chaining anything onto it triggers a permission prompt.
  
  ```bash
  command -v uv
  ```
  
  - **Exit 0 (path printed)** → `uv` is available. Proceed; nothing to report.
  - **Non-zero exit** → check the install locations a fresh shell may not have on
    `PATH` yet (quoted `"$HOME"`, never a quoted tilde — `"~"` does not expand; the
    `.exe` variants are what the Windows installer creates under Git Bash):
  
    ```bash
    ls "$HOME/.local/bin/uv" "$HOME/.local/bin/uv.exe" "$HOME/.cargo/bin/uv" "$HOME/.cargo/bin/uv.exe" /opt/homebrew/bin/uv /usr/local/bin/uv /opt/local/bin/uv 2>/dev/null
    ```
  
    **Read the result from stdout, NOT from the exit status.** This single `ls`
    exits non-zero whenever *any* candidate is absent — the normal case even when
    uv IS installed (at most one of the seven paths exists on a given machine). Any
    path printed on stdout means **FOUND**; only empty stdout means uv is absent.
  
    The same seven candidates, in the same order, are what
    `utils/unattended.find_uv()` probes (after `$MULTI_LLM_UV` and `PATH`), so the
    shim and the backstop agree by construction.
  
    If a candidate is printed, verify it is executable (`test -x "$FOUND"`, or run
    `"$FOUND" --version`). If one exists, **do not reinstall**. Note that launching
    uv by absolute path is NOT covered by the `Bash(uv:*)` allow rule, so every
    subsequent command raises a permission prompt: the primary remedy is to get
    `uv` onto `PATH` (add the directory, or simply restart the shell / the host —
    installers update the profile), then re-run the standalone `command -v uv`.
  
  ## When uv is truly absent
  
  **Print `hosts/uv-missing.txt` verbatim and stop with exit 3.** Nothing else:
  
  - **Never install it.** Installing software is not a decision this skill makes on
    a user's behalf, and unattended there is nobody to consent. The message names
    the official installer and the package-manager alternatives; running one of
    them is the user's step.
  - **Never render a question.** There is no "offer to install" prompt any more: on
    a headless host nothing would answer it, and D6 forbids a question as a
    fallback. "Install uv, re-run" is the whole recovery.
  - **Never fall back to bare `python`.** The skill's dependencies are pinned in
    `uv.lock` and resolved by `uv run` from `pyproject.toml`; a bare interpreter
    runs against whatever happens to be importable, turning a clear "install uv"
    into a `ModuleNotFoundError` or a silently wrong dependency version mid-fan-out.
  - **Exit 3, not 127**, where the host reports the shim's own status, so "needs a
    human" reads the same as every other gate. No `MULTI_LLM_RESULT` line is
    printed, because no dispatcher ran.
  
  ## Supported shells (fail fast otherwise)
  
  This check — and every other command in this skill — is POSIX-shell syntax and
  runs under the host's shell tool (Git Bash on Windows, the native shell on
  macOS/Linux). If the shell environment is **not** a POSIX shell (e.g. a host
  fell back to its PowerShell tool because Git for Windows is not installed),
  **stop immediately** and tell the user:
  
  > Windows support requires Git for Windows (Git Bash); PowerShell-only
  > environments are not supported — install it from
  > https://git-scm.com/download/win and restart the host.
  
  Do NOT attempt PowerShell equivalents of any command in this skill — there is no
  PowerShell instruction path. (The Windows uv installer named in
  `hosts/uv-missing.txt` is itself PowerShell; that is an install command the user
  runs, not an execution path.)
  
  ## After installing
  
  Re-run the probe: first the standalone `command -v uv`, then the seven-candidate
  `ls` — the current shell's `PATH` usually does not pick up a fresh install. On
  Windows the re-detection must include the `.exe` variants. If the binary exists
  but only by absolute path, prefer restarting the shell (or the host) so `uv`
  resolves on `PATH`. If detection still fails, stop with exit 3 and print
  `hosts/uv-missing.txt` again; never proceed to a `uv run` command while `uv`
  cannot be resolved.
  

• skills/multi-llm/references/wave-batching.md5.2 KB2acf436a193fupstream ↗

  # Wave-Based Parallel Spawning
  
  When there are more than 4 batches, spawn them in waves to control context growth.
  
  ## Strategy Selection
  
  - **≤ 4 batches (Strategy A)**: **Spawn subagents** for every batch at once, in one parallel group.
  - **> 4 batches (Strategy B)**: Use wave-based spawning (below).
  
  ## Wave-Based Spawning (Strategy B)
  
  1. Split batches into waves of up to 4 batches each, except the last wave may include up to 6 batches (absorbing any small remainder to avoid an unnecessary extra round — e.g., 5 batches = one wave of 5, 9 batches = wave of 4 + wave of 5, 8 batches = two waves of 4)
  2. For each wave:
     - **Spawn subagents** for every batch in the wave at once, in one parallel group
     - Run each batch's task exactly as the calling instruction's contract says (the sidecar at `prompt_path`, or `task.prompt`), writing the reply to its `output_path`
     - A validation batch whose context was too big to inline is `context_mode: workspace-read`: its prompt holds an excerpt and names a snapshot of the full plan (and, for review-tasks, of the task list) by path. Run it where the subagent can read that path, and never treat the excerpt as the whole document
     - Wait for all agents in the wave to complete
     - **Confirm every batch in the wave wrote its `output_path`** — the file is there and is not empty — before moving on. A missing file is not a batch that failed; it is a batch whose reply never reached you, and nothing else will write it
  3. Proceed to the next wave
  4. After ALL waves complete, and only once every task's `output_path` is on disk, continue to the next step (reaggregation, etc.)
  
  ## Error Handling
  
  - Per-subagent timeout: 60 seconds. If a subagent times out, mark that batch as `validation_failed`.
  - If a subagent returns malformed output or fails validation, retry it once (max 1 retry per batch). `util check-reply` is the test of "malformed" — run it after writing each reply, never on a batch whose subagent has not returned (its `[REPLY_MISSING]` is a reply not written yet, not a malformed one) — and the retry is a fresh reply from the subagent, never a repair of the bad one. If still failing, mark it as `validation_failed` and move on.
  - A missing `output_path` spends that same one retry: re-dispatch the batch and write the reply yourself. Only a batch that comes back empty-handed a second time is `validation_failed`. A batch you never re-dispatched is not a failed batch and must not be reported as one — it is a batch the run dropped, and the merge cannot tell the two apart.
  - If any batch in a wave fails (after retry), log the failed batch index and continue to the next wave -- do NOT abort the workflow.
  - After ALL waves complete, report which batches failed (e.g., "Completed {success}/{total} batches. Failed: batch {indices}.").
  - Proceed to the next step regardless of partial failures -- `merge_batched_validation_results` already handles missing batch files gracefully, so partial results are merged automatically. That grace is for batches the verification above has already re-dispatched and given up on: it means the merge does not crash on a missing file, never that the batch's findings survive it.
  
  ## Important Notes
  
  - Do NOT run these batches detached. Spawn them as ordinary parallel subagents so their results return inline.
  - **Do not end your turn while a dispatched batch is outstanding.** Stay in the turn until the last `output_path` above is on disk. A reply that arrives after the turn ends arrives after a one-shot headless run has ended, and the batch dies with it — unwritten, unreported, and indistinguishable afterwards from a batch that was never dispatched. Saying what you are waiting for is not waiting for it.
  - Context growth per wave is approximately 30-50 lines (4 subagent spawns with their parameters plus responses), so for 5 waves (~20 batches) expect ~150-250 lines of context growth — still manageable within typical context budgets.
  
  ## ETA Reporting
  
  When the calling instruction file wraps the wave loop with `util metrics start ... finish`, each per-batch `util metrics record --batch-index {N} --total-batches {total}` prints an `[ETA]` line to stderr. In wave-parallel runs, summing per-subagent durations would overstate wall-clock time by a factor of ~wave-width, so the ETA helper reports both signals (`per-item` and `wall-clock`) and the predicted-remaining segment uses `min(per_item, wall_clock)` — wall-clock dominates here. Pass the **cumulative** `--batch-index` (1..N across all completed waves), not the within-wave index.
  
  ## Design Rationale
  
  **Why wave size 4 (with flexible last wave)?** The base wave size of 4 balances parallelism against context growth and typical API concurrency limits. The last wave absorbs remaining batches (up to 6 total) to avoid unnecessary serialization at the boundary — the extra context from 1-2 additional parallel subagents is negligible compared to the cost of an entire extra sequential round.
  
  **Trade-off: wave-level synchronization.** Wave-based spawning waits for all subagents in a wave to complete before starting the next wave. If one subagent is slow, the other completed results sit idle until the wave finishes. This is simpler and more predictable than the coordinator approach, but does sacrifice some throughput.
  

• skills/multi-llm/assets/icons/Anthropic.svg584 Bfb2a512944afupstream ↗

  <svg xmlns="http://www.w3.org/2000/svg" width="512" height="512" shape-rendering="geometricPrecision" text-rendering="geometricPrecision" image-rendering="optimizeQuality" fill-rule="evenodd" clip-rule="evenodd" viewBox="0 0 512 512"><rect fill="#CC9B7A" width="512" height="512" rx="104.187" ry="105.042"/><path fill="#1F1F1E" fill-rule="nonzero" d="M318.663 149.787h-43.368l78.952 212.423 43.368.004-78.952-212.427zm-125.326 0l-78.952 212.427h44.255l15.932-44.608 82.846-.004 16.107 44.612h44.255l-79.126-212.427h-45.317zm-4.251 128.341l26.91-74.701 27.083 74.701h-53.993z"/></svg>
  

• skills/multi-llm/assets/icons/Codex.svg1.3 KBbae0b51e845bupstream ↗

  <svg fill="#111" fill-rule="evenodd" height="1em" style="flex:none;line-height:1" viewBox="0 0 24 24" width="1em" xmlns="http://www.w3.org/2000/svg"><title>Codex</title><path clip-rule="evenodd" d="M8.086.457a6.105 6.105 0 013.046-.415c1.333.153 2.521.72 3.564 1.7a.117.117 0 00.107.029c1.408-.346 2.762-.224 4.061.366l.063.03.154.076c1.357.703 2.33 1.77 2.918 3.198.278.679.418 1.388.421 2.126a5.655 5.655 0 01-.18 1.631.167.167 0 00.04.155 5.982 5.982 0 011.578 2.891c.385 1.901-.01 3.615-1.183 5.14l-.182.22a6.063 6.063 0 01-2.934 1.851.162.162 0 00-.108.102c-.255.736-.511 1.364-.987 1.992-1.199 1.582-2.962 2.462-4.948 2.451-1.583-.008-2.986-.587-4.21-1.736a.145.145 0 00-.14-.032c-.518.167-1.04.191-1.604.185a5.924 5.924 0 01-2.595-.622 6.058 6.058 0 01-2.146-1.781c-.203-.269-.404-.522-.551-.821a7.74 7.74 0 01-.495-1.283 6.11 6.11 0 01-.017-3.064.166.166 0 00.008-.074.115.115 0 00-.037-.064 5.958 5.958 0 01-1.38-2.202 5.196 5.196 0 01-.333-1.589 6.915 6.915 0 01.188-2.132c.45-1.484 1.309-2.648 2.577-3.493.282-.188.55-.334.802-.438.286-.12.573-.22.861-.304a.129.129 0 00.087-.087A6.016 6.016 0 015.635 2.31C6.315 1.464 7.132.846 8.086.457zm-.804 7.85a.848.848 0 00-1.473.842l1.694 2.965-1.688 2.848a.849.849 0 001.46.864l1.94-3.272a.849.849 0 00.007-.854l-1.94-3.393zm5.446 6.24a.849.849 0 000 1.695h4.848a.849.849 0 000-1.696h-4.848z"></path></svg>

• skills/multi-llm/assets/icons/Copilot.svg1.5 KB192015fd116dupstream ↗

  <svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16"><path d="M7.998 15.035c-4.562 0-7.873-2.914-7.998-3.749V9.338c.085-.628.677-1.686 1.588-2.065.013-.07.024-.143.036-.218.029-.183.06-.384.126-.612-.201-.508-.254-1.084-.254-1.656 0-.87.128-1.769.693-2.484.579-.733 1.494-1.124 2.724-1.261 1.206-.134 2.262.034 2.944.765.05.053.096.108.139.165.044-.057.094-.112.143-.165.682-.731 1.738-.899 2.944-.765 1.23.137 2.145.528 2.724 1.261.566.715.693 1.614.693 2.484 0 .572-.053 1.148-.254 1.656.066.228.098.429.126.612.012.076.024.148.037.218.924.385 1.522 1.471 1.591 2.095v1.872c0 .766-3.351 3.795-8.002 3.795Zm0-1.485c2.28 0 4.584-1.11 5.002-1.433V7.862l-.023-.116c-.49.21-1.075.291-1.727.291-1.146 0-2.059-.327-2.71-.991A3.222 3.222 0 0 1 8 6.303a3.24 3.24 0 0 1-.544.743c-.65.664-1.563.991-2.71.991-.652 0-1.236-.081-1.727-.291l-.023.116v4.255c.419.323 2.722 1.433 5.002 1.433ZM6.762 2.83c-.193-.206-.637-.413-1.682-.297-1.019.113-1.479.404-1.713.7-.247.312-.369.789-.369 1.554 0 .793.129 1.171.308 1.371.162.181.519.379 1.442.379.853 0 1.339-.235 1.638-.54.315-.322.527-.827.617-1.553.117-.935-.037-1.395-.241-1.614Zm4.155-.297c-1.044-.116-1.488.091-1.681.297-.204.219-.359.679-.242 1.614.091.726.303 1.231.618 1.553.299.305.784.54 1.638.54.922 0 1.28-.198 1.442-.379.179-.2.308-.578.308-1.371 0-.765-.123-1.242-.37-1.554-.233-.296-.693-.587-1.713-.7Z"/><path d="M6.25 9.037a.75.75 0 0 1 .75.75v1.501a.75.75 0 0 1-1.5 0V9.787a.75.75 0 0 1 .75-.75Zm4.25.75v1.501a.75.75 0 0 1-1.5 0V9.787a.75.75 0 0 1 1.5 0Z"/></svg>

• skills/multi-llm/assets/icons/Cursor.svg793 B635d3ccdc6d9upstream ↗

  <?xml version="1.0" encoding="UTF-8"?>
  <svg id="Ebene_1" xmlns="http://www.w3.org/2000/svg" version="1.1" viewBox="0 0 466.73 532.09">
    <!-- Generator: Adobe Illustrator 29.6.1, SVG Export Plug-In . SVG Version: 2.1.1 Build 9)  -->
    <defs>
      <style>
        .st0 {
          fill: #26251e;
        }
      </style>
    </defs>
    <path class="st0" d="M457.43,125.94L244.42,2.96c-6.84-3.95-15.28-3.95-22.12,0L9.3,125.94c-5.75,3.32-9.3,9.46-9.3,16.11v247.99c0,6.65,3.55,12.79,9.3,16.11l213.01,122.98c6.84,3.95,15.28,3.95,22.12,0l213.01-122.98c5.75-3.32,9.3-9.46,9.3-16.11v-247.99c0-6.65-3.55-12.79-9.3-16.11h-.01ZM444.05,151.99l-205.63,356.16c-1.39,2.4-5.06,1.42-5.06-1.36v-233.21c0-4.66-2.49-8.97-6.53-11.31L24.87,145.67c-2.4-1.39-1.42-5.06,1.36-5.06h411.26c5.84,0,9.49,6.33,6.57,11.39h-.01Z"/>
  </svg>

• skills/multi-llm/assets/icons/GoogleGemini.svg623 B97ef1c3e1077upstream ↗

  <svg fill="none" xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 16 16"><path d="M16 8.016A8.522 8.522 0 008.016 16h-.032A8.521 8.521 0 000 8.016v-.032A8.521 8.521 0 007.984 0h.032A8.522 8.522 0 0016 7.984v.032z" fill="url(#prefix__paint0_radial_980_20147)"/><defs><radialGradient id="prefix__paint0_radial_980_20147" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="matrix(16.1326 5.4553 -43.70045 129.2322 1.588 6.503)"><stop offset=".067" stop-color="#9168C0"/><stop offset=".343" stop-color="#5684D1"/><stop offset=".672" stop-color="#1BA1E3"/></radialGradient></defs></svg>
  

• skills/multi-llm/assets/icons/Goose.svg3.2 KBab3535d53654upstream ↗

  <?xml version="1.0" encoding="UTF-8" standalone="no"?>
  <svg width="2048" height="2048" viewBox="0 0 2048 2048" xmlns="http://www.w3.org/2000/svg">    
      <!-- Rounded rectangle background - change fill color here -->
      <rect x="200" y="200" width="1648" height="1648" rx="400" ry="400" fill="#ffffff" stroke="none"/>
      
      <!-- Goose icon in black - adjust transform to resize/move -->
      <g transform="translate(128, 94) scale(3)">
          <path d="M455.145 485.687C473.786 481.639 493.559 470.622 493.559 470.622L458.952 442.115C441.844 428.034 427.282 411.116 415.898 392.108C400.167 365.845 378.431 343.683 352.485 327.445L339.813 320.066C335.471 317.048 332.444 312.344 332.013 307.037C331.737 303.615 332.557 300.556 334.47 297.864C341.068 288.564 375.172 248.097 381.422 242.926C389.471 236.273 398.44 230.739 406.761 224.403C407.944 223.501 409.131 222.604 410.3 221.689C410.341 221.648 410.4 221.616 410.436 221.58C413.106 219.472 415.626 217.233 417.629 214.578C424.862 206.202 426.62 198.797 427.051 195.52C426.072 192.366 423.153 185.314 415.018 177.179C420.117 177.492 426.29 181.525 431.887 186.27C435.644 180.265 439.578 173.92 443.507 167.562C446.131 163.315 442.238 160.138 442.129 160.039L442.107 160.034C442.107 160.034 442.107 160.016 442.102 160.012C442.002 159.903 438.825 156.01 434.588 158.634C425.528 164.24 416.473 169.851 408.42 174.949C408.42 174.949 398.875 174.75 387.572 184.512C384.912 186.52 382.673 189.039 380.57 191.704C380.529 191.745 380.493 191.799 380.461 191.84C379.541 193.005 378.644 194.192 377.747 195.38C371.406 203.705 365.877 212.67 359.224 220.719C354.057 226.973 313.586 261.072 304.286 267.671C301.594 269.584 298.539 270.408 295.113 270.127C289.811 269.701 285.102 266.669 282.083 262.328L274.705 249.656C258.467 223.701 236.305 201.974 210.042 186.243C191.034 174.859 174.12 160.292 160.035 143.188L131.519 108.581C131.519 108.581 120.497 128.35 116.454 146.995C122.078 153.834 136.749 170.807 153.826 183.769C135.466 175.135 121.893 168.459 111.188 162.876C109.538 175.085 110.182 193.549 111.881 207.848C123.47 212.919 143.202 220.732 163.289 224.884C147.222 228.641 129.597 229.325 115.987 229.058C118.385 237.909 121.72 246.937 126.207 256.019C128.115 260.22 130.204 264.322 132.461 268.337C139.663 270.318 167.939 274.437 182.985 271.056C168.016 276.4 142.885 285.378 142.885 285.378C162.187 309.393 183.52 328.931 183.52 328.931C215.969 311.483 223.366 309.099 247.703 293.182C208.292 325.251 198.063 338.344 187 351.8L179.291 362.618C175.285 368.238 171.809 374.207 168.904 380.465C159.183 401.381 145.423 445.949 145.423 445.949C142.967 453.717 148.659 459.41 156.2 456.727C156.2 456.727 200.76 442.967 221.684 433.246C227.939 430.336 233.917 426.86 239.532 422.858L250.35 415.149C253.98 412.163 257.588 409.235 261.549 405.782C261.549 405.782 288.782 438.045 316.776 459.269C316.776 459.269 325.755 434.139 331.098 419.169C327.712 434.22 331.832 462.496 333.817 469.693C337.823 471.95 341.934 474.039 346.135 475.947C355.222 480.438 364.245 483.77 373.097 486.167C372.834 472.553 373.514 454.932 377.271 438.866C381.422 458.952 389.231 478.689 394.307 490.273C408.605 491.973 427.069 492.616 439.279 490.966C433.695 480.262 427.019 466.679 418.386 448.329C431.347 465.406 448.32 480.076 455.159 485.7L455.145 485.687Z" fill="black"/>
      </g>
  </svg>

• skills/multi-llm/assets/icons/Kilocode.svg531 B0cd56876e7bdupstream ↗

  <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32" width="32" height="32" fill="#000"><path d="M23,26v-2h3v-5l-2-2h-4v2h-3v5l2,2h4ZM20,20h3v3h-3v-3Z"/><rect x="12" y="17" width="3" height="3"/><polygon points="26 12 23 12 23 9 20 6 17 6 17 9 20 9 20 12 17 12 17 15 26 15 26 12"/><path d="M0,0v32h32V0H0ZM29,29H3V3h26v26Z"/><polygon points="15 26 15 23 9 23 9 17 6 17 6 23.1875 8.8125 26 15 26"/><rect x="12" y="6" width="3" height="3"/><polygon points="9 12 12 12 12 15 15 15 15 12 12 9 9 9 9 6 6 6 6 15 9 15 9 12"/></svg>

• skills/multi-llm/assets/icons/MiniMax.png1.5 KB1cd16498689dupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/assets/icons/Mistral.svg717 B3b9abf6a7d34upstream ↗

  <svg width="183" height="183" viewBox="0 0 183 183" fill="none" xmlns="http://www.w3.org/2000/svg">
  <rect x="33" y="33" width="24" height="23" fill="#FFAF01"/>
  <rect x="33" y="56" width="47" height="24" fill="#FF8204"/>
  <rect x="33" y="80" width="118" height="23" fill="#FA500F"/>
  <rect x="127" y="103" width="24" height="24" fill="#E10500"/>
  <rect x="80" y="103" width="24" height="24" fill="#E10500"/>
  <rect x="33" y="103" width="24" height="24" fill="#E10500"/>
  <rect x="104" y="127" width="70" height="23" fill="#C4001D"/>
  <rect x="10" y="127" width="70" height="23" fill="#C4001D"/>
  <rect x="104" y="56" width="47" height="24" fill="#FF8204"/>
  <rect x="127" y="33" width="24" height="23" fill="#FFAF01"/>
  </svg>
  

• skills/multi-llm/assets/icons/MoonshotAI.svg957 Bdb43fce6e53eupstream ↗

  <svg viewBox="0 0 512 512" xmlns="http://www.w3.org/2000/svg" fill-rule="evenodd" clip-rule="evenodd" stroke-linejoin="round" stroke-miterlimit="2"><path d="M503 114.333v280c0 60.711-49.29 110-110 110H113c-60.711 0-110-49.289-110-110v-280c0-60.71 49.289-110 110-110h280c60.71 0 110 49.29 110 110z"/><path d="M342.065 189.759c1.886-2.42 3.541-4.63 5.289-6.77.81-1.007.74-1.771-.046-2.824-7.58-9.965-8.298-21.028-3.935-32.254 3.275-8.448 10.52-12.406 19.373-13.25 5.52-.521 10.936.046 15.959 2.73 6.596 3.53 10.438 8.912 11.688 16.341.995 5.926.81 11.712-.868 17.452-2.974 10.161-10.277 15.427-20.287 16.758-8.31 1.11-16.734 1.25-25.113 1.817-.648.046-1.308 0-2.06 0z" fill="#027aff"/><path d="M321.512 144.254h-50.064l-39.637 90.384h-56.036v-89.99H131v232.868h44.787v-98.103h78.973c13.598 0 26.015-7.927 31.744-20.252v118.355h44.787v-98.103c0-23.342-18.239-42.97-41.523-44.671v-.116h-24.593a45.577 45.577 0 0026.884-24.534l29.453-65.838z" fill="#fff"/></svg>

• skills/multi-llm/assets/icons/Nvidia.svg2.4 KBa6e8b188b0b2upstream ↗

  <svg xmlns="http://www.w3.org/2000/svg" xml:space="preserve" viewBox="35.188 31.512 351.46 258.785"><path d="M384.195 282.109c0 3.771-2.769 6.302-6.047 6.302v-.023c-3.371.023-6.089-2.508-6.089-6.278 0-3.769 2.718-6.293 6.089-6.293 3.279-.001 6.047 2.523 6.047 6.292zm2.453 0c0-5.175-4.02-8.179-8.5-8.179-4.511 0-8.531 3.004-8.531 8.179 0 5.172 4.021 8.188 8.531 8.188 4.481 0 8.5-3.016 8.5-8.188m-9.91.692h.91l2.109 3.703h2.316l-2.336-3.859c1.207-.086 2.2-.661 2.2-2.286 0-2.019-1.392-2.668-3.75-2.668h-3.411v8.813h1.961v-3.703m.001-1.492v-2.122h1.364c.742 0 1.753.06 1.753.965 0 .985-.523 1.157-1.398 1.157h-1.719M329.406 237.027l10.598 28.993H318.48l10.926-28.993zm-11.35-11.289-24.423 61.88h17.246l3.863-10.934h28.903l3.656 10.934h18.722l-24.605-61.888-23.362.008zm-49.033 61.903h17.497v-61.922l-17.5-.004.003 61.926zm-121.467-61.926-14.598 49.078-13.984-49.074-18.879-.004 19.972 61.926h25.207l20.133-61.926h-17.851zm70.725 13.484h7.52c10.91 0 17.966 4.898 17.966 17.609 0 12.714-7.056 17.613-17.966 17.613h-7.52v-35.222zm-17.35-13.484v61.926h28.366c15.113 0 20.048-2.512 25.384-8.148 3.769-3.957 6.207-12.641 6.207-22.134 0-8.707-2.063-16.468-5.66-21.304-6.481-8.649-15.817-10.34-29.75-10.34h-24.547zm-165.743-.086v62.012h17.645v-47.086l13.672.004c4.527 0 7.754 1.128 9.934 3.457 2.765 2.945 3.894 7.699 3.894 16.395v27.23h17.098v-34.262c0-24.453-15.586-27.75-30.836-27.75H35.188zm137.583.086.007 61.926h17.489v-61.926h-17.496z"/><path fill="#77B900" d="M82.211 102.414s22.504-33.203 67.437-36.638V53.73c-49.769 3.997-92.867 46.149-92.867 46.149s24.41 70.565 92.867 77.026v-12.804c-50.237-6.32-67.437-61.687-67.437-61.687zm67.437 36.223v11.726c-37.968-6.769-48.507-46.237-48.507-46.237s18.23-20.195 48.507-23.47v12.867c-.023 0-.039-.007-.058-.007-15.891-1.907-28.305 12.938-28.305 12.938s6.958 24.991 28.363 32.183m0-107.125V53.73c1.461-.112 2.922-.207 4.391-.257 56.582-1.907 93.449 46.406 93.449 46.406s-42.343 51.488-86.457 51.488c-4.043 0-7.828-.375-11.383-1.005v13.739c3.04.386 6.192.613 9.481.613 41.051 0 70.738-20.965 99.484-45.778 4.766 3.817 24.278 13.103 28.289 17.168-27.332 22.883-91.031 41.329-127.144 41.329-3.481 0-6.824-.211-10.11-.528v19.306H305.68V31.512H149.648zm0 49.144V65.777c1.446-.101 2.903-.179 4.391-.226 40.688-1.278 67.382 34.965 67.382 34.965s-28.832 40.043-59.746 40.043c-4.449 0-8.438-.715-12.028-1.922V93.523c15.84 1.914 19.028 8.911 28.551 24.786l21.18-17.859s-15.461-20.277-41.524-20.277c-2.833-.001-5.544.198-8.206.483"/></svg>

• skills/multi-llm/assets/icons/OhMyPi.svg434 B553490c5e92bupstream ↗

  <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64">
    <defs>
      <linearGradient id="g" x1="0" y1="0" x2="1" y2="1">
        <stop offset="0" stop-color="#ed4abf" />
        <stop offset=".5" stop-color="#9b4dff" />
        <stop offset="1" stop-color="#5ad8e6" />
      </linearGradient>
    </defs>
    <rect width="64" height="64" rx="12" fill="#0f0a14" />
    <path fill="url(#g)" d="M14 16h36v8H40v32h-8V24h-6v22h-8V24h-4z" />
  </svg>
  

• skills/multi-llm/assets/icons/OpenAI.svg1.7 KB401b8f7ce630upstream ↗

  <svg xmlns="http://www.w3.org/2000/svg" width="256" height="260" preserveAspectRatio="xMidYMid" viewBox="0 0 256 260"><path  d="M239.184 106.203a64.716 64.716 0 0 0-5.576-53.103C219.452 28.459 191 15.784 163.213 21.74A65.586 65.586 0 0 0 52.096 45.22a64.716 64.716 0 0 0-43.23 31.36c-14.31 24.602-11.061 55.634 8.033 76.74a64.665 64.665 0 0 0 5.525 53.102c14.174 24.65 42.644 37.324 70.446 31.36a64.72 64.72 0 0 0 48.754 21.744c28.481.025 53.714-18.361 62.414-45.481a64.767 64.767 0 0 0 43.229-31.36c14.137-24.558 10.875-55.423-8.083-76.483Zm-97.56 136.338a48.397 48.397 0 0 1-31.105-11.255l1.535-.87 51.67-29.825a8.595 8.595 0 0 0 4.247-7.367v-72.85l21.845 12.636c.218.111.37.32.409.563v60.367c-.056 26.818-21.783 48.545-48.601 48.601Zm-104.466-44.61a48.345 48.345 0 0 1-5.781-32.589l1.534.921 51.722 29.826a8.339 8.339 0 0 0 8.441 0l63.181-36.425v25.221a.87.87 0 0 1-.358.665l-52.335 30.184c-23.257 13.398-52.97 5.431-66.404-17.803ZM23.549 85.38a48.499 48.499 0 0 1 25.58-21.333v61.39a8.288 8.288 0 0 0 4.195 7.316l62.874 36.272-21.845 12.636a.819.819 0 0 1-.767 0L41.353 151.53c-23.211-13.454-31.171-43.144-17.804-66.405v.256Zm179.466 41.695-63.08-36.63L161.73 77.86a.819.819 0 0 1 .768 0l52.233 30.184a48.6 48.6 0 0 1-7.316 87.635v-61.391a8.544 8.544 0 0 0-4.4-7.213Zm21.742-32.69-1.535-.922-51.619-30.081a8.39 8.39 0 0 0-8.492 0L99.98 99.808V74.587a.716.716 0 0 1 .307-.665l52.233-30.133a48.652 48.652 0 0 1 72.236 50.391v.205ZM88.061 139.097l-21.845-12.585a.87.87 0 0 1-.41-.614V65.685a48.652 48.652 0 0 1 79.757-37.346l-1.535.87-51.67 29.825a8.595 8.595 0 0 0-4.246 7.367l-.051 72.697Zm11.868-25.58 28.138-16.217 28.188 16.218v32.434l-28.086 16.218-28.188-16.218-.052-32.434Z"/></svg>
  

• skills/multi-llm/assets/icons/Opencode.svg325 B542a9188c3feupstream ↗

  
  <svg width="512" height="512" viewBox="0 0 512 512" fill="none" xmlns="http://www.w3.org/2000/svg">
  <rect width="512" height="512" fill="#FDFCFC"/>
  <path d="M320 224V352H192V224H320Z" fill="#E6E5E6"/>
  <path fill-rule="evenodd" clip-rule="evenodd" d="M384 416H128V96H384V416ZM320 160H192V352H320V160Z" fill="#17181C"/>
  </svg>

• skills/multi-llm/assets/icons/Pi.svg440 Bc28d6242332dupstream ↗

  <?xml version="1.0" encoding="UTF-8"?>
  <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 800 800">
    <rect width="800" height="800" rx="120" fill="#09090b"/>
    <path fill="#fff" fill-rule="evenodd" d="
      M165.29 165.29
      H517.36
      V400
      H400
      V517.36
      H282.65
      V634.72
      H165.29
      Z
      M282.65 282.65
      V400
      H400
      V282.65
      Z
    "/>
    <path fill="#fff" d="M517.36 400 H634.72 V634.72 H517.36 Z"/>
  </svg>
  

• skills/multi-llm/assets/icons/Qwen.svg1.7 KBa4bb382a6359upstream ↗

  <svg fill="currentColor" fill-rule="evenodd" height="1em" style="flex:none;line-height:1" viewBox="0 0 24 24" width="1em" xmlns="http://www.w3.org/2000/svg"><title>Qwen</title><path d="M12.604 1.34c.393.69.784 1.382 1.174 2.075a.18.18 0 00.157.091h5.552c.174 0 .322.11.446.327l1.454 2.57c.19.337.24.478.024.837-.26.43-.513.864-.76 1.3l-.367.658c-.106.196-.223.28-.04.512l2.652 4.637c.172.301.111.494-.043.77-.437.785-.882 1.564-1.335 2.34-.159.272-.352.375-.68.37-.777-.016-1.552-.01-2.327.016a.099.099 0 00-.081.05 575.097 575.097 0 01-2.705 4.74c-.169.293-.38.363-.725.364-.997.003-2.002.004-3.017.002a.537.537 0 01-.465-.271l-1.335-2.323a.09.09 0 00-.083-.049H4.982c-.285.03-.553-.001-.805-.092l-1.603-2.77a.543.543 0 01-.002-.54l1.207-2.12a.198.198 0 000-.197 550.951 550.951 0 01-1.875-3.272l-.79-1.395c-.16-.31-.173-.496.095-.965.465-.813.927-1.625 1.387-2.436.132-.234.304-.334.584-.335a338.3 338.3 0 012.589-.001.124.124 0 00.107-.063l2.806-4.895a.488.488 0 01.422-.246c.524-.001 1.053 0 1.583-.006L11.704 1c.341-.003.724.032.9.34zm-3.432.403a.06.06 0 00-.052.03L6.254 6.788a.157.157 0 01-.135.078H3.253c-.056 0-.07.025-.041.074l5.81 10.156c.025.042.013.062-.034.063l-2.795.015a.218.218 0 00-.2.116l-1.32 2.31c-.044.078-.021.118.068.118l5.716.008c.046 0 .08.02.104.061l1.403 2.454c.046.081.092.082.139 0l5.006-8.76.783-1.382a.055.055 0 01.096 0l1.424 2.53a.122.122 0 00.107.062l2.763-.02a.04.04 0 00.035-.02.041.041 0 000-.04l-2.9-5.086a.108.108 0 010-.113l.293-.507 1.12-1.977c.024-.041.012-.062-.035-.062H9.2c-.059 0-.073-.026-.043-.077l1.434-2.505a.107.107 0 000-.114L9.225 1.774a.06.06 0 00-.053-.031zm6.29 8.02c.046 0 .058.02.034.06l-.832 1.465-2.613 4.585a.056.056 0 01-.05.029.058.058 0 01-.05-.029L8.498 9.841c-.02-.034-.01-.052.028-.054l.216-.012 6.722-.012z"></path></svg>

• skills/multi-llm/assets/icons/xAI.svg343 B27f1e812e8e4upstream ↗

  <svg xmlns="http://www.w3.org/2000/svg" xml:space="preserve" style="enable-background:new 0 0 841.89 595.28" viewBox="0 0 841.89 595.28"><path d="m557.09 211.99 8.31 326.37h66.56l8.32-445.18zM640.28 56.91H538.72L379.35 284.53l50.78 72.52zM201.61 538.36h101.56l50.79-72.52-50.79-72.53zM201.61 211.99l228.52 326.37h101.56L303.17 211.99z"/></svg>

• skills/multi-llm/assets/icons/Zhipu.png442 B73aa0ea15500upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/assets/omp/overlay.yml2.4 KB5d4861291d74upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/AGENTS.md12 KB09ef84e5c47fupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/apply_code_fixes_orchestrator.py59 KB00d467d39664upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/apply_commit_fixes_orchestrator.py2.0 KBbb43069f16c8upstream ↗

  #!/usr/bin/env python3
  """``--apply-commit-fixes``: apply a commit review's validated fixes as uncommitted
  edits.
  
  A thin entry point, as ``improve_code_orchestrator.py`` is. It owns the
  module-level ``parse_args`` the ``--help`` scan reads and the ``main(argv)`` the
  dispatcher calls, one module per mode because ``modes.SCRIPT_TO_MODE`` keys each
  mode by its script. Everything it does lives in ``utils/commit_review.py``, the
  front-door core the three commit modes and ``util commit-brief`` share
  (plans/review-commits.md §2.1), so the doors cannot drift apart. It resolves the range (or, with none, picks the review on record),
  prints the commit block, then runs apply-code-fixes on the commit brief
  in-process, re-recorded as ``apply-code-fixes``.
  
  ``utils.commit_review`` is imported inside each function rather than at module
  scope: importing this module stays side-effect free and cheap, as every
  dispatch target's must (``tests/test_instruction_portability.py``).
  
  Usage::
  
      uv run --project <skill-dir> -- python <skill-dir>/multi_llm.py \\
          apply-commit-fixes [<range>] [--focus "<text>"] [--context-plan <path>] \\
          [--resume] [--fresh] [--yes]
  """
  
  from __future__ import annotations
  
  import argparse
  import os
  import sys
  from pathlib import Path
  from typing import Optional, Sequence
  
  # Absolute, symlinks preserved — see utils/cli_common.py.
  sys.path.insert(0, str(Path(os.path.abspath(__file__)).parent))
  
  from utils.stream_bootstrap import bootstrap_streams  # noqa: E402
  
  #: This module's mode word in ``modes.py``.
  MODE = "apply-commit-fixes"
  
  
  def parse_args(argv: Optional[Sequence[str]] = None) -> argparse.Namespace:
      from utils import commit_review
  
      return commit_review.parse_args(MODE, argv)
  
  
  def main(argv: Optional[Sequence[str]] = None) -> int:
      bootstrap_streams()
      from utils import commit_review
  
      return commit_review.front_door(
          MODE, list(sys.argv[1:] if argv is None else argv)
      )
  
  
  if __name__ == "__main__":
      sys.exit(main(sys.argv[1:]))
  

• skills/multi-llm/apply_suggestions_orchestrator.py15 KBd94cb1dfdc75upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/apply_task_suggestions_orchestrator.py29 KB3dd63cb992c7upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/ask_orchestrator.py116 KB75eb2ab8facbupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/check_workflow_prerequisites.py75 KB3d14eb1a4e3bupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/CLAUDE.md10 Beef4bd20cf97upstream ↗

  @AGENTS.md

• skills/multi-llm/code_review_orchestrator.py332 KB5065f5796d5eupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/display_decisions.py9.9 KB3fa4ea08bd3cupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/finalize_tracking.py40 KB8c8aacbea9d2upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/full_workflow_orchestrator.py56 KB5683b7fc82a3upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/generate_tasks_orchestrator.py38 KB5c1e04af1990upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/hosts/capabilities.yaml48 KB78c690ccf6c4upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/hosts/codex/plugin-skill.md.tmpl2.8 KB6f374d84568eupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/hosts/codex/shim.md.tmpl6.4 KB97239239fe93upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/hosts/opencode/plugin-command.md.tmpl2.2 KBb17bc29a4ef0upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/hosts/opencode/shim.md.tmpl6.3 KBe90a563f6eecupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/hosts/render_capabilities.py48 KB84dbcd347cabupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/hosts/snippets/poll-loop.md4.4 KBbbfe0eb4c3f6upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/hosts/snippets/uv-preflight.md2.2 KBb269082e991fupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/hosts/uv-missing.txt1.5 KB71b11e353822upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/implement_orchestrator.py149 KBd68936ad0013upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/improve_code_orchestrator.py1.5 KBb1832748ed13upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/improve_commits_orchestrator.py2.1 KBa585b869d25fupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/improve_plan_orchestrator.py1.4 KB75a550094a8cupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/init_config.py57 KB28253948777bupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/instructions/apply-code-fixes.md57 KB7aabff486d7eupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/instructions/apply-commit-fixes.md10 KBa832c1d37069upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/instructions/apply-suggestions.md53 KB51289512b37bupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/instructions/apply-task-suggestions.md52 KB4a9c67637cfbupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/instructions/ask.md28 KB44d42639fb71upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/instructions/full-workflow.md24 KB98f23efe08afupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/instructions/generate-tasks.md18 KB7f44a4886b2fupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/instructions/implement.md63 KB2efd9b136697upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/instructions/improve-code.md19 KB6f68e9f24dd2upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/instructions/improve-commits.md25 KBf8b1cad73b1fupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/instructions/improve-plan.md19 KB22355fad0696upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/instructions/init-config.md6.5 KB24de553d2b30upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/instructions/review-code.md45 KBdaa550c13758upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/instructions/review-commits.md11 KB32140ca6b335upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/instructions/review-plan.md43 KB78b4d005da04upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/instructions/review-tasks.md37 KBc3d890ebf2a5upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/legacy/instructions/apply-code-fixes.md35 KBb7c94a1d97efupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/legacy/instructions/apply-suggestions.md39 KB3d8506b7df59upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/legacy/instructions/apply-task-suggestions.md40 KB89d66b3aaaf2upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/legacy/instructions/ask.md12 KB4cdde485544eupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/legacy/instructions/full-workflow.md22 KB747b851df39eupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/legacy/instructions/generate-tasks.md15 KB100f11e80778upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/legacy/instructions/implement.md32 KBd8266b6ecab7upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/legacy/instructions/init-config.md6.5 KB49a5d5589a60upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/legacy/instructions/review-code.md19 KBa58d877d12dfupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/legacy/instructions/review-plan.md20 KBacaa34d855beupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/legacy/instructions/review-tasks.md16 KB07ac0084acf7upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/legacy/references/human-decision-batch.md17 KB58f53055542fupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/legacy/references/resume-detection.md1.5 KBa4ffda033398upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/legacy/references/salvage-handling.md1.4 KB2a8342930e46upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/legacy/references/uv-check.md5.3 KB9ce914e1dce0upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/legacy/references/wave-batching.md3.4 KBcb101d0d45e8upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/modes.py61 KBd8e8c212523bupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/multi_llm.py81 KBf947bff90ffbupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/prompts/ask.txt948 B56aa1decd3d4upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/prompts/code_review.txt4.5 KBc713200d7dcdupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/prompts/commit_review.txt6.2 KB905a67202c95upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/prompts/consolidate_suggestions.txt3.1 KB23d12fd2407cupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/prompts/implementation_task.txt1.4 KB7b836b51687cupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/prompts/plan_review.txt8.0 KB6dbfa98bb8efupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/prompts/task_review.txt8.3 KB01e7ef84efa2upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/providers.yaml78 KBf54797781c32upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/pyproject.toml5.1 KB37d71103a057upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/review_commits_orchestrator.py2.0 KB7f34500c4ee1upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/review_plan_orchestrator.py31 KB68e1be665e16upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/review_tasks_orchestrator.py11 KB07d045810557upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/schemas/code_review_issues.schema.json2.0 KB9c8e1b9714a3upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/schemas/consolidated.schema.json6.5 KB05e10cc53514upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/schemas/consolidation_batch.schema.json3.7 KB1a576d1292a8upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/schemas/generated_tasks.schema.json3.1 KBc243c7939b2eupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/schemas/host_capabilities.schema.json38 KBa675d26b6d2eupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/schemas/human_decision_verdicts.schema.json2.6 KBdce80326ba68upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/schemas/review_suggestions.schema.json2.4 KB0d3b3aa265e8upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/schemas/state_file.schema.json18 KB1fcda81396a3upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/schemas/subagent_tasks.schema.json19 KBe3b4d75482faupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/schemas/task_decomposition.schema.json1.2 KB7f111b190065upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/schemas/write_batch_result.schema.json8.8 KB3bf8dbb52ccdupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/templates/config/providers.override.yaml17 KB0ad754a79018upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/templates/consolidated_report_template.html67 KBac289fc1b386upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/templates/pr_report_template.html205 KBcab89ee74dcaupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/templates/report_template.html94 KB67710eeea452upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/__init__.py0 Be69de29bb2d1upstream ↗

• skills/multi-llm/tests/conftest.py42 KB9fb99e0a3779upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/__init__.py295 Be0498374d80aupstream ↗

  """Container-lane rig: assets, the host-side driver, and the in-container entrypoint.
  
  Nothing in here is skill runtime. The package exists so the container-marked test
  modules can import the shared Docker probe (:mod:`docker_probe`) rather than each
  growing its own copy of the skip logic.
  """
  

• skills/multi-llm/tests/container/aider-requirements.txt192 KB14264948b753upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/cli-surface.yaml29 KBc2100076cee8upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/cli-versions.lock31 KBfc2537115644upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/context_manifest.txt4.6 KB5fff6d701208upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/creds.yaml4.3 KB57db843e8f07upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/docker_probe.py2.8 KB0d487152b685upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/Dockerfile66 KB85640e9ed1b2upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/Dockerfile.codex-version3.0 KB25e4ed4b9e49upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/egress_resolver.py10 KB235523243d1cupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/entrypoint.py332 KBd9ec64ea45deupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/expected_argv.yaml26 KB77b8240ef3b9upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/failserver.py17 KB0d8c1831bc49upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/fx_smoke.py5.0 KB178ad583b1bfupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/harness.py178 KB0695284f454eupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/home_seed/claude-code/.claude.json176 Bf31c4e34b859upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/home_seed/cline/.cline/data/settings/providers.json371 Bfcfe5b6ca51eupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/home_seed/codex/.codex/auth.json89 Bba1337d8d279upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/home_seed/codex/.codex/config.toml3.5 KB0d49aed02c50upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/home_seed/fx/.fx/settings.json575 B7a52ff1d170aupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/home_seed/gemini/.gemini/settings.json83 B644e6b15ff93upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/home_seed/kilocode/.config/kilo/kilo.jsonc442 Bdd19d754b88aupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/home_seed/muse/.config/muse/auth.json138 B7f0f570a60bfupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/home_seed/muse/.config/muse/settings.json55 B23a9fe7eb542upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/home_seed/omp/.omp/agent/models.yml1.3 KB5f152a0b5d99upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/home_seed/opencode/.config/opencode/opencode.json333 B5968d04042fbupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/home_seed/opencode/.local/share/opencode/auth.json79 Bdc22c7293f94upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/home_seed/pi/.pi/agent/models.json232 Ba74867d257f6upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/home_seed/vibe/.vibe/config.toml4.0 KB343a38c4767dupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/host_matrix.yaml345 KB107bdf5868c6upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/host_spend.py13 KB46ea0118da8dupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/link_cli_bins.mjs2.8 KB13d299eb428dupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/live_provider.py48 KB1a85fba90241upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/lock_update.py45 KB5d6edc379fdaupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/next_command_check.py27 KB15b60b79ff59upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/opencode_package_gate.py50 KBfe3f2f0f70c5upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/opencode_package_gate_graders.py43 KBcea097dcad86upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/package-lock.json263 KBb73d99da50d0upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/package.json538 B64b58f4ba566upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/posture.yaml6.9 KB47c77379e553upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/providers.tmpl.yaml5.5 KB8247d9f96093upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/records/20260923T233755Z-codex-release-network-check-rehearsal.json15 KBfae05e5dcdd6upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/records/20261023T132656Z-codex-release-network-check.json16 KBfdb60088daa2upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/records/20261026T025255Z-opencode-release-gate.json14 KB8539047b8babupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/records/20261026T125425Z-opencode-release-gate.json14 KB32c8a81be3b0upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/records/20261026T175524Z-opencode-release-network-check.json30 KBec0458cda476upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/records/20261028T004534Z-opencode-release-gate.json14 KB62b7aef8f62aupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/records/20261030T155243Z-opencode-release-gate.json14 KB8476f6df6564upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/records/20261030T181607Z-codex-release-network-check.json16 KB3b26704826edupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/records/20261030T214755Z-opencode-release-network-check.json39 KBc06d58319c0fupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/records/20261101T004126Z-opencode-release-gate.json14 KB8a7104759234upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/records/20261101T031024Z-codex-release-network-check.json16 KBe808c461a3c7upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/records/20261101T061412Z-opencode-release-network-check.json37 KBf4985bcb36faupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/records/record.schema.json12 KB871bcd4700b8upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/redirect.yaml99 KB36ed113504b0upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/rig-requirements.txt5.3 KB3807c9d99d0cupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/seed_cli_surface.py13 KB913b03e24948upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/seed_container_golden.py26 KB783d434ae43eupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/seed_expected_argv.py10 KB26828bbccf1eupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/seed_workspace.py15 KB5473af034f21upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/stub_server.py63 KB9aa79f2e22a2upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/test_fx_integration.py9.5 KBb064e2738ff5upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/verify_record.py5.7 KB2f57ca2b6d7aupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/verify_versions.py11 KB38d729b8ea6aupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/vibe-requirements.txt109 KB213a716e0833upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/container/wrapper.py40 KB461cefde8396upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/apply_code_fixes_dry_run_exit_code.txt1 Bc227083464fbupstream ↗

  0

• skills/multi-llm/tests/golden/apply_code_fixes_dry_run_stderr.txt882 Baec7f729e482upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/apply_code_fixes_dry_run_stdout.txt0 Be69de29bb2d1upstream ↗

• skills/multi-llm/tests/golden/apply_code_fixes_help.txt12 KBecf8bbfa343bupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/apply_code_fixes_json_exit_code.txt1 Bc227083464fbupstream ↗

  0

• skills/multi-llm/tests/golden/apply_code_fixes_json_stderr.txt635 B4ddd51a0e8c5upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/apply_code_fixes_orchestrator_output.json7.8 KB4548d5bee878upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/apply_code_fixes_output.json7.8 KB4548d5bee878upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/apply_code_fixes_report_parsing.json307 Bef7210e16ddcupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/apply_suggestions_dry_run_exit_code.txt1 Bc227083464fbupstream ↗

  0

• skills/multi-llm/tests/golden/apply_suggestions_dry_run_stderr.txt908 B83a16e92d7bbupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/apply_suggestions_dry_run_stdout.txt0 Be69de29bb2d1upstream ↗

• skills/multi-llm/tests/golden/apply_suggestions_help.txt12 KB3b32b257dd31upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/apply_suggestions_json_exit_code.txt1 Bc227083464fbupstream ↗

  0

• skills/multi-llm/tests/golden/apply_suggestions_json_stderr.txt631 B416950d0df73upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/apply_suggestions_orchestrator_output.json9.3 KB51af5afb4726upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/apply_suggestions_output.json9.3 KB51af5afb4726upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/apply_suggestions_report_parsing.json308 B30296ce27ca3upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/apply_task_suggestions_dry_run_exit_code.txt1 Bc227083464fbupstream ↗

  0

• skills/multi-llm/tests/golden/apply_task_suggestions_dry_run_stderr.txt947 Bcd7858ae63edupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/apply_task_suggestions_dry_run_stdout.txt0 Be69de29bb2d1upstream ↗

• skills/multi-llm/tests/golden/apply_task_suggestions_exit_code.txt1 Bc227083464fbupstream ↗

  0

• skills/multi-llm/tests/golden/apply_task_suggestions_help.txt11 KB1a3e23b1dce1upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/apply_task_suggestions_orchestrator_output.json17 KB8e39d8e5e770upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/apply_task_suggestions_report_parsing.json313 B50b6d586c432upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/apply_task_suggestions_stderr.txt778 Bb9520b2ef38bupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/apply_task_suggestions_stdout.txt1.6 KB1569b06f237cupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/bundle_compare.py14 KBd87343e6bb9eupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/capture_baselines.py34 KB7666ea01bc33upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/capture_metadata.json1.3 KB510af7955939upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/code_review_head_ref_prompt.txt9.0 KB8232aeaa4336upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container/aider/bundle.json244 KB1e2280f147f4upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container/claude-code/bundle.json245 KBa55d584a1e3dupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container/cline/bundle.json244 KB9f9d31c7fc1bupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container/codex/bundle.json175 KB9d8163979584upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container/copilot/bundle.json243 KBfc29dd502300upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container/expected_changes.yaml2.1 KBc8f2199604a4upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container/fx/bundle.json243 KBa5cf35954064upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container/gemini/bundle.json244 KBb4676e1710bbupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container/goose/bundle.json244 KB27fc56264f8eupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container/grok/bundle.json243 KB5197745308baupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container/kilocode/bundle.json244 KB498f80796d04upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container/kimi/bundle.json243 KBf66b9b500314upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container/muse/bundle.json243 KB9396528f1503upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container/omp/bundle.json244 KB30260e5ae64aupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container/opencode/bundle.json244 KB0ffc0195a577upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container/pi/bundle.json244 KBc52a85f7fdb2upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container/qwen-code/bundle.json243 KBddf49e7fb60aupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container/vibe/bundle.json244 KB81fa03353710upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container/writer-claude-code/bundle.json245 KB813bc5796269upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container/writer-opencode/bundle.json244 KB1bd6c16cc8d8upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container_bundle.py32 KB0fba99bb5bc6upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container_turns/apply-code-fixes-batch.txt3.7 KB1bbf5f30d810upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container_turns/apply-suggestions-batch.txt1.8 KB9ce46b5de99dupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container_turns/apply-task-suggestions-batch.txt6.1 KB0464ca20c5dfupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container_turns/ask.txt6.5 KB9cb38bb5c927upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container_turns/implement-batch.txt2.8 KB93d983c3a32eupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container_turns/manifest.yaml6.0 KBe6d571237200upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container_turns/nested-exec-probe.txt72 B28d45dbe99daupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container_turns/review-code-fanout.txt4.4 KB07b22f71fdcfupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container_turns/review-plan-fanout.txt5.4 KB0760c99b8fdeupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container_turns/review-tasks-fanout.txt8.0 KBa28ce8e16904upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container_turns/side_turns/claude-code-session-title.txt6.4 KB0591a147863cupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container_turns/side_turns/goose-session-title.txt5.4 KB9035e1460640upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container_turns/side_turns/grok-session-title.txt5.3 KBe9cc61bdfa34upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container_turns/side_turns/kilocode-session-title.txt7.1 KB6093edf62264upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container_turns/side_turns/muse-reminder-observer-2.txt6.9 KBa02661bc0f22upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container_turns/side_turns/muse-reminder-observer.txt12 KBfadcf2146243upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container_turns/side_turns/opencode-session-title.txt7.1 KBe9fa145f1737upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container_turns/task-generation.txt8.8 KB83bfafdafcd5upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container_turns/validation-code-review.txt8.6 KB9d9abe816bb6upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container_turns/validation-plan-suggestions.txt6.2 KB4bcc568218f9upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/container_turns/validation-task-suggestions.txt6.5 KBe556b32a39f2upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/expected_changes.yaml53 KB84844279fbb8upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/git_two_commit_head_none.json27 KB13bdb6b5e7d5upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/instruction_refactor_bundle.py24 KB4587aed42e3fupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/normalize_argv.py13 KB70f607ff190bupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/prompts/consolidation.txt6.9 KB1155562956ccupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/prompts/human_decision_judge.txt4.9 KB5166046c0d20upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/prompts/revalidation.txt5.4 KB4859fea3f1b4upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/prompts/salvage.txt1.8 KB03b94a0d44f7upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/prompts/task_generation.txt5.5 KB030082e259c5upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/prompts/validation.txt5.4 KB16d50ca3bc4bupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/prompts/validation_code_review.txt5.5 KBf52a38660e73upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/prompts/validation_review_tasks.txt4.9 KB9b033166c3dcupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/prompts/validation_scope_expand.txt6.8 KB278cc12023ddupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/prompts/validation_scope_preserve.txt7.5 KBabf88d9e36abupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/golden/scope_policy_default_apply.json131 KBb83dc96cdcf2upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/harness/__init__.py1.0 KB4129fac95fe2upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/harness/assertion_helpers.py21 KB1ac78fb2f0f2upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/harness/cli_tree.py9.3 KB54816c529037upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/harness/fixture_manager.py17 KBe2d5e551028cupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/harness/mock_provider.py13 KB58a3333a6482upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/harness/skill_runner.py27 KB4030fb88dc4eupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/mock_launchers.py14 KB5e133ced7a58upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/mocks/__init__.py291 Bf859713659aaupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/mocks/mock_cursor_agent.py3.7 KB87965ac96e50upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/mocks/mock_gemini.py3.1 KBe9651b2b44b0upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/mocks/mock_llm.py97 KB6067bc3d3c66upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/mocks/mock_opencode.py3.8 KB71e233d65293upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/opencode_fixtures.py1.9 KB62e4732b4c7cupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/scenario_matcher.py25 KB6b638a6a43e3upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/scope_apply_fixtures.py18 KB227bf2b0183bupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_abort_signal_handlers.py8.1 KB91bfff5fe25cupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_accepted_check_rerun.py14 KBb96b0ed033d4upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_accepted_finding_note.py11 KB4f14cbe286fcupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_accepted_finding_restate.py16 KB56f4a1bcceccupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_accepted_findings_scope.py20 KB0519448742daupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_aider_provider.py29 KBdf2c2202be9eupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_all_failed_fanout_is_recorded.py2.3 KB0935ae1585f1upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_already_completed_rerun.py2.6 KB5198b4cd136bupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_an_answer_answers_one_stop.py12 KB9fc5b8c37e33upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_answer_text.py12 KB124ae574db62upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_applied_without_changes.py28 KB444e33252c07upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_apply_backup_across_rounds.py3.6 KBc4725c625094upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_apply_code_fixes_unit.py127 KB95139a83de1bupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_apply_fix_known_checks.py44 KB6256f8c35872upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_apply_orchestrator_base.py278 KB2d77658296b9upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_apply_phase_in_progress.py6.7 KB2539621d77a4upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_apply_phases_close_like_implement.py7.7 KB89da18d6ad2fupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_apply_suggestions_integration.py50 KBccfff9d193c7upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_apply_task_suggestions.py59 KB010d6053f981upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_apply_task_suggestions_integration.py50 KB9d3ed67f68f1upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_ask.py185 KB30d96defdc2eupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_attempt_backpressure.py16 KBad99a9839242upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_availability.py34 KB2bb08e330b4bupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_backup.py20 KBa11cf0a7c1a5upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_batch_check_on_record.py5.9 KB6fb529d0957dupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_batch_done.py49 KB146fbd0c2a6aupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_batch_own_check.py33 KBa57cd1a3a567upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_batched_validation.py120 KB787cbc5734b7upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_block_reason_says_one_thing.py6.7 KBffe72471cd28upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_build_context.py19 KB091d4e47aec0upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_bypassed_slot_failure_provenance.py11 KB62b4df8989a9upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_capability_promotions.py25 KBa022a6d55f9eupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_check_always_reported.py12 KBb3bc3ae99a66upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_check_findings_hold_dependents.py43 KBec2cf5c0bb50upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_check_gate_fixture.py47 KBc1a5ca8b9f74upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_check_repeats_finding.py24 KBf6197a512cd0upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_check_reply.py11 KB9277a4a7cd14upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_check_task_findings.py16 KB2ac94b752f4cupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_check_tree_stamps.py6.3 KB4a4e6ba064c4upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_cli_surface_emitter.py25 KB0e0423e52863upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_cline_reducer.py12 KB7b1bbd081c66upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_clipped_previews.py18 KB7cf6e4fb0592upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_code_fix_batcher.py41 KBcfd8ae8361f5upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_code_fix_prior_batches.py16 KB441ec75524e6upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_code_review_integration.py14 KB607b8154e24eupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_code_review_orchestrator.py200 KBc3602ac0d8a7upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_codex_jail_rig.py55 KB6774c9d5bc5dupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_codex_long_call_rule.py3.9 KB9128f1e316cdupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_codex_mcp_server.py222 KB51b3941692abupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_codex_package.py105 KB0446b5bca130upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_codex_package_seed.py24 KBa21b42132023upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_codex_route.py34 KBf6518e4e4429upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_codex_stream_audit.py48 KBf36f57c93aecupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_codex_trust.py13 KB62f238a58fabupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_commit_apply.py94 KB37e2a5cc6b87upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_commit_attribution.py26 KB889a3b32fec6upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_commit_brief.py31 KB93ac6becddd1upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_commit_dispatch.py27 KB5a3782db82caupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_commit_front_door.py83 KB722dd795d900upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_commit_range.py60 KB29eba0a1567cupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_commit_review_paths.py24 KB6f55c479adf4upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_commit_review_prompt.py19 KB8d5dfd2e986cupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_commit_review_report.py40 KB44cab4d0eb14upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_commit_spelling.py3.7 KBce3b4ff00474upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_commit_spelling_sites.py33 KBa5d5e69564d2upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_commit_write_policy.py77 KB272077fb153eupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_completion_predates.py11 KB039c086cffdcupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_consolidation.py50 KB2151749fc7ddupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_consolidation_integration.py41 KB23012e5ab3eeupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_consolidation_not_recommended_twice.py10 KBc9ba548a80baupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_container_argv.py18 KBb1f0bbe7cf2bupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_container_cli_surface.py17 KB905a00b2107eupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_container_commit_modes.py15 KB14b61b9000bbupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_container_documented_invocation.py26 KBb8e37c670dcdupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_container_full_chain.py72 KBb1afcd167cc0upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_container_host_lane.py176 KB1423cad9d205upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_container_improve_modes.py16 KB8d2390b08f25upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_container_live_provider.py119 KBfd5cc82d1778upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_container_opencode_deny.py10 KB837a794645e8upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_container_opencode_package_gate.py6.2 KBaf962e0797eeupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_container_provider_lane.py15 KB447f8049aaaeupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_continuation_plan_spelling.py23 KB9362107f4096upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_copilot_home_isolation.py8.4 KBe5085dcf6d98upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_credential_strip.py38 KBd1b299cd7fd5upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_cursor_argv_and_residue.py25 KB9f7941f4ee30upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_cursor_auth_probe.py33 KBeb06ad10aad0upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_cursor_profile_isolation.py44 KBce37b45529e6upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_decline_reason_quotes_the_decision.py4.3 KB8a55ec9b0821upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_declined_reason_punctuation.py10 KB328742158b8eupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_default_models_reach_a_lane.py4.8 KBf95210c0bc47upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_detach.py331 KBdebcc0d9f2d0upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_dispatch_batch_count.py2.0 KBb1058ebf14e1upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_dispatch_counts.py34 KB38724b86497aupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_dispatch_from_a_subdirectory.py31 KB915732a44fc8upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_dockerfile_pins.py21 KB8f750f124afdupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_docs_links.py17 KB76c65157a896upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_doctor.py51 KBe4b472f43737upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_duplicate_run_prevention.py32 KBb22d637d48f3upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_e2e_apply_code_fixes.py40 KB5a473e76b66fupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_e2e_batching.py28 KB373840a730d4upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_e2e_code_review.py37 KBfdcc6b27767bupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_e2e_commit_modes.py48 KB3445d821c03cupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_e2e_exec_subagents.py17 KB15503c700386upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_e2e_failures.py155 KBc123b7e19e4aupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_e2e_full_chain.py40 KBcccce9b3034fupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_e2e_html_report.py20 KB9c32dc379e64upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_e2e_improve_modes.py78 KB1d235e4c4fbfupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_e2e_mock_infrastructure.py35 KBfd31a0d32650upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_e2e_runs_retention.py7.1 KBb4697030a397upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_e2e_validation.py25 KB81ebb332a9f5upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_e2e_validation_edge_cases.py41 KB24e3cbe54fb5upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_e2e_workflow.py27 KBf237355377e3upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_egress_resolver.py4.6 KBa6b086943139upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_empty_review_outcomes.py26 KB7c31604d66abupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_env_allowlist.py32 KB63ae0f87f92aupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_env_home_expansion.py8.1 KBf6b7b9921f72upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_eta_closes_every_ending.py14 KBa4d38ebc4505upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_eta_names_what_did_not_run.py10 KB55c9fb88973eupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_eta_says_what_happened.py30 KB5c032c20efefupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_executor_role_sweep.py12 KB44e9e8a26eb1upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_external_rollback_storage.py13 KB8d24b6c48531upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_failed_slot_reporting.py15 KB07b0c0d9e3ddupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_failure_classifier.py53 KB1b1f82457423upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_fake_lane_output_channel.py9.6 KB554fa486591aupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_fake_lane_roster.py14 KB2b6555d8d9eaupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_fanout_workspace_caches.py11 KB6990249cedc5upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_fast_backoff.py2.9 KBe723736d5dbbupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_file_discovery.py28 KB3e50000e9363upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_filtering.py28 KBd999b707e533upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_finalize_tracking.py69 KB50190037ea9bupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_finished_run_relay.py3.9 KB48d3690a835fupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_format_issue.py12 KB180031062bb2upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_format_suggestion.py31 KB046077ad4034upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_full_workflow_orchestrator.py56 KB0effdf334712upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_fx_provider.py20 KB7d32651e6c82upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_generate_tasks_orchestrator.py60 KB35ba0db5b44aupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_git_env.py22 KBcff1a9b3b8efupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_git_two_commit.py44 KBd51246da514dupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_git_utils.py107 KBd77b89b7b688upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_golden_container_bundle.py30 KB5845810e5522upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_goose_error_kind.py6.0 KB06fce75cdd24upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_grok_dispatch_env.py6.5 KBd4c708c46804upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_harness.py23 KBad3c29c32800upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_hook_transcript_settle.py28 KB18c165a800dfupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_host_capabilities.py88 KB7120e1fc12daupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_host_home_seed.py14 KBd65c4745fb04upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_host_lane_budget.py11 KB36928d345143upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_host_lane_retry.py49 KB5d1e62016d55upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_host_model_pin.py12 KBcc5a70969206upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_html_report_functional.py73 KBf40446f3311fupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_html_report_generator.py85 KB58cf1fc3e8b0upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_html_report_integration.py50 KB5d61f5bfbf9bupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_human_decision_overlay.py16 KB202c3ea0d77dupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_human_decisions.py43 KBcd013e7cad8dupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_human_task_answers.py29 KB80ed3588a15fupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_implement_continues_a_started_run.py33 KBa1fd6b870b0cupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_implement_orchestrator.py104 KBae774282a16fupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_implement_resolution_replay.py2.0 KBb082a68ac0d9upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_implement_stop_account.py21 KB8e2d1856dbdaupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_importance.py12 KBee7292acdac3upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_improve_commits.py43 KBdc4141a40ce6upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_improve_orchestrator.py83 KBe43806bbda0dupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_improve_steps.py59 KBd8fbb0755c32upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_init_config.py29 KB83f7b3617083upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_install_host.py99 KB0e69003ab9e0upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_instruction_portability.py195 KB18ae51cdc991upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_instruction_refactor_guard.py16 KBcc728cc1e306upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_interactive.py14 KB6fb522f187caupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_json_extractor.py43 KB1886eda5cbeaupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_judge_vocab.py36 KB1f037e6b5e6eupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_kept_task_ids.py3.6 KBe1ab66afd7caupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_kimi_home_isolation.py7.4 KBe807fb7f663bupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_landlock_dispatch.py107 KBbadde5e678c0upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_landlock_exec.py33 KBb96448693e39upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_landlock_repo_wide.py37 KB961d32ba10a9upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_lane_a_ladder.py26 KB6c1a1609d0e6upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_lane_b_structured_output.py34 KB4ec491f1bf2dupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_legacy_instructions.py2.6 KBc06910ad9f7cupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_live_lane_variant_echo.py3.4 KB0a4c5684d90aupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_llm_client.py223 KBa4512b3ce50aupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_llm_robustness.py44 KB0dddd7f887a5upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_lock_update.py25 KB9a6cba415189upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_makefile_lanes.py5.9 KBa6c2c2a4149fupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_manual_note_command_last.py4.8 KB0ea77266eab0upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_manual_task_gate.py49 KB81401508fcd6upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_manual_tasks_on_completion.py42 KB92a5e6cfd544upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_marketplace_manifest_location.py9.3 KB2bce5846cdf6upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_metrics.py55 KB948faa380d0dupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_misnamed_result_files.py37 KB87f30e5d6f5dupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_mock_adapter_roundtrip.py18 KB6259a4238cecupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_mock_plugin_hook.py24 KB4b2c6bfe9e10upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_mode_sequence.py6.9 KBa4d3a32a06d1upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_muse_terminal_state.py11 KBb2dc647cd387upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_native_apply_count_over_the_run.py14 KB6f224216de1eupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_native_apply_view_names_declined_items.py12 KBdecdea0089a1upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_native_half_applied_answers.py9.7 KB7067123da8faupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_native_implement_report.py21 KB7a8b238609ccupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_native_prompt_files.py10 KB79189bfc17a7upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_next_command_emitters.py49 KBc380e9986936upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_next_command_live_check.py34 KB4740e02582d1upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_next_phase.py81 KB499b386a5950upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_next_step_markdown.py12 KB0f69eb32877fupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_next_step_relay_rules.py14 KBfcd684394c91upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_no_commit_repository.py37 KB4f9baaf1a194upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_no_committed_secrets.py51 KB2720cc353872upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_notice_clause_join.py7.8 KB616f7097ffe6upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_omp_containment.py23 KBe0082764c80dupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_omp_stream_reading.py37 KB850b5b673521upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_one_own_check_rule.py14 KB79d72abb277eupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_opencode_config_providers.py50 KBe0baf3458554upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_opencode_first_release.py56 KB683445ad9912upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_opencode_hermetic.py58 KB1e6bd9b8280dupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_opencode_host_install.py26 KB86ead5cd48c3upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_opencode_package.py443 KB5383baed53a4upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_opencode_package_gate_graders.py46 KB9a4ac525eb29upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_opencode_permission_block.py24 KBc93d763a73dbupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_opencode_probe_signals.py12 KBc092e31d02beupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_opencode_publish_workflow.py58 KB0d1040c3a306upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_opencode_registry_absent.py43 KB4d64963ba10aupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_opencode_registry_check.py76 KB47cfd272f2f6upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_opencode_registry_record.py30 KBe001b3c8da30upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_opencode_registry_stub.py14 KB944d5c12a96fupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_opencode_release_gate.py84 KBb81d14e5c75bupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_opencode_row7_probe.py42 KB7a98faf9e891upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_opencode_stop_title.py9.4 KBef630892788bupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_opencode_version_pins.py15 KB7a817ded899cupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_opencode_write_profile.py31 KB9674aa50f0b1upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_optional_step_why.py6.3 KB47df530adb23upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_optional_why_wording.py4.3 KBe7e679dfae3dupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_orchestrator_integration.py4.0 KBa898ed21f59eupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_output_handler.py7.1 KB1e6dbdcd73f4upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_own_check_not_recorded.py11 KBb907e7586418upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_partial_detached_result.py23 KB5ecfa6587108upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_phase3c_workflow.py48 KBfade2c387ab5upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_pi_family_stream.py20 KB37dd5dab9bdbupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_pi_json_mode.py40 KB2a060672801eupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_plan_updater.py5.6 KB863bbb59885eupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_planted_state_ids.py5.2 KB4dada768b059upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_plugin_hooks.py4.9 KB581f215826d8upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_plugin_landlock_acceptance.py81 KBb2eff3204af6upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_plugin_landlock_executor.py76 KBd9fe0d66c53fupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_plugin_landlock_fanout.py60 KB029bc2cfa3e1upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_plugin_landlock_surfaces.py27 KB1dc44f302fd3upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_plugin_landlock_write.py61 KB257826c7ca24upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_policy_way_forward.py16 KB53d4b0ecc2c7upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_porcelain_baseline.py8.2 KBa4b98e747b6aupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_prior_batches_named_by_id.py15 KB897f82787097upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_prior_changes.py38 KBd22f07aa7613upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_prior_changes_empty_id.py4.1 KB99a3c9da7506upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_prior_changes_not_quoted_twice.py4.8 KB540962d2c957upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_probe_output_redaction.py24 KB8dac4222d282upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_processed_items_both_legs.py17 KB1c747d287074upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_progress_tracker.py111 KBaa0c501354d5upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_prompt_files_stay_inside.py13 KB6fc941ab12bfupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_prompt_loader.py12 KBc0857899d3f5upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_provider_fixture_rows.py17 KB018ae749a727upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_provider_housekeeping.py48 KBe4e040a89b2dupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_provider_registry.py134 KB632941bb4c80upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_providers.py512 KBeb796139f13cupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_qwen_home_isolation.py9.1 KBbb28b318ff9aupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_read_only_modes.py59 KB0bdb6a6c4668upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_readme_mode_table.py6.3 KB006cf8549061upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_reaggregate_identity.py173 KB81e228a236d3upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_reaggregate_progress_line.py6.4 KBb4f362e428b2upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_reasoning_effort_ladder.py29 KB753589a02862upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_recorded_stop_answers.py5.0 KB24ffe598c2e3upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_redaction.py64 KBdbdcb177d1bfupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_redirect_matrix_claims.py61 KB94f07338877cupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_refused_answers.py9.4 KB20d103648b3fupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_relay_says_it_once.py19 KB07286b93bb26upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_release_history.py46 KB62c65ec73cd3upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_replay_flags.py53 KB5e2892a2493cupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_reply_without_schema_version.py8.9 KB8584caab88c8upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_report_check.py32 KBedc277d29054upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_report_check_composite.py17 KBff4c1e689593upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_report_check_session.py12 KB43ae7eda4e22upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_report_check_stop_answers.py6.7 KB35c734152560upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_report_parser.py73 KBbac7a605da24upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_report_repair_preserves_checks.py5.3 KB78c2c0aaea9bupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_rerun_result_freshness.py20 KB486be4fa9b94upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_result_envelope.py10 KBddbb54fdc833upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_result_envelope_verdicts.py22 KBf42361305099upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_resume_why.py20 KB2552cb842ac2upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_retry_ladder.py30 KBb458c9c8cb65upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_review_code_head_ref.py55 KB543180f613fdupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_review_diff_spill.py25 KBd6835d5d4ae2upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_review_plan_orchestrator.py85 KBc2875b897715upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_review_priority_reset.py879 B888e89a66916upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_review_prompt_rules.py20 KB94dbf3f28411upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_review_tasks_integration.py41 KB522e10b5e438upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_review_tasks_orchestrator.py52 KB84774c1471e7upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_run_anchor_pinning.py21 KBea85ea23c950upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_run_record_write_outcome.py15 KB07e2e488a383upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_runner_catalog_roster.py5.2 KB82db8a6f523fupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_runner_env_skill_venv.py15 KBe2e22ed58b32upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_salvage_text.py44 KBf85574d3b510upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_sandbox_fallback_ladder.py48 KB0065256115bfupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_sandbox_rung_reporting.py29 KBc0f391de3b52upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_sandbox_rung_retirement.py18 KB1e3bb23708c2upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_scenario_matcher_parity.py46 KB21fee3b88125upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_schema_validator.py9.2 KB7b683034df93upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_scope_policy.py18 KB73d897c1bee5upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_scope_policy_apply.py54 KBf1d2b5529f71upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_scope_policy_cli.py20 KB06db889915b8upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_scope_policy_commit_doors.py4.3 KBf683d25ea3ebupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_scope_policy_composites.py22 KBf1a1400bc299upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_scope_policy_default_compat.py6.3 KB2068515b0390upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_scope_policy_leaf_modes.py10.0 KBcd57e75ca639upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_scope_prompts_and_validation.py65 KB3d892a6ea850upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_scope_report_tags.py67 KBd4008dc7129dupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_selected_tasks_and_check_trees.py9.7 KB663ca4d8e70aupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_served_model_reporting.py29 KB0b6f43638864upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_shim_correctness.py46 KB40bab1f53fa1upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_shim_dispatcher_call_form.py2.8 KBdd98059e6f5eupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_sort_integration.py16 KBcc8255e5bdc4upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_sorting.py26 KBc7e40e078477upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_state_manager_decisions.py43 KB8f6d5d2d3dcbupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_state_tracking.py13 KBd5baf9aa8b8eupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_status_after_a_stop.py10.0 KBb543212e7b26upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_status_after_switching_to_native.py13 KB446b7f6d69cfupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_status_file.py26 KB17edd8e4d847upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_status_native_stop_head.py14 KB59bf5d2dab99upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_status_phase_dirs.py6.9 KB9ab386b5d2c2upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_status_recorded_route.py15 KB0932de3d91e5upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_status_run_view_every_leg.py24 KBb050a2a09247upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_status_tallies_every_task.py4.8 KB4450e6cdbac8upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_status_why_punctuation.py7.4 KB73dac67cafbeupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_stderr_diagnosis.py82 KBaf941ca1cb51upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_stop_headline_budget.py11 KBfd21f4fdbb4fupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_stop_line_beside_section.py7.4 KBb29196210d36upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_stop_relay.py18 KB64bacd37409aupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_stop_results_surface.py26 KB5bc1e2c3d8deupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_stop_resume_wording.py13 KB906113c1e4b3upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_stop_says_tests_did_not_run.py8.5 KB1b79fc41b09eupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_stop_section_ready_written.py8.5 KB96a979684072upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_stray_write_paths.py45 KBde40c4004f9fupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_stream_bootstrap.py3.5 KBc267e19574a6upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_stream_bootstrap_entrypoints.py6.2 KB6d48ab79c6c4upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_strict_schema_subset.py15 KB3e5d9d403801upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_structured_output.py43 KB89eb6e53f832upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_stub_scripted_tool_call.py35 KBfe23e7285d04upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_subagent_executor.py302 KB9ac66c911a85upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_subagent_prompts.py46 KB0557f64adab1upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_subagent_tasks.py37 KB18d9b116b2ccupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_subscription_credentials.py19 KB89ad9052c6d0upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_suggestion_batcher.py41 KB71b8335ae908upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_suggestion_processor.py33 KBfdc9668df759upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_summary_answered_task_rows.py3.6 KB1a5c52590c50upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_summary_lists_unapplied_items_apart.py7.1 KBd5931ce40e60upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_task_decomposer.py31 KB824694176c49upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_task_file_resume_guard.py7.7 KB988f7ecf7defupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_task_suggestion_counts.py1.1 KBf91aef747357upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_tasks_graph_check.py8.7 KBe86773c11aa1upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_tests_line_leads_with_what_ran.py20 KBbdf3f747b097upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_tests_not_run_line_relayed_whole.py1.8 KBb240124700aaupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_text_clip.py5.0 KB103da8d60524upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_timed_out_stop_wording.py3.5 KB4057c3c44e71upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_tracking_write_integrity.py1.4 KBea756e40bd7fupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_tui_transcript_rendering.py6.8 KBafe13fc3df69upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_unattended.py64 KBa1dbf8e5b74aupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_unattended_e2e.py19 KB4546dfb18c81upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_update_plan_tasks.py34 KBaee67c841fadupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_usage_reporting.py42 KBab73131908b7upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_user_next_step_result.py9.6 KB396639cfec89upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_uv_candidates.py14 KBc3875fd079efupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_uv_project_flag.py5.7 KBde97a89395e3upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_validation_batch_binding.py36 KBfa1ef568b5f7upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_validation_batcher.py11 KBa581aa34d096upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_validation_context_by_path.py45 KB04530a7c750aupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_validation_context_surfacing.py19 KB7a2fcbdf0b84upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_validation_group_id.py37 KBc01b0211574cupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_validation_recovery.py25 KB24f5b06d57e9upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_validation_reply_printed_once.py5.5 KBc76d8b30d27fupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_validation_subagent.py30 KBca47f27cd435upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_validation_subagent_orchestrators.py19 KB9212aceaaaeeupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_version_gate.py35 KB2691c7e0a8c6upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_vibe_home_isolation.py13 KB4f856667b050upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_vibe_seed_model.py1.8 KBad98d45a1ab1upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_wakeup_check.py25 KB272fb98915abupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_windows_lane_a_jobs.py38 KB6e0d6fea73cbupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_windows_run_jobs.py47 KB2a8c7d418c95upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_windows_tree_jobs.py31 KBcf18ddd61e43upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_workflow_prerequisites.py103 KBdb3a6bf743a0upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_wrapper_env_contract.py19 KBe4804abbab5aupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_write_batch_declined.py54 KBf8c1123fdc56upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_write_batch_leaves_git_alone.py2.4 KBe3f32e9d8cd4upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_write_executor.py281 KBd90c2ae42d53upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_write_executor_orchestrators.py92 KB9911ea62f664upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_write_prompt.py27 KBa10c0d401f42upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_write_reply_prose_before_object.py8.3 KB7e9ce5e70fcfupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_write_resume_verdicts.py4.0 KB55bc079b6277upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_write_retry_redispatch.py22 KBfd22feae77b8upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/tests/test_write_sweep_overlap.py4.8 KB7254f7189353upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/update_plan_tasks.py15 KB5da334d41317upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/__init__.py9.0 KBb1799216619dupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/apply_orchestrator_base.py261 KBd1e68479495bupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/apply_output_helpers.py2.9 KB8f79abd801f3upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/apply_path_helpers.py728 Bfa1d4a7a5755upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/apply_selection_helpers.py6.8 KB011746fe19ccupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/backup.py1.6 KBab5aa79cecd4upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/batch_done.py84 KB92720947d7a6upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/check_reply.py10 KB0ee7577a619bupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/check_tree.py1.2 KB736f7911bf87upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/cli_common.py89 KB51fa4b77ad96upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/code_fix_batcher.py31 KB95b1372908eeupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/codex_trust.py13 KBd7c00503bffbupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/commit_apply.py74 KBe9381506a952upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/commit_attribution.py21 KBc2872cc2168cupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/commit_brief.py33 KB98771b3af031upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/commit_range.py62 KBd9e9ddba56f3upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/commit_report.py20 KB934f09a031a8upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/commit_review.py94 KB0b322639fa26upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/commit_spelling.py8.1 KB499521a8983eupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/consolidation.py92 KB91f0f9f75c0aupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/detach.py111 KB35aa8baad151upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/doctor.py66 KB21c340429929upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/file_discovery.py11 KBfce261249304upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/filtering.py22 KB6981be327a02upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/git_utils.py150 KBccdc72af7700upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/host_capabilities.py48 KBf13f19b10439upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/host_install.py136 KBb38d185ed5b0upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/html_report_generator.py135 KB75e4fc6a6dafupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/human_decisions.py31 KB4ae70e62f370upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/importance.py2.5 KB897e2510feedupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/improve_steps.py26 KB559091f2797fupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/improve_workflow.py92 KBb27eb39509a7upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/interactive.py29 KBd751326d8e9bupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/json_extractor.py49 KB3a3adf321c67upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/judge_vocab.py5.3 KBfab181a9de08upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/known_checks.py38 KBa61a984f9557upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/landlock_dispatch.py90 KBce91bce36120upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/landlock_exec.py21 KB95dbbe2d2980upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/llm_client.py198 KB8fd595ffc1a0upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/metrics.py71 KB85a553ed05a5upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/next_phase.py123 KB844fe5eaa258upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/output_handler.py20 KB691c635aa8f7upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/plan_updater.py16 KBbf12a32a56a1upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/prior_changes.py28 KBf6426959948dupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/process_control.py120 KB24b05d644306upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/progress_tracker.py91 KB41c266769bd7upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/prompt_files.py21 KB0169939bea8dupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/prompt_loader.py895 B448b6d0884b0upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/provider_registry.py93 KB122827f2ae2fupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/providers/__init__.py2.6 KBb4dc222c3c83upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/providers/agy.py15 KB3f545819502dupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/providers/aider.py57 KB0f0fc28369f3upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/providers/base.py237 KB872fc1b25f2aupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/providers/claude_code.py83 KB82ca239abdafupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/providers/cline.py20 KB0649c4d7ce37upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/providers/codex.py101 KB6fb6eca13ed0upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/providers/codex_stream_audit.py31 KB2a6a95b34d54upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/providers/copilot.py49 KBbe508e6bc01dupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/providers/cursor_agent.py76 KB0fffd14ccd83upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/providers/fx.py23 KB2fbc0b2703b4upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/providers/gemini.py29 KB5074d9affccaupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/providers/goose.py25 KBa5531d9396dcupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/providers/grok.py21 KBe96edab522ddupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/providers/kilocode.py19 KB1e88d71da866upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/providers/kimi.py28 KBd8ad466258deupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/providers/muse.py33 KB680889573bfcupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/providers/omp.py84 KB843ab8f5307bupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/providers/opencode.py147 KBfd6e6b246992upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/providers/pi.py52 KBc5197264ede6upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/providers/pi_family_stream.py22 KB44677dacb15dupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/providers/qwen_code.py45 KB765bedf623cbupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/providers/result_envelope.py17 KBa1fe2c4acbe7upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/providers/vibe.py46 KB6a9ad86575abupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/readonly_audit.py5.3 KB4309fbb0549fupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/report_check.py54 KB8653e2c7b5e8upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/report_parser.py50 KBd7db47fdb989upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/restore_batch.py10 KBaecd3e6c0e36upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/result_files.py20 KB340fcf04a71aupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/retry_ladder.py33 KB05f7f115e2e6upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/review_orchestrator_base.py414 KB641116cbb1d7upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/run_registry.py11 KBa06a4d9ec2b7upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/run_status.py281 KBa18ea4a50c5dupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/schema_validator.py24 KB06bafd2ea031upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/scope_apply.py29 KB37c0c58af26eupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/scope_policy.py46 KBabde0c89391bupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/scope_policy_runs.py14 KB376cb5dcaf5bupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/scope_report.py21 KB9a7dd417a4d1upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/scope_round.py26 KBf1d0fb158e0dupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/selection_migration.py7.6 KBad79717d04c5upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/state_manager.py103 KB31bcec7c097cupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/status_file.py26 KB8d8f9b88c63dupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/stream_bootstrap.py4.4 KB10632c162f98upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/structured_output.py33 KBd626ed0f52d1upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/subagent_executor.py508 KBc590e21c6140upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/subagent_prompts.py76 KB96b7d685fa7dupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/subagent_tasks.py48 KBa22a5b6b06c8upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/suggestion_batcher.py17 KBf30c0dfa1094upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/suggestion_processor.py34 KB215c1f10c29fupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/task_decomposer.py36 KB96cad5082ec0upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/tasks_file.py8.0 KB3e7fecad6f5aupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/tasks_graph_check.py3.8 KBa474d0d385ddupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/text_clip.py13 KBc094dbd9e0cbupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/unattended.py48 KBf475804e934cupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/validation.py152 KBd973ff95dc0eupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/validation_batcher.py7.0 KB03a0aecd4136upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/validation_context.py12 KB2251c7e78214upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/wakeup_check.py18 KB5edc863e07e2upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/write_batch_scheduler.py729 KB7e21d87eaeb7upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/write_phase_bridge.py17 KB9b437f15f6faupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/write_prompt.py49 KBd1e23d53daf7upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/utils/write_safety.py115 KBb15b5bf3c9a4upstream ↗

  Contents are not inlined in the catalog. Open the upstream file.

• skills/multi-llm/uv.lock154 KB18990dd340ccupstream ↗

  Contents are not inlined in the catalog. Open the upstream file.