Skip to content

try-works/role-model / .agents/skills/recursive-mode

recursive-mode

Unverified

Repository workflow orchestration skill for staged implementation, locked artifacts, late-phase receipts, and durable memory maintenance. Use when executing recursive-mode runs, resuming a run, locking a phase, or verifying locks.

FileKindSize
.agent/PLANS.mdmarkdown2.6 KB
.codex/AGENTS.mdmarkdown7.5 KB
.gitattributesother522 B
.gitignoreother553 B
.recursive/AGENTS.mdmarkdown3.3 KB
.recursive/DECISIONS.mdmarkdown1.1 KB
.recursive/README.mdmarkdown8.5 KB
.recursive/RECURSIVE.mdmarkdown107.5 KB
.recursive/STATE.mdmarkdown1.6 KB
.recursive/config/recursive-router.jsonconfig1.4 KB
.recursive/memory/MEMORY.mdmarkdown3.3 KB
.recursive/memory/archive/.gitkeepother1 B
.recursive/memory/domains/.gitkeepother1 B
.recursive/memory/episodes/.gitkeepother1 B
.recursive/memory/incidents/.gitkeepother1 B
.recursive/memory/patterns/.gitkeepother1 B
.recursive/memory/skills/SKILLS.mdmarkdown4.3 KB
.recursive/memory/skills/availability/.gitkeepother1 B
.recursive/memory/skills/issues/.gitkeepother1 B
.recursive/memory/skills/patterns/.gitkeepother1 B
.recursive/memory/skills/patterns/delegated-verification-and-refresh.mdmarkdown1.7 KB
.recursive/memory/skills/patterns/phase8-skill-memory-promotion.mdmarkdown1.4 KB
.recursive/memory/skills/usage/.gitkeepother1 B
.recursive/memory/skills/usage/skill-discovery-and-evaluation.mdmarkdown1.6 KB
.recursive/run/.gitkeepother1 B
AGENTS.mdmarkdown7.8 KB
LICENSEother11.1 KB
README.mdmarkdown17.8 KB
SKILL.mdskill md13.1 KB
agents/code-reviewer.mdmarkdown6.1 KB
agents/implementer.mdmarkdown6.3 KB
agents/openai.yamlconfig202 B
docs/templates/commands/check-reusable-repo-hygiene.mdmarkdown1.3 KB
docs/templates/commands/recursive-closeout.mdmarkdown2.8 KB
docs/templates/commands/recursive-init.mdmarkdown2.2 KB
docs/templates/commands/recursive-lock.mdmarkdown1.3 KB
docs/templates/commands/recursive-review-bundle.mdmarkdown3.6 KB
docs/templates/commands/recursive-status.mdmarkdown2.0 KB
docs/templates/commands/recursive-subagent-action.mdmarkdown4.2 KB
docs/templates/commands/test-recursive-mode-smoke.mdmarkdown3.4 KB
docs/templates/hooks/hooks.jsonconfig400 B
docs/templates/hooks/run-hook.cmdscript1.2 KB
docs/templates/hooks/session-start.ps1script3.6 KB
docs/templates/hooks/session-start.shscript3.5 KB
references/agents-block.mdmarkdown7.4 KB
references/artifact-template.mdmarkdown70.7 KB
references/benchmark-addon/recursive-benchmark/BENCHMARK-ADDON.mdmarkdown6.7 KB
references/benchmark-addon/recursive-benchmark/recursive-benchmark/BENCHMARK-ADDON.mdmarkdown6.7 KB
references/benchmark-addon/recursive-benchmark/recursive-benchmark/references/patterns.mdmarkdown4.9 KB
references/benchmark-addon/recursive-benchmark/references/patterns.mdmarkdown4.9 KB
references/benchmarks/README.mdmarkdown1.5 KB
references/benchmarks/local-first-planner/00-requirements.mdmarkdown3.3 KB
references/benchmarks/local-first-planner/README.mdmarkdown1.1 KB
references/benchmarks/local-first-planner/prompt-recursive-off.mdmarkdown1.1 KB
references/benchmarks/local-first-planner/prompt-recursive-on.mdmarkdown14.8 KB
references/benchmarks/local-first-planner/scoring-rubric.mdmarkdown1.3 KB
references/benchmarks/local-first-planner/starter/.gitignoreother30 B
references/benchmarks/local-first-planner/starter/README.mdmarkdown264 B
references/benchmarks/local-first-planner/starter/index.htmlother316 B
references/benchmarks/local-first-planner/starter/package.jsonmanifest628 B
references/benchmarks/local-first-planner/starter/src/App.test.tsxother334 B
references/benchmarks/local-first-planner/starter/src/App.tsxother971 B
references/benchmarks/local-first-planner/starter/src/main.tsxother238 B
references/benchmarks/local-first-planner/starter/src/styles.cssother976 B
references/benchmarks/local-first-planner/starter/src/test-setup.tsscript43 B
references/benchmarks/local-first-planner/starter/src/vite-env.d.tsscript38 B
references/benchmarks/local-first-planner/starter/tsconfig.app.jsonconfig552 B
references/benchmarks/local-first-planner/starter/tsconfig.jsonconfig89 B
references/benchmarks/local-first-planner/starter/vite.config.tsscript214 B
references/benchmarks/release-readiness-dashboard/00-requirements.mdmarkdown5.9 KB
references/benchmarks/release-readiness-dashboard/README.mdmarkdown1.2 KB
references/benchmarks/release-readiness-dashboard/prompt-recursive-off.mdmarkdown1.1 KB
references/benchmarks/release-readiness-dashboard/prompt-recursive-on.mdmarkdown14.8 KB
references/benchmarks/release-readiness-dashboard/scoring-rubric.mdmarkdown1.8 KB
references/benchmarks/release-readiness-dashboard/starter/.gitignoreother30 B
references/benchmarks/release-readiness-dashboard/starter/README.mdmarkdown272 B
references/benchmarks/release-readiness-dashboard/starter/index.htmlother324 B
references/benchmarks/release-readiness-dashboard/starter/package.jsonmanifest628 B
references/benchmarks/release-readiness-dashboard/starter/src/App.test.tsxother342 B
references/benchmarks/release-readiness-dashboard/starter/src/App.tsxother979 B
references/benchmarks/release-readiness-dashboard/starter/src/main.tsxother238 B
references/benchmarks/release-readiness-dashboard/starter/src/styles.cssother976 B
references/benchmarks/release-readiness-dashboard/starter/src/test-setup.tsscript43 B
references/benchmarks/release-readiness-dashboard/starter/src/vite-env.d.tsscript38 B
references/benchmarks/release-readiness-dashboard/starter/tsconfig.app.jsonconfig552 B
references/benchmarks/release-readiness-dashboard/starter/tsconfig.jsonconfig89 B
references/benchmarks/release-readiness-dashboard/starter/vite.config.tsscript214 B
references/benchmarks/scientific-calculator-rust/00-requirements.mdmarkdown4.1 KB
references/benchmarks/scientific-calculator-rust/README.mdmarkdown1.4 KB
references/benchmarks/scientific-calculator-rust/prompt-recursive-off.mdmarkdown1.1 KB
references/benchmarks/scientific-calculator-rust/prompt-recursive-on.mdmarkdown16.6 KB
references/benchmarks/scientific-calculator-rust/scoring-rubric.mdmarkdown1.5 KB
references/benchmarks/scientific-calculator-rust/starter/.gitignoreother14 B
references/benchmarks/scientific-calculator-rust/starter/Cargo.lockmanifest25.7 KB
references/benchmarks/scientific-calculator-rust/starter/Cargo.tomlmanifest226 B
references/benchmarks/team-capacity-board/00-requirements.mdmarkdown3.6 KB
references/benchmarks/team-capacity-board/README.mdmarkdown1.0 KB
references/benchmarks/team-capacity-board/prompt-recursive-off.mdmarkdown1.1 KB
references/benchmarks/team-capacity-board/prompt-recursive-on.mdmarkdown14.8 KB
references/benchmarks/team-capacity-board/scoring-rubric.mdmarkdown1.4 KB
references/benchmarks/team-capacity-board/starter/.gitignoreother30 B
references/benchmarks/team-capacity-board/starter/README.mdmarkdown264 B
references/benchmarks/team-capacity-board/starter/index.htmlother316 B
references/benchmarks/team-capacity-board/starter/package.jsonmanifest628 B
references/benchmarks/team-capacity-board/starter/src/App.test.tsxother334 B
references/benchmarks/team-capacity-board/starter/src/App.tsxother971 B
references/benchmarks/team-capacity-board/starter/src/main.tsxother238 B
references/benchmarks/team-capacity-board/starter/src/styles.cssother976 B
references/benchmarks/team-capacity-board/starter/src/test-setup.tsscript43 B
references/benchmarks/team-capacity-board/starter/src/vite-env.d.tsscript38 B
references/benchmarks/team-capacity-board/starter/tsconfig.app.jsonconfig552 B
references/benchmarks/team-capacity-board/starter/tsconfig.jsonconfig89 B
references/benchmarks/team-capacity-board/starter/vite.config.tsscript214 B
references/bootstrap/RECURSIVE.mdmarkdown109.9 KB
references/fixtures/tiny-tasks-smoke-recipe.mdmarkdown2.6 KB
references/local-first-web-app-checklist.mdmarkdown1.6 KB
references/plans-canonical.mdmarkdown10.8 KB
scripts/check-reusable-repo-hygiene.ps1script625 B
scripts/check-reusable-repo-hygiene.pyscript6.3 KB
scripts/install-recursive-mode.ps1script36.0 KB
scripts/install-recursive-mode.pyscript31.8 KB
scripts/install-recursive-mode.shscript363 B
scripts/lint-recursive-run.ps1script739 B
scripts/lint-recursive-run.pyscript127.4 KB
scripts/recursive-closeout.ps1script1015 B
scripts/recursive-closeout.pyscript24.0 KB
scripts/recursive-init.ps1script18.7 KB
scripts/recursive-init.pyscript12.6 KB
scripts/recursive-lock.ps1script677 B
scripts/recursive-lock.pyscript12.6 KB
scripts/recursive-review-bundle.ps1script2.9 KB
scripts/recursive-review-bundle.pyscript22.1 KB
scripts/recursive-router-cli-configure.ps1script86 B
scripts/recursive-router-cli-configure.pyscript230 B
scripts/recursive-router-cli-init.ps1script81 B
scripts/recursive-router-cli-init.pyscript225 B
scripts/recursive-router-cli-invoke.ps1script83 B
scripts/recursive-router-cli-invoke.pyscript227 B
scripts/recursive-router-cli-probe.ps1script82 B
scripts/recursive-router-cli-probe.pyscript226 B
scripts/recursive-router-cli-resolve.ps1script84 B
scripts/recursive-router-cli-resolve.pyscript228 B
scripts/recursive-router-cli-validate.ps1script85 B
scripts/recursive-router-cli-validate.pyscript229 B
scripts/recursive-router-configure.ps1script798 B
scripts/recursive-router-configure.pyscript2.8 KB
scripts/recursive-router-init.ps1script490 B
scripts/recursive-router-init.pyscript925 B
scripts/recursive-router-invoke.ps1script1.5 KB
scripts/recursive-router-invoke.pyscript4.4 KB
scripts/recursive-router-probe.ps1script735 B
scripts/recursive-router-probe.pyscript1.6 KB
scripts/recursive-router-resolve.ps1script803 B
scripts/recursive-router-resolve.pyscript1.6 KB
scripts/recursive-router-validate.ps1script494 B
scripts/recursive-router-validate.pyscript804 B
scripts/recursive-status.ps1script674 B
scripts/recursive-status.pyscript97.7 KB
scripts/recursive-subagent-action.ps1script5.8 KB
scripts/recursive-subagent-action.pyscript12.4 KB
scripts/recursive-training-extract.ps1script586 B
scripts/recursive-training-extract.pyscript1.0 KB
scripts/recursive-training-grpo.ps1script1.2 KB
scripts/recursive-training-grpo.pyscript47.2 KB
scripts/recursive-training-loader.ps1script2.3 KB
scripts/recursive-training-loader.pyscript20.1 KB
scripts/recursive-training-mcp.ps1script721 B
scripts/recursive-training-mcp.pyscript10.1 KB
scripts/recursive-training-phase8-trigger.ps1script1.4 KB
scripts/recursive-training-phase8-trigger.pyscript4.0 KB
scripts/recursive-training-sync.ps1script735 B
scripts/recursive-training-sync.pyscript6.9 KB
scripts/recursive_phase_rules.pyscript12.7 KB
scripts/recursive_router_cli_lib.pyscript77 B
scripts/recursive_router_lib.pyscript84.5 KB
scripts/run-recursive-benchmark.ps1script2.1 KB
scripts/run-recursive-benchmark.pyscript376.1 KB
scripts/test-recursive-mode-smoke.ps1script1.0 KB
scripts/test-recursive-mode-smoke.pyscript121.0 KB
scripts/test_install_recursive_mode.pyscript38.4 KB
scripts/test_lint_recursive_run.pyscript4.1 KB
scripts/test_recursive_phase_rules.pyscript21.4 KB
scripts/test_recursive_review_bundle.pyscript5.8 KB
scripts/test_recursive_router.pyscript53.3 KB
scripts/test_recursive_subagent_action.pyscript3.2 KB
scripts/test_recursive_training.pyscript12.0 KB
scripts/test_run_recursive_benchmark.pyscript160.0 KB
scripts/verify-locks.ps1script733 B
scripts/verify-locks.pyscript13.8 KB

scripts/recursive_phase_rules.py

View on GitHub
#!/usr/bin/env python3
"""
Shared phase-ordering rules, prerequisite enforcement, and lock-receipt helpers
for recursive-mode.

All gate-related scripts import this module so that phase sequencing, prerequisite
checks, and receipt I/O follow a single canonical model.
"""

from __future__ import annotations

import hashlib
import json
import re
from datetime import datetime, timezone
from pathlib import Path

# ---------------------------------------------------------------------------
# Canonical phase sequence
# ---------------------------------------------------------------------------

PHASE_SEQUENCE: list[str] = [
    "00-requirements.md",
    "00-worktree.md",
    "01-as-is.md",
    "01.5-root-cause.md",
    "02-to-be-plan.md",
    "03-implementation-summary.md",
    "03.5-code-review.md",
    "04-test-summary.md",
    "05-manual-qa.md",
    "06-decisions-update.md",
    "07-state-update.md",
    "08-memory-impact.md",
]

OPTIONAL_PHASES: frozenset[str] = frozenset(
    {
        "01-as-is.md",
        "01.5-root-cause.md",
        "02-to-be-plan.md",
        "03-implementation-summary.md",
        "03.5-code-review.md",
        "04-test-summary.md",
        "05-manual-qa.md",
    }
)

MANDATORY_PHASES: frozenset[str] = frozenset(set(PHASE_SEQUENCE) - OPTIONAL_PHASES)

# Lock receipts live in this subdirectory of the run directory.
LOCKS_SUBDIR = "locks"
RECEIPT_SUFFIX = ".receipt.json"

# ---------------------------------------------------------------------------
# Lock-hash helpers (kept here so callers don't need to duplicate them)
# ---------------------------------------------------------------------------

_LOCK_HASH_LINE_RE = re.compile(r"(?m)^[ \t]*LockHash:.*(?:\n|$)")
_STATUS_RE = re.compile(r'(?m)^[ \t]*Status:\s*(?:`|")?(\w+)(?:`|")?\s*$')
_LOCK_HASH_RE = re.compile(r'(?m)^[ \t]*LockHash:\s*(?:`|")?([a-fA-F0-9]{64})(?:`|")?\s*$')
_LOCKED_AT_RE = re.compile(r'(?m)^[ \t]*LockedAt:\s*(?:`|")?([^`"\r\n]+)(?:`|")?\s*$')


def normalize_for_lock_hash(content: str) -> str:
    normalized = content.replace("\r\n", "\n").replace("\r", "\n")
    return _LOCK_HASH_LINE_RE.sub("", normalized)


def lock_hash_from_content(content: str) -> str:
    normalized = normalize_for_lock_hash(content)
    return hashlib.sha256(normalized.encode("utf-8")).hexdigest()


# ---------------------------------------------------------------------------
# Phase index helpers
# ---------------------------------------------------------------------------


def phase_index(artifact_file: str) -> int:
    """Return the position of an artifact in PHASE_SEQUENCE, or -1 if not found."""
    try:
        return PHASE_SEQUENCE.index(artifact_file)
    except ValueError:
        return -1


def is_core_artifact(artifact_file: str) -> bool:
    """Return True if artifact_file is a known core phase artifact."""
    return artifact_file in PHASE_SEQUENCE


# ---------------------------------------------------------------------------
# Lock-validity helpers
# ---------------------------------------------------------------------------


def get_lock_status(artifact_path: Path) -> str:
    """
    Return one of:
      "MISSING"    – file does not exist
      "DRAFT"      – file exists but Status is not LOCKED
      "STALE_LOCK" – Status is LOCKED but hash or metadata is invalid
      "LOCKED"     – Status is LOCKED and hash is valid
    """
    if not artifact_path.exists():
        return "MISSING"
    content = artifact_path.read_text(encoding="utf-8")
    status_match = _STATUS_RE.search(content)
    if not status_match or status_match.group(1) != "LOCKED":
        return "DRAFT"
    hash_match = _LOCK_HASH_RE.search(content)
    locked_at_match = _LOCKED_AT_RE.search(content)
    if not hash_match or not locked_at_match:
        return "STALE_LOCK"
    stored_hash = hash_match.group(1).lower()
    actual_hash = lock_hash_from_content(content)
    if stored_hash != actual_hash:
        return "STALE_LOCK"
    return "LOCKED"


def is_lock_valid(artifact_path: Path) -> bool:
    """Return True only when get_lock_status returns "LOCKED"."""
    return get_lock_status(artifact_path) == "LOCKED"


# ---------------------------------------------------------------------------
# Prerequisite model
# ---------------------------------------------------------------------------


def get_prerequisites(artifact_file: str, run_dir: Path) -> list[str]:
    """
    Return the ordered list of phase artifact file names that must be LOCKED
    before ``artifact_file`` may be scaffolded or locked.

    The rule is simple: every phase that appears earlier in PHASE_SEQUENCE AND
    is already present on disk in ``run_dir`` must be LOCKED first.  Optional
    phases that have not been created yet are not prerequisites.
    """
    idx = phase_index(artifact_file)
    if idx <= 0:
        return []
    return [phase for phase in PHASE_SEQUENCE[:idx] if (run_dir / phase).exists()]


def get_prerequisite_blockers(
    artifact_file: str, run_dir: Path
) -> list[dict[str, str]]:
    """
    Return a list of prerequisite artifacts that are currently blocking
    ``artifact_file`` from being scaffolded or locked.

    Each entry is a dict with keys:
      "artifact" – filename (e.g. "00-requirements.md")
      "status"   – "MISSING", "DRAFT", or "STALE_LOCK"
      "path"     – absolute path as string
    """
    blockers: list[dict[str, str]] = []
    for prereq in get_prerequisites(artifact_file, run_dir):
        prereq_path = run_dir / prereq
        status = get_lock_status(prereq_path)
        if status != "LOCKED":
            blockers.append(
                {
                    "artifact": prereq,
                    "status": status,
                    "path": str(prereq_path),
                }
            )
    return blockers


def get_next_legal_phase(run_dir: Path) -> str | None:
    """
    Return the file name of the first phase in PHASE_SEQUENCE that is not yet
    LOCKED and whose prerequisites are all LOCKED, or None if the run is
    complete or blocked.

    Optional phases that were never created are treated as intentionally
    skipped — they are invisible to this function unless they exist on disk.
    """
    for phase in PHASE_SEQUENCE:
        phase_path = run_dir / phase
        # Optional phases that don't exist were intentionally omitted; skip them.
        if phase in OPTIONAL_PHASES and not phase_path.exists():
            continue
        lock_status = get_lock_status(phase_path)
        if lock_status == "LOCKED":
            continue
        # Phase is not locked; check whether prerequisites are satisfied.
        blockers = get_prerequisite_blockers(phase, run_dir)
        if not blockers:
            return phase
        # Phase (mandatory or existing optional) has unresolved prerequisites.
        return None
    return None


# ---------------------------------------------------------------------------
# Lock receipt I/O
# ---------------------------------------------------------------------------


def receipt_path(run_dir: Path, artifact_file: str) -> Path:
    stem = Path(artifact_file).stem
    return run_dir / LOCKS_SUBDIR / f"{stem}{RECEIPT_SUFFIX}"


def read_receipt(run_dir: Path, artifact_file: str) -> dict | None:
    """Read the JSON lock receipt for an artifact, or None if not found/invalid."""
    path = receipt_path(run_dir, artifact_file)
    if not path.exists():
        return None
    try:
        return json.loads(path.read_text(encoding="utf-8"))
    except (json.JSONDecodeError, OSError):
        return None


def write_receipt(
    run_dir: Path, artifact_file: str, artifact_path: Path
) -> dict:
    """
    Write a lock receipt for ``artifact_file`` recording:
      - artifact path and content hash
      - ISO-8601 locked_at timestamp
      - prerequisite file names and their current content hashes
      - hash of the previous receipt (for chaining)
      - self-hash of the receipt JSON

    Raises RuntimeError if any prerequisite is not LOCKED at the time of
    writing, ensuring the receipt chain is internally consistent.

    Returns the written receipt dict.
    """
    content = artifact_path.read_text(encoding="utf-8")
    artifact_hash = lock_hash_from_content(content)

    prereq_hashes: dict[str, str] = {}
    for prereq in get_prerequisites(artifact_file, run_dir):
        prereq_path = run_dir / prereq
        if prereq_path.exists():
            prereq_status = get_lock_status(prereq_path)
            if prereq_status != "LOCKED":
                raise RuntimeError(
                    f"Cannot write receipt for {artifact_file!r}: "
                    f"prerequisite {prereq!r} is not LOCKED (status: {prereq_status})"
                )
            prereq_content = prereq_path.read_text(encoding="utf-8")
            prereq_hashes[prereq] = lock_hash_from_content(prereq_content)

    existing = read_receipt(run_dir, artifact_file)
    prev_receipt_hash: str | None = existing.get("receipt_hash") if existing else None

    receipt: dict = {
        "artifact": artifact_file,
        "artifact_path": str(artifact_path),
        "artifact_hash": artifact_hash,
        "locked_at": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
        "prerequisite_hashes": prereq_hashes,
        "previous_receipt_hash": prev_receipt_hash,
    }
    receipt_content = json.dumps(receipt, sort_keys=True)
    receipt["receipt_hash"] = hashlib.sha256(receipt_content.encode("utf-8")).hexdigest()

    locks_dir = run_dir / LOCKS_SUBDIR
    locks_dir.mkdir(exist_ok=True)
    rpath = receipt_path(run_dir, artifact_file)
    rpath.write_text(json.dumps(receipt, indent=2, sort_keys=True), encoding="utf-8")
    return receipt


def invalidate_receipt(run_dir: Path, artifact_file: str) -> bool:
    """Remove the lock receipt for ``artifact_file``. Returns True if a receipt existed."""
    rpath = receipt_path(run_dir, artifact_file)
    if rpath.exists():
        rpath.unlink()
        return True
    return False


# ---------------------------------------------------------------------------
# Stale-chain detection
# ---------------------------------------------------------------------------


def get_stale_downstream_phases(
    artifact_file: str, run_dir: Path
) -> list[dict[str, str]]:
    """
    Return phases that have receipts referencing ``artifact_file`` as a
    prerequisite but whose stored hash no longer matches the current content.

    Each entry: {"artifact": str, "reason": str}
    """
    idx = phase_index(artifact_file)
    if idx < 0:
        return []

    current_hash: str | None = None
    artifact_path = run_dir / artifact_file
    if artifact_path.exists():
        current_hash = lock_hash_from_content(
            artifact_path.read_text(encoding="utf-8")
        )

    stale: list[dict[str, str]] = []
    for downstream in PHASE_SEQUENCE[idx + 1 :]:
        receipt = read_receipt(run_dir, downstream)
        if receipt is None:
            continue
        prereq_hashes = receipt.get("prerequisite_hashes", {})
        if artifact_file not in prereq_hashes:
            continue
        stored_hash = prereq_hashes[artifact_file]
        if current_hash is None or stored_hash != current_hash:
            stale.append(
                {
                    "artifact": downstream,
                    "reason": f"prerequisite {artifact_file!r} hash changed",
                }
            )
    return stale


def get_all_stale_receipts(run_dir: Path) -> list[dict[str, str]]:
    """
    Scan all lock receipts in ``run_dir`` and return entries where a
    prerequisite's current content hash differs from the hash recorded at
    lock time.

    Each entry: {"artifact": str, "stale_prereq": str, "reason": str}
    """
    stale: list[dict[str, str]] = []
    for phase in PHASE_SEQUENCE:
        receipt = read_receipt(run_dir, phase)
        if receipt is None:
            continue
        prereq_hashes = receipt.get("prerequisite_hashes", {})
        locked_at = receipt.get("locked_at", "unknown")
        for prereq, stored_hash in prereq_hashes.items():
            prereq_path = run_dir / prereq
            if not prereq_path.exists():
                stale.append(
                    {
                        "artifact": phase,
                        "stale_prereq": prereq,
                        "reason": f"prerequisite {prereq!r} no longer exists",
                    }
                )
                continue
            current_hash = lock_hash_from_content(
                prereq_path.read_text(encoding="utf-8")
            )
            if stored_hash != current_hash:
                stale.append(
                    {
                        "artifact": phase,
                        "stale_prereq": prereq,
                        "reason": (
                            f"prerequisite {prereq!r} content changed since lock at {locked_at}"
                        ),
                    }
                )
    return stale
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 466kUpdated Claude CodeCodexVerifiedInstall
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 466kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 319kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 319kUpdated Claude CodeCodexVerifiedInstall