devlyn-cli 3.2.0 → 3.3.0

package/config/skills/_shared/terminal-claim-check.py

@@ -9,6 +9,7 @@ import json
 import os
 import pathlib
 import re
+import runpy
 import sys
 import tempfile
 from dataclasses import dataclass
@@ -34,8 +35,6 @@ HALT_WITNESS_PHASES = {
     "plan-empty": "plan",
     "risk-halt": "plan",
     "implement-empty": "implement",
-    "build-gate-exhausted": "build_gate",
-    "verify-exhausted": "verify",
 }
 
 
@@ -130,6 +129,30 @@ def terminal_halt_witness(phases: dict[str, object]) -> tuple[str, str] | None:
     return target, reason
 
 
+def exhausted_origin(state: dict[str, object]) -> str | None:
+    writer = runpy.run_path(str(pathlib.Path(__file__).with_name("state-phase-write.py")))
+    predecessor = writer["repair_predecessor"](state)
+    if predecessor is None:
+        return None
+    name, entry = predecessor
+    if entry.get("completed_at") is None:
+        return None
+    if name == "verify":
+        merged = entry.get("merged")
+        return "verify" if entry.get("verdict") == "NEEDS_WORK" and isinstance(merged, dict) and merged.get("verdict") == "NEEDS_WORK" else None
+    if name == "cleanup":
+        return name if entry.get("verdict") == "FAIL" and entry.get("execution_kind") == "orchestrator_commands" else None
+    if name == "build_gate":
+        return name if entry.get("verdict") == "FAIL" else None
+    progress = entry.get("exec")
+    if not writer["valid_phase_gate_progress"](progress):
+        return None
+    if (entry.get("verdict") == "FAIL"
+        and progress["statuses"][progress["current"] - 1] == "FAIL"):
+        return "phase_gate"
+    return None
+
+
 def classify_state_bytes(
     root: pathlib.Path,
     state_path: pathlib.Path,
@@ -206,6 +229,39 @@ def classify_state_bytes(
     archive_valid = (
         archived and state_path.parent.name == run_id
     ) or archive_state.is_file()
+    report_verdict = final_report.get("verdict") if isinstance(final_report, dict) else None
+    rounds = state.get("rounds")
+    schema_v3 = state.get("version") == "3.0"
+    has_v3_repair_round = schema_v3 and any(
+        isinstance(phases.get(name), dict) and "round" in phases[name]
+        for name in ("implement", "build_gate", "cleanup", "verify")
+    )
+    try:
+        origin = exhausted_origin(state) if schema_v3 and (rounds is not None or has_v3_repair_round) else None
+    except SystemExit:
+        return malformed("repair predecessor has invalid round", run_id), state
+    exhausted = (isinstance(rounds, dict) and type(rounds.get("global")) is int
+                 and type(rounds.get("max_rounds")) is int and rounds["global"] == rounds["max_rounds"]
+                 and rounds["max_rounds"] >= 1)
+    claims_exhaustion = schema_v3 and (report_verdict == "BLOCKED:repair-budget-exhausted" or (
+        report_verdict == "NEEDS_WORK" and state.get("mode") != "verify-only"
+        and (rounds is not None or origin is not None)
+    ))
+    if claims_exhaustion:
+        expected = "NEEDS_WORK" if origin == "verify" else "BLOCKED:repair-budget-exhausted"
+        blocked_source = any(
+            isinstance(entry, dict) and entry.get("verdict") == "BLOCKED"
+            for name, entry in phases.items() if name != "final_report"
+        )
+        if not final_completed or not exhausted or origin is None or report_verdict != expected or blocked_source:
+            return incomplete("final_report", "repair exhaustion witness invalid", run_id), state
+        if not archive_valid:
+            return incomplete("archive", "repair exhaustion report not archived", run_id), state
+        return Classification("CLEAN", None, f"repair budget exhausted at {origin}", run_id, False), state
+    if (origin is not None and verdict is not None
+        and not (state.get("mode") == "verify-only" and origin == "verify" and report_verdict == "NEEDS_WORK")
+        and not (isinstance(report_verdict, str) and report_verdict.startswith("BLOCKED:"))):
+        return incomplete("final_report", "current repair exhaustion cannot use stale VERIFY", run_id), state
     if verdict is not None:
         if not final_completed:
             return incomplete(
@@ -396,6 +452,177 @@ def self_test() -> int:
             },
         }
 
+        def exhausted_case(origin: str) -> dict[str, object]:
+            span = {"started_at": "2026-07-20T00:00:00Z", "completed_at": "2026-07-20T00:01:00Z"}
+            phases = {"verify": {**span, "round": 0, "verdict": "PASS"}}
+            if origin == "phase_gate":
+                phases["implement"] = {**span, "round": 1, "verdict": "FAIL",
+                                        "exec": {"total": 2, "current": 2, "statuses": ["PASS", "FAIL"]}}
+            elif origin == "verify":
+                phases["verify"] = {**span, "round": 1, "verdict": "NEEDS_WORK",
+                                    "merged": {"verdict": "NEEDS_WORK"}}
+            else:
+                phases[origin] = {**span, "round": 1, "verdict": "FAIL"}
+                if origin == "cleanup":
+                    phases[origin]["execution_kind"] = "orchestrator_commands"
+            phases["final_report"] = {**span, "round": 0,
+                                      "verdict": "NEEDS_WORK" if origin == "verify" else "BLOCKED:repair-budget-exhausted"}
+            return {"version": "3.0", "run_id": "repair-" + origin,
+                    "rounds": {"global": 1, "max_rounds": 1},
+                    "phases": phases}
+
+        for origin in ("build_gate", "cleanup", "verify", "phase_gate"):
+            state = exhausted_case(origin)
+            path = base / ".devlyn" / "runs" / state["run_id"] / "pipeline.state.json"
+            raw = json.dumps(state).encode()
+            result, _ = classify_state_bytes(base, path, raw, archived=True)
+            assert result.status == "CLEAN" and not result.incomplete, (origin, result)
+            tests += 1
+            result, _ = classify_state_bytes(base, path, raw, archived=False)
+            assert result.status == "INCOMPLETE:archive", (origin, result)
+            tests += 1
+            for bad in (True, 2):
+                forged = json.loads(raw)
+                forged["rounds"]["global"] = bad
+                result, _ = classify_state_bytes(base, path, json.dumps(forged).encode(), archived=True)
+                assert result.status != "CLEAN", (origin, bad, result)
+                tests += 1
+            opened = json.loads(raw)
+            name = "implement" if origin == "phase_gate" else origin
+            opened["phases"][name]["completed_at"] = None
+            result, _ = classify_state_bytes(base, path, json.dumps(opened).encode(), archived=True)
+            assert result.incomplete, (origin, result)
+            tests += 1
+            opened = json.loads(raw)
+            opened["phases"][name]["history"] = [{"started_at": "2026-07-19T00:00:00Z", "completed_at": None}]
+            result, _ = classify_state_bytes(base, path, json.dumps(opened).encode(), archived=True)
+            assert result.incomplete, (origin, result)
+            tests += 1
+            opened = json.loads(raw)
+            opened["phases"]["final_report"]["completed_at"] = None
+            result, _ = classify_state_bytes(base, path, json.dumps(opened).encode(), archived=True)
+            assert result.incomplete, (origin, result)
+            tests += 1
+            if origin != "verify":
+                stale = json.loads(raw)
+                stale["phases"]["final_report"]["verdict"] = "PASS"
+                result, _ = classify_state_bytes(base, path, json.dumps(stale).encode(), archived=True)
+                assert result.status == "INCOMPLETE:final_report", (origin, result)
+                tests += 1
+            if origin == "phase_gate":
+                forged = json.loads(raw)
+                forged["phases"]["implement"]["exec"]["total"] = 1
+                result, _ = classify_state_bytes(base, path, json.dumps(forged).encode(), archived=True)
+                assert result.status == "INCOMPLETE:final_report", result
+                tests += 1
+            blocked = json.loads(raw)
+            blocked["phases"]["surface_close"] = {"started_at": "2026-07-19T00:00:00Z",
+                "completed_at": "2026-07-19T00:01:00Z", "verdict": "BLOCKED"}
+            result, _ = classify_state_bytes(base, path, json.dumps(blocked).encode(), archived=True)
+            assert result.status == "INCOMPLETE:final_report", (origin, result)
+            tests += 1
+            for missing in (True, False):
+                without_rounds = json.loads(raw)
+                if missing:
+                    del without_rounds["rounds"]
+                else:
+                    without_rounds["rounds"] = None
+                without_rounds["phases"]["final_report"]["verdict"] = (
+                    "NEEDS_WORK" if origin == "verify" else "PASS"
+                )
+                result, _ = classify_state_bytes(
+                    base, path, json.dumps(without_rounds).encode(), archived=True,
+                )
+                assert result.status == "INCOMPLETE:final_report", (origin, missing, result)
+                tests += 1
+
+        def test_higher_priority_terminal_floor() -> None:
+            state = exhausted_case("build_gate")
+            state["rounds"] = {"global": 4, "max_rounds": 4}
+            state["phases"]["build_gate"]["round"] = 4
+            state["phases"]["verify"]["round"] = 3
+            state["phases"]["final_report"]["verdict"] = "BLOCKED:finish-gate-unclean"
+            path = base / ".devlyn" / "runs" / state["run_id"] / "pipeline.state.json"
+            result, _ = classify_state_bytes(base, path, json.dumps(state).encode(), archived=True)
+            assert result.status == "CLEAN", result
+
+        def test_invalid_counters_reject_stale_verify() -> None:
+            for global_ in (True, 5):
+                state = exhausted_case("build_gate")
+                state["rounds"] = {"global": global_, "max_rounds": 4}
+                state["phases"]["build_gate"]["round"] = 4
+                state["phases"]["verify"]["round"] = 3
+                state["phases"]["final_report"]["verdict"] = "PASS"
+                path = base / ".devlyn" / "runs" / state["run_id"] / "pipeline.state.json"
+                result, _ = classify_state_bytes(base, path, json.dumps(state).encode(), archived=True)
+                assert result.status != "CLEAN", (global_, result)
+
+        def test_invalid_phase_gate_witness() -> None:
+            state = exhausted_case("phase_gate")
+            state["phases"]["implement"]["exec"] = {
+                "total": 2, "current": 1, "statuses": ["FAIL", "UNKNOWN"],
+            }
+            writer = runpy.run_path(str(pathlib.Path(__file__).with_name("state-phase-write.py")))
+            try:
+                writer["repair_admission"](state, "implement", 2, None)
+            except SystemExit as exc:
+                assert str(exc) == "BLOCKED:repair-edge-invalid", exc
+            else:
+                raise AssertionError("writer admitted malformed phase gate")
+            path = base / ".devlyn" / "runs" / state["run_id"] / "pipeline.state.json"
+            result, _ = classify_state_bytes(base, path, json.dumps(state).encode(), archived=True)
+            assert result.status == "INCOMPLETE:final_report", result
+
+        def test_verify_only_direct_report_and_stale_verify() -> None:
+            state = exhausted_case("verify")
+            state["mode"] = "verify-only"
+            state["rounds"] = {"global": 0, "max_rounds": 4}
+            state["phases"]["verify"]["round"] = 0
+            path = base / ".devlyn" / "runs" / state["run_id"] / "pipeline.state.json"
+            result, _ = classify_state_bytes(base, path, json.dumps(state).encode(), archived=True)
+            assert result.status == "CLEAN", result
+            for missing in (True, False):
+                direct = json.loads(json.dumps(state))
+                if missing:
+                    del direct["rounds"]
+                else:
+                    direct["rounds"] = None
+                result, _ = classify_state_bytes(base, path, json.dumps(direct).encode(), archived=True)
+                assert result.status == "CLEAN", (missing, result)
+                ordinary = json.loads(json.dumps(direct))
+                ordinary.pop("mode")
+                ordinary["phases"]["verify"]["verdict"] = "PASS"
+                ordinary["phases"]["verify"]["merged"]["verdict"] = "PASS"
+                ordinary["phases"]["final_report"]["verdict"] = "PASS"
+                result, _ = classify_state_bytes(base, path, json.dumps(ordinary).encode(), archived=True)
+                assert result.status == "CLEAN", (missing, result)
+            stale = exhausted_case("build_gate")
+            stale["mode"] = "verify-only"
+            stale["rounds"] = {"global": 0, "max_rounds": 4}
+            stale["phases"]["final_report"]["verdict"] = "PASS"
+            path = base / ".devlyn" / "runs" / stale["run_id"] / "pipeline.state.json"
+            result, _ = classify_state_bytes(base, path, json.dumps(stale).encode(), archived=True)
+            assert result.status == "INCOMPLETE:final_report", result
+
+        def test_pre_v3_exhaustion_archive_compatibility() -> None:
+            for version, expected in (("2.0", "CLEAN"), ("3.0", "INCOMPLETE:final_report")):
+                state = exhausted_case("verify")
+                state["version"] = version
+                state["rounds"] = {"global": 4, "max_rounds": 4}
+                state["phases"]["verify"]["round"] = 4
+                del state["phases"]["verify"]["merged"]
+                root = base / f"exhausted-archive-{version}"
+                write_archived_state(root, state)
+                result = classify(root)
+                assert result.status == expected, (version, result)
+
+        test_higher_priority_terminal_floor()
+        test_invalid_counters_reject_stale_verify()
+        test_invalid_phase_gate_witness()
+        test_verify_only_direct_report_and_stale_verify()
+        test_pre_v3_exhaustion_archive_compatibility()
+        tests += 11
+
         root = base / "set-quantification"
         write_archived_state(root, f23_state)
         write_archived_state(root, fs1_state)
@@ -458,8 +685,6 @@ def self_test() -> int:
             ("plan-empty", "plan", "PASS"),
             ("risk-halt", "plan", "PASS"),
             ("implement-empty", "implement", "PASS"),
-            ("build-gate-exhausted", "build_gate", "FAIL"),
-            ("verify-exhausted", "verify", "NEEDS_WORK"),
             ("fresh-context-unavailable", "implement", "BLOCKED"),
             ("codex-unavailable", "plan", "BLOCKED"),
         )

package/config/skills/_shared/verify-merge-findings.py

@@ -1471,6 +1471,91 @@ def write_state(devlyn: pathlib.Path, summary: dict[str, Any]) -> None:
 def self_test() -> int:
     import subprocess
 
+    with tempfile.TemporaryDirectory() as tmp:
+        work = pathlib.Path(tmp).resolve()
+        devlyn = work / ".devlyn"
+        devlyn.mkdir()
+        role = JUDGE_ROLE_EVIDENCE["ROLE"]
+        (devlyn / "engines.json").write_bytes(role["encoded"]({
+            "roles": {"primary_judge": {"engine": "claude", "model": "fixture-claude-model", "effort": "high"}},
+        }))
+        resolution = role["resolve"](work, "claude", no_pair=True, available=lambda engine: True)
+        state = {"run_id": "merge-relative-role", "engine": "claude", "role_resolution": resolution,
+                 "rounds": {"global": 0, "max_rounds": 1},
+                 "phases": {"verify": {"engine": "claude", "round": 0, "verdict": None,
+                                       "started_at": "2026-01-01T00:00:00Z", "completed_at": "2026-01-01T00:01:00Z"}}}
+        state_path = devlyn / "pipeline.state.json"
+        state_path.write_text(json.dumps(state), encoding="utf-8")
+        stem = "claude-judge.r0"
+        prompt_path = devlyn / (stem + ".prompt")
+        prompt = b"review"
+        prompt_path.write_bytes(prompt)
+        command = ["claude", "-p", "--model", "fixture-claude-model", "--effort", "high",
+                   "--permission-mode", "dontAsk", "--tools", "Read,Grep,Glob",
+                   "--allowedTools", "Read,Grep,Glob", "--setting-sources", "project",
+                   "--output-format", "json", "--strict-mcp-config", "--mcp-config", '{"mcpServers":{}}']
+        argv = ["python3", "run-bounded.py", "600", "--stdin-file", str(prompt_path),
+                "--record-transport", "--", *command]
+        argv_path = devlyn / (stem + ".argv.json")
+        argv_path.write_bytes(role["encoded"](argv))
+        (devlyn / (stem + ".stderr")).write_bytes(b"")
+        (devlyn / (stem + ".output.json")).write_bytes(role["encoded"]({
+            "type": "result", "subtype": "success", "is_error": False, "stop_reason": "end_turn",
+            "session_id": "fixture-claude", "result": "PASS", "modelUsage": {"fixture-claude-model": {}},
+        }))
+        transport = {"schema_version": 1, "transport": "stdin-file",
+                     "prompt": {"path": str(prompt_path), "sha256": role["digest"](prompt), "bytes": len(prompt)},
+                     "command": command, "argv": command, "timeout_sec": 600, "isolated": False,
+                     "status": "completed", "exit_code": 0}
+        (devlyn / (stem + ".prompt.transport.json")).write_text(json.dumps(transport), encoding="utf-8")
+        evidence, derived = JUDGE_ROLE_EVIDENCE["describe"](devlyn, state, "primary_judge", 0)
+        (devlyn / (stem + ".role-evidence.json")).write_bytes(role["encoded"](evidence))
+        (devlyn / (stem + ".stdout")).write_bytes(derived)
+        (devlyn / "claude-judge.stdout").write_bytes(derived)
+        (devlyn / "verify-mechanical.findings.jsonl").write_text("", encoding="utf-8")
+        (devlyn / "verify.findings.jsonl").write_text("", encoding="utf-8")
+        script = str(pathlib.Path(__file__).resolve())
+        def merge_at(directory):
+            return subprocess.run([sys.executable, script, "--devlyn-dir", directory, "--write-state"],
+                                  cwd=work, capture_output=True, text=True)
+        relative = merge_at(".devlyn")
+        assert relative.returncode == 0, relative.stderr
+        relative_state = json.loads(state_path.read_text())
+        assert relative_state["phases"]["verify"]["verdict"] == "PASS", relative.stdout
+        state_path.write_text(json.dumps(state), encoding="utf-8")
+        absolute = merge_at(str(devlyn))
+        assert absolute.returncode == 0, absolute.stderr
+        absolute_state = json.loads(state_path.read_text())
+        assert absolute_state["phases"]["verify"]["role_evidence"] == relative_state["phases"]["verify"]["role_evidence"]
+        argv[4] = str(work / "wrong.prompt")
+        argv_path.write_bytes(role["encoded"](argv))
+        state_path.write_text(json.dumps(state), encoding="utf-8")
+        wrong = merge_at(".devlyn")
+        assert wrong.returncode == 0, wrong.stderr
+        blocked_state = json.loads(state_path.read_text())
+        assert blocked_state["phases"]["verify"]["verdict"] == "BLOCKED"
+        writer = runpy.run_path(str(pathlib.Path(__file__).with_name("state-phase-write.py")))
+        try:
+            writer["do_spawn"](blocked_state, "implement", 1, "verify", None, None, None)
+        except SystemExit as exc:
+            assert str(exc) == "BLOCKED:repair-edge-invalid"
+        else:
+            raise AssertionError("BLOCKED VERIFY entered product repair")
+        assert blocked_state["rounds"]["global"] == 0
+        argv[4] = str(prompt_path)
+        argv_path.write_bytes(role["encoded"](argv))
+        finding = {"id": "fixture-high", "rule_id": "fixture.binding", "severity": "HIGH",
+                   "confidence": "high", "file": "source.txt", "line": 1,
+                   "message": "required behavior is missing", "criterion_ref": "fixture"}
+        (devlyn / "verify.findings.jsonl").write_text(json.dumps(finding) + "\n", encoding="utf-8")
+        state_path.write_text(json.dumps(state), encoding="utf-8")
+        needs_work = merge_at(".devlyn")
+        assert needs_work.returncode == 0, needs_work.stderr
+        repair_state = json.loads(state_path.read_text())
+        assert repair_state["phases"]["verify"]["verdict"] == "NEEDS_WORK"
+        writer["do_spawn"](repair_state, "implement", 1, "verify", None, None, None)
+        assert repair_state["rounds"]["global"] == 1
+
     try:
         loads_strict_json('{"verdict":"PASS","verdict":"BLOCKED"}')
     except ValueError as exc:
@@ -3424,10 +3509,16 @@ def main() -> int:
     if not devlyn.is_dir():
         sys.stderr.write(f"error: {devlyn} is not a directory\n")
         return 1
+    if args.write_state:
+        lock = runpy.run_path(str(pathlib.Path(__file__).with_name("platform-support.py")))["file_lock"]
+        with lock(devlyn.resolve() / "pipeline.state.lock", blocking=True):
+            findings, source_verdicts = read_findings(devlyn)
+            summary = write_outputs(devlyn, findings, source_verdicts)
+            write_state(devlyn, summary)
+            print(json.dumps(summary, sort_keys=True))
+        return 0
     findings, source_verdicts = read_findings(devlyn)
     summary = write_outputs(devlyn, findings, source_verdicts)
-    if args.write_state:
-        write_state(devlyn, summary)
     print(json.dumps(summary, sort_keys=True))
     return 0
 

package/config/skills/devlyn:ideate/SKILL.md

@@ -110,8 +110,8 @@ Structural lint (inline check, no script needed):
 After lint passes:
 1. Write `<spec-dir>/<id>-<slug>/spec.md` (the spec).
 2. Generate `<spec-dir>/<id>-<slug>/spec.expected.json` following `references/spec-template.md` § "Sibling file: `spec.expected.json`" for constraint coverage, diff scope and guard controls.
-3. Run `python3 "$DEVLYN_SHARED_DIR/spec-verify-check.py" --check <spec-path>` to validate the actual spec's carrier shape and supported `complexity` frontmatter. Sibling `spec.expected.json` takes precedence over the legacy inline `## Verification` JSON carrier; any present actionable solo-headroom hypothesis command must match that carrier's `verification_commands[].cmd`. If exit 2, fix the file named in the error and re-run.
-4. Run `python3 "$DEVLYN_SHARED_DIR/spec-verify-check.py" --check-expected <expected-path>` to validate sibling `spec.expected.json` against `_shared/expected.schema.json` plus sibling spec `complexity` frontmatter and any present actionable solo-headroom hypothesis; if the spec has a solo-headroom hypothesis, its observable command must match `spec.expected.json.verification_commands[].cmd`. If exit 2, fix the JSON/frontmatter/hypothesis and re-run.
+3. Run `python3 "$DEVLYN_SHARED_DIR/spec-verify-check.py" --check <spec-path>` to validate the actual spec's carrier shape and supported `complexity` frontmatter. Sibling `spec.expected.json` takes precedence over the legacy inline `## Verification` JSON carrier. If exit 2, fix the file named in the error and re-run.
+4. Run `python3 "$DEVLYN_SHARED_DIR/spec-verify-check.py" --check-expected <expected-path>` to validate sibling `spec.expected.json` against `_shared/expected.schema.json` plus sibling spec `complexity` frontmatter. If exit 2, fix the JSON/frontmatter and re-run.
 5. Print: `spec ready — /devlyn:resolve --spec <spec-path>`.
 
 ## PHASE 1Q: QUICK MODE
@@ -123,7 +123,6 @@ Single-turn assume-and-confirm. Prompt body: see `references/elicitation.md` §
 3. User responds with "go" / "fix X" / "no, different".
 4. On "go": write spec + spec.expected.json + lint + announce.
 5. On "fix X": apply correction, re-show, ask again. Maximum 3 correction rounds before escalating to default mode.
-6. Exception: for benchmark, risk-probe, or pair-evidence goals, do not infer a solo-headroom hypothesis. Ask for the actionable hypothesis first; if unavailable, exit with `spec not ready — solo-headroom hypothesis required`. For new unmeasured benchmark, shadow-fixture, golden-fixture, risk-probe, or pair-evidence candidates, also do not infer solo ceiling avoidance; ask for the concrete difference from rejected or solo-saturated controls such as `S2`-`S6`, and exit with `spec not ready — solo ceiling avoidance required` if unavailable.
 
 ## PHASE 1F: FROM-SPEC MODE
 
@@ -136,7 +135,7 @@ Prompt body: `references/from-spec-mode.md`.
 5. Generate `spec.expected.json` if absent, following the same template carrier guidance as default mode.
 6. Write the normalized spec back to `<spec-dir>/<id>-<slug>/` (preserves original at `<path>` untouched unless user passes `--in-place`).
 7. Run both lint checks: `--check <spec-path>` and `--check-expected <expected-path>`.
-8. Lint pass → announce. Lint fail → surface the unfixable issue and exit non-zero. If the source is a pair-evidence candidate without an actionable solo-headroom hypothesis, the announcement must say `pair-evidence not ready` instead of implying measurement readiness.
+8. Lint pass → announce. Lint fail → surface the unfixable issue and exit non-zero.
 
 ## PHASE 1P: PROJECT MODE
 

package/config/skills/devlyn:ideate/references/elicitation.md

@@ -40,27 +40,6 @@ For most coding tasks, the under-specified blanks are:
    auth/error priority, or exact output shape, ask for one concrete compound
    scenario that exercises the interaction end-to-end instead of accepting only
    isolated happy-path checks.
-8. **Pair-candidate headroom**: when the user is creating a benchmark, risk
-   probe, or pair-evidence candidate, ask for one solo-headroom hypothesis in
-   actionable form: the spec must literally contain `solo-headroom hypothesis`,
-   `solo_claude`, `miss`, and a backticked observable command while naming the
-   visible behavior a capable `solo_claude` baseline should miss; the backticked
-   line itself must contain `miss` and be framed as the command/observable that exposes it. If the
-   answer is only "the task is hard", rework the candidate before spending provider
-   calls. Do not write a benchmark/risk-probe/pair-evidence spec until this
-   hypothesis is actionable; if the user cannot provide it, stop with
-   `spec not ready — solo-headroom hypothesis required` and ask them to return
-   with the visible behavior `solo_claude` is expected to miss.
-9. **Solo ceiling avoidance**: for a new unmeasured benchmark, shadow-fixture,
-   golden-fixture, risk-probe, or pair-evidence candidate, ask how this candidate
-   differs from rejected or solo-saturated controls such as `S2`-`S6`. The note
-   must literally contain `solo ceiling avoidance`, mention `solo_claude`, and
-   name the concrete difference expected to preserve `solo_claude` headroom.
-   Benchmark fixture directories put this in `NOTES.md` as
-   `## Solo ceiling avoidance`; ordinary specs keep it in `## Verification`
-   next to the solo-headroom hypothesis. Do not write or measure the candidate
-   if this answer is missing; stop with
-   `spec not ready — solo ceiling avoidance required`.
 
 Walk through these in roughly this order. Skip the ones already clear from the user's initial text.
 </missing_decisions_to_surface>
@@ -94,8 +73,8 @@ Before declaring the spec ready, verify structurally:
 If the lint fails, fix the missing piece (ask one focused question if needed) before announcing.
 
 After lint passes, run both mechanical checks:
-1. `python3 "$DEVLYN_SHARED_DIR/spec-verify-check.py" --check <spec-path>` validates the spec's verification carrier shape, supported `complexity` frontmatter, and any present actionable solo-headroom hypothesis; if the spec uses a legacy inline `## Verification` JSON carrier, any solo-headroom hypothesis command must match that carrier's `verification_commands[].cmd`.
-2. `python3 "$DEVLYN_SHARED_DIR/spec-verify-check.py" --check-expected <expected-path>` validates sibling `spec.expected.json` against `_shared/expected.schema.json` plus sibling spec `complexity` frontmatter and any present actionable solo-headroom hypothesis; if the spec has a solo-headroom hypothesis, its observable command must match `spec.expected.json.verification_commands[].cmd`.
+1. `python3 "$DEVLYN_SHARED_DIR/spec-verify-check.py" --check <spec-path>` validates the spec's verification carrier shape and supported `complexity` frontmatter.
+2. `python3 "$DEVLYN_SHARED_DIR/spec-verify-check.py" --check-expected <expected-path>` validates sibling `spec.expected.json` against `_shared/expected.schema.json` plus sibling spec `complexity` frontmatter.
 
 If either exits 2: read the stderr message, fix the malformed carrier or JSON, and re-run the failed command. Both commands must exit 0 before ready.
 </lint>
@@ -120,18 +99,6 @@ When `--quick` is set:
 4. On "go": write the spec + spec.expected.json, run both lint checks, announce.
 5. On "fix X": apply correction, re-present, ask again. Maximum 3 correction rounds before escalating to default mode.
 
-Exception: quick mode must not infer a solo-headroom hypothesis for benchmark,
-risk-probe, or pair-evidence goals. If the one-line goal lacks the actionable
-`solo-headroom hypothesis` / `solo_claude` / `miss` / backticked-command
-contract, ask exactly one focused follow-up for that hypothesis before showing a
-draft; if the user cannot provide it, exit with
-`spec not ready — solo-headroom hypothesis required`. For a new unmeasured
-benchmark, shadow-fixture, golden-fixture, risk-probe, or pair-evidence
-candidate, quick mode also must not infer the `solo ceiling avoidance` note; ask
-for the concrete difference from rejected or solo-saturated controls such as
-`S2`-`S6`, and exit with `spec not ready — solo ceiling avoidance required` if
-the user cannot provide it.
-
 Quick mode trades thoroughness for speed. Use it for trivial-medium tasks where the user has a clear-enough goal that one round of inference + correction is sufficient.
 
 ## Anti-patterns

package/config/skills/devlyn:ideate/references/from-spec-mode.md

@@ -37,8 +37,8 @@ You must NOT:
 3. For each missing/malformed piece: apply the smallest allowed fix.
 4. Write the normalized spec. Default location: `<spec-dir>/<id>-<slug>/spec.md`. With `--in-place` flag: write to `<path>` directly (overwrites the original).
 5. Generate or fix `spec.expected.json` per the rules above. Same dir as the spec.
-6. Run `python3 "$DEVLYN_SHARED_DIR/spec-verify-check.py" --check <spec-path>` to validate the actual spec's carrier shape and supported `complexity` frontmatter. Sibling `spec.expected.json` takes precedence over the legacy inline `## Verification` JSON carrier; any present actionable solo-headroom hypothesis command must match that carrier's `verification_commands[].cmd`. If exit 2, fix the file named in the error and re-run.
-7. Run `python3 "$DEVLYN_SHARED_DIR/spec-verify-check.py" --check-expected <expected-path>` to validate sibling `spec.expected.json` plus sibling spec `complexity` frontmatter and any present solo-headroom hypothesis command against `spec.expected.json.verification_commands[].cmd`.
+6. Run `python3 "$DEVLYN_SHARED_DIR/spec-verify-check.py" --check <spec-path>` to validate the actual spec's carrier shape and supported `complexity` frontmatter. Sibling `spec.expected.json` takes precedence over the legacy inline `## Verification` JSON carrier. If exit 2, fix the file named in the error and re-run.
+7. Run `python3 "$DEVLYN_SHARED_DIR/spec-verify-check.py" --check-expected <expected-path>` to validate sibling `spec.expected.json` plus sibling spec `complexity` frontmatter.
 8. If lint still fails after allowed fixes (e.g. Requirements section is empty in the source), surface the issue and exit non-zero — do NOT invent Requirements.
 9. If the preserved Requirements combine state mutation with ordering/priority,
    idempotency, auth/error priority, or exact output shape but the Verification
@@ -46,27 +46,12 @@ You must NOT:
    content. Add a final warning that `/devlyn:resolve` may need default-mode
    ideation or a stronger Verification section before pair-relevant risks are
    measurable.
-10. If the source is a benchmark, risk probe, or pair-evidence candidate and it
-    lacks an actionable solo-headroom hypothesis, do not invent one. Add a final
-    warning that the candidate may be solo-saturated until Context or
-    Verification literally contains `solo-headroom hypothesis`, `solo_claude`,
-    `miss`, and a backticked observable command while naming the visible
-    behavior a capable `solo_claude` baseline is expected to miss; the
-    backticked line itself must contain `miss` and be framed as the
-    command/observable that exposes it. Do not call the normalized spec pair-evidence ready.
-11. If the source is a new unmeasured benchmark, shadow-fixture, golden-fixture,
-    risk-probe, or pair-evidence candidate and it lacks a solo ceiling avoidance
-    note, do not invent one. Add a final warning that the candidate may replay
-    rejected or solo-saturated controls until Context, Verification, or fixture
-    `NOTES.md` literally contains `solo ceiling avoidance`, mentions
-    `solo_claude`, and names a concrete difference from rejected controls such
-    as `S2`-`S6`. Do not call the normalized spec pair-evidence ready.
 </flow>
 
 <output>
 Same as default mode: `<spec-dir>/<id>-<slug>/spec.md` + `<spec-dir>/<id>-<slug>/spec.expected.json`.
 
-Final announcement: `spec normalized — /devlyn:resolve --spec <spec-path>`. If the spec was lint-passing with no changes needed, announce: `spec already canonical — /devlyn:resolve --spec <spec-path>`. If step 9 applies, append: `warning: Verification may need one compound end-to-end scenario before pair-relevant risks are measurable`. If step 10 applies, append: `pair-evidence not ready — Pair-candidate headroom is unproven until the spec states a solo-headroom hypothesis`. If step 11 applies, append: `pair-evidence not ready — Pair-candidate headroom is unproven until the spec states solo ceiling avoidance`.
+Final announcement: `spec normalized — /devlyn:resolve --spec <spec-path>`. If the spec was lint-passing with no changes needed, announce: `spec already canonical — /devlyn:resolve --spec <spec-path>`. If step 9 applies, append: `warning: Verification may need one compound end-to-end scenario before pair-relevant risks are measurable`.
 
 If lint failed unfixably: print the specific failure, exit non-zero. Do not write a partial output.
 </output>

package/config/skills/devlyn:ideate/references/project-mode.md

@@ -15,21 +15,6 @@ The user wants to build a project, not a single feature. Your job is to elicit t
    auth/error priority, or exact output shape, its per-feature Verification must
    include one compound end-to-end scenario; do not hide the interaction in
    project-level prose.
-6. When a feature is intended as a benchmark, risk probe, or pair-evidence
-   candidate, its per-feature Verification must include a solo-headroom
-   hypothesis. The feature spec must literally contain
-   `solo-headroom hypothesis`, `solo_claude`, `miss`, and a backticked
-   observable command while naming the visible behavior a capable
-   `solo_claude` baseline is expected to miss; the backticked line itself must
-   contain `miss` and be framed as the command/observable that exposes it. Do not defer that to
-   project-level prose, and rework the feature spec if the hypothesis is only
-   "the task is hard".
-7. When a feature is a new unmeasured benchmark, shadow-fixture, golden-fixture,
-   risk-probe, or pair-evidence candidate, its per-feature Verification must also include a solo ceiling avoidance note. The feature spec must literally
-   contain `solo ceiling avoidance`, mention `solo_claude`, and name a concrete
-   difference from rejected or solo-saturated controls such as `S2`-`S6`. Do not
-   defer that to project-level prose; benchmark fixture directories mirror the
-   same note in `NOTES.md` as `## Solo ceiling avoidance`.
 </conversation_rules>
 
 <decomposition_rules>
@@ -82,7 +67,7 @@ Anything binding all features (e.g. "no new top-level dependencies", "all CLI ou
 - `<spec-dir>/<id-N>/spec.md` for each feature (per `references/spec-template.md`).
 - `<spec-dir>/<id-N>/spec.expected.json` for each feature (per `_shared/expected.schema.json`).
 
-Each per-feature spec is structurally lint-validated using `python3 "$DEVLYN_SHARED_DIR/spec-verify-check.py" --check <spec-path>`, including supported `complexity` frontmatter and any present actionable solo-headroom hypothesis, and each sibling expected contract plus sibling spec `complexity` frontmatter and any present actionable solo-headroom hypothesis is validated using `python3 "$DEVLYN_SHARED_DIR/spec-verify-check.py" --check-expected <expected-path>`; if the spec has a solo-headroom hypothesis, its observable command must match `spec.expected.json.verification_commands[].cmd`.
+Each per-feature spec is structurally lint-validated using `python3 "$DEVLYN_SHARED_DIR/spec-verify-check.py" --check <spec-path>`, including supported `complexity` frontmatter, and each sibling expected contract plus sibling spec `complexity` frontmatter is validated using `python3 "$DEVLYN_SHARED_DIR/spec-verify-check.py" --check-expected <expected-path>`.
 
 Final announcement: `project ready — N specs at <spec-dir>/. Start with /devlyn:resolve --spec <first-spec-path>`.
 </output>

package/config/skills/devlyn:ideate/references/spec-template.md

@@ -118,6 +118,4 @@ Substantive (ideate's job during elicitation):
 - Avoid formatter-sensitive single-line adjacency checks — prefer a semantic test (runtime, DB, or CLI check), or grep one stable line-local anchor and assert required context separately.
 - Frontmatter `complexity` reflects verification shape: `high` when the spec combines state mutation with ordering/priority, idempotency, auth/error priority, rollback/failure handling, or exact output shape; `medium` for ordinary multi-step work; `trivial` only for a single localized behavior.
 - When Requirements combine state mutation, ordering/priority, idempotency, auth/error priority, or exact output shape, Verification includes at least one compound scenario that exercises the interaction end-to-end; isolated happy paths are insufficient.
-- For benchmark, risk-probe, or pair-evidence specs, include a solo-headroom hypothesis inside `## Verification`: the artifact must literally contain `solo-headroom hypothesis`, `solo_claude`, `miss`, and a backticked observable command while naming the visible behavior a capable `solo_claude` baseline is expected to miss; the backticked line itself must contain `miss`, be framed as the command/observable that exposes it, and match a `spec.expected.json.verification_commands[].cmd` entry. For regenerated pair evidence, this hypothesis is the source for VERIFY's canonical `spec.solo_headroom_hypothesis` trigger reason and must pass `benchmark audit --require-hypothesis-trigger`. If the hypothesis is only "the task is hard", rework the spec before measurement.
-- For new unmeasured benchmark, shadow-fixture, golden-fixture, risk-probe, or pair-evidence candidates, include a solo ceiling avoidance note before measurement: the artifact must literally contain `solo ceiling avoidance`, mention `solo_claude`, and name a concrete difference from rejected or solo-saturated controls such as `S2`-`S6`. If the note cannot say why the candidate should preserve `solo_claude` headroom, rework the candidate instead of spending provider calls. Benchmark fixture directories put this in `NOTES.md` as `## Solo ceiling avoidance`; ordinary specs keep the note in `## Verification` next to the solo-headroom hypothesis.
 - Spec text is plain language — no jargon walls, no "for future flexibility" hedging.

package/config/skills/devlyn:queue/SKILL.md

@@ -23,18 +23,20 @@ DEVLYN_SHARED_DIR="$(cd "$DEVLYN_SKILL_DIR/../_shared" && pwd)"
 Before processing the first item, read and obey
 `../devlyn:resolve/references/outer-loop.md`. Its scoped-commit order is binding.
 
+Queue state is base's `docs/specs/queue.md` plus owned receipts: for each `$(git rev-parse --git-common-dir)/devlyn-completion/*/receipt.json`, read `git show <ref>:docs/specs/queue.md` from its `recovery_ref` if that ref exists (it is never deleted), else its `branch` if it still exists; an item unmarked on base but `[x]`/`[F]` there counts as that mark. Two different terminal marks for one item stop for inspection. Status and drain selection both use this view.
+
 ## No args — status
 
-Read `docs/specs/queue.md` (absent → report "queue empty — nothing staged" and how to add). Print pending `[ ]`, done `[x]`, and blocked `[F]` counts, the next item up, and one usage line per subcommand.
+Read the queue state above (absent `docs/specs/queue.md` → report "queue empty — nothing staged" and how to add). Print pending `[ ]`, done `[x]`, and blocked `[F]` counts, the next item up, and one usage line per subcommand.
 
 ## Subcommands
 
 - `add <intent text>` — append `- [ ] <intent>` to `docs/specs/queue.md` (create the file with its header if missing). If the intent came out of a conversation that already produced a spec, link it: `- [ ] (spec: docs/specs/<id>/spec.md) <intent>`.
 - `drain` — serial drain per the project-instructions contract. For each pending item, in order:
-  1. Allocate the owner's absent task branch per `../devlyn:resolve/references/task-completion.md` (linked worktree optional), then spec it if unspecced (the queue entry is the user's go-ahead). Unattended assumptions may only take scope-narrowing, reversible, non-user-visible defaults; material ambiguity (user-visible behavior, data/state semantics, new files/scripts/flags, implementation surface) → mark `[F] needs-review: <question>`, commit that queue transition, and continue.
-  2. Commit the current queue-item delta and linked spec bundle as the scoped owner baseline, then run `/devlyn:resolve --spec <path>` hands-free.
+  1. Allocate the owner's absent task branch with `--worktree <absent path>` per `../devlyn:resolve/references/task-completion.md`, and work in that worktree; then spec it if unspecced (the queue entry is the user's go-ahead). Unattended assumptions may only take scope-narrowing, reversible, non-user-visible defaults; material ambiguity (user-visible behavior, data/state semantics, new files/scripts/flags, implementation surface) → mark `[F] needs-review: <question>`, commit that queue transition, and continue.
+  2. Bring only the current queue-item delta and linked spec bundle from the queue view into the task worktree, which starts from the fetched remote base with no other local commits, commit that scoped owner baseline, then run `/devlyn:resolve --spec <path>` hands-free.
      After every resolve invocation, run `python3 "$DEVLYN_SHARED_DIR/terminal-claim-check.py" .`; exit 79 marks `[F] FAILED-INCOMPLETE` from the predicate, never from the session self-report.
-  3. Outer loop on the terminal verdict: PASS → mark `[x]`. Findings-backed verdicts (NEEDS_WORK, verify/build-gate exhaustion) → amend the spec, commit that scoped amendment, then re-run — at most 3 outer iterations. Infrastructure / invalid-input / engine-availability / implement-empty BLOCKED verdicts are not spec-amendable → mark `[F] <verdict>` immediately.
+  3. Outer loop on the terminal verdict: PASS → mark `[x]`. Findings-backed verdicts (NEEDS_WORK, BLOCKED:repair-budget-exhausted) → amend the spec, commit that scoped amendment, then re-run — at most 3 outer iterations. Infrastructure / invalid-input / engine-availability / implement-empty BLOCKED verdicts are not spec-amendable → mark `[F] <verdict>` immediately.
   4. Commit each terminal `[x]` / `[F]` queue transition before advancing. For successfully archived normal runs, invoke owner completion once after that declared queue-file-only commit; bind it separately from the verified source. Honor local-only/no-push. Failed products never publish. Retain PR/pending workspaces and use a separate owned branch from base for the next item; unavailable safe placement stops the drain with remaining items pending. A product-blocked item otherwise never halts the queue.
   5. When the queue is drained (or the session must stop), emit the drain report: per-item product verdict and separate delivery status/URL/resume, every logged assumption, and the commit range produced.