ultra-builder-pro-cli 0.10.0 → 0.11.0

package/skills/ultra-review/scripts/review_wait.py

@@ -1,88 +1,254 @@
 #!/usr/bin/env python3
-"""Review Wait - File-based completion waiter for /ultra-review pipeline.
-
-Polls the session directory for expected review JSON files and/or SUMMARY.json.
-Returns a one-line verdict on stdout. Blocks until complete or timeout.
+"""Wait for and validate Ultra review v2 artifacts.
 
 Usage:
-    python3 review_wait.py <session_path> agents <count>   # Wait for N review-*.json files
-    python3 review_wait.py <session_path> summary           # Wait for SUMMARY.json only
+    python3 review_wait.py <session_path> agents <artifact-stem> [<artifact-stem> ...]
+    python3 review_wait.py <session_path> summary
 
-Exit codes:
-    0 - All expected files found
-    1 - Timeout (default 5 minutes)
-    2 - Invalid arguments
+The agents mode validates the exact named JSON files. The summary mode validates the
+two-axis verdict contract. Timeout and poll intervals can be shortened in tests with
+UBP_REVIEW_WAIT_TIMEOUT and UBP_REVIEW_WAIT_POLL.
 """
 
-import glob
 import json
+import os
+import re
 import sys
 import time
 from pathlib import Path
 
-POLL_INTERVAL = 2  # seconds
-DEFAULT_TIMEOUT = 300  # 5 minutes
+FINDINGS_SCHEMA = "ultra-review-findings-v2"
+SUMMARY_SCHEMA = "ultra-review-summary-v2"
+AXES = {"spec_fidelity", "engineering_standards"}
+SEVERITIES = {"P0", "P1", "P2", "P3"}
+AXIS_VERDICTS = {"PASS", "FAIL", "INCOMPLETE"}
+OVERALL_VERDICTS = {"APPROVE", "REQUEST_CHANGES", "INCOMPLETE"}
+ARTIFACT_STEM = re.compile(r"^[a-z][a-z0-9-]*$")
+FINDING_FIELDS = {
+    "id", "axis", "severity", "category", "title", "file", "line", "trigger",
+    "impact", "evidence", "suggestion",
+}
+
+
+def env_seconds(name: str, default: float) -> float:
+    try:
+        value = float(os.environ.get(name, default))
+    except (TypeError, ValueError):
+        return default
+    return value if value > 0 else default
+
+
+DEFAULT_TIMEOUT = env_seconds("UBP_REVIEW_WAIT_TIMEOUT", 300.0)
+POLL_INTERVAL = env_seconds("UBP_REVIEW_WAIT_POLL", 2.0)
+
+
+def read_json(path: Path):
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as error:
+        return None, f"unreadable JSON: {error}"
+    if not isinstance(data, dict):
+        return None, "top-level value must be an object"
+    return data, None
+
+
+def nonempty_string(value) -> bool:
+    return isinstance(value, str) and bool(value.strip())
+
+
+def validate_finding(finding, artifact_axis: str, seen_ids):
+    if not isinstance(finding, dict):
+        return "finding must be an object"
+    missing = sorted(FINDING_FIELDS - set(finding))
+    if missing:
+        return f"finding missing fields: {', '.join(missing)}"
+    if not nonempty_string(finding.get("id")):
+        return "finding id must be a non-empty string"
+    if finding["id"] in seen_ids:
+        return f"duplicate finding id: {finding['id']}"
+    seen_ids.add(finding["id"])
+    if finding.get("axis") != artifact_axis:
+        return "finding axis must match artifact axis"
+    if finding.get("severity") not in SEVERITIES:
+        return "finding severity must be P0, P1, P2, or P3"
+    for field in ["category", "title", "file", "trigger", "impact", "evidence", "suggestion"]:
+        if not nonempty_string(finding.get(field)):
+            return f"finding {field} must be a non-empty string"
+    if not isinstance(finding.get("line"), int) or finding["line"] < 1:
+        return "finding line must be a positive integer"
+    line_end = finding.get("line_end")
+    if line_end is not None and (not isinstance(line_end, int) or line_end < finding["line"]):
+        return "finding line_end must be at or after line"
+    return None
+
+
+def validate_specialist(data):
+    if data.get("$schema") != FINDINGS_SCHEMA:
+        return f"$schema must be {FINDINGS_SCHEMA}"
+    if not nonempty_string(data.get("agent")):
+        return "agent must be a non-empty string"
+    axis = data.get("axis")
+    if axis not in AXES:
+        return "axis must be spec_fidelity or engineering_standards"
+    for field in ["session", "timestamp"]:
+        if not nonempty_string(data.get(field)):
+            return f"{field} must be a non-empty string"
+    scope = data.get("scope")
+    if not isinstance(scope, dict):
+        return "scope must be an object"
+    for field in ["head", "range"]:
+        if not nonempty_string(scope.get(field)):
+            return f"scope.{field} must be a non-empty string"
+    if not isinstance(scope.get("files_analyzed"), list) or not all(
+        nonempty_string(item) for item in scope["files_analyzed"]
+    ):
+        return "scope.files_analyzed must be a string array"
+    if not isinstance(scope.get("diff_only"), bool):
+        return "scope.diff_only must be boolean"
+    if data.get("status") != "complete":
+        return "status must be complete"
+    findings = data.get("findings")
+    if not isinstance(findings, list):
+        return "findings must be an array"
+    seen_ids = set()
+    for finding in findings:
+        error = validate_finding(finding, axis, seen_ids)
+        if error:
+            return error
+    for field in ["positive_observations", "limitations"]:
+        if not isinstance(data.get(field), list):
+            return f"{field} must be an array"
+    return None
 
 
-def wait_for_agents(session_path: Path, expected_count: int, timeout: int) -> bool:
-    """Wait for expected_count review-*.json files to appear.
+def evaluate_artifacts(session_path: Path, expected):
+    done = []
+    missing = []
+    invalid = []
+    errors = {}
+    for stem in expected:
+        path = session_path / f"{stem}.json"
+        if not path.exists():
+            missing.append(stem)
+            continue
+        data, error = read_json(path)
+        if error is None:
+            error = validate_specialist(data)
+        if error:
+            invalid.append(stem)
+            errors[stem] = error
+        else:
+            done.append(stem)
+    return done, missing, invalid, errors
 
-    Returns structured JSON on stdout:
-    - status: "complete" (all agents) or "partial" (>=1 agent on timeout)
-    - agents_done / agents_missing: lists of agent names
-    - count: number of completed agents
 
-    Exit code: 0 if all complete OR partial (>=1), 1 if 0 agents.
-    """
-    all_agents = ["review-code", "review-tests", "review-errors",
-                  "review-design", "review-comments"]
+def wait_for_agents(session_path: Path, expected, timeout: float) -> bool:
     deadline = time.monotonic() + timeout
-    while time.monotonic() < deadline:
-        found = glob.glob(str(session_path / "review-*.json"))
-        if len(found) >= expected_count:
-            names = [Path(f).stem for f in sorted(found)]
-            result = {"status": "complete", "agents_done": names, "agents_missing": [], "count": len(found)}
-            print(json.dumps(result))
+    while True:
+        done, missing, invalid, errors = evaluate_artifacts(session_path, expected)
+        if len(done) == len(expected):
+            print(json.dumps({
+                "status": "complete",
+                "artifacts_done": done,
+                "artifacts_missing": [],
+                "artifacts_invalid": [],
+                "errors": {},
+                "count": len(done),
+            }, sort_keys=True))
             return True
-        remaining = int(deadline - time.monotonic())
-        sys.stderr.write(f"\r  Waiting: {len(found)}/{expected_count} ({remaining}s remaining)")
-        sys.stderr.flush()
-        time.sleep(POLL_INTERVAL)
-
-    # Timeout — report partial results as structured JSON
-    found = glob.glob(str(session_path / "review-*.json"))
-    found_names = [Path(f).stem for f in sorted(found)]
-    missing = [a for a in all_agents if a not in found_names]
-    result = {"status": "partial", "agents_done": found_names, "agents_missing": missing, "count": len(found)}
-    print(json.dumps(result))
-    return len(found) >= 1  # At least 1 agent = partial success
-
-
-def wait_for_summary(session_path: Path, timeout: int) -> bool:
-    """Wait for SUMMARY.json to appear."""
+        if time.monotonic() >= deadline:
+            print(json.dumps({
+                "status": "incomplete",
+                "artifacts_done": done,
+                "artifacts_missing": missing,
+                "artifacts_invalid": invalid,
+                "errors": errors,
+                "count": len(done),
+            }, sort_keys=True))
+            return False
+        time.sleep(min(POLL_INTERVAL, max(0.0, deadline - time.monotonic())))
+
+
+def expected_overall_verdict(data) -> str:
+    verdicts = {data["axes"][axis]["verdict"] for axis in AXES}
+    severities = {finding["severity"] for finding in data["findings"]}
+    if "INCOMPLETE" in verdicts:
+        return "INCOMPLETE"
+    if "FAIL" in verdicts or severities.intersection({"P0", "P1"}):
+        return "REQUEST_CHANGES"
+    return "APPROVE"
+
+
+def validate_summary(data):
+    if data.get("$schema") != SUMMARY_SCHEMA:
+        return f"$schema must be {SUMMARY_SCHEMA}"
+    for field in ["session", "head"]:
+        if not nonempty_string(data.get(field)):
+            return f"{field} must be a non-empty string"
+    if data.get("status") != "complete":
+        return "status must be complete"
+    if data.get("verdict") not in OVERALL_VERDICTS:
+        return "invalid overall verdict"
+    axes = data.get("axes")
+    if not isinstance(axes, dict) or set(axes) != AXES:
+        return "axes must contain exactly spec_fidelity and engineering_standards"
+    for axis in AXES:
+        item = axes[axis]
+        if not isinstance(item, dict) or item.get("verdict") not in AXIS_VERDICTS:
+            return f"invalid {axis} verdict"
+        refs = item.get("evidence_refs")
+        if not isinstance(refs, list) or not refs or not all(nonempty_string(ref) for ref in refs):
+            return f"{axis}.evidence_refs must be a non-empty string array"
+    workers = data.get("workers")
+    if not isinstance(workers, dict):
+        return "workers must be an object"
+    for field in ["completed", "failed", "skipped"]:
+        if not isinstance(workers.get(field), list):
+            return f"workers.{field} must be an array"
+    findings = data.get("findings")
+    if not isinstance(findings, list):
+        return "findings must be an array"
+    seen_ids = set()
+    for finding in findings:
+        axis = finding.get("axis") if isinstance(finding, dict) else None
+        if axis not in AXES:
+            return "summary finding has invalid axis"
+        error = validate_finding(finding, axis, seen_ids)
+        if error:
+            return error
+    for field in ["positive_observations", "limitations"]:
+        if not isinstance(data.get(field), list):
+            return f"{field} must be an array"
+    expected = expected_overall_verdict(data)
+    if data["verdict"] != expected:
+        return f"verdict {data['verdict']} conflicts with evidence; expected {expected}"
+    return None
+
+
+def wait_for_summary(session_path: Path, timeout: float) -> bool:
     summary_path = session_path / "SUMMARY.json"
     deadline = time.monotonic() + timeout
-    while time.monotonic() < deadline:
-        if summary_path.exists() and summary_path.stat().st_size > 0:
-            try:
-                data = json.loads(summary_path.read_text(encoding="utf-8"))
-                verdict = data.get("verdict", "UNKNOWN")
-                p0 = data.get("p0", 0)
-                p1 = data.get("p1", 0)
-                total = data.get("total", 0)
-                print(f"Review complete: {verdict} (P0:{p0} P1:{p1} total:{total})")
+    last_error = "SUMMARY.json is missing"
+    while True:
+        if summary_path.exists():
+            data, error = read_json(summary_path)
+            if error is None:
+                error = validate_summary(data)
+            if error is None:
+                counts = {severity: 0 for severity in sorted(SEVERITIES)}
+                for finding in data["findings"]:
+                    counts[finding["severity"]] += 1
+                print(
+                    f"Review complete: {data['verdict']} "
+                    f"(P0:{counts['P0']} P1:{counts['P1']} P2:{counts['P2']} "
+                    f"P3:{counts['P3']} total:{len(data['findings'])})"
+                )
                 return True
-            except (json.JSONDecodeError, KeyError):
-                pass  # File still being written
-        remaining = int(deadline - time.monotonic())
-        print(
-            f"\r  Waiting for coordinator ({remaining}s remaining)",
-            end="", flush=True
-        )
-        time.sleep(POLL_INTERVAL)
-
-    print("\nTimeout: coordinator did not produce SUMMARY.json")
-    return False
+            last_error = error
+        if time.monotonic() >= deadline:
+            print(json.dumps({"status": "incomplete", "error": last_error}, sort_keys=True))
+            return False
+        time.sleep(min(POLL_INTERVAL, max(0.0, deadline - time.monotonic())))
 
 
 def main():
@@ -92,28 +258,27 @@ def main():
 
     session_path = Path(sys.argv[1])
     mode = sys.argv[2]
-
     if not session_path.is_dir():
         print(f"Error: session directory not found: {session_path}", file=sys.stderr)
         sys.exit(2)
 
-    timeout = DEFAULT_TIMEOUT
-
     if mode == "agents":
-        if len(sys.argv) < 4:
-            print("Error: agents mode requires <count> argument", file=sys.stderr)
+        expected = sys.argv[3:]
+        if not expected or len(expected) != len(set(expected)) or not all(
+            ARTIFACT_STEM.fullmatch(stem) for stem in expected
+        ):
+            print("Error: agents mode requires unique safe artifact stems", file=sys.stderr)
             sys.exit(2)
-        expected = int(sys.argv[3])
-        ok = wait_for_agents(session_path, expected, timeout)
-        sys.exit(0 if ok else 1)
-
+        ok = wait_for_agents(session_path, expected, DEFAULT_TIMEOUT)
     elif mode == "summary":
-        ok = wait_for_summary(session_path, timeout)
-        sys.exit(0 if ok else 1)
-
+        if len(sys.argv) != 3:
+            print("Error: summary mode accepts no additional arguments", file=sys.stderr)
+            sys.exit(2)
+        ok = wait_for_summary(session_path, DEFAULT_TIMEOUT)
     else:
         print(f"Error: unknown mode '{mode}'. Use 'agents' or 'summary'.", file=sys.stderr)
         sys.exit(2)
+    sys.exit(0 if ok else 1)
 
 
 if __name__ == "__main__":

package/skills/ultra-status/SKILL.md

@@ -1,61 +1,46 @@
 ---
 name: ultra-status
-description: "Route the project from its authoritative Ultra breadcrumb, readiness gates, task state, and current verification evidence."
-user-invocable: true
-runtime: all
-mcp_tools_required:
-  - change.breadcrumb
-  - change.list
-  - task.list
-  - task.get
-  - session.list
-  - system.doctor
-cli_fallback: "status --cost --json"
+description: Report authoritative Ultra health, position, readiness, evidence freshness, and one deterministic next action. Use when the user asks where an Ultra project stands or what should happen next.
 ---
 
-# ultra-status — One Router, One Next Action
+# Route from authoritative status
 
-Use this workflow to answer “where are we?” and “what should happen next?” without
-reconstructing project state from prose. `.ultra/state.db` is authoritative; reports
-and Markdown are evidence or projections.
+Answer status questions without reconstructing state from prose. `.ultra/state.db` is
+authoritative; reports and Markdown are evidence or projections.
 
 ## Read order
 
-1. Call `system.doctor { repair: false }`. If authority is unhealthy, route only to
+1. Call `system.doctor` in read-only mode. If authority is unhealthy, route only to
    `ultra-doctor` and include the blocking diagnostic.
-2. Call `change.breadcrumb`. It returns the active change, task, role, gate,
-   readiness, blockers, stale status, and one deterministic next action.
-3. Call `task.list` and `session.list` for counts and active execution detail.
-4. Read `.ultra/test-report.json` and `.ultra/delivery-report.json` only when they
-   exist. Treat a report from a different HEAD as stale.
-5. Read git branch, HEAD, and worktree status. Do not mutate anything.
+2. Call `change.breadcrumb` for the active change, task, role, gate, readiness,
+   blockers, staleness, and next action.
+3. Call `task.list` and `session.list` for progress and active execution details.
+4. Read test and delivery reports only when present, and mark a report stale when its
+   HEAD differs from the current checkout.
+5. Read Git branch, HEAD, and worktree status without mutation.
 
-Never fall back to `.ultra/tasks/tasks.json`, context Markdown frontmatter, or raw
-SQLite when MCP task state is unavailable. Label that panel unavailable.
+If MCP task or change state is unavailable, label that panel unavailable. Never fall
+back to generated task JSON, context frontmatter, or raw SQLite.
 
-## Routing rules
+## Routing
 
-The breadcrumb owns the primary route. Do not print a menu of every Ultra command.
+Follow the breadcrumb's primary route and return one action, not a menu:
 
-| State | Route |
-|---|---|
-| doctor unhealthy | `ultra-doctor` |
-| no Ultra project | `ultra-init` |
-| no baseline specs or tasks | `ultra-research` or `ultra-plan`, matching the missing artifact |
-| readiness blocked or context stale | recompile through `ultra-change`, `ultra-plan`, or `ultra-dev` as named by the breadcrumb |
-| implementation task ready | `ultra-dev <task-id>` |
-| all scoped tasks complete, test report missing/stale | `ultra-test` |
-| review or convergence incomplete | `ultra-review all` or `ultra-deliver`, matching the gate |
-| ready change | `ultra-deliver` |
-| archived change and clean HEAD | report complete; do not invent more work |
+- unhealthy authority: `ultra-doctor`;
+- missing Ultra project: `ultra-init`;
+- missing baseline evidence: `ultra-research` or `ultra-plan`, matching the gap;
+- blocked or stale context: the workflow named by the breadcrumb;
+- ready implementation task: `ultra-dev <task-id>`;
+- completed tasks with missing or stale test evidence: `ultra-test`;
+- incomplete review or convergence: `ultra-review` or `ultra-deliver`;
+- ready change: `ultra-deliver`;
+- archived change with fresh evidence: report completion without inventing more work.
 
-When there is no active change, derive a single baseline route from tasks and reports.
-If several changes are active or blocked, report ambiguity and require an explicit
-change id instead of guessing.
+Require an explicit change id when several active changes make the route ambiguous.
 
 ## Output
 
-Keep the answer compact:
+Use a compact shape:
 
 ```text
 Ultra: <healthy|degraded> · <branch>@<head> · worktree <clean|dirty>
@@ -63,15 +48,8 @@ Position: change=<id|none> task=<id|none> role=<role> gate=<gate>
 Readiness: <ready|blocked|stale> — <blockers or none>
 Progress: <completed>/<total>; sessions=<active count>
 Evidence: tests=<fresh|stale|missing>; delivery=<fresh|stale|missing>
-Next: <exactly one action, including the task/change id when known>
+Next: <one exact action>
 ```
 
-Separate verified facts from unavailable panels. Do not hide a stale context or stale
-test report behind an overall “healthy” label.
-
-## Boundaries
-
-- Read-only: this workflow does not repair, compile context, update tasks, or release.
-- Cost data may use the declared CLI fallback, but task/change authority may not.
-- External memory and code graph providers are optional metadata references; their
-  absence does not change Ultra authority.
+This workflow is read-only. It does not repair state, compile context, update tasks, or
+release software.

package/skills/ultra-test/SKILL.md

@@ -1,94 +1,59 @@
 ---
 name: ultra-test
-description: "Run the pre-delivery check gate from a fresh role context and record exact feedback-loop, wiring, recovery, and acceptance evidence."
-user-invocable: true
-runtime: all
-mcp_tools_required:
-  - task.list
-  - change.list
-  - change.context
-  - change.breadcrumb
+description: Run an independent pre-delivery verification gate and record exact feedback-loop, reachability, recovery, and acceptance evidence. Use when scoped implementation tasks are complete and delivery readiness must be established.
 ---
 
-# ultra-test — Independent Check Context
+# Verify delivery readiness
 
-This is the project/change pre-delivery gate, not a replacement for the task-level TDD
-loop. It produces `.ultra/test-report.json`; task and change authority remain in
-`.ultra/state.db`.
+Run this gate from a fresh checking context. It complements task-level development
+tests and writes `.ultra/test-report.json`; it does not replace authoritative task or
+change state.
 
 ## Entry gate
 
-1. Call `task.list`; require at least one completed task in scope.
-2. Call `change.list` and bind to exactly one relevant active/blocked/ready change, or
-   explicitly record `change_id: null` for an initial baseline.
-3. For a change, compile `change.context` with `role=check`, `gate=verification`, only
-   the tests/specs/source seams needed to verify it, and the same execution contract.
+1. Call `task.list` and require at least one completed task in scope.
+2. Call `change.list` and bind exactly one relevant change, or record a null change id
+   for an initial baseline.
+3. For a change, compile `change.context` for the checking role and verification gate
+   with only the specifications, tests, and source seams needed for acceptance.
 4. Call `change.breadcrumb`; stop when context is stale or readiness is blocked.
 
-Never fall back to `.ultra/tasks/tasks.json`. Do not reuse the implementer's full
+Never use generated task JSON as authority or reuse the implementer's full
 conversation as test context.
 
-## Verification matrix
+## Evidence matrix
 
-Build a matrix from acceptance claims to observable evidence:
+Map each acceptance claim to observable evidence:
 
-| Check | Required evidence | Blocking condition |
+| Check | Evidence | Blocking result |
 |---|---|---|
-| Feedback loop | exact command and observed green | command fails or no prior red for fix/incident |
-| Public seam | reachable entry-to-consumer path | orphan/stub/unwired behavior |
-| Regression | focused and adjacent suites | failure or meaningful skipped assertion |
-| Build/static | typecheck/lint/build as applicable | non-zero result |
-| Error/recovery | failure mode and recovery path | silent/swallowed/unrecoverable critical path |
-| Security | input/auth/secrets/dependency checks in scope | high-severity issue |
-| Docs/spec | delivered behavior matches declared delta | drift or unknown impact |
-
-Use repository-native commands and real boundaries where practical. Test doubles are
-acceptable only at costly or nondeterministic external boundaries and must be named.
-
-## Quality checks
-
-- Detect tautologies, empty tests, weakened assertions, and core-domain over-mocking.
-- Find changed exports without meaningful test coverage.
-- Trace changed source into non-test consumers; flag orphan modules and placeholder
-  handlers/components.
-- Exercise key API/UI/CLI flows when the project exposes them.
-- Inspect error handling, authorization, migrations, idempotency, and rollback in the
-  affected risk surface.
-- Compare current HEAD and context digests with the implementation evidence.
-
-Do not mechanically require every possible test category. Mark a check
-`not_applicable` only with a concrete scope reason.
+| Feedback loop | exact command and observed result | failure or missing baseline signal for a fix |
+| Public seam | reachable entry-to-consumer path | orphan, stub, or unwired behavior |
+| Regression | focused and adjacent suites | failure or weakened assertion |
+| Static/build | applicable type, lint, and build commands | non-zero result |
+| Error/recovery | exercised failure and recovery path | silent or unrecoverable critical path |
+| Security | relevant input, authorization, secret, and dependency checks | high-impact exploitable issue |
+| Docs/spec | delivered behavior matches the declared baseline or delta | drift or unknown impact |
+
+Use repository-native commands and real boundaries when practical. Use test doubles
+only at costly or nondeterministic external boundaries, and state why they preserve
+the contract being tested.
+
+Inspect tests for tautologies, empty assertions, hidden skips, excessive boundary
+mocking, changed exports without behavioral coverage, and code with no non-test
+consumer. Apply checks by risk and scope rather than forcing every category.
 
 ## Report contract
 
-Write `.ultra/test-report.json` atomically with at least:
-
-```json
-{
-  "schema_version": "2.0",
-  "change_id": "<id-or-null>",
-  "git_commit": "<full-head>",
-  "context_manifest_hash": "<hash-or-null>",
-  "passed": true,
-  "feedback_loop": {
-    "command": "<exact command>",
-    "expected_red": "<failure contract or not-applicable reason>",
-    "observed_red": true,
-    "observed_green": true,
-    "deterministic": true
-  },
-  "public_seams": ["<verified seam>"],
-  "checks": [],
-  "blocking_issues": [],
-  "commands": []
-}
-```
+Write the report atomically with the current full HEAD, change id, context manifest
+hash, exact commands, baseline and final signals, verified public seams, checks, and
+blocking issues. Preserve concise failure excerpts instead of full logs.
 
-Set `passed=true` only when every required check passes, the report HEAD is current,
-and at least one public seam is verified. Preserve exact commands, exit results, and
-concise failure excerpts; do not paste full logs.
+Set `passed: true` only when every required check passes, the report HEAD is current,
+and at least one declared public seam is verified. A not-applicable check needs a
+specific scope reason.
 
 ## Exit
 
-Call `change.breadcrumb` and route one next action: fix a named blocker, run
-`/ultra-review all`, or run `/ultra-deliver`. A stale report never routes to delivery.
+Call `change.breadcrumb` and return one next action: fix a named blocker, run
+`ultra-review`, or run `ultra-deliver`. A stale report never routes to delivery.