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

utils/commit_spelling.py

View on GitHub
"""The commit spelling hook: print a commit review's commands as the commit modes.

The two phase front doors re-record their run as the phase they front
(``review-commits`` as ``review-code``, ``apply-commit-fixes`` as
``apply-code-fixes``), so detach, ``status``, run records and the next-step
table all see one phase vocabulary (plans/review-commits.md §2.1, "What step 7
records"). Left alone, every command those readers print would then read
``apply-code-fixes <brief> --base-ref <sha> --head-ref <sha>``: a fronted mode
word plus three flags the front doors refuse with ``[COMMIT_FLAG_CONFLICT]``.

This module is the one place that turns such a command back into the commit
spelling (§2.8, "Spelling of commands"): when the anchor's ``state.json`` holds
``commit_range``, the mode word is mapped back through ``modes.Mode.
commit_view_of``, the plan argument becomes the pinned ``<base12>..<head12>``
(the brief path for a range that starts at the root commit), and the flags the
front door synthesised or consumes are dropped. A plan's run, and a direct
``review-code --head-ref`` run (``head_ref`` only), are never mapped: the plan
is still called a plan and the commands stay review-code's own.

It also owns the second, row-keyed mapping (§2.8, "A second mapping site"):
on a composite whose positional is a range (``improve-commits``) the step words
``review-code`` / ``apply-code-fixes`` read as the commit modes in lines a user
reads, with no anchor state to key on.

Pure apart from reading one ``state.json`` (read-only, no lock, no git call).
"""

from __future__ import annotations

from dataclasses import dataclass
from pathlib import Path
from typing import Any, List, Mapping, Optional, Sequence, Tuple, Union

from .state_file import STATE_FILENAME, read_document
import modes as mode_table
from .output_handler import output_dir_path
from .cli_common import dispatcher_command, retry_command

#: Flags a front door synthesises or consumes; a printed commit command never
#: carries one (the front doors refuse the first three, and the rest are
#: either hidden plumbing or inherited from ``commit_range``).
DROPPED_FLAGS: Tuple[str, ...] = (
    "--plan-file", "--base-ref", "--head-ref", "--commit-stage", "--revs",
    "--focus", "--context-plan",
)


@dataclass(frozen=True)
class CommitView:
    """What a rendered command needs to know about a commit review."""

    brief: str
    base: Optional[str]
    head: str

    @property
    def pinned(self) -> str:
        """The range as typed back: ``<base12>..<head12>``, or the brief path
        for a range that starts at the root commit (§2.2, "What is typed back")."""
        if self.base:
            return f"{self.base[:12]}..{self.head[:12]}"
        return self.brief


def _state_path_for(plan: Union[str, Path]) -> Path:
    return output_dir_path(Path(plan)) / STATE_FILENAME


def _read_state(plan: Union[str, Path]) -> Optional[Mapping[str, Any]]:
    return read_document(_state_path_for(plan))


def commit_view(
    anchor: Union[None, str, Path, Mapping[str, Any]],
    *,
    plan: Union[None, str, Path] = None,
) -> Optional[CommitView]:
    """The commit review behind *anchor*, or ``None`` for anything else.

    *anchor* is a plan/brief path (its ``state.json`` is read) or an already
    loaded state mapping. With a mapping, *plan* names the brief as the caller
    spells it; else the record's own ``brief`` (repo-relative) is used.
    """
    if anchor is None:
        return None
    if isinstance(anchor, Mapping):
        state: Optional[Mapping[str, Any]] = anchor
    else:
        state = _read_state(anchor)
        plan = anchor if plan is None else plan
    if not state:
        return None
    record = state.get("commit_range")
    if not isinstance(record, Mapping):
        return None
    head = record.get("head")
    if not isinstance(head, str) or not head:
        return None
    base = record.get("base")
    brief = str(plan) if plan is not None else str(record.get("brief") or "")
    return CommitView(brief=brief, base=base if isinstance(base, str) and base else None,
                      head=head)


def spell_mode(mode: str, view: Optional[CommitView]) -> str:
    """``review-code`` → ``review-commits`` and ``apply-code-fixes`` →
    ``apply-commit-fixes`` for a commit review; every other word unchanged."""
    if view is None:
        return mode

    for row in mode_table.MODES:
        if row.commit_view_of == mode:
            return row.name
    return mode


def strip_fronted_flags(args: Sequence[Union[str, Path]]) -> List[str]:
    """*args* without :data:`DROPPED_FLAGS` (and their values, ``--x=v`` too)."""
    kept: List[str] = []
    index = 0
    items = [str(arg) for arg in args]
    while index < len(items):
        token = items[index]
        name = token.split("=", 1)[0]
        if name in DROPPED_FLAGS:
            index += 1 if "=" in token else 2
            continue
        kept.append(token)
        index += 1
    return kept


def spell_args(
    mode: str,
    plan: Union[None, str, Path],
    args: Sequence[Union[str, Path]],
    view: Optional[CommitView],
) -> Tuple[str, List[str]]:
    """``(mode, [plan, *args])`` in the commit spelling when *view* is set.

    Without a view the mode, plan and flags come back unchanged (the plan
    first, when given), so a caller can route every command through here.
    """
    if view is None:
        head = [str(plan)] if plan is not None else []
        return mode, head + [str(arg) for arg in args]
    return spell_mode(mode, view), [view.pinned] + strip_fronted_flags(args)


def spell_command(
    mode: str,
    plan: Union[None, str, Path],
    *args: Union[str, Path],
    view: Optional[CommitView] = None,
    base: Optional[Path] = None,
) -> str:
    """``dispatcher_command`` in the commit spelling (unchanged without a view)."""

    word, rest = spell_args(mode, plan, args, view)
    return dispatcher_command(word, *rest, base=base)


def step_word(row_name: str, word: str) -> str:
    """The row-keyed mapping: a composite step word as the user reads it.

    On a composite row whose positional is a range (``improve-commits``), each
    sequence word is spelled through the front-door row whose
    ``commit_view_of`` names it. improve-plan and improve-code keep their words.
    """

    row = mode_table.resolve(row_name)
    if row is None or not row.is_composite:
        return word
    if tuple(row.positionals) != (mode_table.POS_REVS,):
        return word
    for other in mode_table.MODES:
        if other.commit_view_of == word:
            return other.name
    return word


def spell_retry_command(
    mode: str,
    plan_path: Union[str, Path],
    *args: Union[str, Path],
    typed_plan: Union[None, str, Path] = None,
    flags: Optional[Sequence[str]] = None,
    base: Optional[Path] = None,
) -> str:
    """``cli_common.retry_command`` in the commit spelling on a commit review.

    *plan_path* locates the run's ``state.json``; *typed_plan* is the plan as
    the command should spell it when no mapping applies (defaults to
    *plan_path*). On a commit review whose *mode* maps to a commit mode
    (``review-code`` → ``review-commits``), the command names the pinned range
    and carries none of the flags a front door synthesises or consumes, in
    *args* or in the replayed *flags*: ``review-commits <pinned> --reaggregate``
    goes back through the front door, which forwards the verb and restarts
    nothing. A plan's run and a direct ``--head-ref`` run keep the command byte
    for byte (review D, finding 3; plans/review-commits.md §5 "Follow-up
    commands").
    """

    view = commit_view(plan_path)
    word = spell_mode(mode, view)
    if view is None or word == mode:
        shown = typed_plan if typed_plan is not None else plan_path
        return retry_command(mode, shown, *args, flags=flags, base=base)
    return retry_command(
        word, view.pinned, *strip_fronted_flags(args),
        flags=strip_fronted_flags(flags) if flags is not None else None,
        base=base,
    )
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: 319kUpdated Claude CodeCodexVerifiedInstall
requesting-code-reviewobra/superpowersUse when completing tasks, implementing major features, or before merging to verify work meets requirementsStars: 319kUpdated 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: 319kUpdated 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: 319kUpdated Claude CodeCodexVerifiedInstall