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_write_guard.py

View on GitHub
"""The commit write policy's write legs: what a commit review's apply
re-checks before each batch is dispatched.

The apply guard (``utils/commit_apply.py``) decides once and saves what
each fix file must still hold; these helpers read it back, and the
scheduler's ``_dispatch_one``, ``util write-prompt`` and ``util
batch-done`` share them. The lowest of the scheduler's helper modules: it
imports none of the others.

``utils.write_batch_scheduler`` re-exports every name defined here for
reading only: patch one here, never through the scheduler
(docs/development/write-scheduler.md#where-the-schedulers-helpers-live).
"""

from __future__ import annotations

import json
import os
import posixpath
from pathlib import Path
from typing import Any, Dict, List, Mapping, Optional, Sequence, Tuple, Union

from . import git_utils as _git_utils
from .subagent_tasks import declared_file_set
from .write_safety import file_sha256
from .commit_range import pinned_record
from .code_fix_batcher import fix_member_ids


# ---------------------------------------------------------------------------
# The commit write policy's write legs (plans/review-commits.md §2.7: "Every
# batch is re-checked immediately before it is dispatched" and "The commit
# write policy"). The apply guard (``utils/commit_apply.py``) decides once,
# before human decisions and batching, and saves under the pinned record
# (``commit_range`` or ``head_ref``) the content each fix file must still
# have and the protected set. These helpers are what the executor's
# ``_dispatch_one``, ``util write-prompt`` and ``util batch-done`` share. Every
# one of them is a no-op without a guard, and ``utils.commit_apply`` is only
# imported once one exists, so a run on a plan is untouched by any of this.
# ---------------------------------------------------------------------------

#: The one write kind the apply guard governs: its groups are review fixes.
COMMIT_GUARD_KIND = "apply_code_fixes"

#: The phase output whose batches carry each fix's ``files`` on a commit
#: review's apply (``ApplyCodeFixesOrchestrator.format_item_for_output``:
#: every distinct file the fix's group names, in git's form, primary first).
#: Both legs read a batch's fix files from it: the materialized write task
#: carries only the batch's primary file (``declared_files``).
ORCHESTRATOR_OUTPUT_FILENAME = "orchestrator_output.json"


def commit_guard_of(state: Any, kind: Optional[str] = None) -> Optional[Dict[str, Any]]:
    """The live apply guard (``<pinned record>.guard``) of a raw state dict,
    to mutate in place, or ``None``: no dict, no pinned record
    (``commit_range.pinned_record``), no guard in it, or a *kind* the guard
    does not govern."""
    if kind is not None and kind != COMMIT_GUARD_KIND:
        return None
    if not isinstance(state, dict) or not (
        "commit_range" in state or "head_ref" in state
    ):
        return None
    record = pinned_record(state)
    guard = record.get("guard") if isinstance(record, Mapping) else None
    return guard if isinstance(guard, dict) and guard else None


def load_commit_apply() -> Any:
    """``utils.commit_apply``, imported only once a guard exists."""
    # Imported at call time on purpose: tests stand a fake `utils.commit_apply` in `sys.modules` and
    # reach it only through this call.
    from . import commit_apply
    return commit_apply


def commit_head7(guard: Mapping[str, Any]) -> str:
    """The reviewed head's seven-character spelling every commit line uses."""
    return str(guard.get("head") or "")[:7]


def commit_protected_rule(guard: Mapping[str, Any]) -> str:
    """The rule text of the protected set's deny layer: ``changed since
    reviewed commit <head7>``."""
    return f"changed since reviewed commit {commit_head7(guard)}"


def load_orchestrator_batches(phase_dir: Union[str, Path]) -> Optional[List[Any]]:
    """The ``batches`` of ``<phase_dir>/orchestrator_output.json``, or
    ``None`` when the file is absent or cannot be read."""
    try:
        document = json.loads(
            (Path(phase_dir) / ORCHESTRATOR_OUTPUT_FILENAME).read_text(encoding="utf-8")
        )
    except (OSError, ValueError):
        return None
    batches = document.get("batches") if isinstance(document, dict) else None
    return batches if isinstance(batches, list) else None


def batch_fixes_for(
    task: Mapping[str, Any], batches: Optional[Sequence[Any]],
) -> Optional[List[Dict[str, Any]]]:
    """The fixes of *task*'s batch in *batches* (``orchestrator_output.json``'s):
    the batch at the task's ``batch_index`` when its member ids
    (``code_fix_batcher.fix_member_ids``) are the task's ``expected_ids``,
    else the first batch whose are; ``None`` when none matches (an output
    from another run is never read as this one's)."""
    if not batches:
        return None
    expected = [str(item) for item in task.get("expected_ids") or []]
    index = task.get("batch_index")
    ordered = list(batches)
    if isinstance(index, int) and 0 <= index < len(ordered):
        ordered.insert(0, ordered[index])
    for batch in ordered:
        fixes = batch.get("fixes") if isinstance(batch, Mapping) else None
        if not isinstance(fixes, list) or not all(isinstance(f, dict) for f in fixes):
            continue
        if expected and fix_member_ids(fixes) == expected:
            return fixes
    return None


def commit_group_files(
    task: Mapping[str, Any], *, repo_root: Optional[str] = None,
    fixes: Optional[Sequence[Mapping[str, Any]]] = None,
) -> Dict[str, List[str]]:
    """``{group id: [fix files]}`` for one apply-code-fixes write task, each
    file repo-relative in git's form (``git_utils.git_path``): the batch's
    declared (primary) file, then every file the group's fix names in
    *fixes* (:func:`batch_fixes_for`: its ``files``, else its ``file``).
    Without *fixes* a group's fix files are the declared ones."""
    def form(path: Any) -> str:
        try:
            name = _git_utils.git_path(str(path), repo_root)
        except Exception:  # noqa: BLE001 - a name is still a name
            name = str(path).replace(os.sep, "/")
        # `..` resolved lexically, as the guard's own names are
        # (`commit_apply._git_name`), so `docs/../a.py` meets its `a.py` key.
        if name and not os.path.isabs(name) and ".." in name.split("/"):
            name = posixpath.normpath(name)
        return name

    declared: List[str] = []
    for path in declared_file_set(dict(task)):
        name = form(path)
        if name and name not in declared:
            declared.append(name)
    named: Dict[str, List[str]] = {}
    if fixes:
        for member_id, fix in zip(fix_member_ids([dict(f) for f in fixes]), fixes):
            listed = fix.get("files")
            if not isinstance(listed, (list, tuple)):
                listed = [fix.get("file")]
            named[str(member_id)] = [
                str(path) for path in listed if isinstance(path, str) and path.strip()
            ]
    groups: Dict[str, List[str]] = {}
    for group_id in task.get("expected_ids") or []:
        group_id = str(group_id)
        if not group_id:
            continue
        files = list(declared)
        for path in named.get(group_id, ()):
            name = form(path)
            if name and name not in files:
                files.append(name)
        groups[group_id] = files
    return groups


def commit_recheck_failing(
    guard: Mapping[str, Any], groups: Mapping[str, Sequence[str]], *,
    repo_root: str, commit_apply: Any = None,
) -> List[str]:
    """The fix files of *groups* the pre-dispatch re-check fails, in the
    batch's order: ``commit_apply.recheck_files``' answer over every fix
    file the batch declares (each against its saved ``head`` or ``batch``
    identity), plus each one in the saved protected set (§2.7, "Every
    target, before dispatch": a fix that names a protected path is skipped
    like a guard skip)."""
    commit_apply = commit_apply or load_commit_apply()
    files: List[str] = []
    for group_files in groups.values():
        for path in group_files:
            if path not in files:
                files.append(path)
    if not files:
        return []

    def sha256_of(path: str) -> Optional[str]:
        return file_sha256(path if os.path.isabs(path) else os.path.join(repo_root, path))

    failing = {
        str(path) for path in commit_apply.recheck_files(
            guard, files, cwd=repo_root, file_sha256=sha256_of,
        ) or ()
    }
    protected = guard.get("protected")
    if isinstance(protected, Mapping):
        failing |= {path for path in files if path in protected}
    return [path for path in files if path in failing] + sorted(failing - set(files))


def commit_stale_split(
    groups: Mapping[str, Sequence[str]], failing: Sequence[str],
) -> Tuple[List[str], List[str]]:
    """``(skipped, held back)``: the groups that name a failing file, and
    the batch's other groups, which are held back rather than lost."""
    bad = set(failing)
    skipped = [gid for gid, files in groups.items() if bad.intersection(files)]
    return skipped, [gid for gid in groups if gid not in skipped]


def commit_stale_line(
    task_id: str, failing: Sequence[str], guard: Mapping[str, Any], *,
    marker: str = "[COMMIT_FIXES_STALE]",
) -> str:
    """``[COMMIT_FIXES_STALE] <task id>: <files> changed since reviewed
    commit <head7>``, both legs' line for a batch the re-check stops."""
    return (
        f"{marker} {task_id}: {', '.join(failing)} changed since reviewed "
        f"commit {commit_head7(guard)}"
    )


def commit_stale_reason(
    failing: Sequence[str], guard: Mapping[str, Any], *, held: bool,
) -> str:
    """The reason a stopped batch is recorded ``failed`` with: ``held back:
    batched with <files>`` when some of its groups passed (a ``--resume``
    re-batches them without the skipped ones), else the skip itself."""
    if held:
        return f"held back: batched with {', '.join(failing)}"
    return f"skipped: {', '.join(failing)} {commit_protected_rule(guard)}"
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