Skip to content

hashgraph-online/awesome-codex-plugins / plugins/beastlabai/multi-llm-plugin/skills/multi-llm

multi-llm

Flagged

Orchestrate plan reviews, task generation, implementation and code reviews across several LLM CLIs in parallel, or ask every model one free-text question about a plan. Use when the user says: review my plan, multi-llm, run a code review, generate tasks from a plan, implement this plan, ask the models about my plan.

FileKindSize
SKILL.mdskill md4.0 KB
apply_code_fixes_orchestrator.pyscript56.6 KB
apply_commit_fixes_orchestrator.pyscript2.3 KB
apply_suggestions_orchestrator.pyscript4.5 KB
apply_task_suggestions_orchestrator.pyscript19.1 KB
ask_orchestrator.pyscript162.5 KB
assets/icons/Anthropic.svgother584 B
assets/icons/Codex.svgother1.3 KB
assets/icons/Copilot.svgother1.5 KB
assets/icons/Cursor.svgother793 B
assets/icons/GoogleGemini.svgother623 B
assets/icons/Goose.svgother3.2 KB
assets/icons/Kilocode.svgother531 B
assets/icons/MiniMax.pngbinary1.5 KB
assets/icons/Mistral.svgother717 B
assets/icons/MoonshotAI.svgother957 B
assets/icons/Nvidia.svgother2.4 KB
assets/icons/OhMyPi.svgother434 B
assets/icons/OpenAI.svgother1.7 KB
assets/icons/Opencode.svgother325 B
assets/icons/Pi.svgother440 B
assets/icons/Qwen.svgother1.7 KB
assets/icons/Zhipu.pngbinary442 B
assets/icons/xAI.svgother343 B
assets/omp/overlay.ymlconfig2.4 KB
check_workflow_prerequisites.pyscript74.5 KB
code_review_orchestrator.pyscript324.0 KB
display_decisions.pyscript9.8 KB
finalize_tracking.pyscript1.3 KB
full_workflow_orchestrator.pyscript58.8 KB
generate_tasks_orchestrator.pyscript44.2 KB
hosts/capabilities.yamlconfig49.9 KB
hosts/codex/plugin-skill.md.tmplother2.8 KB
hosts/codex/shim.md.tmplother7.3 KB
hosts/opencode/plugin-command.md.tmplother2.2 KB
hosts/opencode/shim.md.tmplother6.8 KB
hosts/render_capabilities.pyscript48.4 KB
hosts/snippets/poll-loop.mdmarkdown4.4 KB
hosts/snippets/uv-preflight.mdmarkdown2.2 KB
hosts/uv-missing.txtmarkdown1.5 KB
implement_orchestrator.pyscript156.0 KB
improve_code_orchestrator.pyscript1.6 KB
improve_commits_orchestrator.pyscript2.5 KB
improve_plan_orchestrator.pyscript1.6 KB
init_config.pyscript57.6 KB
instructions/apply-code-fixes.mdmarkdown52.0 KB
instructions/apply-commit-fixes.mdmarkdown10.3 KB
instructions/apply-suggestions.mdmarkdown48.2 KB
instructions/apply-task-suggestions.mdmarkdown53.9 KB
instructions/ask.mdmarkdown27.6 KB
instructions/full-workflow.mdmarkdown24.6 KB
instructions/generate-tasks.mdmarkdown18.1 KB
instructions/implement.mdmarkdown54.0 KB
instructions/improve-code.mdmarkdown25.0 KB
instructions/improve-commits.mdmarkdown24.8 KB
instructions/improve-plan.mdmarkdown26.2 KB
instructions/init-config.mdmarkdown6.6 KB
instructions/review-code.mdmarkdown43.5 KB
instructions/review-commits.mdmarkdown11.4 KB
instructions/review-plan.mdmarkdown38.4 KB
instructions/review-tasks.mdmarkdown37.8 KB
modes.pyscript58.8 KB
multi_llm.pyscript101.1 KB
prompts/ask.txtmarkdown948 B
prompts/code_review.txtmarkdown4.5 KB
prompts/commit_review.txtmarkdown6.2 KB
prompts/consolidate_suggestions.txtmarkdown3.1 KB
prompts/implementation_task.txtmarkdown1.4 KB
prompts/plan_review.txtmarkdown8.0 KB
prompts/task_review.txtmarkdown8.3 KB
providers.yamlconfig19.6 KB
pyproject.tomlmanifest6.8 KB
references/apply-write-executor.mdmarkdown3.0 KB
references/consolidation.mdmarkdown5.6 KB
references/host-capabilities.mdmarkdown13.5 KB
references/human-decision-batch.mdmarkdown17.2 KB
references/implement-prerequisites.mdmarkdown6.0 KB
references/implement-write-executor.mdmarkdown4.9 KB
references/interrupted-run-recovery.mdmarkdown3.1 KB
references/own-check.mdmarkdown4.3 KB
references/resume-detection.mdmarkdown8.5 KB
references/revalidation.mdmarkdown6.9 KB
references/review-code-apply-fixes.mdmarkdown4.3 KB
references/salvage-handling.mdmarkdown12.5 KB
references/summary-format.mdmarkdown10.0 KB
references/uv-check.mdmarkdown5.7 KB
references/wave-batching.mdmarkdown5.2 KB
review_commits_orchestrator.pyscript2.3 KB
review_plan_orchestrator.pyexecutablescript22.3 KB
review_tasks_orchestrator.pyscript10.7 KB
schemas/cascade_record.schema.jsonconfig6.6 KB
schemas/code_review_issues.schema.jsonconfig2.0 KB
schemas/consolidated.schema.jsonconfig6.8 KB
schemas/consolidation_batch.schema.jsonconfig3.7 KB
schemas/generated_tasks.schema.jsonconfig3.1 KB
schemas/host_capabilities.schema.jsonconfig38.3 KB
schemas/human_decision_verdicts.schema.jsonconfig2.6 KB
schemas/result_line.schema.jsonconfig10.1 KB
schemas/review_suggestions.schema.jsonconfig2.4 KB
schemas/state_file.schema.jsonconfig21.5 KB
schemas/status_file.schema.jsonconfig24.9 KB
schemas/status_json.schema.jsonconfig10.8 KB
schemas/subagent_tasks.schema.jsonconfig20.5 KB
schemas/task_decomposition.schema.jsonconfig1.2 KB
schemas/write_batch_result.schema.jsonconfig8.8 KB
templates/config/providers.override.yamlconfig17.2 KB
templates/consolidated_report_template.htmlother44.1 KB
templates/pr_report_template.htmlother181.2 KB
templates/report_template.htmlother67.5 KB
templates/shared/report_core.cssother4.1 KB
templates/shared/report_core.jsscript25.5 KB
update_plan_tasks.pyscript20.9 KB
utils/__init__.pyscript284 B
utils/advisory.pyscript4.8 KB
utils/apply_orchestrator_base.pyscript220.6 KB
utils/apply_output_helpers.pyscript10.9 KB
utils/apply_path_helpers.pyscript683 B
utils/apply_report.pyscript51.2 KB
utils/apply_selection_helpers.pyscript6.8 KB
utils/apply_suggestion_phase.pyscript11.7 KB
utils/atomic_io.pyscript12.9 KB
utils/attempt_classifier.pyscript31.4 KB
utils/backup.pyscript2.0 KB
utils/batch_done.pyscript79.2 KB
utils/batch_ledger.pyscript27.4 KB
utils/batch_prompt.pyscript29.3 KB
utils/batch_prompt_builder.pyscript12.2 KB
utils/batch_reply.pyscript32.9 KB
utils/cascade_archive.pyscript50.6 KB
utils/cascade_ledger.pyscript39.3 KB
utils/cascade_provenance.pyscript22.0 KB
utils/check_records.pyscript59.3 KB
utils/check_reply.pyscript9.5 KB
utils/check_tree.pyscript1.2 KB
utils/cli_common.pyscript91.2 KB
utils/cli_version_cache.pyscript14.0 KB
utils/clock.pyscript3.5 KB
utils/code_fix_batcher.pyscript30.6 KB
utils/codex_trust.pyscript12.9 KB
utils/commit_apply.pyscript73.3 KB
utils/commit_attribution.pyscript21.2 KB
utils/commit_brief.pyscript32.2 KB
utils/commit_front_door.pyscript81.6 KB
utils/commit_paths.pyscript18.0 KB
utils/commit_range.pyscript61.2 KB
utils/commit_report.pyscript19.9 KB
utils/commit_review.pyscript413 B
utils/commit_spelling.pyscript7.9 KB
utils/commit_write_guard.pyscript9.9 KB
utils/concurrency.pyscript11.6 KB
utils/consolidation.pyscript87.3 KB
utils/detach.pyscript186.8 KB
utils/dispatch_spawn.pyscript56.3 KB
utils/doctor.pyscript76.7 KB
utils/env_vars.pyscript20.5 KB
utils/failure_capture.pyscript10.1 KB
utils/file_discovery.pyscript11.0 KB
utils/filtering.pyscript19.9 KB
utils/git_diff.pyscript23.6 KB
utils/git_utils.pyscript86.6 KB
utils/held_folder.pyscript21.3 KB
utils/host_capabilities.pyscript48.0 KB
utils/host_install.pyscript77.6 KB
utils/host_paths.pyscript12.0 KB
utils/host_routes/__init__.pyscript5.7 KB
utils/host_routes/codex.pyscript18.3 KB
utils/host_routes/npm.pyscript12.2 KB
utils/host_shim.pyscript14.7 KB
utils/html_report_generator.pyscript118.9 KB
utils/human_decisions.pyscript38.3 KB
utils/human_task_plan.pyscript30.2 KB
utils/importance.pyscript6.2 KB
utils/improve_cascade.pyscript63.7 KB
utils/improve_cascade_next.pyscript22.2 KB
utils/improve_steps.pyscript32.4 KB
utils/improve_workflow.pyscript114.4 KB
utils/interactive.pyscript31.6 KB
utils/json_extractor.pyscript61.5 KB
utils/judge_vocab.pyscript5.3 KB
utils/known_checks.pyscript37.5 KB
utils/landlock_dispatch.pyscript103.8 KB
utils/landlock_exec.pyscript21.4 KB
utils/launch_limiter.pyscript13.5 KB
utils/llm_client.pyscript126.9 KB
utils/manual_tasks.pyscript14.9 KB
utils/metrics.pyscript68.1 KB
utils/next_phase.pyscript96.1 KB
utils/next_phase_words.pyscript6.4 KB
utils/output_handler.pyscript23.2 KB
utils/phase_walk.pyscript6.4 KB
utils/plan_updater.pyscript17.9 KB
utils/positionals.pyscript5.8 KB
utils/prior_changes.pyscript28.7 KB
utils/probe_state.pyscript17.9 KB
utils/process_capture.pyscript37.6 KB
utils/process_control.pyscript228.7 KB
utils/process_state.pyscript6.6 KB
utils/progress_tracker.pyscript92.2 KB
utils/prompt_channels.pyscript34.1 KB
utils/prompt_files.pyscript24.5 KB

hosts/capabilities.yaml

View on GitHub
# Host capability data (D5b) — one entry per host id, validated against
# schemas/host_capabilities.schema.json.
#
# WHAT THIS FILE IS. The verb -> mechanism map the host-neutral instruction core
# defers to. The core says *spawn subagents* / *ask the user* / *run detached*; the
# three fields `subagents`, `ask` and `detach` say what each one resolves to for a
# given host. That resolution is paid **once**, when a shim is rendered, and never
# per run by an agent.
#
# WHAT THIS FILE IS NOT. It is not on any agent read path. It is consumed by
# `multi_llm.py`, by `install-host`, by `hosts/render_capabilities.py` and by the
# tests. No instruction file and no shim ever tells an agent to open it or to open
# `references/host-capabilities.md` — the shim's baked sentence *is* the answer this
# matrix would have given. An agent reasoning over a capability table mid-workflow
# would be a worse instruction-following failure mode than the one this design
# removes.
#
# PROVENANCE IS LOAD-BEARING. Host docs churn faster than this design does, so
# every value carries a provenance: `verified` (a recorded live smoke observed it),
# `documented` (host docs only) or `unknown` (the shipping default). **A
# `documented`-only value never selects the non-conservative path.** Concretely,
# today: Codex and OpenCode are `subagents: executor` because spawn-from-exec is
# unconfirmed, and `detach: python`/`required` rather than trusting a raised command
# timeout. Promoting either is a one-line edit here, not a shim rewrite — but only
# once a smoke run has recorded it.
#
# A cell is `documented` until a recorded run has observed it, and most of them
# still are — which is why the conservative resolution is what executes. The
# `verified` cells each name the run that promoted them in a comment beside the
# entry, and `tests/test_host_capabilities.py`'s smoke ledger fails any promotion
# that does not.

version: 1

hosts:

  claude-code:
    # The reference host. There is deliberately no hosts/claude-code/shim.md.tmpl:
    # Claude Code loads a skill from <skill-root>/SKILL.md and nowhere else, so a
    # copy under hosts/ could only be dead text or a duplicate to keep in sync.
    # `installable: false` -> `install-host claude-code` is --check-only, and the
    # shim-correctness test asserts SKILL.md's three hand-written verb sentences are
    # byte-identical to what the renderer emits for this entry.
    shim: {template: null, installed: SKILL.md, format: markdown+frontmatter}
    # Rationale: this host's mandatory manifest is 23 lines on its own (a long
    # `description`, the rendered `argument-hint`, and 18 `allowed-tools` grants
    # that cannot be shortened without losing a permission). The shim *body* — what
    # the ~100-line budget is actually about — is 97 lines and still inside the
    # 100-line contract `DEFAULT_SHIM_MAX_LINES` holds every shim to; this key only
    # ever absorbed the frontmatter, and 120 is 23 + 97 exactly, so the next
    # addition is the same deliberate decision again rather than slack to spend.
    #
    # 110 -> 120 (2026-09-22): step 4 gained the truncation rule. Measured, not
    # defensive: Claude Code persists a Bash result over ~30 000 characters to a
    # file and returns a ~2.2 KB stub holding the output's *first 2 KB*, and seven
    # of the eleven cores are over that cap — so the read step this shim exists to
    # name silently delivered a fragment. Run 20260922T191142Z has one row that took
    # the fragment for the whole, never spawned a subagent, and reported four
    # batches applied with zero edits made. Step 4 now reads the core through
    # `util instructions <mode> --to-file` and a `Read` of the file it names
    # (docs/development/hosts.md, "The read step comes in three forms"); the printed
    # form keeps its head banner for the hosts and fallbacks that still use it.
    shim_max_lines: 120
    # The plugin-host baseline: the lowest build this skill was RUN on with all of
    # its host mechanisms working. A record, not a gate: nothing reads it to decide
    # anything, and the reviewer adapter's floor in utils/providers/claude_code.py
    # protects a different thing (the CLI's JSON result envelope).
    #
    # Measured 2026-11-07 on a throwaway HOME, `claude -p --permission-mode default
    # --plugin-dir <frozen tree>`, `openai/gpt-6-luna` through OpenRouter. A build
    # passes if the skill loads, `Agent` creates a subagent and `SendMessage` resumes
    # it. 2.1.319, 2.1.300, 2.1.280, 2.1.250 and 2.1.200 pass; 2.1.319 defers
    # `SendMessage` behind `ToolSearch`. 2.1.150 and 2.1.100 load the skill and create
    # a subagent but expose no `SendMessage`, so a batch cannot be resumed there.
    # Versions between 2.1.150 and 2.1.200 were not tried. Every run was headless, so
    # no interactive prompt was observed, and none reported a permission denial on
    # `Agent` or `SendMessage`.
    min_host_version: "2.1.200"
    installable: false
    install_paths:
      project: [".claude/skills/multi-llm"]
      global: ["$HOME/.claude/skills/multi-llm"]
      legacy: []
    reload: none
    arguments: placeholder            # $ARGUMENTS / ${CLAUDE_SKILL_DIR}
    # The plugin's own invocation, namespace included. `documented`, not
    # `verified`: no row has ever typed it into a Claude Code session — the
    # container lane drives this host headless with a prompt, exactly as the two
    # installable hosts' `documented` cells were before 2026-08-24.
    #
    # The trailing clause names the second install route: a copy under one of
    # `install_paths` is a plain skill, invoked without the plugin namespace. It
    # is appended, so the leading ``as `/`` `hosts/render_capabilities.py` keys
    # on is unchanged, and it is the prose `next_command.skill` is held to.
    invocation: "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`."
    # The next-phase command a finished phase ends its report with, per install
    # route (plans/next-phase-command.md §2.1). Read by `utils/next_phase.py` at
    # run time, so it is required. `default` is the plugin (the route
    # `invocation` documents first); `skill` is a copy under `install_paths`,
    # which `resolve_route` recognises from the dispatcher's own skill root.
    # `skill` is `verified` (2026-10-01, T10 of plans/next-phase-command.md,
    # claude-code 2.1.285): the container lane stages this host as a plain skill
    # under `$HOME/.claude/skills/multi-llm`, and `claude-code-next-command` ran
    # twice on that route: runs/20261001T114907Z on `openai/gpt-6-luna` through
    # OpenRouter, and runs/20261001T121548Z on `sonnet` through the Claude
    # subscription (`--creds fallback`). Each printed `/multi-llm --implement
    # "/work/sample-project/plans/next phase.md"`, and that command typed as the
    # whole prompt of a fresh `claude -p` session dispatched `implement` with the
    # fixture unquoted. NOT covered: `default` (the plugin route) has never been
    # typed by a recorded run (the lane cannot stage it) and stays `documented`;
    # the plugin's Stop hook (plain-skill staging loads no plugin hooks); and
    # typing into the TUI (both runs were headless `claude -p`).
    next_command:
      default: "/multi-llm:multi-llm {args}"
      skill: "/multi-llm {args}"
    multi_turn: true
    subagents: native
    ask: structured
    detach: native
    native_tool:
      # `Agent` is the tool's current name, and `Task` is its compatibility alias in
      # settings and agent definitions, so SKILL.md's `allowed-tools` keeps `Task`.
      # The spelling is not a permission fix: subagent launches need no permission.
      subagents: Agent
      ask: AskUserQuestion
      detach: run_in_background
    # No session rung: this host dispatches subagents natively through `Agent`
    # and picks their model from `subagent_tiers`, so there is nothing for a
    # session model to be substituted into — and nothing on the skill's side of
    # the boundary reads the session's selected model in the first place.
    session_runner_provider: null
    default_subagent_runner: "claude-code:sonnet"
    # subagents: native, so the tier -> model map lives here rather than in
    # providers.yaml driver.subagent_runner{,_cheap} (D2e).
    subagent_tiers: {full: sonnet, cheap: haiku}
    runners:
      claude-code: {bundled: true, needs_auth: false, login_cmd: "",
                    profiles: [generate, agent-readonly, agent-write], usage: full}
      cursor-agent: {bundled: false, needs_auth: true,
                     login_cmd: "cursor-agent login",
                     profiles: [generate], usage: partial}
    # In-session native dispatch: no process of ours sits between parent and child,
    # so there is nothing to strip and nothing to neutralize.
    nested_exec: {spawn: allowed, network: allowed, credentials: allowed,
                  notes: "Native subagents run in-session; the executor is not on
                    the default path for this host."}
    # Audited and non-empty: these are the variables Claude Code injects, which a
    # dispatched third-party runner must not inherit. Literal names only — a
    # wildcard would strip the runner's own credentials along with the guard.
    #
    # `passthrough` is EMPTY, and the entry that used to sit here is the reason
    # this comment is worth reading. It carried `ANTHROPIC_API_KEY`, sanctioned
    # as "an API key the host owns". `subagent_executor` re-admits every
    # passthrough name last, so that one cell silently cancelled M3/§2.1's
    # credential strip on the agent-profile lane while leaving it in force on
    # the fan-out lane: the same claude-code slot stripped the key on Lane A and
    # inherited it on Lane B, and the money bug the strip exists to close stayed
    # open for every subagent dispatch. Re-adding it would restore exactly that.
    #
    # The strip is not unconditional and does not need a passthrough as its
    # escape hatch: it is gated on the sanitized `claude auth status` preflight
    # and fails OPEN — an API-key-only user's key is preserved byte-for-byte —
    # and a user who wants it back unconditionally sets
    # `providers.claude-code.strip_vendor_keys: never` in providers.yaml, which
    # is a per-provider decision rather than a host-wide one.
    #
    # NOTE: this is a HOST-side allowlist, keyed by the host multi-llm is
    # *running inside*, not by the runner it dispatches. `codex` and `opencode`
    # both already carry `passthrough: []`, so emptying this one changes exactly
    # one situation: claude-code dispatched from inside claude-code.
    env_guards:
      guards: ["CLAUDECODE", "CLAUDE_CODE_ENTRYPOINT"]
      session_scoped: ["CLAUDE_SESSION_ID", "CLAUDE_SKILL_DIR"]
      passthrough: []
    max_concurrent_subagents: 10
    timeout_ceiling_s: 600            # Bash tool hard cap, silently clamped above
    timeout_override: {frontmatter: none, env: none, config: none}
    provenance:
      shim: documented
      shim_max_lines: verified      # counted on the file in the repo
      min_host_version: verified    # the runs in the comment beside the key
      installable: verified
      install_paths: documented
      reload: documented
      arguments: verified
      invocation: documented
      next_command: {default: documented, skill: verified}
      multi_turn: verified
      subagents: verified
      ask: verified
      detach: verified
      native_tool: verified
      session_runner_provider: documented
      default_subagent_runner: verified
      subagent_tiers: verified
      runners: documented
      nested_exec: documented
      env_guards: documented
      max_concurrent_subagents: documented
      timeout_ceiling_s: documented
      timeout_override: documented

  codex:
    # Same skills format, and no longer on paper. The 2026-08-24 container
    # documented-invocation row installed this shim into a fresh `$HOME` and codex
    # enumerated it, advertising `multi-llm` to the model inside
    # `<skills_instructions>` with its `SKILL.md` locator — so the format claim
    # itself is measured. What the same row measured is the half that claim never
    # covered, and it is a negative: see `invocation` below. A codex skill is
    # reached by the MODEL choosing to read it; the composer rejects `/multi-llm`
    # outright. `invocation` is therefore the one cell promoted to `verified` here.
    # shim/arguments/install_paths stay `documented`: that row graded the host's
    # command surface in one scope on one platform, not placeholder substitution
    # and not the rest of the path matrix, and a promotion may not claim more than
    # the run behind it.
    shim: {template: hosts/codex/shim.md.tmpl, installed: SKILL.md,
           format: markdown+frontmatter}
    installable: true
    install_paths:
      # A preferred entry names the directory to write into (the file name comes
      # from `shim.installed`); a legacy entry names the FILE, because a
      # deprecated layout's file name is the host's own old convention and not
      # ours. Deprecated Codex prompts were `~/.codex/prompts/<command>.md`, so
      # the copy to detect is `multi-llm.md` — probing `prompts/SKILL.md` would
      # be a path no install of any vintage ever created.
      project: [".codex/skills/multi-llm"]
      global: ["$HOME/.codex/skills/multi-llm"]
      legacy: ["$HOME/.codex/prompts/multi-llm.md"]
    reload: new-session
    arguments: placeholder
    # MEASURED 2026-08-24, codex-cli 0.146.0, container documented-invocation row,
    # and it is a NEGATIVE result: typing `/multi-llm --review-plan <plan>` into a
    # fresh composer prints `Unrecognized command '/multi-llm'` and sends nothing
    # at all — no request reached the stub. The `/` popup lists no skill, `/multi`
    # offers no completion, and a file at the deprecated `install_paths.legacy`
    # prompts location is rejected the same way. Headless, `codex exec "/multi-llm
    # …"` passes the line through verbatim. The shim IS discovered — codex
    # advertises it to the model inside `<skills_instructions>` with its `SKILL.md`
    # locator — so it is model-invoked rather than typed, which is what this
    # sentence has to say. Read into the generated pages after "Invoke it ".
    invocation: >-
      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`.
    # Per route (plans/next-phase-command.md §2.1). `default` is the file shim
    # `invocation` documents; `package` is the Codex plugin, the spelling
    # `package.invocation` documents. Both `verified` since T10 (2026-10-01) —
    # by a recorded run that typed the PRINTED command, never by derivation
    # from `invocation` (see the provenance row below for the runs).
    next_command:
      default: "Use the multi-llm skill with exactly these arguments: {args}"
      package: "$multi-llm:multi-llm {args}"
    multi_turn: true                 # documented, not observed: `codex exec`
                                     # runs a tool loop and `codex exec resume`
                                     # continues the session — either would give
                                     # the agent the follow-up turn.
    subagents: executor              # agents are GA in the TUI; spawn-from-exec is
                                     # unconfirmed, and the failure is
                                     # silent-then-fatal, so the exec profile is
                                     # `executor` until a recorded run says
                                     # otherwise. native_tool names the tool for
                                     # documentation, not for dispatch.
                                     #
                                     # EVIDENCE, NOT A PROMOTION (2026-08-25,
                                     # codex-cli 0.149.1, read out of the captured
                                     # tools[] array of a real headless request):
                                     # `multi_agent_v1` IS offered in `codex exec`,
                                     # carrying spawn_agent, wait_agent, send_input,
                                     # resume_agent and close_agent with a
                                     # documented model-override list. That closes
                                     # "is it offered" and leaves "does it work"
                                     # open, which is the half this cell grades — a
                                     # tool in the array is not a recorded run, and
                                     # the failure mode here is silent-then-fatal.
                                     # One detail a `native` promotion would have to
                                     # clear: spawn_agent's own description reads
                                     # "Do not spawn sub-agents unless the user or
                                     # applicable AGENTS.md/skill instructions
                                     # explicitly ask" — a skill CAN grant that
                                     # permission, so the lever exists.
    ask: free-text                   # request_user_input is Plan-Mode-only
                                     #
                                     # EVIDENCE, NOT A PROMOTION (same capture):
                                     # request_user_input is in the tool list and
                                     # its own description says "This tool is only
                                     # available in Plan mode." — which CONFIRMS the
                                     # line above rather than contradicting it, so
                                     # the cell does not move. What is new is a flag
                                     # to watch: `codex features list` reports
                                     # `default_mode_request_user_input under
                                     # development false`. That is the switch that
                                     # would make the tool generally available, so
                                     # re-probe it on each codex bump.
    detach: python
    native_tool:
      subagents: agent
    # The plugin's server exports the turn metadata's `model` (codex 0.156.1 sent `--model
    # stub-model` as `"model": "stub-model"`, 2026-09-25 package rows); no effort key rides along.
    session_runner_provider: codex
    # UNVALIDATED MODEL ID — THE ROSTER OWNS THE ID; THIS PIN FOLLOWS IT. This is
    # a credential-free floor (the last rung of `resolve_subagent_runner`'s
    # ladder, chosen so a zero-config install dispatches at all), not an
    # independent opinion about which model is current. `providers.yaml` is where
    # the codex model is actually chosen and re-measured (3f95a6e moved the whole
    # fan-out to gpt-6-astra against a live catalog), so the edit only ever runs
    # one way: the roster moves, then this pin. The fan-out's `:xhigh` effort
    # suffix does NOT come across — the floor takes the model's default effort
    # until somebody measures that it is not enough for a subagent dispatch.
    # No test resolves this id against a catalog (only kilocode has a captured
    # one), so this rule buys consistency, not correctness: after it, the pin is
    # wrong only when the roster is. Whoever finds a dead id edits
    # `providers.yaml` and lets this line follow.
    default_subagent_runner: "codex:gpt-6-astra"
    subagent_tiers: null             # forbidden to carry a map: subagents != native
    runners:
      codex: {bundled: true, needs_auth: false, login_cmd: "",
              profiles: [generate, agent-readonly, agent-write], usage: full}
      claude-code: {bundled: false, needs_auth: true, login_cmd: "claude login",
                    profiles: [generate, agent-readonly, agent-write], usage: full}
    nested_exec: {spawn: unknown, network: unknown, credentials: unknown,
                  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."}
    # Empty because the env diff has not run yet, not because the host is clean —
    # which is what provenance: unknown records.
    env_guards: {guards: [], session_scoped: [], passthrough: []}
    max_concurrent_subagents: 4
    timeout_ceiling_s: 0             # 0 = no documented cap on `codex exec`
    timeout_override: {frontmatter: none, env: unknown, config: unknown}
    # Shell output budget, read off codex-cli 0.167.0 (2026-11-08); a comment,
    # not a field, because no dispatch decision reads it. Every model in its
    # catalog carries `truncation_policy: {mode: tokens, limit: 10000}`, and both
    # shell tools (`exec_command`, code mode's `exec`) document `max_output_tokens`
    # as "Defaults to 10000 tokens", a budget the model may lower per call (the
    # `exec` tool's own example passes 1000). Over budget, codex keeps the head
    # and the tail, drops the middle (`…N tokens truncated…`) and counts about 4
    # bytes a token, so the file shim reads the core with `util instructions
    # --page` (multi_llm.CORE_PAGE_SIZE_DEFAULT; docs/development/hosts.md,
    # "Paged delivery").
    # A second install route — the Codex plugin marketplace — NOT a second host,
    # for the same reason as opencode's block below: every harness property above
    # is the same however the skill got installed. What the plugin adds is a
    # model-callable `multi_llm` tool (an MCP server bundled with the plugin) and
    # a thin skill advertised as `multi-llm:multi-llm` that points at it. A
    # plugin exposes no slash command (R21), so `provides` has no `command`.
    #
    # `update: reinstall` is two different commands from the install, not the
    # install re-run: `marketplace add` on a marketplace already added is a
    # no-op ("Marketplace … is already added", R37), so the upgrade is
    # `codex plugin marketplace upgrade` then `codex plugin add`, then a new
    # session (R30). The renderer's registry row owns that sentence.
    #
    # No `version`: the number is owned by `skills/multi-llm/pyproject.toml`,
    # and the codex end of that chain is the GENERATED
    # `.codex-plugin/plugin.json`, never a hand-typed copy here.
    package:
      registry: codex-marketplace
      name: multi-llm
      marketplace: beastlabai
      repo: beastlabai/multi-llm-plugin
      ref: release
      sparse: [.agents, packaging/codex]
                                      # The slug, the ref and the two sparse paths the first
                                      # install command needs. Cells rather than literals in
                                      # the shared form string, which every later
                                      # codex-marketplace package would inherit.
      config_key: plugins             # [plugins."multi-llm@beastlabai"] in $CODEX_HOME/config.toml (R15)
      provides: [skill, tool]         # NOT command (R21)
      update: reinstall               # `marketplace upgrade` then `plugin add` (R30/R37)
      write_posture: refuses-under-readonly
                                      # The server runs outside the session's exec sandbox
                                      # (R46), so an install hands a `--sandbox read-only`
                                      # session a write path it had refused (R45).
                                      # The server reads the session's posture per call
                                      # (`sandbox_mode` in codex's turn metadata, 0.156.1):
                                      # under `read-only`, or a posture it cannot read,
                                      # write-capable modes are refused before the spawn
                                      # unless MULTI_LLM_CODEX_UNSANDBOXED_WRITES=1 is in the
                                      # environment (D3b); `workspace-write` and
                                      # `danger-full-access` allow them. The renderer reads this cell into
                                      # the generated install paragraph, so a user meets it
                                      # before installing, not after.
      min_host_version: "0.159.2"     # the lowest codex the plugin route was RUN on (T10's container
                                      # rows, 2026-10-01, below), the schema's own wording — never the
                                      # container pin or packaging/codex/ingestion_rules.py's stamp, which
                                      # follow each pin bump; it moves on a measured break, and test_codex_route
                                      # holds it at or below both. Not bisected (Open question 5)
      invocation: >-
        with a `$` mention of the namespaced skill — `$multi-llm:multi-llm <the same
        arguments the Claude Code skill takes>`; plugins add no slash command, so
        `/multi-llm` stays unrecognized. If the model ever reworks the arguments,
        spell it out — `Use the multi-llm:multi-llm skill with exactly these
        arguments: <args>` — or let the model call the `multi_llm` tool directly.
    provenance:
      shim: documented
      installable: documented
      install_paths: documented
      reload: documented
      arguments: documented
      invocation: verified
      # PROMOTED BY T10 (plans/next-phase-command.md), codex-cli 0.159.2,
      # container rows `codex-next-command` / `codex-package-next-command`. Each
      # route ran `generate-tasks` on a fixture plan whose path holds a space
      # (`plans/next phase.md`), then handed the command its dispatcher printed
      # (`user_next_step.command`), verbatim and as the whole prompt, to a FRESH
      # headless `codex exec` session on the same route
      # (`entrypoint.run_typed_followup`). In both sessions on both routes the
      # dispatcher's own receipt then recorded `implement` with the plan
      # argument naming the fixture and holding no quote character:
      #   default: `Use the multi-llm skill with exactly these arguments:
      #     --implement "plans/next phase.md"` — runs/20261001T113914Z
      #     (~deepseek/deepseek-v4-flash-latest) and runs/20261001T115800Z
      #     (deepseek/deepseek-v4.1-flash), argv `plans/next phase.md`;
      #   package: `$multi-llm:multi-llm --implement "/work/sample-project/plans/
      #     next phase.md"` — the `$` mention, typed into `codex exec` — runs/
      #     20261001T113244Z (~deepseek/deepseek-v4-flash-latest) and runs/
      #     20261001T115346Z (deepseek/deepseek-v4.1-flash), a `multi_llm` tool
      #     call whose argv held the absolute fixture path unquoted. The plugin
      #     was installed from the image's local marketplace mirror, which is
      #     why `package` (the published Git route) below stays `documented`.
      # What it does NOT cover, and the cell claims no more: the interactive
      # composer (no row has typed either spelling into the TUI against a real
      # model — the `$` popup's own resolution is unmeasured), other platforms,
      # and the four other workflow modes' commands (one template, one row).
      next_command: {default: verified, package: verified}
      multi_turn: documented
      subagents: documented
      ask: documented
      detach: documented
      native_tool: documented
      session_runner_provider: verified   # the model key in codex-package-sandbox-posture's mcp-tap
      default_subagent_runner: documented
      subagent_tiers: documented
      runners: documented
      nested_exec: unknown
      env_guards: unknown
      max_concurrent_subagents: documented
      timeout_ceiling_s: unknown
      timeout_override: unknown
      # PROMOTED 2026-10-23 with the first release, codex-v0.1.0 (ae089856),
      # on the two Git-route records rule (j) asks for, never the container's
      # local-path installs: the offline Git-route row `codex-package-git-route`
      # (an ssh://localhost bare repository with `release` one commit behind,
      # `--ref release` and both `--sparse` paths; green on codex 0.159.2,
      # 0.163.0 and 0.164.0 in the stamped gate session 2bc2b6ca), and the
      # manual network check from GitHub itself,
      # tests/container/records/20261023T132656Z-codex-release-network-check.json
      # (a fresh stock-image container, codex 0.164.0, all six criteria pass
      # for the tag). After promotion the published `--ref release` line was
      # run the same way in a second fresh container: the snapshot resolved to
      # the tagged commit, all six criteria passed, and `marketplace upgrade` +
      # `plugin add` left the install byte-identical. Linux only.
      package: verified

  opencode:
    # commands/ is PLURAL — the singular command/ path is simply not scanned.
    shim: {template: hosts/opencode/shim.md.tmpl,
           installed: commands/multi-llm.md, format: markdown+frontmatter}
    installable: true
    install_paths:
      project: [".opencode/commands"]
      global: ["$XDG_CONFIG_HOME/opencode/commands", "$HOME/.config/opencode/commands"]
      # Empty on purpose, and `.opencode/command` is the entry that is NOT here:
      # OpenCode never scans the singular directory, so a file sitting in it is
      # not a copy that loads. Listing it would make `--check` report — and, as
      # the highest-precedence project location, *rank first* — a file the host
      # will never discover, marking the real install shadowed. A compatibility
      # location is a place an install of an older vintage really works, never
      # a place a file might merely exist.
      legacy: []
    reload: new-session
    arguments: placeholder           # $ARGUMENTS / $1 — verified: the message
                                     # text reaches the command body.
    # Measured, and a trap worth shipping: `opencode run` parses the message
    # with yargs, so an argument list that STARTS with a flag (`--ask …`,
    # `--review-plan …` — i.e. every invocation this skill takes) is swallowed
    # as an option and the run silently prints yargs' own help instead. The
    # `--` separator is mandatory headless. Harmless in the TUI, where
    # `/multi-llm --ask …` needs no separator.
    headless_invocation: 'opencode run --command multi-llm -- "<args>"'
    # MEASURED 2026-08-24, opencode 1.18.18, container documented-invocation row:
    # the published spelling WORKS in a fresh TUI session. Typing
    # `/multi-llm --review-plan <plan>` expanded the installed command into the
    # turn the host sent — the shim's own text, its dispatcher block with
    # `{SKILL_DIR}` already substituted, the baked `--host opencode --yes
    # --exec-subagents`, and the mode flag still adjacent to its argument. Read
    # into the generated pages after "Invoke it "; the headless correction above
    # is rendered separately, because `--command` is what resolves the shim
    # there, not this spelling.
    invocation: "as `/multi-llm <the same arguments the Claude Code skill takes>`."
    # Per route (plans/next-phase-command.md §2.1): the file shim and the npm
    # package both answer to `/multi-llm` (the package's `config` hook injects
    # the same command). Both `verified` since T10 (2026-10-01); the runs are
    # named on the provenance row below.
    next_command:
      default: "/multi-llm {args}"
      package: "/multi-llm {args}"
    # A second, recommended install route — NOT a second host. `reload`,
    # `subagents`, `ask`, `detach`, `max_concurrent_subagents` and
    # `timeout_ceiling_s` are properties of this harness, not of how the skill
    # got installed, so an `opencode-plugin` host id would duplicate every one
    # of them and split the matrix.
    #
    # What it buys over the file shim: the plugin computes the skill dir from
    # its own on-disk location at every startup, so there is no baked absolute
    # prefix to go stale and no `install-host --all` owed after an update. The
    # baked flags stop being prose a model may improvise past and become code
    # the plugin appends.
    #
    # `update: pinned-spec` is not a preference. The npm cache key is the
    # literal spec string and the installer early-returns whenever the package
    # directory already exists, so an unpinned entry resolves ONCE and never
    # again — bumping the pin is the only clean upgrade, and there is no
    # `opencode plugin update` command.
    #
    # `version` is a COPY. The number is owned by
    # `skills/multi-llm/pyproject.toml` — which ships *inside* the tarball, so a
    # package declaring a different one would ship a payload that disagrees with
    # it — and `test_version_source_is_singular` asserts the chain.
    #
    # `public_version` is the last version whose registry install check passed,
    # the one the generated paragraph and the hand-written README and
    # docs/hosts.md pins tell a user to pin. `version` is the candidate and moves
    # at every bump, so a recommendation built from it would name a version npm
    # does not serve yet. The schema requires `public_version` while
    # `provenance.package` below is `verified`, never newer than `version`. It
    # was set in the edit that promoted that row (0.1.1, backed by
    # records/20261026T175524Z-opencode-release-network-check.json), and it
    # moves only once the next version's registry record validates.
    package:
      registry: npm
      name: opencode-multi-llm
      version: "0.1.9"
      public_version: "0.1.8"
      config_key: plugin
      provides: [command, tool]
      min_host_version: "1.19.5"   # the one supported opencode release (the
                                    # newest; `make opencode-bump` moves it with
                                    # every other pin), never a lower one that
                                    # might work: `engines` is a hard gate, and
                                    # a floor asserted from an assumption either
                                    # admits a version that then fails somewhere
                                    # less legible or gets defended by a claim no
                                    # evidence backs.
      update: pinned-spec
      invocation: "as `/multi-llm <the same arguments the Claude Code skill takes>`, or by calling the `multi_llm` tool directly."
    multi_turn: true                 # measured: its agent takes further tool
                                     # turns inside one `opencode run` and acts
                                     # on what they printed — see the promotion
                                     # note below.
    subagents: executor              # `mode: subagent` dispatch is documented only;
                                     # dispatch is instructed in the command body,
                                     # never via frontmatter `subtask:` (which the
                                     # parser accepts and then ignores).
    ask: free-text                   # the `question` tool is unreliable headless
    detach: required                 # the ~120 s bash cap is documented, not
                                     # measured, and every fan-out mode runs far
                                     # longer than it, as does every apply mode
                                     # and `implement`, whose write batches the
                                     # executor runs inside the command — so no
                                     # foreground path is offered for either.
    native_tool:
      subagents: task
    # A CREDENTIAL-FREE FLOOR WITH A KNOWN EXPIRY, NOT A RECOMMENDATION (D3).
    # This is the last rung of `resolve_subagent_runner`'s ladder — what a user
    # who configured nothing falls to — so its one requirement is that it
    # dispatches on a fresh install with nothing logged in. It is NOT the
    # recommended validation runner: validation-grade work configures
    # `driver.subagent_runner` with a full-capability model (`providers.yaml`
    # ships `claude-code:sonnet` in that shape). `opencode/big-pickle` is a Zen
    # stealth id served from the same server-side catalog that retired
    # `opencode/sonnet`, so it is measured, dated, and re-probed on each
    # opencode bump — that re-probe is the gate on any commit that moves an
    # opencode version (container pin, `engines` floor, or a fixture
    # recapture), and `tests/test_container_host_lane.py`'s catalog diff is
    # what makes a skipped ritual visible.
    #
    # RE-PROBED 2026-11-06 on opencode 1.19.5 (the pinned build), zero
    # credentials: HOME and all four XDG dirs (XDG_CACHE_HOME too) at empty
    # scratch dirs (`opencode auth list` → `└  0 credentials`), every
    # `*_API_KEY` unset, never wrapped in `timeout` (which wedges `opencode
    # run`). The listing was taken twice with the same answer: from the host's
    # installed 1.19.5 and inside mllm-e2e:local (its real binary, not the
    # rig's PATH wrapper).
    # REFRESH FIRST. With an empty cache, and always under the image's
    # OPENCODE_DISABLE_MODELS_FETCH=1, `opencode models` answers from the
    # catalog built into the binary and writes no models.json. That copy still
    # listed `opencode/nemotron-3-ultra-free` on this day, although models.dev
    # already marked it `status: deprecated` and a fetched listing hides it.
    #   $ opencode models --refresh && opencode models | grep '^opencode/'
    #   opencode/beam-free                 opencode/glm-5.3-flash-free
    #   opencode/big-pickle                opencode/mimo-v2.6-flash-free
    #   opencode/crouton-alpha-free        opencode/nemotron-3.5-lightning-free
    #   opencode/deepseek-v4.1-flash-free  opencode/nemotron-3.5-super-vl-free
    #   opencode/flint-40b-free            opencode/pulse-alpha-free
    # The user's own HOME (its models.json fetched 2026-11-05) listed the same
    # 10 ids: the listing is a catalog, not an entitlement check. Gone since
    # 2026-09-11: `opencode/nemotron-3-ultra-free`, the one shipped id, which
    # providers.yaml replaced with `opencode/nemotron-3.5-super-vl-free`, the
    # listed Nemotron that is not the lightning id measured hanging below. Also
    # gone: ling-3.0-flash-fin-free, mimo-v2.5-free and both
    # muse-spark-*-contributor-free ids, none of them shipped.
    #   `opencode run --model <id> --print-logs --log-level ERROR
    #    "Reply with the single word OK."` (host build, same scratch pair)
    #   opencode/big-pickle                  exit 0, stdout `OK`, 2 s
    #   opencode/nemotron-3.5-super-vl-free  exit 0, stdout `OK`, 2 s
    # The floor stands. The validation-batch gate below was not re-run because
    # the floor did not move.
    # FIRST PROBED 2026-09-11 on opencode 1.18.30, the same recipe without the
    # refresh. It listed 7 `opencode/` ids: big-pickle, ling-3.0-flash-fin-free,
    # mimo-v2.5-free, muse-spark-1.2-contributor-free,
    # muse-spark-1.3-contributor-free, nemotron-3-ultra-free and
    # nemotron-3.5-lightning-free. It listed no `opencode/sonnet`,
    # `opencode/deepseek-v4-flash-free` or `opencode/hy3-free`, and all three
    # were dropped from providers.yaml the same day. The same `OK` prompt gave:
    #   opencode/big-pickle                 exit 0, stdout `OK`, a few seconds
    #   opencode/nemotron-3.5-lightning-free zero bytes on either stream >7 min,
    #                                        killed (exit 143)
    #   opencode/sonnet                     exit 1, `ProviderModelNotFoundError:
    #                                        Model not found: opencode/sonnet`
    # The `*-free` siblings are NOT automatically the safer alternative. The
    # lightning id reproduced the zero-byte hang, which costs `default_timeout`
    # per task. One answering `OK` (super-vl, 2026-11-06) has passed only that
    # check, not the validation-batch gate below.
    # VALIDATION-BATCH GATE (existence is not fitness), MEASURED 2026-09-11
    # from the same zero-credential pair, opencode 1.18.30: a scratch git repo
    # whose `.multi-llm/providers.yaml` set `driver.subagent_runner:
    # opencode:opencode/big-pickle` (and `quick_models` to the same id, so the
    # whole run was credential-free), `multi_llm.py review-plan plans/tiny.md
    # --host opencode --yes --quick --exec-subagents` over the 285-byte
    # tests/fixtures/sample_plan.md: 12 suggestions → 10 groups → 7
    # `agent-readonly` validation batches; `subagent_batch_report.json`
    # `counts: {ok: 7}`, 0 unparseable_result, 0 schema_invalid, 7 attempts,
    # 34,679 tokens at `cost_usd: 0.0`, batches 4.5–29 s each; `validation.json`
    # carried 10 per-group verdicts each with its own reason and confidence
    # (0.85–0.98). Exit 0, 77 s wall clock.
    # The preflight itself, same pair, completes rather than exiting 3:
    # `auth: not-required`, `model_catalog: ok`, `nested_exec: allowed`, while
    # `opencode:openrouter/deepseek/deepseek-v4-flash-0731` on the same CLI in
    # the same process is refused `not_authenticated`.
    # If this id vanishes: the replacement is whichever `opencode/*` id answers
    # `OK` from a zero-credential HOME AND clears the validation-batch gate; if
    # none does, opencode has no credential-free default — drop the entry from
    # `OpenCodeProvider.credential_free_models` in the same commit and let the
    # out-of-the-box run refuse `not_authenticated` with its login hint.
    # THE FLOOR IS THE NEWEST RELEASE (policy since 2026-10-02): opencode is
    # supported on its newest release only, so `min_host_version` above,
    # `engines.opencode`, the adapter's `min_version`/`verified_version` and the
    # container's pin are one version, the one the parser fixtures were
    # captured from. `make opencode-bump VERSION=<x.y.z>` moves them together
    # (never below the current pin without ALLOW_DOWNGRADE=1), and
    # `tests/test_opencode_version_pins.py` fails the build when one did not.
    # THE SESSION RUNG (`resolve_subagent_runner`, layer `session`). Names the
    # CLI of this host's own that can be pointed at whatever model the *session*
    # is currently running on, which the plugin exports as
    # `MULTI_LLM_HOST_SESSION_MODEL` (owned by `utils/provider_registry.py`; the
    # plugin reads the name out of the generated cli-surface.json and never
    # spells it in JS). The rung sits below every explicit `driver.*` layer and
    # above `default_subagent_runner`.
    #
    # WHY. A `--review-plan --quick` run launched from the TUI with
    # "Nemotron 3 Ultra Free · OpenCode Zen" selected validated all sixteen of
    # its batches on `opencode/big-pickle`: no layer above the floor had an
    # opinion, and the floor is a credential-free *default*, not a choice anyone
    # made. The session's own model is the nearest thing to an operator opinion
    # that exists when no config file does.
    #
    # MEASURED 2026-09-11, opencode 1.18.30 (the installed build), never wrapped
    # in `timeout`:
    #   $ opencode run --model opencode/nemotron-3-ultra-free \
    #       "Reply with the single word OK."
    #   OK                                 exit 0, 62 s
    # (That id has since been deprecated and is unlisted on 2026-11-06; see the
    # re-probe above. The claim here is about the mechanism, not that id.)
    # So `opencode run --model <the session's own id>` really serves a TUI model
    # id, which is the whole claim this field makes. `opencode/big-pickle` stays
    # the credential-free floor below it, and the fallback is what keeps the
    # rung safe: a session model that fails preflight for any reason (a private
    # id, a logged-out provider, an unresolvable slug) drops to the next rung
    # with one printed line rather than refusing the batch.
    session_runner_provider: opencode
    default_subagent_runner: "opencode:opencode/big-pickle"
    subagent_tiers: null
    runners:
      opencode: {bundled: true, needs_auth: false, login_cmd: "",
                 profiles: [generate, agent-readonly, agent-write], usage: full}
      claude-code: {bundled: false, needs_auth: true, login_cmd: "claude login",
                    profiles: [generate, agent-readonly, agent-write], usage: full}
    nested_exec: {spawn: unknown, network: unknown, credentials: unknown,
                  notes: "Filled by the Phase 3 nested-exec smoke from inside
                    `opencode run`."}
    env_guards: {guards: [], session_scoped: [], passthrough: []}
    max_concurrent_subagents: 4
    timeout_ceiling_s: 120           # documented default bash timeout
    # No `timeout` field exists in the V2 command contract, so the ceiling moves
    # only through the environment/config surface — and the installer only ever
    # writes through a non-`none` channel.
    timeout_override: {frontmatter: none, env: unknown, config: unknown}
    # Promoted from a recorded smoke on opencode 1.18.12 (2026-08-08): the
    # installed command was discovered by name in a new session, its uv
    # preflight ran ahead of the first `uv run`, the baked prefix resolved, and
    # a `--detach`ed `ask` fan-out was polled through `status --wait` to a
    # terminal `done` and its answers file read back. That same run settles
    # `multi_turn`, which had shipped `false` on nothing: its agent took four
    # tool turns inside a single `opencode run` — `command -v uv`, then
    # `util instructions status`, then `status`, then a read of the answers —
    # and followed `MULTI_LLM_RESULT.next` on its own initiative, which is
    # precisely the follow-up turn the field claims. Everything that run did
    # not exercise stays where it was — in particular `subagents` (no subagent
    # was dispatched) and `ask` (nothing was asked), which is what keeps the
    # conservative resolution in force.
    provenance:
      shim: verified
      installable: verified
      install_paths: verified
      reload: verified
      arguments: verified
      headless_invocation: verified
      # PROMOTED BY THE FIRST RELEASE'S REGISTRY CHECK (opencode-v0.1.1,
      # f4f024c7, 2026-10-26). The criterion was always a *registry* install,
      # never a local build, which is why the container lane's `route: package`
      # rows (a LOCAL DIRECTORY at `/opt/mllm/opencode-plugin`, since
      # 2026-09-19) never promoted it. `make opencode-registry-check
      # ENVIRONMENT=container` installed `opencode-multi-llm@0.1.1` from
      # registry.npmjs.org into a stock node:22-bookworm-slim container with
      # opencode 1.19.4 and empty caches, and passed all eight first-release
      # criteria: the spec resolves with the gated integrity, the installed
      # tree equals the candidate rebuilt from the tag, `/multi-llm` resolves
      # the installed skill, the `multi_llm` tool runs `init` from that payload,
      # first use installs the runtime dependencies, a warm `status` runs with
      # the network cut, and a restart on the same pin serves the same payload
      # (records/20261026T175524Z-opencode-release-network-check.json, validated
      # by `registry_record.py validate --profile release`). What it does NOT
      # cover: macOS and Windows (Linux only, as packaging/opencode/README.md
      # says), or an upgrade from an earlier npm version (none existed at
      # that first release). The later-release proof below covers upgrades.
      # RECHECKED 2026-10-30 for opencode-v0.1.3 on OpenCode 1.19.5.
      # A fresh npm install passed all nine later-release criteria, including
      # offline use, same-pin restart, and an upgrade from 0.1.1 executing
      # the new payload (records/20261030T214755Z-opencode-release-network-check.json).
      # RECHECKED 2026-11-01 for opencode-v0.1.4 on OpenCode 1.19.5.
      # All nine registry criteria passed, including offline operation and
      # a 0.1.3 -> 0.1.4 upgrade executing the newly installed payload
      # (records/20261101T061412Z-opencode-release-network-check.json).
      # RECHECKED 2026-11-12 for opencode-v0.1.8 on OpenCode 1.19.5.
      # All nine registry criteria passed, including offline operation and
      # a 0.1.4 -> 0.1.8 upgrade executing the newly installed payload
      # (records/20261112T160945Z-opencode-release-network-check.json).
      package: verified
      invocation: verified
      # PROMOTED BY T10 (plans/next-phase-command.md), opencode 1.18.33,
      # container rows `opencode-next-command` / `opencode-package-next-command`.
      # Each route ran `generate-tasks` on `plans/next phase.md`, then handed the
      # PRINTED command to a FRESH `opencode run` on the same route through the
      # host's verified headless spelling, `--command multi-llm -- <args>` — the
      # command's own `/multi-llm ` prefix is what `--command multi-llm` names,
      # and the argument string is the printed one, byte for byte (`opencode run
      # -- "/multi-llm …"` never expands, measured on the documented-invocation
      # row, which separately verified the TUI's `/multi-llm` resolution). The
      # dispatcher's own receipt then recorded `implement` with the fixture as
      # its plan argument and no quote character in it:
      #   default: `--implement "plans/next phase.md"` — runs/20261001T113344Z
      #     (~deepseek/deepseek-v4-flash-latest) and runs/20261001T115548Z
      #     (deepseek/deepseek-v4.1-flash), a shell dispatch;
      #   package: `--implement "/work/sample-project/plans/next phase.md"` —
      #     runs/20261001T112645Z (~deepseek/deepseek-v4-flash-latest) and
      #     runs/20261001T115138Z (deepseek/deepseek-v4.1-flash), a `multi_llm`
      #     tool call. The plugin was the image's local-directory install, which
      #     is why `package` (a registry install) above stays `documented`.
      # Not covered: a real model typing into the TUI, other platforms, and the
      # other modes' commands. (Both default-route runs' FINAL MESSAGES left the
      # optional review-tasks command unfenced — criterion 4, a separate
      # question this cell does not grade.)
      next_command: {default: verified, package: verified}
      multi_turn: verified
      subagents: documented
      ask: documented
      detach: verified
      native_tool: documented
      session_runner_provider: documented
      default_subagent_runner: documented
      subagent_tiers: documented
      runners: documented
      nested_exec: unknown
      env_guards: unknown
      max_concurrent_subagents: documented
      timeout_ceiling_s: documented
      timeout_override: unknown
receiving-code-reviewobra/superpowersUse when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementationStars: 322kUpdated Claude CodeCodexVerifiedInstall
requesting-code-reviewobra/superpowersUse when completing tasks, implementing major features, or before merging to verify work meets requirementsStars: 322kUpdated Claude CodeCodexVerifiedInstall
using-git-worktreesobra/superpowersUse when starting feature work that needs isolation from current workspace or before executing implementation plans - ensures an isolated workspace exists via native tools or git worktree fallbackStars: 322kUpdated Claude CodeCodexVerifiedInstall
verification-before-completionobra/superpowersUse when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions alwaysStars: 322kUpdated Claude CodeCodexVerifiedInstall