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

references/summary-format.md

View on GitHub
# 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.
    Any lookup can print a `[RUNNER_WARNING]` line above the `[NEXT_COMMAND]`
    block, when the command it names would be refused for the runner the
    config resolves to; neither the markdown nor the rest of `user_next_step`
    carries it (on a tool route it stays in the result's `output`): give the
    text after its tag verbatim in the report too, as plain text, 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).
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: 321kUpdated Claude CodeCodexVerifiedInstall
requesting-code-reviewobra/superpowersUse when completing tasks, implementing major features, or before merging to verify work meets requirementsStars: 321kUpdated 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: 321kUpdated 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: 321kUpdated Claude CodeCodexVerifiedInstall