faberun 0.10.0 → 0.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "faberun",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "Faberun is a development orchestration system that turns intent into verified software: harness- and model-agnostic, it keeps the intent, coordinates the work, verifies the result and decides what happens next.",
   "type": "module",
   "bin": {

package/src/contract/task-packet.mjs

@@ -27,6 +27,15 @@ const PROMPT_MAX_BYTES = 64 * 1024;
  */
 const VERIFICATION_PARAGRAPH = "The controller runs every command below after you report; its recorded results are the proof of this node. Running a command yourself is optional and only for one that finishes in seconds and spawns no long-lived process. Keep output bounded (pipe through `| tail -n 200`). Never wait on a background job, never run the whole test suite, and never run tests that start and terminate other processes.";
 
+/**
+ * The `## Required output` schema every mode states: literally every key
+ * `validateWorkerResult` requires, so a worker never loses a valid result to
+ * a field this paragraph failed to name. What belongs in `artifacts` (if
+ * anything) is this packet's own content contract, stated in its own
+ * `instructions`, not repeated or guessed here.
+ */
+const REQUIRED_OUTPUT_SCHEMA = 'Return exactly one JSON object, with no markdown or prose, matching this shape: {"status":"done"|"blocked_context","summary":"string","verification":["string"],"artifacts":["string"],"missingContext":["string"]}. status is "done" when the node is complete or "blocked_context" when required context is missing; summary is prose for a human reader; verification and artifacts are string arrays, sent as [] when this node ran no command or has nothing to put there; missingContext lists exactly what is absent, non-empty only for blocked_context. Use blocked_context only when missingContext is non-empty; use done only when missingContext is empty.';
+
 /**
  * `validateRelativePath`'s answer when a path is absent and the caller asked to
  * defer the missing-path verdict rather than throw it. Only contract loading
@@ -128,7 +137,7 @@ export function renderWorkerPrompt(packet, nodeId) {
     ...packet.verification.map((command) => `- ${command.argv.join(" ")}`),
     "",
     "## Required output",
-    'Return exactly one JSON object, with no markdown or prose: {"status":"done"|"blocked_context","summary":"string","verification":["string"],"artifacts":["string"],"missingContext":["string"]}. Use blocked_context only when missingContext is non-empty; use done only when missingContext is empty.',
+    REQUIRED_OUTPUT_SCHEMA,
   ];
   const prompt = `${lines.join("\n")}\n`;
   if (Buffer.byteLength(prompt, "utf8") > PROMPT_MAX_BYTES) {
@@ -432,7 +441,7 @@ function renderDiscoveryPrompt(packet, nodeId) {
     ...bulletOrNone(packet.nonGoals),
     "",
     "## Required output",
-    'Return exactly one worker-result JSON object, with no markdown or prose. Set status to "done", missingContext to [], and artifacts to an array containing exactly one JSON-stringified execution task packet with every required taskPacket field. The packet readFiles and writeFiles must be non-empty and scoped to this repository. Put structured findings meant to inform that packet in `output` (a JSON object, at most 65536 bytes); prose belongs in `summary`.',
+    `${REQUIRED_OUTPUT_SCHEMA} Put structured findings meant to inform this packet's own instructions in \`output\` instead (a JSON object, at most 65536 bytes).`,
     "",
     "## Verification",
     VERIFICATION_PARAGRAPH,
@@ -481,7 +490,7 @@ function renderAutonomousPrompt(packet, nodeId) {
     ...packet.verification.map((command) => `- ${command.argv.join(" ")}`),
     "",
     "## Required output",
-    'Return exactly one JSON object, with no markdown or prose: {"status":"done"|"blocked_context","summary":"string","verification":["string"],"artifacts":["string"],"missingContext":["string"]}. Use blocked_context only when missingContext is non-empty; use done only when missingContext is empty.',
+    REQUIRED_OUTPUT_SCHEMA,
   ];
   const prompt = `${lines.join("\n")}\n`;
   if (Buffer.byteLength(prompt, "utf8") > PROMPT_MAX_BYTES) throw new TypeError(`worker prompt exceeds ${PROMPT_MAX_BYTES} bytes`);

package/src/engine/dispatch.mjs

@@ -668,6 +668,19 @@ export async function startJudge(contract, node, state, runDir, running, workerR
       error.code = "judge_prompt_too_large";
       throw error;
     }
+    // Captured at the last possible instant before the judge can touch
+    // anything, so the settlement pass's comparison proves what the judge
+    // itself wrote rather than racing whatever ran just before dispatch. A
+    // capture failure must not block dispatch -- the write check is a
+    // controller invariant on top of whatever the judge does, not a
+    // precondition for running it -- so it degrades to unchecked instead of
+    // to a refusal.
+    let judgeBaseline;
+    try {
+      judgeBaseline = captureWorkspaceSnapshot(workspace);
+    } catch {
+      judgeBaseline = null;
+    }
     const job = startProcess({
       contract, node, state, runtime, workspace,
       prompt: phasePlan.prompt,
@@ -678,6 +691,10 @@ export async function startJudge(contract, node, state, runDir, running, workerR
       }),
       onInvocation: (invocation, currentJob) => {
         stampInvocation(invocation, contract, node, runtime, state, runDir, "judge", phasePlan.mode, phasePlan.continuationId);
+        // Reusing the worker phase's own scratch field: a job is never both a
+        // worker and a judge, and this field carries no persisted shape of
+        // its own that a judge borrowing it would have to match.
+        currentJob.scopeBaseline = judgeBaseline;
         persistInvocation(runDir, state, invocation, currentJob, lock);
         persistInvocationIntent(runDir, invocation, {
           nodeId: node.id,

package/src/engine/lifecycle.mjs

@@ -17,17 +17,8 @@ import {
   SETTLED,
 } from "./prompts.mjs";
 import {
-  judgeReaskOutstanding,
-} from "./judge-gate.mjs";
-import {
-  judgeVerdictEvidence,
-} from "../contract/review-modes.mjs";
-import {
-  JUDGE_MAX_FAILURES,
-  applyJudgeProtocolFailure,
   applyJudgeResult,
   applyJudgeRound,
-  settleUnavailableJudge,
 } from "./review.mjs";
 import { routeRuntimeForState, routingBackoffActive, runtimeSnapshot } from "./failover.mjs";
 import {
@@ -65,6 +56,7 @@ import { startJudge, startResultMaterialization } from "./dispatch.mjs";
 import { raiseNodeAttention, settleDone } from "./settle.mjs";
 import { applyRejection, applyVerificationFailure } from "./settle.mjs";
 import { emitNodeAdvisories } from "./notify-queue.mjs";
+import { judgeWorkspaceWriteViolation, settleJudgeRound } from "./settle-judge.mjs";
 
 /** @typedef {import("../repo/integrate.mjs").IntegrationResult} IntegrationResult */
 /** @typedef {import("./backoff.mjs").Transition} Transition */
@@ -80,7 +72,6 @@ import { emitNodeAdvisories } from "./notify-queue.mjs";
 /** @typedef {import("../contract/index.mjs").GateResult} GateResult */
 /** @typedef {import("../contract/index.mjs").SnapshotError} SnapshotError */
 /** @typedef {import("../contract/index.mjs").BoundedScope} BoundedScope */
-/** @typedef {import("../repo/workspace.mjs").WorkspaceSnapshot} WorkspaceSnapshot */
 /** @typedef {import("../run/lock.mjs").LockRecord} LockRecord */
 /** @typedef {ReturnType<typeof acquireLock>} LockHandle */
 /** @typedef {import("../harnesses/index.mjs").HarnessRuntime} HarnessRuntime */
@@ -90,7 +81,6 @@ import { emitNodeAdvisories } from "./notify-queue.mjs";
 /** @typedef {import("../contract/verification.mjs").VerificationAttempt} VerificationAttempt */
 /** @typedef {import("../contract/verification.mjs").VerificationAttemptResult} VerificationAttemptResult */
 /** @typedef {import("../contract/verification.mjs").VerificationResult} VerificationResult */
-/** @typedef {import("../repo/workspace.mjs").ScopeComparison} ScopeComparison */
 /** @typedef {import("../contract/worker-result.mjs").WorkerResult} WorkerResult */
 /** @typedef {import("../campaign/index.mjs").Campaign} Campaign */
 /** @typedef {{path: string, campaign: Campaign}} CampaignRef */
@@ -277,7 +267,7 @@ export function autoRetryParkedNodes(contract, runDir, states, lock, previouslyP
  *
  * @param {NodeSnapshot} state
  */
-function clearTierExhaustion(state) {
+export function clearTierExhaustion(state) {
   if (!state.routing || state.routing.tierExhaustion === undefined) return;
   const routing = { ...state.routing };
   delete routing.tierExhaustion;
@@ -393,6 +383,25 @@ export async function finalizeClosedJobs(contract, runDir, states, running, lock
     appendUsageRecord(runDir, state.invocations.find((invocation) => invocation.id === job.invocation.id));
     state.usage = invocationUsage(state);
     state.costUsd = invocationCost(state);
+    // Checked before any other branch can act on how this invocation closed --
+    // a done verdict, a provider failure, a bounded re-dispatch, or exhaustion
+    // -- so a judge that wrote into its own workspace is caught here rather
+    // than laundered through a re-dispatch whose fresh baseline would already
+    // contain the write (the whole point of TECH-SPEC's write check: blocked
+    // outright, never re-asked). A comparison that cannot even be completed --
+    // an edited ignore source, a symlink escaping the tree, too many entries --
+    // is the same violation as an ordinary write, never silence: the worker
+    // path (`engine/scope.mjs`'s `checkWorkerScope`) already fails closed on
+    // exactly the same throw.
+    if (job.phase === "judge") {
+      const violation = judgeWorkspaceWriteViolation(job);
+      if (violation) {
+        clearTierExhaustion(state);
+        transition(runDir, state, "blocked", { phase: "judge", result: state.result, usage: state.usage, error: { code: "judge_protocol", message: violation.message } }, lock);
+        await raiseNodeAttention(campaignPath, runDir, state, "judge_protocol");
+        continue;
+      }
+    }
     // A closed worker whose canonical result file is valid and whose scope
     // passed is completed work, no matter what the provider envelope or the
     // exit code said. The durable file was read above, before the scope gate,
@@ -425,55 +434,17 @@ export async function finalizeClosedJobs(contract, runDir, states, running, lock
       continue;
     }
     // A judge provider that failed outright (its turn died, its tool host was
-    // gone) is a provider failure, never a verdict: the gate cannot adopt a
-    // result the judge could not ground in inspection. Re-dispatch the judge
-    // once on the same routing, then settle by review mode so a judge failure
-    // is surfaced, never silently settled. A stream that never reached its
-    // terminal envelope is a protocol defect instead and takes the bounded
-    // re-ask below.
-    if (job.phase === "judge" && envelope.status === "failed" && envelope.error?.code !== "incomplete_stream") {
-      // A judge that lost its socket is not an unavailable judge. It buys the
-      // same bounded network waits a worker does, on the runtime it already
-      // warmed, and spends none of the one re-dispatch counted below.
-      const network = networkTransition(contract, job.node, state, "judge", envelope, job.exitCode);
-      if (network && handleProviderExhaustion(contract, runDir, job.node, state, "judge", envelope, job.runtime.id, lock, states, campaignPath, network)) continue;
-      clearTierExhaustion(state);
-      // The provider died on the bounded re-ask itself, so the one permitted
-      // re-ask is spent: settle by review mode here rather than dispatch a
-      // third judge invocation behind a fresh failure count.
-      // The provider died on the bounded re-ask itself, so the one permitted
-      // re-ask is spent: settle by review mode here rather than dispatch a
-      // third judge invocation behind a fresh failure count.
-      if (judgeReaskOutstanding(state)) {
-        await applyJudgeProtocolFailure(contract, job.node, state, runDir, running, lock, states, campaignPath, envelope.error?.message ?? "judge provider failed");
-        continue;
-      }
-      state.judgeFailures = (state.judgeFailures ?? 0) + 1;
-      if (state.judgeFailures < JUDGE_MAX_FAILURES) {
-        writeNode(runDir, state, lock);
-        await applyJudgeRound(await startJudge(contract, job.node, state, runDir, running, state.result, lock, states, campaignPath),
-          contract, job.node, state, runDir, running, lock, states, campaignPath, state.result);
-        continue;
-      }
-      await settleUnavailableJudge(contract, job.node, state, runDir, lock, states, campaignPath, envelope.error?.message ?? "judge provider failed");
-      continue;
-    }    // Whatever else this invocation produced, it is not exactly one usable
-    // verdict: no verdict at all, several of them in separate agent messages,
-    // an unparseable one, a stream cut off before its terminal envelope, or a
-    // phase killed on its wall clock. One bounded re-ask, then the review mode
-    // decides — advisory completes, blocking enters attention with the work
-    // preserved so a retry in place can re-judge it.
+    // gone) is a provider failure, never a verdict, and a verdict that arrived
+    // but is not exactly one usable one (none at all, several of them, an
+    // unparseable one, a stream cut off before its terminal envelope, or a
+    // phase killed on its wall clock) is a protocol defect rather than a
+    // pass. Both are settled by `settleJudgeRound`, moved out of this file
+    // for the same reason `engine/settle.mjs` was: this file and
+    // `test/engine/judge.test.mjs` both sit on the 800-line ceiling
+    // `test/repo/source-shape.test.mjs` enforces. The write check above has
+    // already run, so nothing here can adopt or launder a judge's own write.
     if (job.phase === "judge") {
-      const evidence = judgeVerdictEvidence(envelope);
-      if (!evidence.ok) {
-        const network = networkTransition(contract, job.node, state, "judge", envelope, job.exitCode);
-        if (network && handleProviderExhaustion(contract, runDir, job.node, state, "judge", envelope, job.runtime.id, lock, states, campaignPath, network)) continue;
-        clearTierExhaustion(state);
-        await applyJudgeProtocolFailure(contract, job.node, state, runDir, running, lock, states, campaignPath, evidence.reason);
-        continue;
-      }
-      clearTierExhaustion(state);
-      await applyJudgeResult(contract, job.node, state, evidence.result, runDir, lock, running, states, campaignPath);
+      await settleJudgeRound(contract, job, state, runDir, running, lock, states, campaignPath, envelope, { clearTierExhaustion, handleProviderExhaustion });
       continue;
     }
     // An empty final message is a missing worker result, not a no-op worker:

package/src/engine/settle-judge.mjs

@@ -0,0 +1,141 @@
+/**
+ * The judge branch of `finalizeClosedJobs`, and the workspace comparison its
+ * fail-closed write check depends on. Split out of `lifecycle.mjs` for the
+ * same reason `engine/settle.mjs` was: `lifecycle.mjs` and
+ * `test/engine/judge.test.mjs` both sit on the 800-line ceiling
+ * `test/repo/source-shape.test.mjs` enforces.
+ *
+ * `settleJudgeRound` runs only after `lifecycle.mjs` has already called
+ * `judgeWorkspaceWriteViolation` and found nothing: the check has to run
+ * before any branch here (a failed provider, a bounded re-dispatch, or a
+ * verdict) can adopt or launder a judge's own write, so it cannot live inside
+ * this function without reintroducing the escape it closes.
+ *
+ * `clearTierExhaustion` and `handleProviderExhaustion` are `lifecycle.mjs`'s
+ * own -- importing them back from there would recreate the exact
+ * `lifecycle.mjs` <-> `review.mjs` cycle `test/repo/source-shape.test.mjs`
+ * once caught and `AGENTS.md` records as fixed, so the caller passes them in
+ * instead.
+ */
+import { judgeReaskOutstanding } from "./judge-gate.mjs";
+import { judgeVerdictEvidence } from "../contract/review-modes.mjs";
+import {
+  JUDGE_MAX_FAILURES,
+  applyJudgeProtocolFailure,
+  applyJudgeResult,
+  applyJudgeRound,
+  settleUnavailableJudge,
+} from "./review.mjs";
+import { networkTransition } from "./backoff.mjs";
+import { startJudge } from "./dispatch.mjs";
+import { writeNode } from "./state.mjs";
+import { compareWorkspaceSnapshot } from "../repo/workspace.mjs";
+import { errorCode, errorMessage, excerpt } from "../util.mjs";
+
+/** @typedef {import("../contract/index.mjs").ValidatedContract} ValidatedContract */
+/** @typedef {import("../contract/index.mjs").NodeSnapshot} NodeSnapshot */
+/** @typedef {import("./process.mjs").Job} Job */
+/** @typedef {import("../run/lock.mjs").LockRecord} LockRecord */
+/** @typedef {ReturnType<typeof import("../run/lock.mjs").acquire>} LockHandle */
+/** @typedef {import("../harnesses/index.mjs").ProviderEnvelope} ProviderEnvelope */
+/** @typedef {ProviderEnvelope & {costProvenance?: "priced"}} PricedEnvelope */
+
+/**
+ * Whether a closed judge job wrote into its own workspace, or a workspace
+ * comparison error that means the same thing: either is a violation, never
+ * silence. `compareWorkspaceSnapshot` throws `snapshot_ignore_changed` when
+ * the judge edits an ignore source, `snapshot_symlink_escape` when it creates
+ * a symlink out of the tree, and `snapshot_too_large` when it adds enough
+ * entries -- all ordinary judge writes that must fail closed exactly like the
+ * worker path (`engine/scope.mjs`'s `checkWorkerScope`), never vanish into a
+ * "no writes" result. `job.scopeBaseline` is null only when the capture at
+ * dispatch time itself failed -- `startJudge` degrades to unchecked rather
+ * than refuse to run the judge at all -- and that is the one case with
+ * nothing to compare, not a violation.
+ *
+ * @param {Job} job
+ * @returns {{message: string}|null}
+ */
+export function judgeWorkspaceWriteViolation(job) {
+  const baseline = job.scopeBaseline;
+  if (!baseline) return null;
+  try {
+    const { unexpectedPaths } = compareWorkspaceSnapshot(/** @type {import("../repo/workspace.mjs").WorkspaceSnapshot} */ (baseline), job.cwd);
+    if (!unexpectedPaths.length) return null;
+    return { message: excerpt(`judge wrote into its own workspace (${unexpectedPaths.length}): ${unexpectedPaths.slice(0, 8).join(", ")}`) ?? "judge wrote into its own workspace" };
+  } catch (error) {
+    return { message: excerpt(`judge workspace comparison failed (${errorCode(error) ?? "scope_snapshot_invalid"}): ${errorMessage(error)}`) ?? "judge workspace comparison failed" };
+  }
+}
+
+/**
+ * Settle a closed judge invocation whose write check already passed: a
+ * provider that failed outright gets one bounded re-dispatch, then review-mode
+ * settlement; anything else that is not exactly one usable verdict (none at
+ * all, several of them, an unparseable one, a stream cut off before its
+ * terminal envelope, or a phase killed on its wall clock) takes the same
+ * bounded re-ask; a clean verdict is applied.
+ *
+ * @param {ValidatedContract} contract
+ * @param {Job} job
+ * @param {NodeSnapshot} state
+ * @param {string} runDir
+ * @param {Map<string, Job>} running
+ * @param {LockHandle} lock
+ * @param {Map<string, NodeSnapshot>} states
+ * @param {string} campaignPath
+ * @param {PricedEnvelope} envelope
+ * @param {{clearTierExhaustion: (state: NodeSnapshot) => void, handleProviderExhaustion: typeof import("./lifecycle.mjs").handleProviderExhaustion}} hooks
+ *   `lifecycle.mjs`'s own tier-exhaustion clear and provider-exhaustion router, passed in rather than imported back.
+ * @returns {Promise<void>}
+ */
+export async function settleJudgeRound(contract, job, state, runDir, running, lock, states, campaignPath, envelope, { clearTierExhaustion, handleProviderExhaustion }) {
+  const node = job.node;
+  // A judge provider that failed outright (its turn died, its tool host was
+  // gone) is a provider failure, never a verdict: the gate cannot adopt a
+  // result the judge could not ground in inspection. Re-dispatch the judge
+  // once on the same routing, then settle by review mode so a judge failure
+  // is surfaced, never silently settled. A stream that never reached its
+  // terminal envelope is a protocol defect instead and takes the bounded
+  // re-ask below.
+  if (envelope.status === "failed" && envelope.error?.code !== "incomplete_stream") {
+    // A judge that lost its socket is not an unavailable judge. It buys the
+    // same bounded network waits a worker does, on the runtime it already
+    // warmed, and spends none of the one re-dispatch counted below.
+    const network = networkTransition(contract, node, state, "judge", envelope, job.exitCode);
+    if (network && handleProviderExhaustion(contract, runDir, node, state, "judge", envelope, job.runtime.id, lock, states, campaignPath, network)) return;
+    clearTierExhaustion(state);
+    // The provider died on the bounded re-ask itself, so the one permitted
+    // re-ask is spent: settle by review mode here rather than dispatch a
+    // third judge invocation behind a fresh failure count.
+    if (judgeReaskOutstanding(state)) {
+      await applyJudgeProtocolFailure(contract, node, state, runDir, running, lock, states, campaignPath, envelope.error?.message ?? "judge provider failed");
+      return;
+    }
+    state.judgeFailures = (state.judgeFailures ?? 0) + 1;
+    if (state.judgeFailures < JUDGE_MAX_FAILURES) {
+      writeNode(runDir, state, lock);
+      await applyJudgeRound(await startJudge(contract, node, state, runDir, running, state.result, lock, states, campaignPath),
+        contract, node, state, runDir, running, lock, states, campaignPath, state.result);
+      return;
+    }
+    await settleUnavailableJudge(contract, node, state, runDir, lock, states, campaignPath, envelope.error?.message ?? "judge provider failed");
+    return;
+  }
+  // Whatever else this invocation produced, it is not exactly one usable
+  // verdict: no verdict at all, several of them in separate agent messages,
+  // an unparseable one, a stream cut off before its terminal envelope, or a
+  // phase killed on its wall clock. One bounded re-ask, then the review mode
+  // decides — advisory completes, blocking enters attention with the work
+  // preserved so a retry in place can re-judge it.
+  const evidence = judgeVerdictEvidence(envelope);
+  if (!evidence.ok) {
+    const network = networkTransition(contract, node, state, "judge", envelope, job.exitCode);
+    if (network && handleProviderExhaustion(contract, runDir, node, state, "judge", envelope, job.runtime.id, lock, states, campaignPath, network)) return;
+    clearTierExhaustion(state);
+    await applyJudgeProtocolFailure(contract, node, state, runDir, running, lock, states, campaignPath, evidence.reason);
+    return;
+  }
+  clearTierExhaustion(state);
+  await applyJudgeResult(contract, node, state, evidence.result, runDir, lock, running, states, campaignPath);
+}

package/src/harnesses/protocol.mjs

@@ -498,6 +498,50 @@ export function isVerdictCandidate(text) {
   }
 }
 
+/**
+ * A judge's final message can carry its whole verdict on one line with no
+ * newline before the JSON: `Confirmed. Now write the verdict JSON.{"verdict":
+ * "fail", ...}`, measured 2026-09-17 at 5662 characters. A line-boundary-only
+ * suffix scan never finds it, extractJson returns null, isVerdictCandidate
+ * returns false, and a correct, evidenced verdict is discarded as
+ * `judge_unavailable`. The candidate starts tried here are every `{` and `[`
+ * offset, not just line starts, so a JSON object glued directly to prose is
+ * still reachable.
+ */
+const SUFFIX_CANDIDATE_LIMIT = 200;
+
+/**
+ * The last parseable suffix of `trimmed`, trying every `{`/`[` offset from the
+ * end backwards. Bounded to the last `SUFFIX_CANDIDATE_LIMIT` offsets: without
+ * a cap this is one `JSON.parse` per bracket character, quadratic on a
+ * pathological message built mostly of brackets. 200 is comfortably above the
+ * bracket count of any real verdict object (the measured 5662-character
+ * message resolves on one of its first few tries, since its outermost `{` is
+ * also its first) and keeps every call to at most 200 parses regardless of
+ * message length.
+ *
+ * @param {string} trimmed
+ * @returns {string|null}
+ */
+function suffixJsonCandidate(trimmed) {
+  const offsets = [];
+  for (let index = 0; index < trimmed.length; index += 1) {
+    const char = trimmed[index];
+    if (char === "{" || char === "[") offsets.push(index);
+  }
+  const floor = Math.max(0, offsets.length - SUFFIX_CANDIDATE_LIMIT);
+  for (let index = offsets.length - 1; index >= floor; index -= 1) {
+    const candidate = trimmed.slice(offsets[index]);
+    try {
+      JSON.parse(candidate);
+      return candidate;
+    } catch {
+      // This suffix is not JSON; keep trying earlier bracket offsets.
+    }
+  }
+  return null;
+}
+
 /**
  * Extract a JSON value from a provider response that may carry prose, taking
  * the last parseable suffix or fenced JSON block.
@@ -514,16 +558,8 @@ export function extractJson(value) {
   } catch {
     // Not JSON as a whole: fall through to the suffix and fenced-block scans below.
   }
-  const lines = trimmed.split(/\r?\n/u);
-  for (let index = lines.length - 1; index > 0; index -= 1) {
-    const candidate = lines.slice(index).join("\n").trim();
-    try {
-      JSON.parse(candidate);
-      return candidate;
-    } catch {
-      // This suffix is not JSON; keep trying earlier line boundaries.
-    }
-  }
+  const suffix = suffixJsonCandidate(trimmed);
+  if (suffix !== null) return suffix;
   const blocks = [...value.matchAll(/```json\s*([\s\S]*?)```/giu)];
   for (const block of blocks.reverse()) {
     const candidate = block[1].trim();

package/src/host/preflight.mjs

@@ -254,6 +254,22 @@ export function declaredVerificationCommands(contract) {
   return [...commands.values()];
 }
 
+/**
+ * Environment names removed before spawning a timing candidate. The probe
+ * only measures how long a command takes; a subtraction of a named few, not
+ * an allowlist, so PATH, HOME and every ordinary variable the command needs
+ * to run at all still pass through unchanged.
+ */
+const SIDE_EFFECT_ENV_KEYS = [
+  NOTIFY_BIN_ENV, // a measurement must not notify a human
+  "FABERUN_CODEX_BIN", // could redirect the timed command at a live, paid codex binary instead of this repository's own fixtures
+  "FABERUN_CLAUDE_BIN", // same, for the claude harness
+  "FABERUN_AGY_BIN", // same, for the agy harness
+  "FABERUN_DSH_BIN", // same, for the dsh harness
+  "FABERUN_ZCODE_BIN", // same, for the zcode harness
+  "FABERUN_EXEC_JSONL_BIN", // same, for the exec-jsonl harness
+];
+
 /**
  * Run every declared verification command once and report what it actually
  * costs against the timeout the contract gives it.
@@ -275,6 +291,8 @@ export function declaredVerificationCommands(contract) {
 export function timeVerificationCommands(contract, probes = {}) {
   const now = probes.now ?? (() => Date.now());
   const run = probes.run ?? spawnSync;
+  const env = { ...process.env };
+  for (const key of SIDE_EFFECT_ENV_KEYS) delete env[key];
   return declaredVerificationCommands(contract).map((command) => {
     const label = command.argv.join(" ");
     const name = `verification timing · ${label}`;
@@ -288,6 +306,7 @@ export function timeVerificationCommands(contract, probes = {}) {
       timeout: ceilingSec * 1_000,
       stdio: "ignore",
       encoding: "utf8",
+      env,
     });
     const seconds = (now() - startedAt) / 1_000;
     const measured = `${seconds.toFixed(1)}s measured against ${command.timeoutSec}s declared`;