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

View on GitHub
"""Where a host's shim can live: scopes, path tokens and locations (D7c).

Every path comes from ``hosts/capabilities.yaml`` through
:mod:`utils.host_capabilities`; nothing here names a host.
:mod:`utils.host_install` re-exports these names, and the rules they serve are
in its docstring and in ``docs/development/hosts.md``.
"""

from __future__ import annotations

import os
import re
from dataclasses import dataclass
from pathlib import Path
from typing import Dict, List, Optional, Tuple

from . import host_capabilities as caps


class Refused(Exception):
    """An installer-owned refusal: exit 3, message already written for a human."""


# ---------------------------------------------------------------------------
# Scopes and path tokens (D7c)
# ---------------------------------------------------------------------------

SCOPE_PROJECT = "project"
SCOPE_GLOBAL = "global"
SCOPE_LEGACY = "legacy"

#: Writable scopes, in the order ``--check`` reports them: the host's own
#: discovery precedence, recorded rather than assumed (project beats global on
#: every host surveyed).
WRITABLE_SCOPES: Tuple[str, ...] = (SCOPE_PROJECT, SCOPE_GLOBAL)

#: Default scope for a write. ``--global`` is the machine-wide install a user
#: expects from a one-off command; ``--project`` is the opt-in.
DEFAULT_SCOPE = SCOPE_GLOBAL

#: The per-user root tokens, in the order they are honoured. ``$HOME`` is what the
#: data spells; ``%USERPROFILE%`` is the same directory under native Windows and
#: is accepted as a token so a future entry may spell it either way.
_HOME_TOKENS: Tuple[str, ...] = ("$HOME", "${HOME}", "%USERPROFILE%", "~")

_XDG_TOKENS: Tuple[str, ...] = ("$XDG_CONFIG_HOME", "${XDG_CONFIG_HOME}")

#: A native-absolute entry, in either platform's spelling: a leading separator, a
#: drive prefix (``C:\…``) or a UNC root. Rejected for the same reason ``..`` is —
#: an ``install_paths`` entry names a directory *under* the token it starts with
#: or under the project root, and neither form does.
_ABSOLUTE_RE = re.compile(r"^(?:[/\\]|[A-Za-z]:[/\\]?)")


def user_home(env: Optional[Dict[str, str]] = None) -> Path:
    """The per-user root a ``$HOME``/``~``/``%USERPROFILE%`` token expands to.

    ``HOME`` first (POSIX, and what Git Bash sets on Windows), then
    ``USERPROFILE`` (native Windows Python), then the interpreter's own answer.
    One function, so no caller re-derives the platform rule and a test can hand it
    a temp home on either platform.
    """
    env = os.environ if env is None else env
    for name in ("HOME", "USERPROFILE"):
        value = env.get(name)
        if value:
            return Path(value)
    return Path.home()


def expand_path_tokens(
    raw: str,
    *,
    env: Optional[Dict[str, str]] = None,
    project_root: Optional[Path] = None,
) -> Path:
    """Expand one ``install_paths`` entry into a native absolute directory.

    OS variance is a token expansion, not extra rows in the data: ``$HOME``/``~``
    is ``%USERPROFILE%`` on Windows, and the XDG-style roots honour
    ``$XDG_CONFIG_HOME`` when it is set (falling back to ``<home>/.config``, which
    is what the second global entry of an XDG host spells literally — the two
    collapse to one path and are de-duplicated by :func:`locations`).

    A relative entry is a project-scope path and resolves against *project_root*.
    A token is only a token when the entry *is* it or continues with a separator,
    so ``$XDG_CONFIG_HOMEx`` is not an XDG path, and the entry itself is checked
    (:func:`checked_entry`) before any of it is joined.
    """
    env = os.environ if env is None else env
    text = checked_entry(raw)
    home = user_home(env)
    for token in _XDG_TOKENS:
        if text == token or text.startswith(token + "/"):
            configured = (env.get("XDG_CONFIG_HOME") or "").strip()
            root = Path(configured) if configured else home / ".config"
            return _join(root, text[len(token):])
    for token in _HOME_TOKENS:
        if text == token or text.startswith(token + "/"):
            return _join(home, text[len(token):])
    root = Path(project_root) if project_root is not None else Path.cwd()
    return _join(root, text)


def checked_entry(raw: str) -> str:
    """The stripped ``install_paths`` entry, or :class:`Refused`.

    An entry names a directory *under* the token it starts with, or under the
    project root — nothing else is expressible, and both other shapes are silent
    rather than loud: :func:`_join` normalizes through ``os.path.abspath``, so a
    single ``..`` segment relocates the write outside the root the entry names,
    and a native-absolute entry ignores the root entirely. The schema states the
    same rule (``install_path``), but the schema is CI's guard while this is the
    runtime one — an entry reaching expansion is the last moment a bad path is
    still a message instead of a file in the wrong directory.
    """
    text = raw.strip()
    if not text:
        raise Refused(
            "ERROR: an install_paths entry is empty.\n"
            "       Each entry names one directory, token-rooted ($HOME, "
            "%USERPROFILE%, $XDG_CONFIG_HOME, ~) or relative to the project "
            "root. Fix the entry in hosts/capabilities.yaml."
        )
    remainder, rooted = text, False
    for token in _XDG_TOKENS + _HOME_TOKENS:
        if text == token or text.startswith(token + "/"):
            remainder, rooted = text[len(token):], True
            break
    if any(segment == ".." for segment in re.split(r"[/\\]", remainder)):
        raise Refused(
            f"ERROR: install_paths entry '{text}' contains a '..' segment.\n"
            "       An entry names a directory under the token it starts with "
            "(or under the project root); a parent-directory segment would move "
            "the write outside it. Fix the entry in hosts/capabilities.yaml."
        )
    if not rooted and _ABSOLUTE_RE.match(text):
        raise Refused(
            f"ERROR: install_paths entry '{text}' is an absolute path.\n"
            "       An entry is token-rooted ($HOME, ${HOME}, %USERPROFILE%, ~, "
            "$XDG_CONFIG_HOME, ${XDG_CONFIG_HOME}) or relative to the project "
            "root, so that one entry expands correctly on every OS. Fix the "
            "entry in hosts/capabilities.yaml."
        )
    return text


def _join(root: Path, remainder: str) -> Path:
    remainder = remainder.lstrip("/")
    return Path(os.path.abspath(str(root / remainder) if remainder else str(root)))


# ---------------------------------------------------------------------------
# Where a host's shim can live
# ---------------------------------------------------------------------------

@dataclass(frozen=True)
class Location:
    """One place a host's shim may sit, with its precedence already decided."""

    host_id: str
    scope: str            # project | global | legacy
    writable: bool        # False for a compatibility location (read-only, D7)
    raw: str              # the unexpanded token form, for messages
    directory: Path
    path: Path

    @property
    def label(self) -> str:
        kind = "preferred" if self.writable else "compat"
        return f"{self.scope}/{kind}"


def shim_filename(host_id: str, base: Optional[str] = None) -> str:
    """The file name a host's shim takes.

    ``shim.installed`` is recorded relative to the host's own config root
    (``commands/multi-llm.md``, ``SKILL.md``) while ``install_paths`` names the
    directory to write into, so the file name is its basename. One rule, both
    hosts, no branch.
    """
    installed = caps.entry(host_id, base)["shim"]["installed"]
    return os.path.basename(installed.replace("\\", "/"))


def locations(
    host_id: str,
    *,
    base: Optional[str] = None,
    env: Optional[Dict[str, str]] = None,
    project_root: Optional[Path] = None,
) -> List[Location]:
    """Every location for *host_id*, in the host's discovery-precedence order.

    Precedence is the host's, not ours, and it is recorded rather than assumed: on
    every host surveyed project scope wins over global and a preferred root wins
    over a legacy one. A legacy entry belongs to the scope its own token implies —
    rooted at the user's home (or XDG) means global, relative means project — so
    the classification stays data-driven too.

    The two kinds of entry compose differently, and that is the one deviation
    worth spelling out: a **preferred** entry names the directory to write into
    and takes its file name from ``shim.installed``, while a **legacy** entry
    names the *file*. A deprecated layout's file name is the host's own old
    convention rather than ours (Codex's ``~/.codex/prompts/multi-llm.md`` is a
    prompt file, not a skill directory), so joining our basename onto it would
    probe a path no install of any vintage ever created — detection that can only
    ever miss.
    """
    entry = caps.entry(host_id, base)
    paths = entry["install_paths"]
    name = shim_filename(host_id, base)
    buckets: Dict[str, List[Tuple[str, bool]]] = {
        SCOPE_PROJECT: [(raw, True) for raw in paths[SCOPE_PROJECT]],
        SCOPE_GLOBAL: [(raw, True) for raw in paths[SCOPE_GLOBAL]],
    }
    for raw in paths[SCOPE_LEGACY]:
        scope = SCOPE_GLOBAL if _is_user_rooted(raw) else SCOPE_PROJECT
        buckets[scope].append((raw, False))

    found: List[Location] = []
    seen: set = set()
    for scope in WRITABLE_SCOPES:
        # Preferred roots first, then this scope's compatibility locations.
        for writable in (True, False):
            for raw, is_writable in buckets[scope]:
                if is_writable is not writable:
                    continue
                expanded = expand_path_tokens(
                    raw, env=env, project_root=project_root
                )
                # Preferred: a directory, plus our own file name. Legacy: the
                # file itself (see the docstring).
                directory = expanded if writable else expanded.parent
                path = expanded / name if writable else expanded
                if str(path) in seen:
                    continue
                seen.add(str(path))
                found.append(
                    Location(
                        host_id=host_id,
                        scope=scope,
                        writable=writable,
                        raw=raw,
                        directory=directory,
                        path=path,
                    )
                )
    return found


def _is_user_rooted(raw: str) -> bool:
    text = raw.strip()
    return any(
        text == token or text.startswith(token + "/")
        for token in _HOME_TOKENS + _XDG_TOKENS
    ) or Path(text).is_absolute()


def target_location(
    host_id: str,
    scope: str = DEFAULT_SCOPE,
    *,
    base: Optional[str] = None,
    env: Optional[Dict[str, str]] = None,
    project_root: Optional[Path] = None,
) -> Location:
    """The one path a write goes to: the **first** preferred path of *scope*.

    Compatibility locations are supported deliberately and read-only: an existing
    install keeps working and ``--check`` finds it, but nothing new is ever created
    there. Migrating is: re-run ``install-host``, then delete the file it names.
    """
    for location in locations(
        host_id, base=base, env=env, project_root=project_root
    ):
        if location.scope == scope and location.writable:
            return location
    raise Refused(
        f"ERROR: host '{host_id}' declares no {scope}-scope install path.\n"
        f"       install_paths.{scope} is empty in hosts/capabilities.yaml, so "
        "there is nowhere to write. Pass the other scope, or add the path to the "
        "data (a host doc change is a data edit, never a code edit)."
    )


def existing_copies(
    host_id: str,
    *,
    base: Optional[str] = None,
    env: Optional[Dict[str, str]] = None,
    project_root: Optional[Path] = None,
) -> List[Location]:
    """Locations that hold a file today, in precedence order."""
    return [
        location
        for location in locations(
            host_id, base=base, env=env, project_root=project_root
        )
        if location.path.is_file()
    ]
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