devlyn-cli 2.10.0 → 2.10.1

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

@@ -169,6 +169,44 @@ def read_findings(devlyn: pathlib.Path) -> tuple[list[dict[str, Any]], dict[str,
                     source_verdicts[source], RANK_VERDICT[finding_rank(item)]
                 )
     findings.extend(detect_pair_stdout_contract_violations(devlyn, source_verdicts))
+    pair_summary_path = devlyn / "pair-judge.summary.json"
+    pair_carrier_exists = any(
+        (devlyn / name).is_file()
+        for name in ("verify.pair.findings.jsonl", "verify.pair-judge.findings.jsonl")
+    )
+    if pair_carrier_exists and pair_summary_path.is_file():
+        try:
+            pair_summary = loads_strict_json(pair_summary_path.read_text(encoding="utf-8"))
+        except ValueError as exc:
+            summary_error = f"pair-judge.summary.json is malformed JSON: {exc}"
+        else:
+            pair_verdict = pair_summary.get("verdict") if isinstance(pair_summary, dict) else None
+            summary_error = None
+            if not isinstance(pair_summary, dict):
+                summary_error = "pair-judge.summary.json must be a JSON object."
+            elif not isinstance(pair_verdict, str) or pair_verdict not in {
+                "PASS", "PASS_WITH_ISSUES", "FAIL", "NEEDS_WORK", "BLOCKED"
+            }:
+                summary_error = (
+                    "pair-judge.summary.json verdict must be PASS, PASS_WITH_ISSUES, "
+                    "FAIL, NEEDS_WORK, or BLOCKED."
+                )
+        if summary_error is not None:
+            findings.append(
+                pair_blocker(
+                    "verify-pair-summary-invalid",
+                    summary_error,
+                    pair_summary_path.name,
+                )
+            )
+            source_verdicts["pair_judge"] = "BLOCKED"
+        elif (
+            source_verdicts["pair_judge"] != "TIMEOUT"
+            or rank(pair_verdict) > rank("TIMEOUT")
+        ):
+            source_verdicts["pair_judge"] = worse(
+                source_verdicts["pair_judge"], pair_verdict
+            )
     return findings, source_verdicts
 
 
@@ -2331,6 +2369,138 @@ def self_test() -> int:
         state = loads_strict_json((devlyn / "pipeline.state.json").read_text(encoding="utf-8"))
         assert summary["verdict"] == "PASS", summary
         assert state["phases"]["verify"]["sub_verdicts"]["pair_judge"] == "PASS", state
+
+        # iter-0083: canonical summary verdict conservation.
+        iter_0083_paths = (
+            "pipeline.state.json",
+            "verify-mechanical.findings.jsonl",
+            "verify.findings.jsonl",
+            "verify.pair.findings.jsonl",
+            "verify.pair-judge.findings.jsonl",
+            "pair-judge.summary.json",
+            "codex-primary-judge.summary.json",
+            "grok-judge.summary.json",
+            "verify.pair.timeout.json",
+            "codex-judge.stdout",
+            "claude-judge.stdout",
+        )
+
+        def iter_0083_reset() -> None:
+            for name in iter_0083_paths:
+                (devlyn / name).unlink(missing_ok=True)
+
+        def iter_0083_case(
+            summary_payload: object | None,
+            severity: str | None,
+            *,
+            carrier: str | None = "verify.pair.findings.jsonl",
+            other_summary: str | None = None,
+            timeout: bool = False,
+        ) -> tuple[list[dict[str, Any]], dict[str, Any]]:
+            iter_0083_reset()
+            if carrier is not None:
+                content = (
+                    json.dumps({"id": "iter-0083", "severity": severity}) + "\n"
+                    if severity
+                    else ""
+                )
+                (devlyn / carrier).write_text(content, encoding="utf-8")
+            if summary_payload is not None:
+                content = (
+                    summary_payload
+                    if isinstance(summary_payload, str)
+                    else json.dumps(summary_payload)
+                )
+                (devlyn / "pair-judge.summary.json").write_text(content, encoding="utf-8")
+            if other_summary is not None:
+                (devlyn / other_summary).write_text(
+                    json.dumps({"verdict": "BLOCKED"}), encoding="utf-8"
+                )
+            if timeout:
+                (devlyn / "verify.pair.timeout.json").write_text(
+                    json.dumps({"engine": "claude", "budget_seconds": 600}),
+                    encoding="utf-8",
+                )
+            case_findings, case_source_verdicts = read_findings(devlyn)
+            return case_findings, write_outputs(devlyn, case_findings, case_source_verdicts)
+
+        for case_id, verdict, severity, expected in (
+            ("P1", "NEEDS_WORK", "INFO", "NEEDS_WORK"),
+            ("P2", "NEEDS_WORK", "LOW", "NEEDS_WORK"),
+            ("P3", "NEEDS_WORK", "MEDIUM", "NEEDS_WORK"),
+            ("P4", "PASS", "HIGH", "NEEDS_WORK"),
+            ("P5", "BLOCKED", "INFO", "BLOCKED"),
+            ("P6", "FAIL", "INFO", "NEEDS_WORK"),
+            ("P7", "PASS", None, "PASS"),
+        ):
+            _, summary = iter_0083_case({"verdict": verdict}, severity)
+            assert summary["source_verdicts"]["pair_judge"] == expected, case_id
+            assert summary["verdict"] == expected, case_id
+
+        for case_id, severity, expected in (
+            ("P8-INFO", "INFO", "PASS"),
+            ("P8-LOW", "LOW", "PASS_WITH_ISSUES"),
+        ):
+            _, summary = iter_0083_case(None, severity)
+            assert summary["source_verdicts"]["pair_judge"] == expected, case_id
+            assert summary["verdict"] == expected, case_id
+
+        def assert_iter_0083_blocked(
+            case_id: str,
+            case_findings: list[dict[str, Any]],
+            summary: dict[str, Any],
+        ) -> None:
+            assert summary["source_verdicts"]["pair_judge"] == "BLOCKED", case_id
+            assert summary["verdict"] == "BLOCKED", case_id
+            assert any(
+                finding.get("source") == "pair_judge"
+                and finding.get("severity") == "CRITICAL"
+                and finding.get("file") == "pair-judge.summary.json"
+                for finding in case_findings
+            ), case_id
+
+        for case_id, payload in (
+            ("N1-malformed", "{"),
+            ("N1-non-object", []),
+            ("N1-unknown", {"verdict": "UNKNOWN"}),
+            ("N2", {}),
+            ("N7", {"verdict": "TIMEOUT"}),
+        ):
+            case_findings, summary = iter_0083_case(payload, "INFO")
+            assert_iter_0083_blocked(case_id, case_findings, summary)
+
+        _, summary = iter_0083_case({"verdict": "BLOCKED"}, None, carrier=None)
+        assert summary["source_verdicts"]["pair_judge"] is None, summary
+        assert summary["verdict"] == "PASS", summary
+
+        _, summary = iter_0083_case(
+            {"verdict": "PASS"},
+            "INFO",
+            other_summary="codex-primary-judge.summary.json",
+        )
+        assert summary["source_verdicts"]["pair_judge"] == "PASS", "N4"
+        assert summary["verdict"] == "PASS", "N4"
+
+        _, summary = iter_0083_case(
+            None,
+            "INFO",
+            other_summary="grok-judge.summary.json",
+        )
+        assert summary["source_verdicts"]["pair_judge"] == "PASS", "N5"
+        assert summary["verdict"] == "PASS", "N5"
+
+        _, summary = iter_0083_case(
+            {"verdict": "NEEDS_WORK"},
+            "INFO",
+            carrier="verify.pair-judge.findings.jsonl",
+        )
+        assert summary["source_verdicts"]["pair_judge"] == "NEEDS_WORK", "N6"
+        assert summary["verdict"] == "NEEDS_WORK", "N6"
+
+        case_findings, summary = iter_0083_case({"verdict": "BLOCKED"}, None, timeout=True)
+        assert case_findings == [], "VERIFY-JUDGE-001"
+        assert summary["source_verdicts"]["pair_judge"] == "BLOCKED", "VERIFY-JUDGE-001"
+        assert summary["verdict"] == "BLOCKED", "VERIFY-JUDGE-001"
     return 0
 
 

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

@@ -40,7 +40,7 @@ pair judge    codex        binary rule     (pin order with: pair <name>,...)
 
 ## Subcommands
 
-- `executor <name>` — pin the executor (PLAN/IMPLEMENT/CLEANUP + primary VERIFY judge). Refuse names with no `_shared/adapters/<name>.md`, or whose adapter's `## Role eligibility` section declares `executor: no` (judge-only backends), listing the valid names either way. If the engine's CLI is not currently available, still write the pin but warn: pins are promises — the run will stop with `BLOCKED:<name>-unavailable` until it is installed.
+- `executor <name>` — pin the executor (IMPLEMENT/CLEANUP + primary VERIFY judge; PLAN is orchestrator-fixed and never follows the pin). Refuse names with no `_shared/adapters/<name>.md`, or whose adapter's `## Role eligibility` section declares `executor: no` (judge-only backends), listing the valid names either way. If the engine's CLI is not currently available, still write the pin but warn: pins are promises — the run will stop with `BLOCKED:<name>-unavailable` until it is installed.
 - `pair <name>[,<name>...]` — set `pair_judge_priority` (ordered; first adapter-valid, pair-judge-eligible, non-primary, available entry wins at VERIFY/risk-probe time). Refuse names with no `_shared/adapters/<name>.md`, or whose adapter declares `pair_judge: no`.
 - `clear` — remove both pins; delete `.devlyn/engines.json` when nothing else remains in it.
 

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

@@ -24,7 +24,7 @@ The user does not know context engineering. They will under-specify and over-ass
 </elicitation_contract>
 
 <harness_principles>
-Read `_shared/runtime-principles.md` (Subtractive-first / Goal-locked / No-workaround / Evidence). The principles bind the spec content as well as your conversation. A spec that says "for future flexibility" is a Subtractive-first violation. A spec that asks for `try { ... } catch { return null }` is a No-workaround violation. AI flags these in elicitation, not after `/devlyn:resolve` has built them.
+Read `_shared/runtime-principles.md` (Subtractive-first / Goal-locked / Evidence-over-claim). The principles bind the spec content as well as your conversation. A spec that says "for future flexibility" is a Subtractive-first violation. A spec that asks for `try { ... } catch { return null }` is a No-workaround violation. AI flags these in elicitation, not after `/devlyn:resolve` has built them.
 </harness_principles>
 
 <runtime_paths>

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

@@ -51,10 +51,10 @@ fi
 Each phase routes to an engine and prepends the per-engine adapter header from `_shared/adapters/<engine>.md` (e.g. `claude.md`, `codex.md`) to the canonical phase body. Adapter is the per-model delta (Anthropic's prompt-engineering guide for Claude, OpenAI's prompt guidance for Codex). Canonical body is engine-agnostic.
 
 - Phase spawning is mandatory for every orchestrator. Same-context PLAN / IMPLEMENT / BUILD_GATE / CLEANUP / VERIFY is a contract violation. If the current CLI cannot spawn a fresh worker, write the current phase verdict as `"BLOCKED"` and report `BLOCKED:fresh-context-unavailable` with the failed spawn command; do not continue with ad-hoc same-context execution.
-- Claude Code phases: spawn `Agent` (`mode: "bypassPermissions"`); prompt = adapter-header + canonical-body + task-context.
+- Claude Code phases other than PLAN: spawn `Agent` (`mode: "bypassPermissions"`); prompt = adapter-header + canonical-body + task-context. PLAN uses the native foreground call shape in PHASE 1.
 - Codex CLI phases: shell out via `bash "$CODEX_MONITORED_PATH"` with the same compounded prompt. Each `codex exec` child is a new session/fresh context. The wrapper closes stdin and emits a heartbeat. No MCP. The wrapper call is foreground-blocking — never a background shell (`run_in_background`, `&`, `nohup`), never end your message while it runs: headless print-mode wind-down kills backgrounded children (0-byte delivery); the heartbeat is the observability channel.
 - oh-my-pi phases: spawn the native `task` tool with a fresh `context` containing adapter-header + canonical-body + task-context. Capture the task result into `.devlyn/<phase>.stdout` and any tool error into `.devlyn/<phase>.stderr` before updating state. If the `task` tool is unavailable for an omp-routed phase, write the current phase verdict as `"BLOCKED"` and report `BLOCKED:fresh-context-unavailable`; do not fall back to same-context execution or a nested `omp -p` subprocess.
-- Default engine: Claude for PLAN / IMPLEMENT / BUILD_GATE / CLEANUP when the orchestrator has Claude Code's native `Agent` primitive; otherwise the default route is the current CLI's fresh worker (`codex` child process for Codex CLI, native `task` for oh-my-pi). Role resolution (`_shared/engine-preflight.md#role-resolution`): explicit `--engine` flag > machine-local `.devlyn/engines.json` `executor` pin > orchestrator-supported default above. Explicit routes and pins still fail closed when their required engine/spawn channel is unavailable. VERIFY/JUDGE selects the OTHER engine by default when available — OTHER = first adapter-valid, non-primary, available entry of `engines.json` `pair_judge_priority`, or the binary claude↔codex complement when unset.
+- Default engine: Claude for IMPLEMENT / BUILD_GATE / CLEANUP when the orchestrator has Claude Code's native `Agent` primitive; otherwise the default route is the current CLI's fresh worker (`codex` child process for Codex CLI, native `task` for oh-my-pi). PLAN is orchestrator-fixed and never inherits `--engine`, an executor pin, or `state.engine`. Role resolution (`_shared/engine-preflight.md#role-resolution`): explicit `--engine` flag > machine-local `.devlyn/engines.json` `executor` pin > orchestrator-supported default above. Explicit routes and pins still fail closed when their required engine/spawn channel is unavailable. VERIFY/JUDGE selects the OTHER engine by default when available — OTHER = first adapter-valid, non-primary, available entry of `engines.json` `pair_judge_priority`, or the binary claude↔codex complement when unset.
 - The `--engine` flag does not disable default pairing: the second judge uses the OTHER engine by default when available.
 - Multi-LLM evolution: when a new model adapter ships in `_shared/adapters/`, that engine becomes selectable for the roles its adapter declares eligible without further skill changes (NORTH-STAR.md "Multi-LLM evolution direction").
 </engine_routing>
@@ -101,15 +101,15 @@ For every direct complete→spawn handoff, call `state-phase-write.py ... --phas
 
 Skip in verify-only mode. The heaviest phase by design — spec/criteria define non-negotiable invariants; plan formalizes how the implementation hits them.
 
-Engine: Claude (PLAN-pair is **research-only** — iter-0033d/f/g; unblock conditions in PHASE 1 / iter-0033g §H; iter-0020 falsified Codex-BUILD/IMPLEMENT, NOT PLAN-pair). Prompt body: `references/phases/plan.md`.
+Engine: PLAN is orchestrator-fixed and never inherits `--engine`, an executor pin, or `state.engine`; Claude Code uses a native Claude `Agent` worker, while Codex CLI / oh-my-pi use their own fresh worker per `_shared/engine-preflight.md` (PLAN-pair is **research-only** — iter-0033d/f/g; unblock conditions in PHASE 1 / iter-0033g §H; iter-0020 falsified Codex-BUILD/IMPLEMENT, NOT PLAN-pair). Before rendering, assign the current orchestrator's literal adapter name (`PLAN_ENGINE=claude`, `PLAN_ENGINE=codex`, or `PLAN_ENGINE=omp`) and assign `PLAN_MODEL=<exact model id passed to that fresh worker>`; replace the metavalue and fail closed if either assignment is empty. Write the data-only task context to `.devlyn/plan.task-context` with `PLAN_WORKING_DIR="$(pwd -P)"`: its first two lines are exactly `Working directory: $PLAN_WORKING_DIR` and `Plan output: $PLAN_WORKING_DIR/.devlyn/plan.md`, followed by the task data. Then render adapter + `references/phases/plan.md` + task context without byte normalization: `PLAN_PROMPT_SHA256="$(python3 "$DEVLYN_SHARED_DIR/phase-prompt-render.py" --adapter "$DEVLYN_SHARED_DIR/adapters/$PLAN_ENGINE.md" --canonical-body "$DEVLYN_SKILL_DIR/references/phases/plan.md" --task-context .devlyn/plan.task-context --output .devlyn/plan.prompt)"`. The renderer fails closed before writing `.devlyn/plan.prompt` if either fixed header field is missing, non-absolute, or mismatches the active repository paths. Open round 0 with `state-phase-write.py ... --phase plan spawn --round 0 --engine "$PLAN_ENGINE" --model "$PLAN_MODEL" --prompt-sha256 "$PLAN_PROMPT_SHA256"`. In Claude Code, invoke the native `Agent` with its `prompt` field set to the exact `.devlyn/plan.prompt` bytes, explicitly set `run_in_background: false`, and omit `mode`; this is a data field, so a path, `$(cat ...)`, or any variable-reference substitution is not the rendered prompt. If native input validation rejects this call, surface the failure without retrying a different `mode` or background shape and fail closed through the existing `BLOCKED:fresh-context-unavailable` path. The PLAN worker inherits the parent's permission context: the hands-free parent already uses native `bypassPermissions`, while a non-bypass parent's permission prompt remains the user's native boundary and is never silently escalated. Codex CLI and oh-my-pi deliver the same prompt through their unchanged routes. Product code records rendered intent; it never parses a transcript or intercepts, rewrites, wraps, or forces native delivery.
 
 Subagent output (writes `.devlyn/plan.md`): file list to touch, risk list (out-of-scope expansions, ambiguous spec sections), acceptance restatement (what `## Verification` actually requires verbatim). For large work only, PLAN may add a fourth section `## Execution phases` under the conditions in `references/phases/plan.md`; a phase block missing a runnable `gate:` line disqualifies the whole section — treat the run as single-phase and log the disqualification.
 
-State write: `phases.plan.{started_at, verdict, completed_at, duration_ms}`.
+State write: each PLAN receipt carries spawn-known `round`, `started_at`, `triggered_by`, `engine`, `model_requested`, and `prompt_sha256`; completion enriches it with `completed_at`, `duration_ms`, `verdict`, and nullable `model_effective`.
 
 After return:
 1. If `.devlyn/plan.md` lists zero files → halt with verdict `BLOCKED:plan-empty`.
-2. If risk list flags an out-of-scope expansion the user did not authorize → re-spawn once with the reminder; second fail → halt.
+2. If risk list flags an out-of-scope expansion the user did not authorize → the sole legal corrective re-spawn is round 1: update the data-only task context, repeat render + digest, open PLAN with `--round 1 --triggered-by plan` and the actual engine/model/digest, then deliver the new `.devlyn/plan.prompt` using the same native call shape as round 0. A second failed plan halts; no further PLAN dispatch is authorized.
 3. After any re-spawn above, if `state.risk_profile.risk_probes_enabled == true` and `state.risk_profile.risk_probes_explicit == false`, parse the `authorized_surface` array from the JSON block under `<!-- devlyn:authorized-surface -->`. For a well-formed string array, compute `probe_scale_small := len(authorized_surface) <= 2 AND no entry ends in "/**"`. If true, set `risk_probes_enabled = false`, leave `high_risk` unchanged, and append `auto-risk-probes demoted: plan surface small (<n> paths)` to `reasons` using the actual length. A missing or malformed block leaves probe state unchanged; BUILD_GATE owns its malformed-block failure.
 
 ## PHASE 1.5: RISK_PROBES
@@ -156,7 +156,8 @@ When visible text names exact keys, fields, row shapes, JSON objects, response
 bodies, stdout/stderr objects, or exact error bodies, `shape_contract` must
 include `uses_visible_input_key_names`, `asserts_visible_output_key_names`, and
 `asserts_no_unexpected_output_keys`; exact JSON error objects/bodies must also
-include `asserts_exact_error_object`. Cart/pricing success probes should use
+include `visible_text_names_exact_json_error_object` and
+`asserts_exact_error_object`. Cart/pricing success probes should use
 `shape_contract` unless they satisfy the `ordering_inversion` markers. The probe
 command must not reference external network URLs; use only worktree-local or
 localhost resources.

package/config/skills/devlyn:resolve/references/phases/build-gate.md

@@ -20,7 +20,7 @@ Detect the project shape from files in `state.base_ref.sha`:
 Run in this order; each emits findings into `.devlyn/build_gate.findings.jsonl`:
 
 1. **Type check** (TypeScript / mypy / etc.). Each error → one finding, severity `HIGH`, rule `correctness.type-check`.
-2. **Lint** (eslint / ruff / clippy / etc.). Each error → finding, severity `MEDIUM`, rule `quality.lint`. Warnings stay LOW unless the spec elevates them.
+2. **Lint**. Run a recognized configured language linter (for example, ESLint with a config, `ruff`, or `clippy`) and/or the exact `package.json` `scripts.lint` command. A declared specialized `lint:*` script (for example, `lint:json`) is not the general language lint gate on the strength of its declaration alone. If the spec's verification commands explicitly name such a specialized command, step 4 executes it and preserves its real failure severity. If no linter is applicable, log an explicit SKIP in `.devlyn/build_gate.log.md` and emit zero lint findings. Each error → finding, severity `MEDIUM`, rule `quality.lint`. Warnings stay LOW unless the spec elevates them.
 3. **Test suite** (npm test / pytest / go test / cargo test). Each failing test → finding, severity `HIGH`, rule `correctness.test-failure`. Include the failing test's file:line and the assertion.
 4. **Spec literal verification + risk probes**: `python3 "$DEVLYN_SHARED_DIR/spec-verify-check.py" --include-risk-probes`. The script self-stages from sibling `spec.expected.json` next to `state.source.spec_path`, or the legacy inline carrier when the sibling is absent; benchmark-prestaged `.devlyn/spec-verify.json` still wins. It appends `.devlyn/risk-probes.jsonl` when present, and requires that file when `state.risk_profile.risk_probes_enabled == true`. Malformed `state.risk_profile` is also CRITICAL because it can hide enabled risk probes. When probes are enabled or `.devlyn/risk-probes.jsonl` exists, missing or mismatched top-level `state.risk_probes_digest` emits `correctness.risk-probe-integrity` CRITICAL; the digest binds `.devlyn/risk-probes.jsonl` plus referenced `.devlyn/probes/` script bytes. Command or risk-probe mismatch → CRITICAL finding. Missing required risk probes, missing/malformed generated carrier, or malformed sibling expected file → `correctness.spec-verify-malformed` CRITICAL. The same invocation also enforces PLAN's declared `authorized_surface` (the json block under `.devlyn/plan.md`'s `<!-- devlyn:authorized-surface -->` section, located by that sentinel regardless of the heading's language) against this run's diff and untracked delta: any changed path or created-during-run untracked path outside the declared surface → `scope.out-of-scope-file` CRITICAL (`.devlyn/` exempt) — the only sanctioned fix is removing the file, never widening the declared surface, since that would let the same worker that leaked scope self-authorize the leak; missing sentinel, malformed `plan.md`/surface block, or missing `.devlyn/untracked.baseline` → `scope.authorized-surface-malformed` CRITICAL. This scope check runs only here (BUILD_GATE), not when VERIFY MECHANICAL reuses this script post-CLEANUP, because CLEANUP's own allowlist legitimately touches paths PLAN never declared.
 5. **Browser** (only when diff touches `*.tsx`, `*.jsx`, `*.vue`, `*.svelte`, `page.*`, `layout.*`, `route.*`, `*.css`, `*.html`): start the dev server and run the repo's existing browser checks, or a minimal curl/HTML check when no browser test harness exists. Each failed check → finding, severity `HIGH`, rule `correctness.browser-flow-failed`.
@@ -35,7 +35,7 @@ Append all findings; do not stop on the first failure.
 </output>
 
 <quality_bar>
-- Same commands every time. Configuration drift between this gate and CI is a defect; raise as a finding rather than soften this gate.
+- Same commands every time. Configuration drift between this gate and CI is a defect; raise as a finding rather than soften this gate. A package-script declaration alone is not evidence that CI executes it.
 - Forbidden-pattern check (regex against `git diff`) for `spec.expected.json.forbidden_patterns` runs as part of step 4. Disqualifier-severity matches → CRITICAL findings.
 - Reporter artifacts the gate generates (Playwright traces, coverage HTML) belong in gitignored paths. If they leak into `git diff --stat`, flag as `scope.tooling-artifact-leak` MEDIUM and let the fix loop / cleanup handle removal.
 </quality_bar>

package/config/skills/devlyn:resolve/references/phases/implement.md

@@ -33,7 +33,7 @@ Read `_shared/runtime-principles.md`. Codex-routed phases receive the inlined ex
 
 - Subtractive-first: every accretion-shaped change is visible in the commit message or a flagged finding. Net-deletion is the default; pure-addition needs a citation.
 - Goal-locked: implement only the listed Requirements. Adjacent code that "looks fixable" is drift unless the spec or plan listed it.
-- No-workaround: no `any`, no `@ts-ignore`, no silent `catch`, no hardcoded values, no helper scripts that bypass root cause. Required unavailable engines stop with `BLOCKED:<engine>-unavailable`; they do not downgrade.
+- No-workaround: no `any`, no `@ts-ignore`, no silent `catch`, no hardcoded fallback that hides a broken contract, no helper scripts that bypass root cause. Required unavailable engines stop with `BLOCKED:<engine>-unavailable`; they do not downgrade.
 - Evidence: every claim cites file:line you opened. Hallucinated APIs are excluded.
 </runtime_principles>
 

package/config/skills/devlyn:resolve/references/phases/plan.md

@@ -32,12 +32,8 @@ Report your verdict in this reply: `PASS` if plan is shippable; `BLOCKED` if spe
 </quality_bar>
 
 <runtime_principles>
-Read `_shared/runtime-principles.md` (Subtractive-first / Goal-locked / No-workaround / Evidence). Codex-routed phases receive the contract excerpt inlined:
-
 - Subtractive-first: prefer trimming an existing helper to introducing a new one. Pure-addition needs a cited prior failure mode or an explicit spec/user requirement.
 - Goal-locked: refuse "while I'm here" cleanups, speculative robustness, mid-flight re-scoping. Single test before any deviation: "did the user ask for this OR does the stated goal strictly require it?"
-- No-workaround: no `any`, no `@ts-ignore`, no silent `catch`, no hardcoded values, no helper scripts that bypass root cause.
+- No-workaround: no `any`, no `@ts-ignore`, no silent `catch`, no hardcoded fallback that hides a broken contract, no helper scripts that bypass root cause.
 - Evidence: every claim cites file:line opened at planning time. Vague claims excluded.
 </runtime_principles>
-
-The task is: [orchestrator pastes the task description and spec context here]

package/config/skills/devlyn:resolve/references/phases/probe-derive.md

@@ -170,8 +170,8 @@ Rules:
     shapes, JSON objects, response bodies, stdout/stderr objects, or exact error
     bodies: `uses_visible_input_key_names`,
     `asserts_visible_output_key_names`, `asserts_no_unexpected_output_keys`.
-    If it names an exact JSON error object/body, also include
-    `asserts_exact_error_object`.
+    If it names an exact JSON error object/body, also include both
+    `visible_text_names_exact_json_error_object` and `asserts_exact_error_object`.
   Tags not listed here may use an empty evidence list or be omitted from
   `tag_evidence`.
 - `cmd` must not reference `BENCH_FIXTURE_DIR`, `verifiers/`, benchmark fixture
@@ -182,6 +182,8 @@ Rules:
   replayed probe and obeys the same hidden-path/external-URL rules as `cmd`.
   Solo-headroom hypothesis probes keep the hypothesis's backticked observable
   command inline in `cmd` for mechanical validation.
+- A probe may declare `timeout_sec` from 1 through 600 when the exercised
+  verification legitimately needs more than the default 60 seconds.
 - Match the spec's visible input and output key names literally; do not invent
   aliases such as `stock` for `lots`, `order_id` for `id`, or `warehouse_id`
   for `warehouse`.

package/config/skills/devlyn:resolve/references/phases/verify.md

@@ -177,7 +177,11 @@ When eligible and the orchestrator spawns a second VERIFY agent with the OTHER e
   A targeted probe must compare the full externally visible result
   (stdout/stderr/exit and full parsed output object, including accepted/scheduled
   rows, rejected rows, and remaining state when present), not just a single
-  property. When the spec names exact keys, row shapes, JSON object shape, or an
+  property. The mandatory dominance-loss anchor must run as a single command
+  with no shell chain operators. Chains used only to re-capture exit status are
+  forbidden because the tool result already carries it; this does not ban
+  compound shell generally or multi-step probes issued as separate tool calls.
+  When the spec names exact keys, row shapes, JSON object shape, or an
   exact error body, compare parsed key sets/deep equality so aliased keys,
   missing keys, and extra keys are verdict-binding failures. Use the spec's
   visible input key names literally when constructing the probe input. For

package/config/skills/devlyn:resolve/references/state-schema.md

@@ -57,7 +57,7 @@ Single authoritative verdict source for `/devlyn:resolve`. The orchestrator bran
 - **risk_probes_digest** — top-level sha256 written by PHASE 1.5 after probe validation; BUILD_GATE/VERIFY replay semantics live in `phases/build-gate.md` step 4.
 - **rounds.global** — incremented every fix-loop pass (BUILD_GATE → fix-loop, VERIFY → fix-loop, OR a phase-gate fix respawn inside phase-gated IMPLEMENT).
 - **phases.implement.exec** — only on phase-gated large runs (plan.md has `## Execution phases` with >1 phase): `{ "total": N, "current": k, "statuses": ["PASS"|"FAIL"|null, ...], "commits": ["<sha>", ...] }`. Phase definitions live in plan.md (immutable contract); progress lives here (routing truth — never route on plan.md checkboxes). Absent on single-phase runs. `cumulative.patch` for such runs is `git diff <base_ref.sha>...HEAD`.
-- **phases.probe_derive** — optional PHASE 1.5 entry when `--risk-probes` is enabled. Artifacts include `.devlyn/risk-probes.jsonl`. Probe failures later surface through BUILD_GATE/VERIFY as `correctness.risk-probe-failed`.
+- **phases.probe_derive** — optional PHASE 1.5 entry when `--risk-probes` is enabled. Artifacts include `.devlyn/risk-probes.jsonl`. Probe failures later surface through BUILD_GATE/VERIFY as `correctness.risk-probe-failed`, or as `correctness.verification-timeout` when the probe exceeds its verification budget.
 - **phases.surface_close** — generated trivial/medium one-shot: `pre_sha`, `input_patch_sha256`, assembled-byte `prompt_sha256`, `untracked_before`; spawn requires Claude plus a requested model, and `surface-check` gates PASS. `.devlyn/surface-close.output.json` retains the Claude JSON wrapper used for completion attestation while the round JSONL remains the execution-audit backstop. Automatic Claude unavailability alone records null verdict plus `skipped_reason: "auto_surface_close_claude_unavailable"`. After an adjudication-malformed reply only, successful rollback plus transcript write-audit records the two nonterminal fields `skipped_reason: "surface_close_rolled_back_adjudication_malformed"` and `continued_after_block: true`; neither creates a terminal floor. Other failures store bare `"BLOCKED"`. `durability[]` is append-only: `{round, origin_phase, receipt_path, receipt_sha256, restore_commit_sha}` per `.devlyn/closure-durability.round-<n>.json`.
 - **bypasses** — array of phase names from `--bypass`. Valid: `"build-gate" | "cleanup"`. PLAN, IMPLEMENT, VERIFY are non-bypassable (orchestrator rejects at parse time).
 - **implement_passed_sha** — captured at end of PHASE 2; null until then. Activates the post-implement invariant for SURFACE_CLOSE, CLEANUP, and VERIFY.
@@ -91,7 +91,7 @@ Each entry under `phases.<name>` (for `plan`, `probe_derive`, `implement`, `surf
 `history` is absent until a phase is re-entered. Immediately before re-entry overwrites the live `started_at`, `verdict`, `completed_at`, and `duration_ms`, `state-phase-write.py` appends those prior values as one object to `history[]`, creating the append-only array on first re-entry.
 
 - `verdict` — `"PASS" | "PASS_WITH_ISSUES" | "FAIL" | "NEEDS_WORK" | "BLOCKED"`. PHASE 6 (FINAL_REPORT) writes its own verdict per the terminal-verdict precedence.
-- `model_requested` / `model_effective` — `model_requested` is supplied by the orchestrator through `--model`; `model_effective` is parsed only from completion-time engine session evidence. Codex evidence accepts the `model: <id>` exec header or, for `.jsonl`, rollout `turn_context.payload.model`; Claude JSON output accepts the sole `modelUsage` key. A supplied but unreadable, unparseable, ambiguous, or requested/effective-mismatched session log makes the phase verdict `BLOCKED` and the completion command fail. For mutation phases, omission of `--engine-session-log` also fails closed when `.devlyn/<artifact-phase>.worker-session.<round>.jsonl` exists; the error names that retained file. Otherwise omission records `model_effective: null` and attests that the engine class exposed no session log for that invocation.
+- `model_requested` / `model_effective` — `model_requested` is supplied by the orchestrator through `--model`; `model_effective` is parsed only from completion-time engine session evidence. Codex evidence accepts the `model: <id>` exec header or, for `.jsonl`, rollout `turn_context.payload.model`; Claude JSON output accepts a singleton `modelUsage` key or, for multiple entries, the sole key whose `inputTokens`, `outputTokens`, `cacheReadInputTokens`, and `cacheCreationInputTokens` exactly match top-level `usage.input_tokens`, `usage.output_tokens`, `usage.cache_read_input_tokens`, and `usage.cache_creation_input_tokens`. Missing or malformed counters, zero or multiple matches, and requested/effective mismatch fail closed: the phase verdict becomes `BLOCKED` and the completion command fails. For mutation phases, omission of `--engine-session-log` also fails closed when `.devlyn/<artifact-phase>.worker-session.<round>.jsonl` exists; the error names that retained file. Otherwise omission records `model_effective: null` and attests that the engine class exposed no session log for that invocation.
 - `triggered_by` — null on first run; one of `"build_gate" | "verify"` when the phase is a fix-loop respawn.
 - `pre_sha` — captured before SURFACE_CLOSE or CLEANUP. It bounds that phase's post-spawn diff and rollback.
 - `post_sha` — captured when SURFACE_CLOSE or CLEANUP completes; finish-gate subtracts CLEANUP's `pre_sha..post_sha` window.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devlyn-cli",
-  "version": "2.10.0",
+  "version": "2.10.1",
   "description": "Loop & harness engineering for AI coding agents (Claude Code, Codex, and any AGENTS.md-driven agent) — take intent to shipped, engineer-quality software hands-free with phase-gated pipelines and agent orchestration",
   "homepage": "https://github.com/fysoul17/devlyn-cli#readme",
   "bin": {

package/scripts/lint-fixtures.sh

@@ -161,7 +161,7 @@ def fallback_validate():
             if not isinstance(command, dict):
                 errors.append(f"verification_commands[{idx}] must be an object")
                 continue
-            unknown_command = sorted(set(command) - {"cmd", "exit_code", "stdout_contains", "stdout_not_contains", "contract_refs"})
+            unknown_command = sorted(set(command) - {"cmd", "exit_code", "timeout_sec", "stdout_contains", "stdout_not_contains", "contract_refs"})
             if unknown_command:
                 errors.append(f"verification_commands[{idx}] has unknown key(s): {', '.join(unknown_command)}")
             if not isinstance(command.get("cmd"), str) or not command.get("cmd"):
@@ -169,6 +169,9 @@ def fallback_validate():
             exit_code = command.get("exit_code", 0)
             if isinstance(exit_code, bool) or not isinstance(exit_code, int):
                 errors.append(f"verification_commands[{idx}].exit_code must be an integer")
+            timeout_sec = command.get("timeout_sec", 60)
+            if isinstance(timeout_sec, bool) or not isinstance(timeout_sec, int) or not 1 <= timeout_sec <= 600:
+                errors.append(f"verification_commands[{idx}].timeout_sec must be an integer from 1 to 600")
             for key in ("stdout_contains", "stdout_not_contains", "contract_refs"):
                 if key in command and not is_string_list(command[key]):
                     errors.append(f"verification_commands[{idx}].{key} must be an array of non-empty strings")