claude-dev-env 2.16.0 → 2.18.0

package/.agents/skills/name-by-capability-audit/reference/report-template.md

@@ -0,0 +1,29 @@
+# Report template
+
+Emit this shape. Keep it compact.
+
+```markdown
+## Name-by-capability audit — PR #<N>
+
+**Verdict:** <clean | N violations, M OK drivers>
+
+### Violations
+| Finding | Path / title | Why | Suggested rename direction |
+|---------|--------------|-----|----------------------------|
+| Driver word on capability | `path/or/Title` | <one sentence> | <capability-oriented name family> |
+
+### OK drivers
+| Surface | Path / title | Why OK |
+|---------|--------------|--------|
+| Queue / routing / … | `path` | <one sentence> |
+
+### Notes
+- <optional: expanded offense in a package this PR grew, doc-only context, etc.>
+```
+
+### Rules for filling cells
+
+- **Finding** — short label for Violations rows only (`Driver word on capability`, `Motive framing in title`).
+- **Why** — cite the checklist item (reuse? action name? motive reserved for drivers?).
+- **Suggested rename direction** — a family of names (e.g. “STP color batch / color UID rewrite”).
+- When clean: **Verdict: clean** and omit Violation rows (keep the OK drivers / Notes sections if useful).

package/.agents/skills/name-by-capability-audit/reference/rule-checklist.md

@@ -0,0 +1,38 @@
+# Name-by-capability rule (skill-local)
+
+Prefer `docs/agents/name-by-capability.md` when that file exists in the worktree. This file is the fallback so audits still run when the docs PR has not merged yet.
+
+## Rule
+
+Name packages and modules for the **reusable work they perform**. Put a workflow or motive word (`cert`, `portal`, `export`, a product name, …) in the name only when that surface exists **solely** for that driver.
+
+1. **Capability name first.** Prefer names that say the operation (replace an asset slot, rewrite a color UID, send an email, locate a folder on disk, …).
+2. **Drivers stay at the edge.** Queue drains, report parsers, and other workflow-only shells may keep the workflow word. Libraries they call use capability names.
+3. **Orchestrators apply capabilities.** When several operations run on one artifact, one apply/orchestrator module owns stage → apply in order → result. Callers that know *why* map intents onto a registry of capability adapters.
+4. **Extend the capability, then wire the driver.** New use cases add or extend a capability adapter, then teach the driver which inputs map to it.
+
+## Checklist before accepting a new or renamed path
+
+A driver word in the name plus reuse by another workflow is a **violation**.
+
+1. Would another workflow reuse this? When yes, name the package/module for the shared action.
+2. Does the name state the action or artifact change?
+3. Is any motive word reserved for driver-only code?
+
+## Driver / motive words (non-exhaustive)
+
+Treat these as driver words when they appear in a package or module name for reusable library code:
+
+- `cert`, `cert_fix`, `cert_closeout`
+- `portal`, `export`, `submission`, `discount`
+- Product or campaign names used as a motive rather than an operation
+
+## What to score on a PR
+
+| Signal | Score when |
+|--------|------------|
+| New package/dir | Path segment carries a driver word |
+| Renamed package/module | Old or new name carries a driver word on capability code |
+| New module under an existing package | File/module stem carries a driver word for a general op |
+| PR title / scope | Frames a general shared capability change with a driver/motive word |
+| Unchanged misnamed package | Score when this PR **expands** the offense (new public API, new callers); otherwise list under Notes as out-of-diff context |

package/.agents/skills/name-by-capability-audit/reference/task-seeds.md

@@ -0,0 +1,9 @@
+# Task seeds
+
+Register each item on `TodoWrite` / `TaskCreate` at audit start. Complete with evidence.
+
+1. Load the rule: `docs/agents/name-by-capability.md` when present, else `reference/rule-checklist.md` (always keep the skill checklist as fallback).
+2. Fetch PR title, body, and changed/renamed paths via `reference/fetch-commands.md`.
+3. Classify each naming signal as violation, OK driver, or skip (`reference/offense-examples.md` classifier first).
+4. Emit report from `reference/report-template.md`.
+5. Apply the requested or suggested rename direction by default; an explicit audit-only request ends after the report.

package/.agents/skills/orchestrator/SKILL.md

@@ -122,9 +122,11 @@ pending, or when the tool is `CronCreate`.
    `rearm_pending` when already active, but still do not re-arm.)
 2. **Bind the shared advisor before any executor.** Follow
    [`_shared/advisor/advisor-protocol.md`](../../_shared/advisor/advisor-protocol.md)
-   end to end: detect the host profile, compute the floor from the
+   end to end: name the session identity, compute the floor from the
    orchestrator consumer set — this session plus every tier in the
-   routing table (its Model floor section) — walk the ladder top-down,
+   routing table (its Model floor section) — walk the ladder for that
+   host (Claude: Fable first, then Sol when Fable is out of usage;
+   Codex: Sol in-session; ThirdParty: headless Fable then Sol),
    and fail closed when nothing binds. This session owns the advisor's
    whole lifecycle (its Lifecycle ownership section); executors only ever
    message the warm agent or report here, and an executor that finds the
@@ -261,8 +263,8 @@ Routing rules:
   way — the coding spawn stops and the orchestrator reports it.
 - Host detection follows
   [`_shared/advisor/advisor-protocol.md`](../../_shared/advisor/advisor-protocol.md)
-  (Host profiles section, `detect_host_profile`) — the sole detection
-  system, with no second one.
+  (Host profiles section, `resolve_session_identity` then
+  `detect_host_profile`) — the sole detection system, with no second one.
 - Resume a warm workflow agent before creating a new workflow run when
   the warm agent holds the relevant context.
 - Review and verification workflows apply the [review guide](../reviews/SKILL.md#review-workflow).

package/.agents/skills/orchestrator-refresh/SKILL.md

@@ -10,10 +10,10 @@ description: >-
 
 # Orchestrator Refresh
 
-Detect the host profile first (see Host profiles in
+Name the session identity first (see Host profiles in
 [`_shared/advisor/advisor-protocol.md`](../../_shared/advisor/advisor-protocol.md)).
 Re-assert the discipline for that host only — do not invent an Agent-tool
-Claude `session-advisor` spawn on a third-party host.
+Claude `session-advisor` spawn on a Codex or third-party host.
 
 ## 0. status_gate first (deterministic)
 
@@ -94,9 +94,13 @@ once, and reports the unreachable advisor.
      the protocol's warm-up rule states;
      `hooks/blocking/fable_spawn_gate.py` denies a fable spawn whose
      prompt lacks it.
-   - **Third-party host:** advisor is a max-tier Claude CLI bind owned
-     by this session (`claude_chain_runner.py`, Fable high then Opus
-     max). Do **not** spawn `session-advisor` via Agent. Executors
+   - **Codex host:** advisor is a native in-session Sol subagent owned
+     by this session. Do **not** spawn Claude `session-advisor` via
+     Agent. Executors consult that Sol subagent in-session. If Sol does
+     not bind, fail closed.
+   - **Third-party host:** advisor is a Claude CLI bind owned
+     by this session (`claude_chain_runner.py`, Fable then Sol when Fable
+     is out of usage, both at `ADVISOR_EFFORT`). Do **not** spawn `session-advisor` via Agent. Executors
      report blockers here; consult the CLI advisor and relay signals.
      If the CLI bind is unreachable, fail closed — do not answer the
      four signals as this third-party session.

package/.agents/skills/pr-cleanup/SKILL.md

@@ -0,0 +1,99 @@
+---
+name: pr-cleanup
+description: >-
+  Clean a PR end-to-end with one coding agent: shared-extraction-audit,
+  name-by-capability-audit, sr-loop, then small-cl — apply and validate fixes
+  as they return. Use when the user asks for /pr-cleanup or full PR cleanup
+  (place, name, converge, then shrink).
+---
+
+# PR cleanup
+
+One coding agent cleans a pull request end-to-end: put code in the right place,
+name it for what it does, run the converging cleanup loop, then shrink the
+change into a reviewable size.
+
+This skill is host-neutral. Any coding agent that can edit the PR head, run
+scoped tests, and invoke the composed skills may run it.
+
+## When to use
+
+- `/pr-cleanup <PR>` or “run pr-cleanup on this PR”
+- A PR needs extraction + naming + sr-loop + a smaller reviewable slice in one pass
+
+## Inputs
+
+- Target: PR URL, number, or branch (required). Missing → ask:
+  `Give a GitHub PR number or URL for pr-cleanup.`
+- Repo: take from the PR URL when given; otherwise the user’s default monitored repo
+
+## Composition (run in this order)
+
+| Step | Skill | Role |
+|------|--------|------|
+| 1 | `shared-extraction-audit` | Wrong *place* (workflow package vs shared library) |
+| 2 | `name-by-capability-audit` | Wrong *name* (driver word on reusable capability) |
+| 3 | `sr-loop` / `e-simplify` then `e-code-review` | Converging simplify + high-effort review with `--fix` |
+| 4 | `small-cl` | Split / shrink into a focused reviewable PR |
+
+All four run under **one coding agent session** on the same worktree / PR head.
+For sr-loop advisor consults, bind `team-advisor` as a second session at equal
+tier when the host supports it (see `team-advisor` and the advisor docs).
+
+## Fix-as-you-go (required)
+
+Some of these skills can report without changing code. For **pr-cleanup**, that
+is not enough:
+
+1. **Stream findings** — as each audit/loop returns an item (offense, rename,
+   simplify fix, review finding), treat it as work to do now, not a backlog.
+2. **Apply the fix** on the PR head (or the first small-cl increment if already
+   splitting) before moving on to the next item when practical.
+3. **Validate** after each applied fix: scoped tests beside touched files (or
+   `py_compile` / package tests when there is no adjacent suite). No test theater.
+4. **Commit + push** after each validated changing pass (one concern per commit
+   when possible; keep the PR draft).
+5. **Do not** finish with an audit-only report while known P0/P1 fixes sit
+   unapplied — either fix them or hard-block with why.
+
+If the user says **audit-only**, stop after reports and skip apply / small-cl.
+
+## Process
+
+1. Resolve PR → convert to draft if needed; clean worktree of the PR head;
+   never mark ready for review.
+2. Run the four composed skills in order on that head:
+   - `shared-extraction-audit` in the **implement** band (not audit-only)
+   - `name-by-capability-audit`; apply clear rename directions (or ones the user
+     already approved), noting rename direction in the commit message
+   - `sr-loop`: Phase A `e-simplify`, Phase B `e-code-review` at **xhigh** with
+     `--fix` (not the default low); consult `team-advisor` before the first
+     write and after writes + validation
+   - Apply fixes as each pass returns findings; validate → commit → push
+3. After the loop converges (or nits-only stop): run **small-cl** — identify the
+   first coherent reviewable increment; if the PR is still too wide, split or
+   retitle/scope per small-cl (do not invent extra PRs unless the user asked).
+4. Return the finish report below. Merge-ready email / chat delivery is owned by
+   the caller (for example a PR monitor host), not this skill.
+
+## Hard rules
+
+- No test theater.
+- Real spawn/behavior validation when the PR claims an external binary path.
+- Prefer cleanup; functional only for correctness. Label each commit
+  `cleanup` vs `functional`.
+- Keep the PR draft. Never mark ready for review during this skill.
+- Extraction before rename when both apply to the same symbol (move, then name
+  the new home).
+- small-cl last — shrink only after place / name / cleanup are settled enough
+  that the slice is honest.
+
+## Finish report
+
+- PR / repo / starting_sha / ending_sha
+- Per step: extraction findings applied, naming violations applied, sr-loop
+  passes + commits, small-cl outcome (kept / split plan)
+- `commits_pushed` with cleanup|functional labels
+- `validation_ran` + outcomes
+- `hard_block` or null
+- `draft_still: true`

package/.agents/skills/prototype/reference/honest-limitations.md

@@ -8,7 +8,7 @@ State both of these to the user, in these terms, whenever a proof-of-concept is
 
 Promotion records the controls applied to the real diff:
 
-- review and verification under the [review guide](../../reviews/SKILL.md#review-workflow);
+- review and verification under the [review guide](../../skills-archived/reviews/SKILL.md#review-workflow);
 - the `privacy-hygiene` sweep for personal data and secrets;
 - the pull-request review criteria and any PR-loop reviewers.
 

package/.agents/skills/prototype/reference/promotion-tasks.md

@@ -14,7 +14,7 @@ Promotion runs in the **normal, fully-hooked session** — never inside the `--b
 
 5. **Privacy sweep.** Run the `privacy-hygiene` skill over the full applied working tree, not only the diff — a POC that pulled live data can leave a secret in a file the diff view hides. Evidence: its clean report, or the leak it found and how it was removed. If the skill is missing, do a manual PII and secret review and say so.
 
-6. **Review and verify the real diff.** Apply the [review guide](../../reviews/SKILL.md#review-workflow). Evidence: the checks run and each required finding repaired. Do not rely on sandbox testing as promotion evidence.
+6. **Review and verify the real diff.** Apply the [review guide](../../skills-archived/reviews/SKILL.md#review-workflow). Evidence: the checks run and each required finding repaired. Do not rely on sandbox testing as promotion evidence.
 
 7. **Commit and open a draft PR.** After the review and verification record is complete, commit by hand per the `git-workflow` rule, then open a draft PR. Evidence: the commit hash and the PR URL.
 

package/.agents/skills/prototype/scripts/test_build_sandbox_settings.py

@@ -27,7 +27,7 @@ DESTRUCTIVE_HOOK_BASENAME = ALL_SAFETY_HOOK_SCRIPT_BASENAMES[1]
 
 CODE_RULES_HOOK_BASENAME = "code_rules_enforcer.py"
 TDD_HOOK_BASENAME = "tdd_enforcer.py"
-PLAIN_LANGUAGE_HOOK_BASENAME = "plain_language_blocker.py"
+QUESTION_SHAPE_HOOK_BASENAME = "ask_user_question_shape_blocker.py"
 
 BASH_MATCHER = "Bash"
 WRITE_MATCHER = "Write"
@@ -186,7 +186,7 @@ def test_build_excludes_every_non_safety_hook() -> None:
     for each_excluded in (
         CODE_RULES_HOOK_BASENAME,
         TDD_HOOK_BASENAME,
-        PLAIN_LANGUAGE_HOOK_BASENAME,
+        QUESTION_SHAPE_HOOK_BASENAME,
     ):
         assert all(each_excluded not in each_command for each_command in all_commands)
 

package/.agents/skills/prototype/workflows/promotion.md

@@ -15,11 +15,11 @@ The task seeds carry the full ordered detail. The shape:
 3. **Bring content as an uncommitted diff.** Copy the POC's file changes into the new branch's working tree. Do not cherry-pick or merge the sandbox commits; the sandbox history stays behind.
 4. **Cleanup.** Remove scratch files, debug dumps, and temp helpers the POC created (`cleanup-temp-files` rule).
 5. **Privacy sweep** via `privacy-hygiene` over the diff.
-6. **Review and verify** the real diff against the [review guide](../../reviews/SKILL.md#review-workflow). Record the checks run and repair every required finding.
+6. **Review and verify** the real diff against the [review guide](../../skills-archived/reviews/SKILL.md#review-workflow). Record the checks run and repair every required finding.
 7. **Commit and PR.** After the review and verification record is complete, commit by hand per the `git-workflow` rule, then open a draft PR.
 8. **State the honest limitations** from `reference/honest-limitations.md` in the PR body or to the user.
 9. **Converge** by handing the PR to `autoconverge` by default; use `pr-converge` for paced ticks or `bugteam` for an open-loop audit.
 
 ## Why the clean room, not a push
 
-`code_rules_enforcer` is a write-time Write/Edit gate. Content that lands through `git apply`, `git checkout`, or cherry-pick receives the clean-room controls in steps 4–6: cleanup, privacy review, and review and verification under the [review guide](../../reviews/SKILL.md#review-workflow). The promotion record states the checks run and the remaining TDD limitation.
+`code_rules_enforcer` is a write-time Write/Edit gate. Content that lands through `git apply`, `git checkout`, or cherry-pick receives the clean-room controls in steps 4–6: cleanup, privacy review, and review and verification under the [review guide](../../skills-archived/reviews/SKILL.md#review-workflow). The promotion record states the checks run and the remaining TDD limitation.

package/.agents/skills/review-router/SKILL.md

@@ -0,0 +1,51 @@
+---
+name: review-router
+description: >-
+  Resolve and arm one supported `route_review_config` route through the registered Agent|Task gate. Triggers: /review-router and guarded reviewer spawn.
+---
+
+# Review Router
+
+Resolve and arm the supported `e-simplify` route. The registered `PreToolUse Agent|Task` hook enforces the exact armed spawn payload.
+
+## When this applies
+
+Use for `/review-router` and route execution after `/review-tier`. Return `UNSUPPORTED_ROUTE` for `e-code-review`; preserve `/e-code-review` behavior.
+
+## Operations
+
+1. Register `reference/task-seeds.md` with the host task tool.
+2. Call `scripts/review_router_cli.py resolve` for the current `route_policy_hash` decision and optional tier override.
+3. Call `arm` for the exact selected slot and dispatch the returned Agent|Task payload.
+4. Let the registered hook enforce the payload, then call `close`.
+
+The route topology is fixed: T1 uses one Luna High slot, T2 uses one Luna Max slot, and T3 uses six ordered Luna High slots.
+
+## Composition
+
+| Peer | When | Produces | Missing behavior |
+|---|---|---|---|
+| `/review-tier` | Before routing | Current tier decision | Return the route request to `/review-tier`. |
+| `/e-simplify` | When cleanup review is requested | Cleanup review request | Return `UNSUPPORTED_ROUTE`. |
+
+## File index
+
+| File | Purpose |
+|---|---|
+| `SKILL.md` | Route contract and operations |
+| `reference/route-policy.json` | Supported route topology |
+| `reference/task-seeds.md` | Current route task seeds |
+| `scripts/review_router.py` | `route_policy_hash` input and route resolution |
+| `scripts/review_router_cli.py` | Resolve, arm, and close operations |
+| `scripts/test_review_router.py` | Route policy tests |
+| `scripts/test_review_router_cli.py` | CLI rejection tests |
+| `scripts/test_review_router_integration.py` | CLI and registered-hook tests |
+| `scripts/review_router_constants/config/constants.py` | Portable route constants |
+| `scripts/review_router_constants/config/__init__.py` | Runtime configuration package |
+| `scripts/review_router_constants/__init__.py` | Constants package |
+| `scripts/conftest.py` | Test import setup |
+
+## Folder map
+
+- `reference/` — route policy and task seeds.
+- `scripts/` — route resolution, CLI operations, and tests.

package/.agents/skills/review-router/reference/route-policy.json

@@ -0,0 +1,7 @@
+{
+  "version": 1,
+  "routes": {
+    "e-simplify": {"status": "SUPPORTED", "skill": "e-simplify", "tiers": ["T1", "T2", "T3"], "models": {"T1": {"role": "executor", "model": "gpt-5.6-luna", "effort": "high", "pass_ids": ["simplify-01"]}, "T2": {"role": "executor", "model": "gpt-5.6-luna", "effort": "max", "pass_ids": ["simplify-01"]}, "T3": {"role": "executor", "model": "gpt-5.6-luna", "effort": "high", "pass_ids": ["simplify-01", "simplify-02", "simplify-03", "simplify-04", "simplify-05", "simplify-06"]}}},
+    "e-code-review": {"status": "UNSUPPORTED_ROUTE", "skill": "e-code-review", "tiers": []}
+  }
+}

package/.agents/skills/review-router/reference/task-seeds.md

@@ -0,0 +1 @@
+Register resolve e-simplify, apply override, arm exact slot, enforce through the registered Agent|Task hook, close the decision, and report unsupported e-code-review as host tasks. Complete each with command output or the current decision/armed record.

package/.agents/skills/review-router/scripts/conftest.py

@@ -0,0 +1,4 @@
+from pathlib import Path
+import sys
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))

package/.agents/skills/review-router/scripts/review_router.py

@@ -0,0 +1,50 @@
+"""Thin route orchestrator for review-tier decisions."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from review_router_constants.config.constants import UNSUPPORTED_ROUTE, UNSUPPORTED_TIER
+
+
+def load_route_policy() -> dict:
+    """Load versioned route policy data.
+
+    Args:
+    Returns:
+        Route policy mapping.
+    Raises:
+        ValueError: If the policy schema is invalid.
+    """
+    policy_path = Path(__file__).parent.parent / "reference" / "route-policy.json"
+    policy = json.loads(policy_path.read_text(encoding="utf-8"))
+    if policy.get("version") != 1 or not isinstance(policy.get("routes"), dict):
+        raise ValueError("malformed route policy")
+    return policy
+
+
+def resolve_route(route: str, tier: str, policy: dict | None = None) -> dict:
+    """Resolve one route or return a stable unsupported result.
+
+    Args:
+        route: Requested route name.
+        tier: Effective tier.
+        policy: Optional route policy.
+    Returns:
+        Dispatch record or unsupported status.
+    """
+    selected_policy = policy or load_route_policy()
+    route_record = selected_policy["routes"].get(route)
+    if route_record is None or route_record["status"] != "SUPPORTED":
+        return {"status": UNSUPPORTED_ROUTE, "route": route, "tier": tier}
+    if tier not in route_record["tiers"]:
+        return {"status": UNSUPPORTED_TIER, "route": route, "tier": tier}
+    dispatch = route_record["models"][tier]
+    return {
+        "status": "SUPPORTED",
+        "route": route,
+        "tier": tier,
+        "skill": route_record["skill"],
+        "dispatch": dispatch,
+    }

package/.agents/skills/review-router/scripts/review_router_cli.py

@@ -0,0 +1,211 @@
+"""CLI for signed review decisions and one-time spawn permits."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import hmac
+import json
+import os
+import shlex
+import secrets
+import sys
+from pathlib import Path
+
+tier_script = Path(__file__).resolve().parents[1].parent / "review-tier" / "scripts"
+if str(tier_script) not in sys.path:
+    sys.path.insert(0, str(tier_script))
+from review_router_constants.config.constants import (  # noqa: E402
+    ALL_OVERRIDE_VALUES,
+    CLEANUP_CONTRACT,
+    DECISION_ID_BYTES,
+    INTEGRITY_KEY_BYTES,
+    INVALID_ROUTE_ARM,
+    INVALID_ROUTE_RECORD,
+    MALFORMED_TIER_OVERRIDE,
+    ROUTE_SPAWN_ARMED,
+    UNKNOWN_ROUTE_SLOT,
+    UNSUPPORTED_ROUTE,
+)
+from review_tier import (  # noqa: E402
+    build_generation,
+    canonical_json_hash,
+    inventory_generation,
+    policy_hash,
+    router_state_directory,
+    router_state_root,
+    router_state_root_id,
+)
+from review_router import load_route_policy, resolve_route  # noqa: E402
+
+
+def _write_signed(directory: Path, name: str, record: dict, secret: bytes) -> None:
+    encoded = _encode_record(record)
+    temporary = directory / f".{name}.tmp"
+    temporary.write_bytes(encoded)
+    temporary.replace(directory / name)
+    (directory / f"{name}.hmac").write_text(hmac.new(secret, encoded, hashlib.sha256).hexdigest(), encoding="ascii")
+
+
+def _read_signed(directory: Path, name: str) -> dict:
+    secret = (directory / "integrity.key").read_bytes()
+    record_path = directory / name
+    encoded = record_path.read_bytes()
+    expected = hmac.new(secret, encoded, hashlib.sha256).hexdigest()
+    if not hmac.compare_digest(expected, (directory / f"{name}.hmac").read_text(encoding="ascii")):
+        raise ValueError(INVALID_ROUTE_RECORD)
+    return json.loads(encoded)
+
+
+def _encode_record(record: dict) -> bytes:
+    return json.dumps(record, sort_keys=True, separators=(",", ":")).encode()
+
+
+def _override(arguments: str) -> str | None:
+    tokens = shlex.split(arguments)
+    matches = [token for token in tokens if token == "--tier" or token.startswith("--tier=")]
+    if len(matches) > 1:
+        raise ValueError(MALFORMED_TIER_OVERRIDE)
+    if not matches:
+        return None
+    if matches[0] == "--tier":
+        index = tokens.index("--tier")
+        if index + 1 >= len(tokens) or tokens[index + 1] not in ALL_OVERRIDE_VALUES:
+            raise ValueError(MALFORMED_TIER_OVERRIDE)
+        return f"T{tokens[index + 1]}"
+    override = matches[0].split("=", 1)[1]
+    if override not in ALL_OVERRIDE_VALUES:
+        raise ValueError(MALFORMED_TIER_OVERRIDE)
+    return f"T{override}"
+
+
+def resolve(cwd: str, review_kind: str, arguments: str, base_ref: str | None) -> dict:
+    """Create a signed review decision.
+
+    Args:
+        cwd: Repository path.
+        review_kind: Requested review route.
+        arguments: Review command arguments.
+        base_ref: Optional base reference.
+    Returns:
+        Decision summary.
+    Raises:
+        ValueError: If the override or base reference is invalid.
+    """
+    route_policy = load_route_policy()
+    route_record = route_policy["routes"].get(review_kind)
+    if route_record is None or route_record.get("status") != "SUPPORTED":
+        return {"status": UNSUPPORTED_ROUTE}
+    override = _override(arguments)
+    directory = router_state_directory(cwd)
+    if (directory / "armed-spawn.json").exists():
+        raise ValueError(ROUTE_SPAWN_ARMED)
+    directory.mkdir(parents=True, exist_ok=True)
+    key_path = directory / "integrity.key"
+    if not key_path.exists():
+        key_path.write_bytes(secrets.token_bytes(INTEGRITY_KEY_BYTES))
+    secret = key_path.read_bytes()
+    state_root = router_state_root(cwd)
+    generation = build_generation(cwd, requested_override=override, base_ref=base_ref, state_root=state_root)
+    route = resolve_route(review_kind, generation["effective_tier"], route_policy)
+    decision_id = secrets.token_hex(DECISION_ID_BYTES)
+    dispatch = route["dispatch"]
+    slots = [{"slot_id": each_slot_id, "model": dispatch["model"], "effort": dispatch["effort"]} for each_slot_id in dispatch["pass_ids"]]
+    decision = {**generation, "decision_id": decision_id, "review_kind": review_kind, "route_policy_hash": policy_hash(route_policy), "state_root_id": router_state_root_id(state_root), "slots": slots}
+    _write_signed(directory, "decision.json", decision, secret)
+    return {"status": "SUPPORTED", "decision_id": decision_id, "effective_tier": decision["effective_tier"], "automatic_tier": decision["calculated_tier"], "slot_ids": [slot["slot_id"] for slot in slots]}
+
+
+def arm(cwd: str, decision_id: str, slot_id: str) -> dict:
+    """Create a one-time spawn permit.
+
+    Args:
+        cwd: Repository path.
+        decision_id: Decision identifier.
+        slot_id: Selected dispatch slot.
+    Returns:
+        Agent tool payload.
+    Raises:
+        OSError: If signed state is unavailable.
+        ValueError: If the decision or slot is invalid.
+    """
+    directory = router_state_directory(cwd)
+    secret = (directory / "integrity.key").read_bytes()
+    decision = _read_signed(directory, "decision.json")
+    if decision["decision_id"] != decision_id or (directory / "armed-spawn.json").exists():
+        raise ValueError(INVALID_ROUTE_ARM)
+    consumed_prefix = f"{decision_id}--{slot_id}"
+    if any(path.name.startswith(consumed_prefix) for path in (directory / "consumed").glob(f"{consumed_prefix}*")):
+        raise ValueError(INVALID_ROUTE_ARM)
+    slot = next((each_slot for each_slot in decision["slots"] if each_slot["slot_id"] == slot_id), None)
+    if slot is None:
+        raise ValueError(UNKNOWN_ROUTE_SLOT)
+    consumed_slots = {path.name.split("--", 1)[1].split(".", 1)[0] for path in (directory / "consumed").glob(f"{decision_id}--*.json")}
+    expected_slots = [each_slot["slot_id"] for each_slot in decision["slots"] if each_slot["slot_id"] not in consumed_slots]
+    if expected_slots and slot_id != expected_slots[0]:
+        raise ValueError(INVALID_ROUTE_ARM)
+    decision_base = decision.get("base_ref") if decision.get("base_source") == "explicit" else None
+    state_root = router_state_root(cwd)
+    current_hash = str(inventory_generation(cwd, decision_base, state_root=state_root)["diff_hash"])
+    if current_hash != decision["diff_hash"]:
+        raise ValueError(INVALID_ROUTE_ARM)
+    prompt = f"{CLEANUP_CONTRACT} Review {decision['review_kind']} for {decision['worktree']}. Angles: Reuse, Simplification, Efficiency, Altitude. Apply direct fixes within scope. Skip correctness, security, behavior-changing, and out-of-scope findings. Decision {decision_id}; slot {slot_id}."
+    spawn = {"decision_id": decision_id, "decision_hash": canonical_json_hash(decision), "state_root_id": router_state_root_id(state_root), "slot_id": slot_id, "tool_name": "Agent", "executor_type": "Luna", "model": slot["model"], "effort": slot["effort"], "prompt": prompt, "prompt_hash": hashlib.sha256(prompt.encode()).hexdigest(), "diff_hash": decision["diff_hash"]}
+    _write_signed(directory, "armed-spawn.json", spawn, secret)
+    return {"tool_name": "Agent", "tool_input": {"executor_type": "Luna", "model": spawn["model"], "effort": spawn["effort"], "prompt": prompt}}
+
+
+def close(cwd: str, decision_id: str) -> dict:
+    """Close a decision after its permit is consumed.
+
+    Args:
+        cwd: Repository path.
+        decision_id: Decision identifier.
+    Returns:
+        Closure summary.
+    Raises:
+        OSError: If signed state is unavailable.
+        ValueError: If the decision is invalid or still armed.
+    """
+    directory = router_state_directory(cwd)
+    decision = _read_signed(directory, "decision.json")
+    if decision["decision_id"] != decision_id or (directory / "armed-spawn.json").exists():
+        raise ValueError(ROUTE_SPAWN_ARMED)
+    (directory / "decision.json").unlink()
+    (directory / "decision.json.hmac").unlink()
+    return {"status": "CLOSED", "decision_id": decision_id}
+
+
+def main() -> int:
+    """Run the review-routing command line interface.
+
+    Returns:
+        Process exit status.
+    """
+    parser = argparse.ArgumentParser()
+    parser.add_argument("command", choices=("resolve", "arm", "close"))
+    parser.add_argument("--review-kind", default="e-simplify")
+    parser.add_argument("--cwd", default=os.getcwd())
+    parser.add_argument("--arguments", default="")
+    parser.add_argument("--base-ref")
+    parser.add_argument("--decision-id")
+    parser.add_argument("--slot")
+    parser.add_argument("--requested", action="store_true")
+    options = parser.parse_args()
+    if options.requested:
+        parser.error("--requested is not supported")
+    try:
+        if options.command == "resolve":
+            dispatch_record = resolve(options.cwd, options.review_kind, options.arguments, base_ref=options.base_ref)
+        elif options.command == "arm":
+            dispatch_record = arm(options.cwd, options.decision_id, options.slot)
+        else:
+            dispatch_record = close(options.cwd, options.decision_id)
+    except (OSError, ValueError) as error:
+        parser.error(str(error))
+    print(json.dumps(dispatch_record, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/.agents/skills/review-router/scripts/review_router_constants/__init__.py

@@ -0,0 +1 @@
+"""Review-router constants package."""

package/.agents/skills/review-router/scripts/review_router_constants/config/constants.py

@@ -0,0 +1,13 @@
+"""Constants for route_review_config."""
+
+UNSUPPORTED_ROUTE = "UNSUPPORTED_ROUTE"
+UNSUPPORTED_TIER = "UNSUPPORTED_TIER"
+INVALID_ROUTE_RECORD = "INVALID_ROUTE_RECORD"
+MALFORMED_TIER_OVERRIDE = "MALFORMED_TIER_OVERRIDE"
+INVALID_ROUTE_ARM = "INVALID_ROUTE_ARM"
+UNKNOWN_ROUTE_SLOT = "UNKNOWN_ROUTE_SLOT"
+ROUTE_SPAWN_ARMED = "ROUTE_SPAWN_ARMED"
+ALL_OVERRIDE_VALUES = ("1", "2", "3")
+INTEGRITY_KEY_BYTES = 32
+DECISION_ID_BYTES = 16
+CLEANUP_CONTRACT = """This is a cleanup-only review of the current diff, not a correctness or security bug hunt. Gather the diff and include uncommitted changes. Review reuse, simplification, efficiency, and altitude. Reuse existing helpers and adjacent patterns. Simplify redundant state, copy-paste, nesting, dead code, and unnecessary complexity. Remove redundant computation, repeated I/O, sequential independent work, and long-lived captured objects. Fix each issue at the owning abstraction and preserve the intended behavior. Apply safe fixes directly within the reviewed diff. Each finding has file, line, summary, and concrete cost. Skip findings whose fix changes intended behavior, reaches outside the diff, or belongs to correctness review. Respond exactly: That's a correctness review — use /e-code-review, not this skill. Finish with what was fixed and what was skipped."""