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/failure_capture.py

View on GitHub
"""What the executor writes about a run, and the redaction every one of
those writes goes through first.

``redact.redact_text`` (the one redactor, imported here and applied
before any tail or cut) and :func:`_redact_json` (the same over a JSON
payload), :func:`_redact_probe_tail` (the boundary a probe's
stream crosses before it reaches a message), :func:`_atomic_write_json`
(owner-only, same-directory temp file, ``os.replace``) and the
per-attempt diagnostic captures under ``failed/``
(:func:`_write_failure_capture`, D3k). It imports none of the executor's
other modules.

``utils.subagent_executor`` re-exports every name defined here for reading
only: patch one here, never through the executor
(docs/development/delegation.md#where-the-executors-helpers-live).
"""

from __future__ import annotations

import hashlib
import json
import re
from datetime import datetime, timezone
from pathlib import Path
from typing import Any, Dict, Optional, Sequence

from .held_folder import plan_dir_of, write_in_plan_dir
from .retry_ladder import (  # noqa: F401 - re-exported, see below
    RUNG_BY_STATUS,
)
from .redact import redact_text
from .write_safety import (
    WriteSafetyError,
    contain_local_path,
    rename_below_root,
    write_below_root,
)


#: Per-attempt diagnostic captures (D3k). A directory, so the reaggregation glob
#: (``{phase_dir}/*.json``) never sees them.
FAILED_CAPTURE_DIRNAME = "failed"

#: Per-stream diagnostic capture cap (D3k): last 64 KiB each of stdout/stderr.
MAX_CAPTURE_BYTES = 64 * 1024


def _atomic_write_json(path: str, data: Any) -> bytes:
    """Write ``data`` as JSON, owner-only (0600), by ``atomic_io``'s atomic write;
    the bytes written.

    An executor killed mid-batch (expected on the D4 detached path) therefore
    never leaves a half-written result for the reaggregation glob to pick up.
    The file is published through its folder held below the plan's directory,
    made there if missing (``held_folder.write_in_plan_dir``): a link swapped
    in for the phase folder during the run is refused, never written through
    (docs/development/write-safety.md#plan-output-containment).
    """
    encoded = json.dumps(data, indent=2).encode("utf-8")
    write_in_plan_dir(path, encoded, make=True, mode=0o600)
    return encoded


def _tail(text: str, limit: int = MAX_CAPTURE_BYTES) -> str:
    """The last ``limit`` bytes of ``text``, decoded leniently for diagnostics.

    **Every caller redacts first (``redact_text``), then tails, never the
    reverse.** This keeps the *last* bytes, so a cut landing inside
    ``aws_secret_access_key=`` leaves ``_access_key=<value>`` — a shape
    ``SECRET_KEY`` does not match, so no later pass could recover it.
    """
    encoded = (text or "").encode("utf-8", errors="replace")
    if len(encoded) <= limit:
        return text or ""
    return encoded[-limit:].decode("utf-8", errors="replace")


def _redact_probe_tail(text: str, limit: int = MAX_CAPTURE_BYTES) -> str:
    """A captured stream, redacted then tailed, for quoting into a refusal.

    Also the wrapper for a tail that leaves this module with no redacting sink
    behind it to name — ``dispatch_task``'s ``after_result`` payload, whose
    consumer is a caller's callback.

    The refusal-message counterpart to
    ``providers.cursor_agent.redact_probe_output``, and the same §4.5 boundary as
    ``redact_text`` — not a second mechanism, a wrapper that fixes the two things
    a refusal needs on top of it.

    **Diagnostic value is the point.** A refusal quotes a probe so the reader can
    see *why* the runner was refused, so this redacts identity- and
    credential-shaped **values** and nothing else: cursor-agent's ``status
    --format json`` is a nine-key object, three of whose keys are §4.5.1 P13
    identity fields, and the other six — plus every key name — survive, so two
    runs stay diffable. Dropping the whole tail would trade one regression for
    another.

    Redaction runs **before** ``_tail`` for the reason :func:`_tail` states: the
    tail keeps the *last* bytes, so a cut landing inside a keyword leaves a value
    no later pass can match.

    **Fail safe.** A redactor that raises must never
    fall back to the raw stream — the fallback drops the text exactly the way
    M13's probe boundary does.
    """
    try:
        redacted = redact_text(text or "")
    except Exception:  # noqa: BLE001 - a diagnostic never leaks on failure
        return "<redacted:probe-output>"
    return _tail(redacted, limit).strip()


def _redact_json(value: Any) -> Any:
    """``value`` with every string in it redacted, structure preserved.

    Used at the two JSON write boundaries. A per-field list would have to be
    kept in step with every new diagnostic field a failure record grows; walking
    the payload cannot fall behind one.
    """
    if isinstance(value, str):
        return redact_text(value)
    if isinstance(value, dict):
        return {key: _redact_json(item) for key, item in value.items()}
    if isinstance(value, list):
        return [_redact_json(item) for item in value]
    return value


def _safe_task_filename(task_id: str) -> str:
    return re.sub(r"[^A-Za-z0-9._-]", "_", task_id or "task") or "task"


def _retire_capture(target: Path, root: str, *, resolve_root: bool = True) -> None:
    """Move an earlier invocation's capture aside rather than overwrite it.

    Attempt numbering restarts at 1 on every invocation, and a re-invoked phase
    re-dispatches the failed task under the same id — so without this the retry
    destroyed the evidence of the attempt it was retrying (measured
    2026-09-14: two ``generate-tasks`` runs an hour apart left one
    ``task_generation.attempt1.json``, the second's). The stamp is the retired
    file's own mtime in UTC, so the name says when that attempt ran; the batch
    report that named the old path is rewritten by the same invocation.
    Best-effort: a rename that fails leaves the overwrite as it was. *target*
    is checked below the phase folder, and renamed in its folder held below
    *root*, the plan's directory as the run recorded it, not resolved again
    (*resolve_root* off; ``write_safety.rename_below_root``), never through a
    link.
    """
    try:
        if not target.exists():
            return
        stamp = datetime.fromtimestamp(
            target.stat().st_mtime, tz=timezone.utc
        ).strftime("%Y%m%dT%H%M%SZ")
        retired = target.with_name(f"{target.stem}.{stamp}{target.suffix}")
        serial = 1
        while retired.exists():
            retired = target.with_name(
                f"{target.stem}.{stamp}-{serial}{target.suffix}"
            )
            serial += 1
        rename_below_root(root, target, retired.name, resolve_root=resolve_root)
    except OSError:  # pragma: no cover - diagnostics must never fail a run
        return


def _write_failure_capture(
    *,
    phase_dir: str,
    task: Dict[str, Any],
    attempt_index: int,
    argv: Sequence[str],
    prompt: str,
    stdout: str,
    stderr: str,
    exit_code: Optional[int],
    duration: float,
    status: str,
    error: str,
    repair: Optional[str] = None,
) -> Optional[str]:
    """Persist one failed attempt's bounded capture (D3k). Best-effort.

    A detached or CI failure has no chat context and no stdout to scroll back
    through, so the diagnosis has to survive on disk. The rendered argv carries
    the prompt **elided to its sha256 and byte length** — never the prompt bytes,
    which embed the plan/diff under review.

    Six of the nine planted secret shapes landed here, three times each: the
    existing 64 KiB ``_tail`` preserved every one, which is why §4.4 does not
    subsume §4.5. Redaction runs on the **full** stream before the tail is taken,
    and the assembled payload is walked once more on the way out.
    """
    try:
        capture_dir = Path(phase_dir) / FAILED_CAPTURE_DIRNAME
        name = f"{_safe_task_filename(str(task.get('task_id', '')))}.attempt{attempt_index}.json"
        digest = hashlib.sha256((prompt or "").encode("utf-8")).hexdigest()
        rendered = [
            f"<prompt sha256:{digest} bytes:{len((prompt or '').encode('utf-8'))}>"
            if arg == prompt
            else arg
            for arg in argv
        ]
        # Checked below the phase folder and below the plan's directory as
        # the run recorded it, then retired and written through the capture
        # folder held from that recorded directory, never resolved again, the
        # phase folder and `failed/` walked: never through a link swapped in
        # for any of them (docs/development/write-safety.md#plan-output-containment).
        target = contain_local_path(capture_dir / name, phase_dir,
                                    what="failure capture")
        recorded = plan_dir_of(capture_dir / name)
        if recorded is not None and not target.is_relative_to(recorded):
            return None
        root = recorded or phase_dir
        _retire_capture(target, root, resolve_root=recorded is None)
        payload = _redact_json({
            "task_id": task.get("task_id"),
            "kind": task.get("kind"),
            "attempt": attempt_index,
            "status": status,
            "rung": RUNG_BY_STATUS.get(status),
            "error": error,
            "exit_code": exit_code,
            "duration_seconds": round(duration, 3),
            "argv": rendered,
            "prompt_sha256": digest,
            "prompt_bytes": len((prompt or "").encode("utf-8")),
            # §4.5 before §4.4: redact the whole stream, then tail it. Tailing
            # first would keep a value whose key name the cut had just removed.
            "stdout_tail": _tail(redact_text(stdout)),
            "stderr_tail": _tail(redact_text(stderr)),
            # Only on the schema-repair re-ask, so every other capture keeps
            # exactly the keys it always had.
            **({"repair": repair} if repair else {}),
        })
        write_below_root(root, target,
                         json.dumps(payload, indent=2).encode("utf-8"), mode=0o600,
                         resolve_root=recorded is None)
        return str(capture_dir / name)
    except (OSError, WriteSafetyError):  # pragma: no cover - diagnostics must never fail a run
        return None
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