devlyn-cli 4.0.1 → 4.2.0

package/config/skills/_shared/codex-config.md

@@ -1,81 +0,0 @@
-# Shared — Codex Invocation
-
-Single source of truth for how every skill calls Codex. **MCP is not used.** Skills shell out via the wrapper at `$CODEX_MONITORED_PATH`, resolved from the invoked skill's sibling `_shared/codex-monitored.sh`, which fronts the local Codex CLI.
-
-## Canonical invocations
-
-All long-running Codex calls go through `codex-monitored.sh`. It streams full stdout and emits a `[codex-monitored] heartbeat` every 30s on stderr. Write multiline prompts as exact UTF-8 bytes to a task-local file; set `DEVLYN_CODEX_PROMPT_FILE` and pass the sole prompt argument `-`. The wrapper snapshots those bytes before dispatch and seals actual argv, prompt digest and completion in `<prompt-file>.transport.json`. Missing/unreadable files, competing prompt arguments and receipt/prompt mismatches fail before launch. Without file transport, stdin remains DEVNULL (avoiding the open-stdin plus argument-prompt hang).
-
-Use the DEVLYN_SHARED_DIR established by the invoking skill; if it was
-lost, re-establish it by that skill's rules. When this document is
-opened directly, bind DEVLYN_SHARED_DIR to its reader-supplied
-containing directory, resolving directory symlinks. Never take it from
-an environment variable, cwd or another installation; without either
-source, stop with BLOCKED:skill-source-unresolved.
-
-Bind CODEX_MONITORED_PATH to DEVLYN_SHARED_DIR/codex-monitored.sh and
-verify the file before calling it; failure is
-BLOCKED:shared-dir-unresolved with the failed path.
-
-After establishing DEVLYN_SHARED_DIR in a Bash invocation:
-```bash
-CODEX_MONITORED_PATH="$DEVLYN_SHARED_DIR/codex-monitored.sh"
-```
-
-**Read-only critique / adversarial review / debate** (`/devlyn-resolve` VERIFY pair-mode, plus any future ideate read-only critique). Codex returns findings on stdout; the orchestrator writes files.
-
-```bash
-DEVLYN_CODEX_PROMPT_FILE="<prompt-file>" CODEX_MONITORED_ISOLATED=1 CODEX_MONITORED_TIMEOUT_SEC=600 bash "$CODEX_MONITORED_PATH" \
-  -C <project-root> \
-  -s read-only \
-  -c model_reasoning_effort=xhigh \
-  -
-```
-
-**Workspace-write implementation** (`/devlyn-resolve` IMPLEMENT phase when `--engine codex` or `--engine auto` routes to Codex, plus codex-routed `/devlyn-ideate` phases):
-
-```bash
-DEVLYN_CODEX_PROMPT_FILE="<prompt-file>" bash "$CODEX_MONITORED_PATH" \
-  -C <project-root> \
-  -s workspace-write \
-  -c sandbox_workspace_write.network_access=false \
-  -c model_reasoning_effort=xhigh \
-  -
-```
-
-PLAN uses owner reasoning; BUILD_GATE/CLEANUP run owner commands, without separate Codex invocations. Code/doc cleanup runs inside the selected IMPLEMENT invocation. An already-open historical BUILD span without `execution_kind` keeps its receipt-bound workspace-write/network-true worker route; do not reinterpret or rewrite that evidence.
-
-Notes:
-- `DEVLYN_CODEX_PROMPT_FILE` — use the same file as `DEVLYN_INVOCATION_PROMPT_FILE` for receipt-bound calls. Retain the generated transport carrier with the prompt/session/argv evidence; a path or claimed environment value alone does not prove delivery. Do not use shell command substitution for prompt bytes.
-- `-C` — project root so Codex's working directory matches.
-- `-s read-only` / `-s workspace-write` — sandbox policy. Use workspace-write for implementation/probe phases that write tracked files or `.devlyn` artifacts.
-- `-c sandbox_workspace_write.network_access=<true|false>` — required and receipt-bound for mutation phases: `true` only for historical receipt-bound BUILD_GATE and, per call, PROBE-DERIVE when the probe's visible Verification command requires a localhost service; `false` for IMPLEMENT, historical worker PLAN/CLEANUP, and PROBE-DERIVE by default. This allows CI-equivalent loopback/network tests without widening to `danger-full-access` and prevents user configuration from silently changing other phases.
-- `-c model_reasoning_effort=xhigh` — config override for reasoning depth. Required for deep critique; skills may choose `high` or `medium` when thoroughness doesn't warrant xhigh.
-- **For every receipt-bound Codex call, add `--json -m <model_requested>` to the recipes above**, matching the model recorded at spawn; keep the skill’s existing model-selection rules. Other routes keep their omission rules unless an explicit role profile supplies a model: normal workers may inherit user config, while unconfigured isolated VERIFY uses its CLI default. Explicit profiles use role-config.py options and the separate judge-role-evidence.py contract; they do not relax mutation receipts. Omission proves neither model identity nor role fitness. Re-certify seats after model/version changes before re-pinning them.
-- `CODEX_MONITORED_ISOLATED=1` — required for bounded read-only critique/probe/judge calls. The wrapper adds `--ignore-user-config --ignore-rules --ephemeral --disable codex_hooks --disable hooks` so user config, AGENTS.md, hooks, and project rules cannot add hidden context, tool calls, or transcript side effects. Do not set it for workspace-write implementation phases.
-- Wrapper calls are **foreground-blocking**. Never launch them via a backgrounded shell (`run_in_background`, `&`, `nohup`) and never end the orchestrator message while one runs: a headless print-mode session kills backgrounded children at wind-down (observed 2026-07-07: an FS1 A-arm IMPLEMENT codex call was killed at turn end → 0-byte delivery). The heartbeat stream is the observability channel; block on the call. Interactive Claude Code caps a foreground Bash call at `BASH_MAX_TIMEOUT_MS` (the installer sets at least 3600000 ms, IMPLEMENT's effective outer ceiling), so every foreground Codex wrapper call must pass the Bash `timeout` explicitly at that ceiling or the phase's own budget (for example, 600s judges) — never rely on the 120 s default.
-- Raw `codex exec ...` invocations are **forbidden** in skill prompts. The benchmark variant arm runs a PATH shim (`scripts/codex-shim/codex`) that transparently re-routes any raw `codex exec` to the wrapper as a safety net, but skills should always emit the wrapper form directly so the orchestrator's first-attempt has the right shape. Two prior iterations (iter-0006 universal foreground ban, iter-0008 prompt-level kill-shape contract) failed because the orchestrator picked starvation-prone shapes (`codex exec ... 2>&1 | tail -200`) from its own pattern prior — the wrapper plus the shim is the runtime binding layer those iters lacked. See `autoresearch/iterations/0009-wrapper-and-hook.md`.
-
-## Constrained Windows judge reads
-
-Codex supports [native Windows sandboxing](https://learn.chatgpt.com/docs/windows/windows-sandbox). A policy-denied read selects a constrained-read route for that judge; it does not establish that Windows lacks sandbox support or denies every read. The orchestrator supplies the complete spec, sibling expected contract, accepted source SHA and cumulative diff, relevant source/tests with file:line locators, and validated sealed MECHANICAL results, manifests and required raw streams inline in the prompt file. Tell the fresh judge: "Judge only the supplied evidence; run no tools. Missing, truncated or unbound inputs require a verdict-binding BLOCKED finding." Keep `-s read-only`, isolation, freshness, selected model/effort, the 600s budget and normal findings/timeout handling. Never widen sandbox permissions or invent evidence to complete the packet.
-
-## Availability check
-
-Before the first Codex call in a run, verify the CLI is on PATH:
-
-```bash
-command -v codex >/dev/null 2>&1
-```
-
-If the check fails while Codex is explicitly selected or conditionally required by pair/risk-probe VERIFY, follow `_shared/engine-preflight.md`: stop with `BLOCKED:codex-unavailable`, preserve run evidence, and print setup guidance. Do not convert the run to Claude. `--no-pair` and `--no-risk-probes` are explicit user opt-outs for reruns, not automatic fallbacks.
-
-## Why CLI over other paths
-
-The local Codex CLI, fronted by `codex-monitored.sh`, is the integration boundary. CLI flags compose with the existing phase routes and keep invocation evidence inspectable. The shared preflight checks availability; a present binary does not establish model identity or role fitness.
-
-## Invocation from inside a skill prompt
-
-Skills write the invocation as a Bash command the runtime executes. Example shape from `/devlyn-resolve` PHASE 2 IMPLEMENT when routed to Codex:
-
-> Run `DEVLYN_CODEX_PROMPT_FILE="<IMPLEMENT-prompt-file>" bash "$CODEX_MONITORED_PATH" --json -C <state.base_ref.repo_root> -s workspace-write -m <model_requested> -c sandbox_workspace_write.network_access=false -c model_reasoning_effort=xhigh -`. Capture stdout as the IMPLEMENT reply; non-zero exit → treat as subagent failure. The wrapper emits `[codex-monitored]` heartbeat and lifecycle lines on **stderr** — stdout stays clean for Codex output, so the orchestrator can parse the reply without filtering. Heartbeat-on-stderr keeps the orchestrator's combined-output stream non-silent (defeats the iter-0008 byte-watchdog kill) without polluting the codex-reply view of stdout. Do not pipe the wrapper; direct capture or file redirection preserves streaming and avoids the pipe-refusal exit.

package/config/skills/_shared/collect-codex-findings.py

@@ -1,505 +0,0 @@
-#!/usr/bin/env python3
-"""Normalize raw pair-JUDGE stdout into canonical VERIFY JSONL."""
-
-from __future__ import annotations
-
-import argparse
-import json
-import pathlib
-import runpy
-import sys
-import tempfile
-from typing import Any
-
-
-MERGE_CONTRACT = runpy.run_path(pathlib.Path(__file__).with_name("verify-merge-findings.py"))
-PARSER = runpy.run_path(pathlib.Path(__file__).with_name("judge-output-parser.py"))
-VERDICT_RANK = MERGE_CONTRACT["VERDICT_RANK"]
-finding_rank = MERGE_CONTRACT["finding_rank"]
-
-
-def reject_json_constant(token: str) -> None:
-    raise ValueError(f"invalid JSON numeric constant: {token}")
-
-
-def reject_duplicate_keys(pairs: list[tuple[str, object]]) -> dict:
-    result = {}
-    for key, value in pairs:
-        if key in result:
-            raise ValueError(f"duplicate JSON key: {key}")
-        result[key] = value
-    return result
-
-
-def loads_strict_json(text: str) -> Any:
-    return json.loads(
-        text,
-        parse_constant=reject_json_constant,
-        object_pairs_hook=reject_duplicate_keys,
-    )
-
-
-def atomic_write(path: pathlib.Path, text: str) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    with tempfile.NamedTemporaryFile(
-        "w", encoding="utf-8", dir=path.parent, delete=False
-    ) as handle:
-        handle.write(text)
-        tmp_name = handle.name
-    pathlib.Path(tmp_name).replace(path)
-
-
-def collect_text(
-    text: str, source: pathlib.Path
-) -> tuple[list[dict[str, Any]], dict[str, Any] | None]:
-    findings, summary = PARSER["collect_text"](text, source)
-    if findings and summary is None:
-        raise SystemExit("error: findings without terminal verdict")
-    if summary is not None and summary["verdict"] == "PASS" and any(finding_rank(finding) == 2 for finding in findings):
-        raise SystemExit("error: verdict-binding finding cannot have a PASS verdict")
-    if not findings and (summary is None or summary.get("verdict") != "PASS"):
-        raise SystemExit("error: non-PASS verdict without JSONL findings")
-    return findings, summary
-
-
-def collect_stdout(stdout_path: pathlib.Path) -> tuple[list[dict[str, Any]], dict[str, Any] | None]:
-    findings, summary = PARSER["collect_stdout"](stdout_path)
-    if findings and summary is None:
-        raise SystemExit("error: findings without terminal verdict")
-    if summary is not None and summary["verdict"] == "PASS" and any(finding_rank(finding) == 2 for finding in findings):
-        raise SystemExit("error: verdict-binding finding cannot have a PASS verdict")
-    if not findings and (summary is None or summary.get("verdict") != "PASS"):
-        raise SystemExit("error: non-PASS verdict without JSONL findings")
-    return findings, summary
-
-
-def self_test() -> int:
-    try:
-        loads_strict_json('{"verdict":"PASS","verdict":"BLOCKED"}')
-    except ValueError as exc:
-        assert "duplicate JSON key" in str(exc)
-    else:
-        raise AssertionError("duplicate judge result key was accepted")
-    with tempfile.TemporaryDirectory() as tmp:
-        root = pathlib.Path(tmp)
-        stdout_path = root / "pair-judge.stdout"
-        out_path = root / "verify.pair.findings.jsonl"
-        summary_path = root / "pair-judge.summary.json"
-
-        def assert_rejected(text: str, label: str, *message_parts: str) -> None:
-            stdout_path.write_text(text, encoding="utf-8")
-            try:
-                collect_stdout(stdout_path)
-            except SystemExit as exc:
-                message = str(exc)
-                assert all(part in message for part in message_parts)
-            else:
-                raise AssertionError(f"{label} must be rejected")
-
-        plain_finding = {"id": "a", "severity": "HIGH"}
-        plain_summary = {"verdict": "NEEDS_WORK"}
-        stdout_path.write_text(
-            json.dumps(plain_finding) + "\n"
-            + plain_summary["verdict"] + "\n",
-            encoding="utf-8",
-        )
-        findings, summary = collect_stdout(stdout_path)
-        assert findings == [plain_finding]
-        assert summary == plain_summary
-        write_outputs(findings, summary, out_path, summary_path)
-        assert out_path.read_text(encoding="utf-8").count("\n") == 1
-        assert loads_strict_json(summary_path.read_text(encoding="utf-8"))["verdict"] == "NEEDS_WORK"
-        assert_rejected(
-            '{"id":"nan","severity":NaN}\n',
-            "NaN pair-JUDGE stdout finding",
-            "invalid JSON numeric constant: NaN",
-        )
-        assert_rejected(
-            '# SUMMARY {"verdict":"PASS","verdict":"BLOCKED"}\n',
-            "duplicate pair-JUDGE summary verdict",
-            "duplicate JSON key: verdict",
-        )
-        rejection_cases = (
-            ("", "no verdict line", "non-PASS verdict without JSONL findings"),
-            (json.dumps(plain_finding) + "\n", "finding without terminal verdict", "findings without terminal verdict"),
-            ('{"verdict":"pass"}\n', "lowercase pass", "finding missing valid severity"),
-            ('{"verdict":"UNKNOWN"}\n', "unknown verdict", "finding missing valid severity"),
-        )
-        for text, label, message in rejection_cases:
-            assert_rejected(
-                text,
-                label,
-                message,
-            )
-
-        def envelope(text: Any, stop_reason: str = "EndTurn") -> str:
-            return json.dumps(
-                {
-                    "text": text,
-                    "stopReason": stop_reason,
-                    "sessionId": "session",
-                    "requestId": "request",
-                }
-            )
-
-        envelope_finding = {
-            "id": "envelope-finding",
-            "severity": "HIGH",
-            "detail": {"preserved": True},
-        }
-        envelope_summary = {"verdict": "NEEDS_WORK"}
-        stdout_path.write_text(
-            envelope(
-                json.dumps(envelope_finding)
-                + "\n" + envelope_summary["verdict"] + "\n"
-            ),
-            encoding="utf-8",
-        )
-        findings, summary = collect_stdout(stdout_path)
-        assert findings == [envelope_finding]
-        assert summary == envelope_summary
-
-        assert_rejected(
-            envelope("review completed without findings"),
-            "findings-less envelope text",
-            "invalid JSONL",
-        )
-        assert_rejected(
-            envelope('{"findings":[],"verdict":"PASS"}', "Cancelled"),
-            "Cancelled envelope",
-            "envelope stopReason must be 'EndTurn'",
-            "'Cancelled'",
-        )
-        assert_rejected(
-            envelope("", "UnknownStop"),
-            "unknown envelope stopReason",
-            "envelope stopReason must be 'EndTurn'",
-            "'UnknownStop'",
-        )
-        assert_rejected(
-            envelope(None),
-            "non-string envelope text",
-            "error: envelope text must be a string",
-        )
-        assert_rejected(
-            envelope("I will inspect the result.\n" + envelope_summary["verdict"] + "\n"),
-            "narrative envelope preamble",
-            "invalid JSONL",
-        )
-        dual_document = (
-            json.dumps(envelope_finding)
-            + json.dumps({"id": "second", "severity": "LOW"})
-            + "\n" + envelope_summary["verdict"] + "\n"
-        )
-        assert_rejected(
-            envelope(dual_document),
-            "concatenated envelope documents",
-            "invalid JSONL",
-        )
-        clean_summary = {"verdict": "PASS"}
-        stdout_path.write_text(
-            envelope(clean_summary["verdict"] + "\n"),
-            encoding="utf-8",
-        )
-        findings, summary = collect_stdout(stdout_path)
-        assert findings == []
-        assert summary == clean_summary
-        stdout_path.write_text(
-            json.dumps(
-                {
-                    "type": "system",
-                    "text": clean_summary["verdict"] + "\n",
-                    "stopReason": "EndTurn",
-                    "sessionId": "session",
-                    "requestId": "request",
-                }
-            ),
-            encoding="utf-8",
-        )
-        findings, summary = collect_stdout(stdout_path)
-        assert findings == []
-        assert summary == clean_summary
-
-        # R4: a valid plain finding may carry an unrelated `type` field. A
-        # first-line `type: system` finding is not a stream discriminator.
-        system_finding = {"id": "system-finding", "severity": "LOW", "type": "system"}
-        stdout_path.write_text(
-            json.dumps(system_finding) + "\n" + clean_summary["verdict"] + "\n",
-            encoding="utf-8",
-        )
-        findings, summary = collect_stdout(stdout_path)
-        assert findings == [system_finding]
-        assert summary == clean_summary
-
-        # iter-0106 — Grok whole-message NDJSON carrier (R2/R3).
-        def init_record(session: str = "s1") -> dict[str, Any]:
-            return {"type": "system", "subtype": "init", "session_id": session, "model": "grok-build"}
-
-        def assistant_record(
-            blocks: list[Any], stop_reason: str = "end_turn", session: str = "s1"
-        ) -> dict[str, Any]:
-            return {
-                "type": "assistant",
-                "message": {"id": "msg", "role": "assistant", "content": blocks, "stop_reason": stop_reason},
-                "parent_tool_use_id": None,
-                "session_id": session,
-            }
-
-        def result_record(
-            text: str,
-            session: str = "s1",
-            subtype: str = "success",
-            is_error: Any = False,
-            stop_reason: str = "end_turn",
-        ) -> dict[str, Any]:
-            return {
-                "type": "result",
-                "subtype": subtype,
-                "is_error": is_error,
-                "result": text,
-                "stop_reason": stop_reason,
-                "session_id": session,
-            }
-
-        def text_block(value: str) -> dict[str, Any]:
-            return {"type": "text", "text": value}
-
-        def stream(*records: Any) -> str:
-            return "".join(json.dumps(record) + "\n" for record in records)
-
-        pass_text = "PASS\n"
-        stdout_path.write_text(
-            stream(init_record(), assistant_record([text_block(pass_text)]), result_record(pass_text)),
-            encoding="utf-8",
-        )
-        findings, summary = collect_stdout(stdout_path)
-        assert findings == []
-        assert summary == {"verdict": "PASS"}
-
-        # A real tool turn precedes the contract, and the terminal message arrives
-        # as two text blocks whose in-order concatenation is the result text.
-        stream_finding = {"id": "stream-finding", "severity": "HIGH"}
-        head = json.dumps(stream_finding) + "\n"
-        tail = "# SUMMARY " + json.dumps({"verdict": "NEEDS_WORK"}) + "\n"
-        contract = head + tail
-        narration = assistant_record(
-            [
-                text_block("Let me read the file."),
-                {"type": "tool_use", "id": "call_1", "name": "read_file", "input": {"path": "src/main.rs"}},
-            ],
-            stop_reason="tool_use",
-        )
-        tool_result = {
-            "type": "user",
-            "message": {
-                "role": "user",
-                "content": [{"type": "tool_result", "tool_use_id": "call_1", "content": "fn main() {}"}],
-            },
-            "parent_tool_use_id": None,
-            "session_id": "s1",
-        }
-        stdout_path.write_text(
-            stream(
-                init_record(),
-                narration,
-                tool_result,
-                assistant_record([text_block(head), text_block(tail)]),
-                result_record(contract),
-            ),
-            encoding="utf-8",
-        )
-        findings, summary = collect_stdout(stdout_path)
-        assert findings == [stream_finding]
-        assert summary == {"verdict": "NEEDS_WORK"}
-
-        # The welded body is exactly the shape envelope recovery accepts, so this
-        # also proves the stream branch never falls through to that recovery.
-        welded = "I reviewed the diff.\n" + contract
-        stream_rejections = (
-            (
-                stream(init_record(), assistant_record([text_block(welded)]), result_record(welded)),
-                "narration welded into the terminal message",
-                "invalid JSONL",
-            ),
-            (
-                stream(
-                    init_record(),
-                    assistant_record([text_block(contract)]),
-                    assistant_record([text_block(contract)]),
-                    result_record(contract),
-                ),
-                "two terminal end_turn messages",
-                "exactly one final end_turn assistant message",
-            ),
-            (
-                stream(
-                    init_record(),
-                    assistant_record([text_block(contract)]),
-                    assistant_record([text_block("more")], stop_reason="tool_use"),
-                    result_record(contract),
-                ),
-                "end_turn message that is not the final assistant message",
-                "exactly one final end_turn assistant message",
-            ),
-            (
-                # The malformed line is the only defect: skipping it leaves a valid stream.
-                stream(init_record(), assistant_record([text_block(pass_text)]))
-                + '{"type":"assistant"\n'
-                + stream(result_record(pass_text)),
-                "malformed stream NDJSON inside an otherwise valid stream",
-                "invalid stream NDJSON",
-            ),
-            (
-                stream(init_record(), assistant_record([text_block(pass_text)])),
-                "stream without a terminal result",
-                "exactly one terminal result",
-            ),
-            (
-                stream(
-                    init_record(),
-                    assistant_record([text_block(pass_text)]),
-                    result_record(pass_text),
-                    tool_result,
-                ),
-                "data after the terminal result",
-                "exactly one terminal result",
-            ),
-            (
-                stream(
-                    init_record(),
-                    assistant_record([text_block(pass_text)]),
-                    tool_result,
-                    result_record(pass_text),
-                ),
-                "data between the terminal assistant and result",
-                "exactly one final end_turn assistant message",
-            ),
-            (
-                stream(
-                    init_record(),
-                    assistant_record([text_block(pass_text)]),
-                    result_record(pass_text, subtype="error_during_execution"),
-                ),
-                "error result subtype",
-                "not a successful end_turn",
-            ),
-            (
-                stream(
-                    init_record(),
-                    assistant_record([text_block(pass_text)]),
-                    result_record(pass_text, stop_reason="cancelled"),
-                ),
-                "cancelled result",
-                "not a successful end_turn",
-            ),
-            (
-                stream(
-                    init_record(),
-                    assistant_record([text_block(pass_text)]),
-                    result_record(pass_text, is_error=True),
-                ),
-                "error-flagged result",
-                "not a successful end_turn",
-            ),
-            (
-                stream(
-                    init_record(),
-                    assistant_record([text_block(pass_text)]),
-                    result_record("NEEDS_WORK\n"),
-                ),
-                "result text that disagrees with the terminal message",
-                "result text does not match the terminal message",
-            ),
-            (
-                stream(
-                    init_record(),
-                    assistant_record([text_block(pass_text)]),
-                    result_record(pass_text, session="s2"),
-                ),
-                "result from another session",
-                "session identity does not agree",
-            ),
-            (
-                stream(
-                    init_record(),
-                    {"type": "stream_event", "event": {"type": "content_block_delta"}, "session_id": "s1"},
-                    assistant_record([text_block(pass_text)]),
-                    result_record(pass_text),
-                ),
-                "partial-message frame",
-                "unknown stream record",
-            ),
-            (
-                stream(
-                    init_record(),
-                    {"type": "system", "subtype": "compact_boundary", "session_id": "s1"},
-                    assistant_record([text_block(pass_text)]),
-                    result_record(pass_text),
-                ),
-                "compact boundary",
-                "second system record",
-            ),
-            (
-                stream(
-                    init_record(),
-                    {"type": "unknown", "session_id": "s1"},
-                    assistant_record([text_block(pass_text)]),
-                    result_record(pass_text),
-                ),
-                "unknown record type",
-                "unknown stream record",
-            ),
-            (
-                stream(
-                    {"type": "system", "subtype": "compact_boundary", "session_id": "s1"},
-                    assistant_record([text_block(pass_text)]),
-                    result_record(pass_text),
-                ),
-                "stream that does not open with system/init",
-                "must open with system/init",
-            ),
-        )
-        for text, label, message in stream_rejections:
-            assert_rejected(text, label, message)
-    return 0
-
-
-def write_outputs(
-    findings: list[dict[str, Any]],
-    summary: dict[str, Any] | None,
-    out_path: pathlib.Path,
-    summary_path: pathlib.Path,
-) -> None:
-    atomic_write(
-        out_path,
-        "".join(json.dumps(item, sort_keys=True, separators=(",", ":")) + "\n" for item in findings),
-    )
-    if summary is not None:
-        atomic_write(summary_path, json.dumps(summary, indent=2, sort_keys=True) + "\n")
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--devlyn-dir", default=".devlyn")
-    parser.add_argument("--stdout-file", default="pair-judge.stdout")
-    parser.add_argument("--out", default="verify.pair.findings.jsonl")
-    parser.add_argument("--summary-out", default="pair-judge.summary.json")
-    parser.add_argument("--self-test", action="store_true")
-    args = parser.parse_args()
-    if args.self_test:
-        return self_test()
-
-    devlyn = pathlib.Path(args.devlyn_dir)
-    stdout_path = devlyn / args.stdout_file
-    if not stdout_path.is_file():
-        sys.stderr.write(f"error: {stdout_path} not found\n")
-        return 1
-    findings, summary = collect_stdout(stdout_path)
-    write_outputs(findings, summary, devlyn / args.out, devlyn / args.summary_out)
-    print(json.dumps({"findings_count": len(findings), "summary": summary}, sort_keys=True))
-    return 0
-
-
-if __name__ == "__main__":
-    runpy.run_path(str(pathlib.Path(__file__).with_name("platform-support.py")))["configure_utf8"]()
-    raise SystemExit(main())