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

View on GitHub
"""The prompt one write dispatch is sent, on the executor leg (D2g, fix round 17).

:class:`BatchPromptBuilder` turns one materialized write task into the text its
runner receives: the task's prompt with the prior changes bound
(:meth:`BatchPromptBuilder.dispatched_prompt`), the result contract and the
known checks it is told to run (:meth:`BatchPromptBuilder.with_result_contract`,
:meth:`BatchPromptBuilder.known_checks_section`), the scope policy's refusal
(:meth:`BatchPromptBuilder.scope_refusal`), and the copy of what was sent kept
in the pinned phase folder (:meth:`BatchPromptBuilder.keep_dispatched_prompt`).
The texts are ``batch_prompt``'s, shared with the native leg's ``util
write-prompt`` (docs/development/write-scheduler.md#prompt-order).

``WriteBatchScheduler`` composes it with the run's ``RunContext``
(docs/development/write-scheduler.md#where-the-schedulers-helpers-live). It
writes the known checks it told each task into the scheduler's
``told_checks``, which the reply's classification reads; its own state is the
pinned phase folder and the warnings already given.
"""

from __future__ import annotations

import os
import threading
from typing import Any, Dict, List, Optional, Set, Tuple

from . import batch_prompt as _batch_prompt
from . import check_records as _check_records
from . import known_checks as _known_checks
from . import prompt_files as _prompt_files
from . import write_context as _write_context
from .subagent_tasks import APPLY_WRITE_KINDS


class BatchPromptBuilder:
    """The text one write dispatch is sent, and where it is kept.

    Built once per run by the scheduler. *told_checks* is the scheduler's
    ``_told_checks`` (``task id -> the known check commands its prompt
    listed``), filled here and read by the reply's classification.
    """

    def __init__(
        self,
        ctx: _write_context.RunContext,
        *,
        plan_file: Optional[str],
        scope_policy: Optional[str],
        scope_baseline_id: Optional[str],
        told_checks: Dict[str, List[str]],
    ) -> None:
        self._ctx = ctx
        self._plan_file = plan_file
        self._scope_policy = scope_policy
        self._scope_baseline_id = scope_baseline_id
        self._told_checks = told_checks
        #: Fix round 17: the phase dir the dispatched prompts are kept in,
        #: pinned (``prompt_files.pin_phase_dir``) before any batch of this
        #: run can replace it — a jailed repo-wide batch can write the phase
        #: dir, and this process is not jailed. ``None`` until it exists.
        self.pin: Optional[_prompt_files.PhasePin] = None
        self._pin_lock = threading.Lock()
        #: The ``(task id, leftover entry)`` pairs already warned about
        #: (:meth:`warn_prompt_keep`).
        self._keep_warnings: Set[Tuple[str, Optional[str]]] = set()

    def dispatched_prompt(self, task: Dict[str, Any]) -> str:
        """The prompt that actually goes to the runner, bound *now*.

        :func:`bind_prior_changes` over this phase's log; see it for the
        contract. Kept as a method so the dispatch site reads as before.
        An implement task gets the note about the checks upstream of it
        whose findings the user accepted (fix round 14), read from the
        state as it is at dispatch, as ``util write-prompt`` reads it.
        """
        accepted: List[Tuple[str, str, List[str]]] = []
        if self._ctx.kind == "implement":
            accepted = _check_records.accepted_upstream_checks(
                self._ctx.tasks, str(task.get("task_id") or ""), self._ctx.state,
            )
        return _batch_prompt.bind_prior_changes(
            task, output_dir=self._ctx.output_dir, phase=self._ctx.phase,
            accepted_checks=accepted,
            state=_write_context.manager_or_none(self._ctx.state),
        )

    def scope_refusal(self, task: Dict[str, Any]) -> Optional[str]:
        """Why an apply task must not dispatch under the effective scope
        policy (``scope_apply.stale_task_refusal``), else ``None``."""
        if self._ctx.kind not in APPLY_WRITE_KINDS:
            return None
        scope = _batch_prompt._scope_apply()
        if self._scope_policy is not None:
            policy, baseline = self._scope_policy, self._scope_baseline_id
        else:
            state = getattr(self._ctx.state, "state", None)
            if not isinstance(state, dict):
                state = _batch_prompt._state_on_disk(self._ctx.output_dir)
            policy, baseline = scope.effective_from_state(
                state if isinstance(state, dict) else {}, self._ctx.phase)
        return scope.stale_task_refusal(task, policy, baseline)

    def with_result_contract(self, task: Dict[str, Any], prompt: str) -> str:
        """Append the write-batch result contract (:func:`with_result_contract`),
        with an apply-code-fixes batch's known checks (fix round 20)."""
        return _batch_prompt.with_result_contract(
            self._ctx.kind, task, prompt, checks_section=self.known_checks_section(task),
        )

    def known_checks(self) -> List[Tuple[str, str]]:
        """The repository's known check commands
        (:func:`known_checks.known_check_commands`), read now from the state
        this run holds (else the plan dir's ``state.json``), as ``util
        write-prompt`` reads them on the native leg. Never run here."""
        return _known_checks.known_check_commands(
            self._ctx.output_dir, plan_file=self._plan_file,
            repo_root=self._ctx.repo_root,
            state=_write_context.manager_or_none(self._ctx.state),
        )

    def known_checks_section(self, task: Dict[str, Any]) -> str:
        """Fix round 20 (live run 8, Codex racing 08): an apply-code-fixes
        batch is told the repository's known check commands, to run after its
        edits, and which earlier batch of the run reported a failing check.
        ``""`` for every other kind. The commands told to each batch are kept
        (``_told_checks``), so its reply's ``listed`` is read against them."""
        if self._ctx.kind != "apply_code_fixes":
            return ""
        task_id = str(task.get("task_id") or "")
        try:
            checks = self.known_checks()
            state = _write_context.manager_or_none(self._ctx.state)
            earlier = _known_checks.earlier_batch_check_failures(
                state if state is not None else _known_checks.read_state(self._ctx.output_dir),
                self._ctx.tasks, task_id,
            )
        except Exception:  # noqa: BLE001 - advisory: the batch is still dispatched
            checks, earlier = [], []
        self._told_checks[task_id] = [command for command, _where in checks]
        return _known_checks.known_checks_section(checks, earlier)

    def pinned_phase_dir(self) -> "_prompt_files.PhasePin":
        """The phase dir as pinned for the prompt files (fix round 17): its
        ``realpath`` inside the repository root and its identity, taken once
        — at construction, or on the first prompt kept when the phase dir did
        not exist yet. Raises ``OSError`` naming why it cannot be pinned."""
        with self._pin_lock:
            pin = self.pin
            if pin is None:
                pin = _prompt_files.pin_phase_dir(self._ctx.phase_dir, self._ctx.repo_root)
                self.pin = pin
            return pin

    def keep_dispatched_prompt(
        self, task_id: str, attempt: int, sent: str, batch_prompt: str
    ) -> None:
        """Keep the prompt this attempt sends, beside the native leg's.

        Run 6 (#10b): on the executor leg the prompt a task was dispatched
        with was in no plan artifact — the audit line keeps its sha256 and
        length only — so T007's prompt with "## Check findings the user
        accepted" could not be audited on Codex at all, and on OpenCode only
        from the host's session database. The native leg's ``util
        write-prompt`` always wrote ``{phase}/prompts/<id>.prompt.txt``; this
        writes the same file, the same bytes, just before the child starts.

        * The batch's prompt **overwrites** the file on every dispatch, as a
          ``--resume`` rebinds the native one: it is what the task was last
          told, and the audit log's ``prompt_sha256`` on that ``dispatched``
          line verifies it.
        * An attempt that sends something else (a report re-ask, rule 9's
          re-send) goes to ``<id>.attempt-<n>.prompt.txt`` instead, so the
          batch's file is never replaced by a re-ask; the task's next first
          attempt clears those, so none outlives the dispatch it belongs to.
        * Never for a task refused before dispatch: the policy check and the
          snapshot run first, so a task declaring a denied path leaves no
          file. The text is the native file's, unredacted — plan and task
          text, the prior-changes summaries, accepted check findings, all
          already on disk in the phase and plan dirs — and it lies inside the
          phase dir, which the containment sweep never attributes to a runner.

        A jailed repo-wide batch can write the phase dir and this process is
        not jailed, so nothing here follows a link (fix round 17: round 16
        checked ``prompts`` once by path, which a phase dir replaced by a link
        or a ``prompts`` swapped after the check still redirected outside the
        repository): the phase dir is the one pinned before any batch ran,
        reached from the repository root without following a link, and every
        file is created, renamed and unlinked relative to the folder's own
        descriptor (:mod:`utils.prompt_files`).

        Best-effort: a write that fails never fails the dispatch, and warns
        once for that task, naming it (fix round 17: one warning for the
        whole run let a directory planted under one task's file name silence
        every later task's failure). An earlier re-ask file that cannot be
        removed is named and left; the batch's own prompt is still kept.
        """
        where = os.path.join(self._ctx.phase_dir, _batch_prompt.DISPATCHED_PROMPTS_SUBDIR)
        try:
            if not task_id or os.path.basename(task_id) != task_id or task_id in (
                    ".", ".."):
                raise OSError(f"{task_id!r} is not a file name")
            with _prompt_files.PromptFolder.open(self.pinned_phase_dir()) as folder:
                if sent == batch_prompt:
                    name = _batch_prompt.dispatched_prompt_name(task_id)
                    if attempt <= 1:
                        head, tail = f"{task_id}.attempt-", ".prompt.txt"
                        for entry in folder.names():
                            if not (entry.startswith(head) and entry.endswith(tail)
                                    and entry[len(head):-len(tail)].isdigit()):
                                continue
                            try:
                                folder.remove(entry)
                            except OSError as exc:
                                self.warn_prompt_keep(
                                    task_id, entry,
                                    f"[write-subagents] could not remove "
                                    f"{task_id}'s earlier re-ask prompt {entry} "
                                    f"under {where}: {exc}. It is not this "
                                    f"dispatch's prompt; {task_id}'s own prompt "
                                    f"is kept beside it.",
                                )
                else:
                    name = _batch_prompt.dispatched_prompt_name(task_id, attempt)
                folder.write(name, sent)
        except (OSError, ValueError) as exc:
            self.warn_prompt_keep(
                task_id, None,
                f"[write-subagents] could not keep {task_id}'s dispatched "
                f"prompt under {where}: {exc}. The dispatch goes ahead; the "
                f"audit log keeps its sha256.",
            )

    def warn_prompt_keep(
        self, task_id: str, entry: Optional[str], line: str
    ) -> None:
        """Log ``line`` once per task (and per leftover ``entry`` it names):
        a retried dispatch that meets the same problem says nothing new,
        another task always does."""
        if (task_id, entry) in self._keep_warnings:
            return
        self._keep_warnings.add((task_id, entry))
        self._ctx.log(line)
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