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

View on GitHub
"""Remove the codex trust entries a multi-llm run added to the user's config.

Plan ``codex-sandbox-unavailable-findings-and-fixes`` §5, issue I12 (step 5,
2026-09-30). codex (measured 0.158.0 through 0.159.1) appends

    [projects."<git toplevel>"]
    trust_level = "trusted"

to ``$CODEX_HOME/config.toml`` whenever a ``codex exec`` child runs under
``workspace-write`` or ``danger-full-access`` in a repository the user never
trusted — even with ``--skip-git-repo-check``. Every write-capable child the
plugin starts does this (the fan-out's ``generate``, ``agent-write``, the
uncontained rung and the plugin-landlock rung), so a plugin run silently made a
security decision for the user: that repo's project-level config is honoured in
the user's later Codex sessions.

**Option A was measured and not adopted** (2026-09-30, codex 0.159.0): the one
override that stops the write, ``-c projects={"<cwd>"={trust_level=
"untrusted"}}``, never widens what the child loads but *narrows* it — the child
no longer reads the repo's ``AGENTS.md`` or ``.codex/config.toml``. The plan
admits option A only "if it measures clean"; it does not, so this is option B:
**remove only what the run added.**

* :func:`arm` runs before a codex child starts (the adapter's side-effect-only
  ``note_dispatch`` hook, which ``llm_client.provider_dispatch_context`` calls
  on both spawn sites — not ``hermetic_dispatch``, which stays opencode's
  alone): for the resolved
  ``$CODEX_HOME`` it records, per repository key, whether ``config.toml``
  already had a ``[projects."<key>"]`` table. Idempotent; the first arm of a
  home also keeps its pre-run bytes and mode in memory.
* :func:`restore_all` runs once, from ``multi_llm.main``'s ``finally`` — after
  the run's last codex child exited, on a normal return, an exception, Ctrl-C
  or a foreground SIGTERM — and, for a detached worker, from the two endings
  that ``os._exit`` past that ``finally``: the ``--abort`` signal handler
  (after the CLI sweep) and the heartbeat-lost exit (``utils/detach.py``). It removes a table only if it was absent at arm time and now holds
  exactly ``trust_level = "trusted"``; anything else means someone changed it
  during the run, and it is left with a warning. The edit removes only that
  table's lines (and the one blank line codex inserted before it); every other
  byte, comment and table stays; the pre-run mode is restored (codex forces
  0600); the write goes through a temp file and a rename in the same directory.
  Never a TOML round-trip, which drops comments. Never mid-run: children share
  the file and codex rewrites it by atomic rename.

Residual (the plan's, never worse than before): a SIGKILLed run, or an
overlapping run in the same repo (which sees the earlier run's entry as
pre-existing), can leave an entry behind.
"""

from __future__ import annotations

import os
import re
import subprocess
import sys
import threading
from dataclasses import dataclass, field
from typing import Dict, Iterable, List, Optional, Set, Tuple

from .atomic_io import atomic_write_bytes
from .git_utils import git_argv
from .process_state import process_cache

CONFIG_NAME = "config.toml"

#: Reentrant because :func:`restore_all` also runs inside the detached worker's
#: SIGTERM handler, on the main thread, which may have been interrupted inside
#: :func:`arm`'s ``with _LOCK`` — a plain lock would deadlock the abort there.
_LOCK = threading.RLock()


@dataclass
class _HomeRecord:
    home: str
    existed: bool
    pre_bytes: bytes
    pre_mode: Optional[int]
    #: key → whether its table existed at the time the key was armed.
    keys: Dict[str, bool] = field(default_factory=dict)


_RECORDS: Dict[str, _HomeRecord] = {}

#: The test suite turns this off (``tests/conftest.py``) so no test arms the
#: developer's real ``~/.codex``; the tests of this module turn it back on
#: against a temp home.
ENABLED = True


#: realpath'd directory → its :func:`repo_keys`, so a repeat arm for the same
#: anchor and cwd spawns no ``git``. Only answers from a successful
#: ``git rev-parse`` are kept; a directory's toplevel is taken as fixed for the
#: life of a run, so nothing invalidates an entry but :func:`reset`.
_REPO_KEYS: Dict[str, Tuple[str, ...]] = process_cache("utils.codex_trust._REPO_KEYS", lock=_LOCK)


def reset() -> None:
    """Forget every armed home and cached repository key (tests; a new run in
    the same interpreter)."""
    with _LOCK:
        _RECORDS.clear()
        _REPO_KEYS.clear()


def _config_path(home: str) -> str:
    return os.path.join(home, CONFIG_NAME)


def _read(path: str) -> Tuple[bool, bytes, Optional[int]]:
    try:
        with open(path, "rb") as handle:
            data = handle.read()
        return True, data, os.stat(path).st_mode & 0o7777
    except FileNotFoundError:
        return False, b"", None


def _unescape_basic(text: str) -> str:
    return text.replace('\\"', '"').replace("\\\\", "\\")


_HEADER = re.compile(
    r'^\[projects\.(?:"((?:[^"\\]|\\.)*)"|\'([^\']*)\')\][ \t]*$'
)


def _table_keys(text: str) -> Set[str]:
    keys: Set[str] = set()
    for line in text.splitlines():
        match = _HEADER.match(line.strip())
        if match:
            keys.add(_unescape_basic(match.group(1)) if match.group(1) is not None else match.group(2))
    return keys


def repo_keys(directory: Optional[str]) -> List[str]:
    """The keys codex uses for ``directory``: the ``realpath`` of its git
    toplevel and, for a linked worktree, of the main repository root
    (measured 2026-09-30). ``[]`` outside a git repository.

    Memoised per ``realpath``'d directory: :func:`arm` runs before every codex
    child, and only the first call for a directory spawns ``git``. A failed
    probe (not a repository, git missing, a timeout) is not cached."""
    start = os.path.realpath(directory or os.getcwd())
    if os.path.isfile(start):
        start = os.path.dirname(start) or "."
    cached = _REPO_KEYS.get(start)
    if cached is not None:
        return list(cached)
    keys: List[str] = []
    try:
        top = subprocess.run(
            git_argv("rev-parse", "--show-toplevel", "--git-common-dir", cwd=start),
            capture_output=True, text=True, cwd=start, timeout=10,
            encoding="utf-8", errors="replace",
        )
    except (OSError, subprocess.SubprocessError):
        return keys
    if top.returncode != 0:
        return keys
    lines = [line.strip() for line in top.stdout.splitlines() if line.strip()]
    if lines:
        keys.append(os.path.realpath(lines[0]))
    if len(lines) > 1:
        common = lines[1]
        if not os.path.isabs(common):
            common = os.path.join(start, common)
        main_root = os.path.realpath(os.path.dirname(os.path.realpath(common)))
        if main_root not in keys:
            keys.append(main_root)
    if keys:
        _REPO_KEYS[start] = tuple(keys)
    return keys


def arm(codex_home: Optional[str], repo_dirs: Iterable[Optional[str]]) -> None:
    """Record, before a codex child starts, which trust tables ``codex_home``'s
    config already holds for the repositories of ``repo_dirs``. Idempotent and
    cheap after the first call per (home, key): the keys come from
    :func:`repo_keys`' cache, and once every key is recorded for the home the
    config is not re-read. Never raises."""
    if not codex_home or not ENABLED:
        return
    try:
        home = os.path.realpath(os.path.expanduser(codex_home))
        keys: List[str] = []
        for directory in repo_dirs:
            for key in repo_keys(directory):
                if key not in keys:
                    keys.append(key)
        with _LOCK:
            record = _RECORDS.get(home)
            if record is not None and all(key in record.keys for key in keys):
                return
            existed, data, mode = _read(_config_path(home))
            if record is None:
                record = _RECORDS[home] = _HomeRecord(
                    home=home, existed=existed, pre_bytes=data, pre_mode=mode,
                )
            present = _table_keys(data.decode("utf-8", errors="replace")) if existed else set()
            for key in keys:
                if key not in record.keys:
                    record.keys[key] = key in present
    except Exception as exc:  # noqa: BLE001 - bookkeeping may never block a dispatch
        print(f"multi-llm warning: could not record codex trust state: {exc}", file=sys.stderr)


def _remove_table(text: str, key: str) -> Tuple[str, str]:
    """``(new text, verdict)`` where verdict is ``removed``, ``absent`` or
    ``changed`` (the table holds more than the expected trust line)."""
    lines = text.splitlines(keepends=True)
    for index, line in enumerate(lines):
        match = _HEADER.match(line.strip())
        if not match:
            continue
        found = _unescape_basic(match.group(1)) if match.group(1) is not None else match.group(2)
        if found != key:
            continue
        # The table's own lines: the consecutive non-blank lines under the
        # header. They must be exactly the trust line codex writes.
        end = index + 1
        while end < len(lines) and lines[end].strip() and not lines[end].lstrip().startswith("["):
            end += 1
        body = [lines[i].strip() for i in range(index + 1, end)]
        if body != ['trust_level = "trusted"']:
            return text, "changed"
        # Past a blank line, only comments and blank lines may precede the next
        # header: a stray key there would still belong to this table in TOML,
        # and removing the header would hand it to the previous one.
        look = end
        while look < len(lines):
            stripped = lines[look].strip()
            if stripped.startswith("["):
                break
            if stripped and not stripped.startswith("#"):
                return text, "changed"
            look += 1
        # Drop the header, the trust line and the one blank line codex put
        # before the table; the blank lines and comments that follow stay.
        start = index
        if start > 0 and not lines[start - 1].strip():
            start -= 1
        new_lines = lines[:start] + lines[end:]
        return "".join(new_lines), "removed"
    return text, "absent"


def _atomic_write(path: str, data: bytes, mode: int) -> None:
    """Replace codex's config with *data*, its permission bits exactly *mode*."""
    atomic_write_bytes(path, data, mode=mode, temp_prefix=".multi-llm-trust-")


def restore_home(record: _HomeRecord) -> List[str]:
    """Remove the trust tables this run added to one home. Returns warnings."""
    warnings: List[str] = []
    path = _config_path(record.home)
    added = [key for key, present in record.keys.items() if not present]
    if not added:
        return warnings
    existed, data, mode = _read(path)
    if not existed:
        return warnings
    text = data.decode("utf-8", errors="surrogateescape")
    removed_any = False
    for key in added:
        text, verdict = _remove_table(text, key)
        if verdict == "removed":
            removed_any = True
        elif verdict == "changed":
            warnings.append(
                f"codex's config {path} has a [projects.\"{key}\"] table this run "
                f"did not find there before, but it holds more than the trust entry "
                f"codex adds; left as it is — review it"
            )
    if not removed_any:
        return warnings
    new = text.encode("utf-8", errors="surrogateescape")
    pre = record.pre_bytes
    if record.existed and not pre.endswith(b"\n") and new == pre + b"\n":
        # codex terminated a final line that had no newline before inserting.
        new = pre
    if not record.existed and not new.strip():
        try:
            os.unlink(path)
        except OSError as exc:
            warnings.append(f"could not remove codex's config {path}, which this run's trust entry created: {exc}")
        return warnings
    target_mode = record.pre_mode if record.pre_mode is not None else (mode or 0o600)
    try:
        _atomic_write(path, new, target_mode)
    except OSError as exc:
        warnings.append(f"could not remove this run's codex trust entry from {path}: {exc}")
    return warnings


def restore_all() -> List[str]:
    """Remove every trust table this process's codex children added, then
    forget the records. Called from ``multi_llm.main``'s ``finally`` and from
    a detached worker's ``--abort``/heartbeat-lost exits; a second call finds
    nothing left. Never raises. Returns (and prints) warnings."""
    with _LOCK:
        records = list(_RECORDS.values())
        _RECORDS.clear()
    warnings: List[str] = []
    for record in records:
        try:
            warnings.extend(restore_home(record))
        except Exception as exc:  # noqa: BLE001 - close-out must never mask the result
            warnings.append(f"could not restore codex's config under {record.home}: {exc}")
    for line in warnings:
        print(f"multi-llm warning: {line}", file=sys.stderr)
    return warnings


__all__ = ["arm", "repo_keys", "reset", "restore_all", "restore_home"]
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