@iowarp/clio-coder 0.4.3 → 0.4.4

package/src/domains/dispatch/host-verification.ts

@@ -5,6 +5,7 @@ import { dirname, join, resolve } from "node:path";
 import { PATH_BOUNDARY_MAX_ENTRIES, pathBoundaryCovers, resolvePathBoundary } from "../../core/path-boundary.js";
 import { withStateFileLockSync } from "../../core/state-file-lock.js";
 import { clioStateDir } from "../../core/xdg.js";
+import { judgeNumericTexts, judgePerfTexts } from "../../tools/verify/scripts.js";
 import { FLEET_COMMAND_BASE_ENV, type FleetCommand } from "../agents/fleet-commands.js";
 import { runCodeStep } from "./code-step.js";
 import type { DispatchRequest } from "./contract.js";
@@ -12,7 +13,7 @@ import type { RunHostVerification, RunHostVerificationAttribution, RunHostVerifi
 import { captureWorkspaceSnapshot } from "./write-boundary.js";
 
 const OUTPUT_TAIL_BYTES = 2_048;
-const MEMO_VERSION = 1;
+const MEMO_VERSION = 2;
 
 type ResolvedCheck = NonNullable<DispatchRequest["resolvedVerification"]>[number];
 
@@ -37,7 +38,7 @@ interface MemoEntry {
 }
 
 interface MemoFile {
-	version: 1;
+	version: typeof MEMO_VERSION;
 	entries: MemoEntry[];
 }
 
@@ -108,10 +109,10 @@ function storeMemoEntry(stateDir: string, entry: MemoEntry): void {
 	});
 }
 
-function memoKey(command: FleetCommand, fingerprint: string, env: NodeJS.ProcessEnv): string {
+function memoKey(command: FleetCommand, judgment: string, fingerprint: string, env: NodeJS.ProcessEnv): string {
 	const names = [...FLEET_COMMAND_BASE_ENV, ...command.env];
 	const values = Object.fromEntries(names.map((name) => [name, env[name] ?? null]));
-	return sha256(JSON.stringify({ fingerprint, argv: command.argv, cwd: command.cwd, env: values }));
+	return sha256(JSON.stringify({ fingerprint, judgment, env: values }));
 }
 
 export function hostVerificationRejection(
@@ -124,10 +125,63 @@ export function hostVerificationRejection(
 		detail:
 			failedCheck === undefined
 				? "host verification rejected"
-				: `host verification check '${failedCheck.check}' rejected with exit code ${failedCheck.exitCode}`,
+				: failedCheck.report !== undefined
+					? `host verification check '${failedCheck.check}' rejected: ${failedCheck.report.summary}`
+					: `host verification check '${failedCheck.check}' rejected with exit code ${failedCheck.exitCode}`,
 	};
 }
 
+function readSealedFile(absolutePath: string): string | undefined {
+	try {
+		return readFileSync(absolutePath, "utf8");
+	} catch {
+		return undefined;
+	}
+}
+
+/**
+ * The kind-specific verdict for a resolved check that already ran. A command
+ * check keeps its exit code. A numeric-compare check judges captured stdout
+ * against the sealed reference; a perf-budget check judges the measured
+ * duration against the sealed budget or baseline. Either judgement turns a
+ * clean exit into exit 1 when it fails, and a judgement that cannot be made
+ * (missing reference, unparseable output) fails with the reason in the tail.
+ */
+function judgeResolvedCheck(
+	resolvedCheck: ResolvedCheck,
+	exitCode: number,
+	durationMs: number,
+	stdout: string,
+): { exitCode: number; report?: RunHostVerificationCheck["report"]; outputTail?: string } {
+	if (resolvedCheck.kind === undefined || resolvedCheck.kind === "command" || exitCode !== 0) return { exitCode };
+	if (resolvedCheck.kind === "numeric-compare" && resolvedCheck.numeric !== undefined) {
+		const referenceText = readSealedFile(resolvedCheck.numeric.reference);
+		if (referenceText === undefined) {
+			return { exitCode: 1, outputTail: `numeric-compare: reference '${resolvedCheck.numeric.reference}' cannot be read` };
+		}
+		const report = judgeNumericTexts(
+			stdout,
+			referenceText,
+			resolvedCheck.numeric.tolerance,
+			`reference '${resolvedCheck.numeric.reference}'`,
+		);
+		if (report instanceof Error) return { exitCode: 1, outputTail: `numeric-compare: ${report.message}` };
+		return { exitCode: report.passed ? 0 : 1, report, outputTail: outputTail(report.summary) };
+	}
+	if (resolvedCheck.kind === "perf-budget" && resolvedCheck.perf !== undefined) {
+		const baselinePath = resolvedCheck.perf.baseline;
+		const report = judgePerfTexts(
+			durationMs,
+			resolvedCheck.perf,
+			baselinePath === undefined ? undefined : readSealedFile(baselinePath),
+			`baseline '${baselinePath ?? ""}'`,
+		);
+		if (report instanceof Error) return { exitCode: 1, outputTail: `perf-budget: ${report.message}` };
+		return { exitCode: report.passed ? 0 : 1, report, outputTail: outputTail(report.summary) };
+	}
+	return { exitCode: 1, outputTail: `${resolvedCheck.kind}: sealed check carries no parameters` };
+}
+
 async function runResolvedCheck(input: {
 	runId: string;
 	index: number;
@@ -145,9 +199,9 @@ async function runResolvedCheck(input: {
 		env: [],
 		description: `Host verification check ${resolvedCheck.check}.`,
 	};
+	const judgmentKey = checkDedupeKey(resolvedCheck);
 	const fingerprint = workspaceFingerprint(resolvedCheck.cwd);
-	const key =
-		fingerprint === null ? null : memoKey({ ...command, cwd: resolve(resolvedCheck.cwd) }, fingerprint, input.env);
+	const key = fingerprint === null ? null : memoKey(command, judgmentKey, fingerprint, input.env);
 	const hit =
 		key === null
 			? undefined
@@ -168,17 +222,24 @@ async function runResolvedCheck(input: {
 		env: input.env,
 	});
 	const artifactPath = outcome.record.artifactPaths[0];
+	const judgement = judgeResolvedCheck(
+		resolvedCheck,
+		outcome.record.exitCode,
+		outcome.record.durationMs,
+		outcome.stdout,
+	);
 	const check: RunHostVerificationCheck = {
 		check: resolvedCheck.check,
 		argv: [...outcome.record.argv],
 		cwd: outcome.record.cwd,
-		exitCode: outcome.record.exitCode,
+		exitCode: judgement.exitCode,
 		durationMs: outcome.record.durationMs,
 		memo: false,
-		outputTail: outputTail(outcome.report.outputExcerpt),
+		outputTail: judgement.outputTail ?? outputTail(outcome.report.outputExcerpt),
 		...(artifactPath !== undefined ? { artifactPath } : {}),
+		...(judgement.report !== undefined ? { report: judgement.report } : {}),
 	};
-	if (check.exitCode === 0 && key !== null) {
+	if (check.exitCode === 0 && key !== null && checkDedupeKey(resolvedCheck) === judgmentKey) {
 		try {
 			storeMemoEntry(input.stateDir, { key, runId: input.runId, check });
 		} catch (error) {
@@ -229,14 +290,45 @@ function implicatedPaths(outputExcerpt: string, checkCwd: string): string[] {
 	return [...paths].sort();
 }
 
-/** Identity of a resolved check across batch members: same command, same cwd, same bound. */
+/** Identity shared by memo reuse and batch deduplication, including the declared judgment and its input files. */
 function checkDedupeKey(resolvedCheck: ResolvedCheck): string {
+	const numeric = resolvedCheck.numeric;
+	const perf = resolvedCheck.perf;
 	return sha256(
 		JSON.stringify({
 			check: resolvedCheck.check,
 			argv: [...resolvedCheck.argv],
 			cwd: resolve(resolvedCheck.cwd),
 			timeoutMs: resolvedCheck.timeoutMs,
+			kind: resolvedCheck.kind ?? "command",
+			numeric:
+				numeric === undefined
+					? undefined
+					: {
+							reference: numeric.reference,
+							referenceDigest: sha256(JSON.stringify(readSealedFile(numeric.reference) ?? null)),
+							tolerance: {
+								absolute: numeric.tolerance.absolute,
+								relative: numeric.tolerance.relative,
+								ulp: numeric.tolerance.ulp,
+							},
+						},
+			perf:
+				perf === undefined
+					? undefined
+					: {
+							budget:
+								perf.budget === undefined
+									? undefined
+									: {
+											wallTimeMs: perf.budget.wallTimeMs,
+											tolerance: perf.budget.tolerance,
+										},
+							baseline: perf.baseline,
+							baselineDigest:
+								perf.baseline === undefined ? undefined : sha256(JSON.stringify(readSealedFile(perf.baseline) ?? null)),
+							tolerance: perf.tolerance,
+						},
 		}),
 	);
 }
@@ -304,6 +396,12 @@ function memberBoundary(participant: BatchVerificationParticipant): string[] {
  * the tree. `basis` is the weakest evidence behind the charge set, never the
  * strongest, so `write_roots` on a receipt means every charged run has a named
  * path inside its own declared boundary.
+ *
+ * A `worktree: true` member's write roots resolve against its own checkout
+ * (`request.cwd`) while the shared check ran in the parent frame, so none of
+ * its roots can cover a path the check named: attribution cannot exculpate
+ * anyone on its account and every declarer is charged, the conservative
+ * fallback those receipts sealed before batch settlement existed.
  */
 function attributeFailure(input: {
 	implicated: ReadonlyArray<string>;
@@ -421,9 +519,11 @@ export function createBatchVerificationGate(
 			string,
 			{ resolvedCheck: ResolvedCheck; owner: BatchVerificationParticipant; index: number }
 		>();
+		const checkKeys = new Map<ResolvedCheck, string>();
 		for (const member of contributors) {
 			for (const resolvedCheck of member.request.resolvedVerification ?? []) {
 				const key = checkDedupeKey(resolvedCheck);
+				checkKeys.set(resolvedCheck, key);
 				if (!distinct.has(key)) distinct.set(key, { resolvedCheck, owner: member, index: distinct.size });
 			}
 		}
@@ -448,7 +548,7 @@ export function createBatchVerificationGate(
 		for (const [key, entry] of ran) {
 			if (entry.check.exitCode === 0) continue;
 			const declarers = contributors.filter((member) =>
-				(member.request.resolvedVerification ?? []).some((candidate) => checkDedupeKey(candidate) === key),
+				(member.request.resolvedVerification ?? []).some((candidate) => checkKeys.get(candidate) === key),
 			);
 			const implicated = implicatedPaths(entry.outputExcerpt, entry.check.cwd);
 			const verdict = attributeFailure({ implicated, declarers, wave: members });
@@ -478,7 +578,8 @@ export function createBatchVerificationGate(
 			let rejected = false;
 			let unimplicated = false;
 			for (const resolvedCheck of member.request.resolvedVerification ?? []) {
-				const key = checkDedupeKey(resolvedCheck);
+				const key = checkKeys.get(resolvedCheck);
+				if (key === undefined) throw new Error("host verification: declared check has no batch identity");
 				const shared = ran.get(key);
 				if (shared === undefined) continue;
 				own.push(

package/src/domains/dispatch/intent.ts

@@ -271,13 +271,34 @@ export function normalizeDispatchIntent(
 	if (!Array.isArray(writeRoots)) return writeRoots;
 	const relevantPaths = normalizePathList(raw.relevant_paths, "intent.relevant_paths");
 	if (!Array.isArray(relevantPaths)) return relevantPaths;
-	const expectedOutputs = normalizePathList(
-		raw.expected_outputs,
-		"intent.expected_outputs",
-		normalizeExpectedOutputEntry,
-	);
+	const expectedOutputs = normalizeIntentExpectedOutputs(raw.expected_outputs);
 	if (!Array.isArray(expectedOutputs)) return expectedOutputs;
-	const rawVerification = raw.verification ?? [];
+	const verification = normalizeIntentVerification(raw.verification, checks);
+	if (!Array.isArray(verification)) return verification;
+
+	return {
+		ok: true,
+		intent: {
+			version: 2,
+			readRoots,
+			writeRoots,
+			relevantPaths,
+			pathProvenance: declaredIntentPathProvenance({ readRoots, writeRoots, relevantPaths }),
+			expectedOutputs,
+			verification,
+		},
+	};
+}
+
+export function normalizeIntentExpectedOutputs(raw: unknown): string[] | DispatchIntentNormalizationResult {
+	return normalizePathList(raw, "intent.expected_outputs", normalizeExpectedOutputEntry);
+}
+
+export function normalizeIntentVerification(
+	raw: unknown,
+	checks: ReadonlyMap<string, DispatchIntentCheckBound>,
+): DispatchIntentVerification[] | DispatchIntentNormalizationResult {
+	const rawVerification = raw ?? [];
 	if (!Array.isArray(rawVerification)) {
 		return fail("verification_malformed", "intent.verification must be an array");
 	}
@@ -321,16 +342,5 @@ export function normalizeDispatchIntent(
 			timeoutMs: Math.min(declared.timeoutMs, Math.max(DISPATCH_INTENT_TIMEOUT_MIN_MS, requested)),
 		});
 	}
-	return {
-		ok: true,
-		intent: {
-			version: 2,
-			readRoots,
-			writeRoots,
-			relevantPaths,
-			pathProvenance: declaredIntentPathProvenance({ readRoots, writeRoots, relevantPaths }),
-			expectedOutputs,
-			verification,
-		},
-	};
+	return verification;
 }

package/src/domains/dispatch/orphan-recovery.ts

@@ -49,6 +49,7 @@ function receiptsDir(): string {
  */
 function envelopeFromReceipt(receipt: RunReceipt, status: RunStatus, receiptPath: string): RunEnvelope {
 	const envelope: RunEnvelope = {
+		version: 1,
 		id: receipt.runId,
 		agentId: receipt.agentId,
 		executionRole: receipt.executionRole,
@@ -97,6 +98,7 @@ function envelopeFromReceipt(receipt: RunReceipt, status: RunStatus, receiptPath
 	if (receipt.gate !== undefined) envelope.gate = receipt.gate;
 	if (receipt.plan !== undefined) envelope.plan = receipt.plan;
 	if (receipt.personaOverride !== undefined) envelope.personaOverride = receipt.personaOverride;
+	if (receipt.decisionRefs !== undefined) envelope.decisionRefs = receipt.decisionRefs;
 	return envelope;
 }
 

package/src/domains/dispatch/receipt-integrity.ts

@@ -99,6 +99,9 @@ export const RECEIPT_INTEGRITY_FIELD_COVERAGE = {
 	plan: true,
 	fleetGate: true,
 	personaOverride: true,
+	// Absent unless the parent board held decisions, so older receipts and
+	// decision-free runs digest exactly as before.
+	decisionRefs: true,
 	projectContext: true,
 	// Always set on receipts written after #104 landed; absent only on older
 	// receipts, which omit these fields from canonical serialization.
@@ -193,6 +196,7 @@ function ledgerDigestFields(envelope: RunEnvelope): Record<string, unknown> {
 		executionRole: envelope.executionRole,
 		task: envelope.task,
 		...(envelope.budget !== undefined ? { budget: envelope.budget } : {}),
+		...(envelope.decisionRefs !== undefined ? { decisionRefs: envelope.decisionRefs } : {}),
 		targetId: envelope.targetId,
 		wireModelId: envelope.wireModelId,
 		runtimeId: envelope.runtimeId,

package/src/domains/dispatch/reservation-store.ts

@@ -1,5 +1,5 @@
 import { randomBytes } from "node:crypto";
-import { withStateFileLockSync } from "../../core/state-file-lock.js";
+import { withStateFileLock, withStateFileLockSync } from "../../core/state-file-lock.js";
 import { endpointLabel } from "../providers/endpoint-capacity.js";
 import {
 	acquireCapacityLease,
@@ -361,8 +361,10 @@ export function rebindDispatchReservationMember(input: {
 	costUpperBoundUsd: number;
 	capacity: ReservationCapacitySnapshot;
 	nowMs?: number;
-}): DispatchReservationRecord {
-	return withStateFileLockSync(capacityStateLockPath(), () => {
+}): Promise<DispatchReservationRecord> {
+	// Retry admission runs inside the async dispatch attempt, so it can yield
+	// while waiting for the cross-process lock instead of blocking the event loop.
+	return withStateFileLock(capacityStateLockPath(), () => {
 		const nowMs = input.nowMs ?? Date.now();
 		const records = expireRecords(readStore(), nowMs, false);
 		const record = records.find((entry) => entry.ownerId === input.ownerId);

package/src/domains/dispatch/state.ts

@@ -52,6 +52,7 @@ export interface LedgerOptions {
 
 export type CreateRunInput = Omit<
 	RunEnvelope,
+	| "version"
 	| "id"
 	| "startedAt"
 	| "endedAt"
@@ -143,6 +144,10 @@ export function listFleetRuns(limit = MAX_FLEET_RUN_SCAN): FleetRunRecord[] {
 	return records.slice(0, Math.max(0, limit));
 }
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // `RunEnvelope.heartbeatAt` deliberately persists only the absolute wall-clock
 // anchor used for operator display and crash recovery. The monotonic heartbeat
 // stamp belongs to the live transport in this process; serializing it would
@@ -152,9 +157,16 @@ function readRuns(): RunEnvelope[] {
 	if (!existsSync(path)) return [];
 	const raw = readFileSync(path, "utf8").trim();
 	if (raw.length === 0) return [];
-	const parsed = JSON.parse(raw) as RunEnvelope[];
+	const parsed = JSON.parse(raw) as unknown;
 	if (!Array.isArray(parsed)) return [];
-	return parsed;
+	const envelopes: RunEnvelope[] = [];
+	for (const entry of parsed) {
+		if (!isRecord(entry)) continue;
+		const version = entry.version === undefined ? 1 : entry.version;
+		if (version !== 1) continue;
+		envelopes.push({ ...(entry as unknown as RunEnvelope), version: 1 });
+	}
+	return envelopes;
 }
 
 function resolveMaxRuns(opt?: number | undefined): number {
@@ -241,6 +253,7 @@ export function openLedger(opts?: LedgerOptions): Ledger {
 	return {
 		create(input: CreateRunInput): RunEnvelope {
 			const envelope: RunEnvelope = {
+				version: 1,
 				id: input.id ?? newRunId(),
 				agentId: input.agentId,
 				executionRole: input.executionRole,

package/src/domains/dispatch/types.ts

@@ -10,6 +10,7 @@ import type { GatewayRoutingObservation } from "../../core/gateway-routing.js";
 import type { ResponseModelIdObservation } from "../../core/response-model-id.js";
 import type { SkillActivation } from "../../core/skill-activation.js";
 import type { ToolProfileName } from "../../tools/profiles.js";
+import type { DeclaredCheckReport } from "../../tools/verify/scripts.js";
 import type { AgentAudience } from "../agents/spec.js";
 import type { EvidenceTag } from "../evidence/index.js";
 import type { CostProvenance, RuntimeTargetSnapshot } from "../providers/index.js";
@@ -442,6 +443,7 @@ export interface RunReceiptFindingsSummary {
 }
 
 export interface RunEnvelope {
+	version: 1;
 	id: string;
 	agentId: string;
 	/** Semantic role this attempt's route statistics belong to. */
@@ -483,6 +485,8 @@ export interface RunEnvelope {
 	plan?: RunPlanProvenance;
 	/** Ad-hoc specialist provenance; present only when a persona override composed the stable prompt. */
 	personaOverride?: RunPersonaOverride;
+	/** Decision refs active on the parent decision board at dispatch; absent when the board was empty. */
+	decisionRefs?: ReadonlyArray<string>;
 	exitCode: number | null;
 	pid: number | null;
 	heartbeatAt: string | null;
@@ -710,11 +714,14 @@ export interface RunHostVerificationCheck {
 	check: string;
 	argv: string[];
 	cwd: string;
+	/** For a numeric-compare or perf-budget check, 1 when the judgement failed even though the command exited 0. */
 	exitCode: number;
 	durationMs: number;
 	memo: boolean;
 	outputTail: string;
 	artifactPath?: string;
+	/** Structured verdict of a numeric-compare or perf-budget check; absent for a command check. Covered by the receipt digest through `hostVerification`. */
+	report?: DeclaredCheckReport;
 	/** Run that owns the evidence when it did not come from this run: a memo hit, or the batch member the shared check ran under. */
 	evidenceRunId?: string;
 }
@@ -811,8 +818,14 @@ export interface RunReceipt {
 	node?: RunNodeIdentity;
 	/**
 	 * Route and node identity attested by the worker process that executed the
-	 * run. Absent only when no worker announced, which is the stubbed-spawn path
-	 * contract tests use; every native and remote transport attests.
+	 * run. Every native and remote worker transport attests, so a receipt from
+	 * the worker path carries this field. It is legitimately absent on receipts
+	 * that no worker process produced: the print-mode main-agent receipt
+	 * (src/cli/modes/print.ts), which runs in the orchestrator process, and ACP
+	 * delegation receipts, whose external agent never sends an announce frame.
+	 * The eval process invariants (src/domains/eval/metrics/invariants.ts) rely
+	 * on that absence to skip the main-agent path when counting orphaned
+	 * workers. Contract tests that stub the spawn also leave it absent.
 	 */
 	attestation?: RunReceiptAttestation;
 	/** Dead-node failover hops, oldest first; absent when the run was never rerouted. */
@@ -828,6 +841,8 @@ export interface RunReceipt {
 	fleetGate?: { path: string; pathHash: string };
 	/** Ad-hoc specialist provenance; present only when a persona override composed the stable prompt. */
 	personaOverride?: RunPersonaOverride;
+	/** Decision refs active on the parent decision board at dispatch; absent when the board was empty. */
+	decisionRefs?: ReadonlyArray<string>;
 	/** Effective project-context tier for this run; absent on receipts written before this field landed. */
 	projectContext?: RunProjectContextProvenance;
 	/**

package/src/domains/eval/runners/clio-run.ts

@@ -1,6 +1,5 @@
 import { isAbsolute, relative, resolve, sep } from "node:path";
 import { normalizeClioCoderEventRecord } from "../../../core/naming-events.js";
-import { shellQuote } from "../../../core/shell-quote.js";
 import { clioStateDir } from "../../../core/xdg.js";
 import {
 	evidenceMetricsFromReceipt,
@@ -22,19 +21,23 @@ export async function runClioRunRunner(
 	readObservation?: { allowedPaths: string[]; decoyPaths: string[] },
 ): Promise<EvalRunnerOutput> {
 	const prompt = runner.prompt ?? "";
-	const args = [
-		shellQuote(clioEntry),
+	// Spawned as an argv, not a shell line: the task timeout has to reach the
+	// Clio process itself so the receipt it seals and the exit code this
+	// runner reports describe the same ending. See runShellCommand.
+	const args: [string, ...string[]] = [
+		process.execPath,
+		clioEntry,
 		"run",
 		"--json",
-		...(runner.agent === undefined ? [] : ["--agent", shellQuote(runner.agent)]),
+		...(runner.agent === undefined ? [] : ["--agent", runner.agent]),
 		"--target",
-		shellQuote(target.id),
-		...(target.model === undefined ? [] : ["--model", shellQuote(target.model)]),
-		...(target.thinking === undefined ? [] : ["--thinking", shellQuote(target.thinking)]),
+		target.id,
+		...(target.model === undefined ? [] : ["--model", target.model]),
+		...(target.thinking === undefined ? [] : ["--thinking", target.thinking]),
 		...(runner.autonomy === undefined ? [] : ["--autonomy", runner.autonomy]),
-		shellQuote(prompt),
+		prompt,
 	];
-	const result = await runShellCommand(`${process.execPath} ${args.join(" ")}`, cwd, runner.timeoutMs ?? timeoutMs, env);
+	const result = await runShellCommand(args, cwd, runner.timeoutMs ?? timeoutMs, env);
 	// Usage is folded from the live stream, not from the bounded stdout
 	// artifact: a verbose run's `message_end` events do not survive truncation.
 	const tokens = result.usage;

package/src/domains/eval/runners/context-index.ts

@@ -1,4 +1,3 @@
-import { shellQuote } from "../../../core/shell-quote.js";
 import type { EvalSuiteTargetV2 } from "../schema/suite.js";
 import { type EvalRunnerOutput, runShellCommand } from "./external-command.js";
 
@@ -9,12 +8,8 @@ export async function runContextIndexRunner(
 	target: EvalSuiteTargetV2,
 	env?: NodeJS.ProcessEnv,
 ): Promise<EvalRunnerOutput> {
-	const result = await runShellCommand(
-		`${shellQuote(process.execPath)} ${shellQuote(clioEntry)} context index --json`,
-		cwd,
-		timeoutMs,
-		env,
-	);
+	const args: [string, ...string[]] = [process.execPath, clioEntry, "context", "index", "--json"];
+	const result = await runShellCommand(args, cwd, timeoutMs, env);
 	const parsed = parseContextIndexOutput(result.stdout);
 	return {
 		assignmentId: null,

package/src/domains/eval/runners/context-init.ts

@@ -1,6 +1,5 @@
 import { existsSync, statSync } from "node:fs";
 import { join } from "node:path";
-import { shellQuote } from "../../../core/shell-quote.js";
 import type { EvalRunnerV2, EvalSuiteTargetV2 } from "../schema/suite.js";
 import { type EvalRunnerOutput, runShellCommand } from "./external-command.js";
 
@@ -13,7 +12,7 @@ export async function runContextInitRunner(
 	env?: NodeJS.ProcessEnv,
 ): Promise<EvalRunnerOutput> {
 	const extraArgs = runner.args ?? [];
-	const command = [
+	const args: [string, ...string[]] = [
 		process.execPath,
 		clioEntry,
 		"context",
@@ -25,10 +24,8 @@ export async function runContextInitRunner(
 		...(target.model === undefined ? [] : ["--model", target.model]),
 		...(target.thinking === undefined ? [] : ["--thinking", target.thinking]),
 		...extraArgs,
-	]
-		.map(shellQuote)
-		.join(" ");
-	const result = await runShellCommand(command, cwd, runner.timeoutMs ?? timeoutMs, env);
+	];
+	const result = await runShellCommand(args, cwd, runner.timeoutMs ?? timeoutMs, env);
 	const payload = parseInitPayload(result.stdout);
 	const candidateGeneration = recordField(payload, "generation");
 	const generation = isValidGenerationPayload(payload, candidateGeneration) ? candidateGeneration : null;

package/src/domains/eval/runners/external-command.ts

@@ -65,6 +65,11 @@ const OUTPUT_HEAD_LIMIT = 20_000;
 const OUTPUT_TRUNCATION_MARKER = "\n[output middle truncated; tail preserved]\n";
 const METRIC_JSONL_LIMIT = 256_000;
 const METRIC_JSONL_LINE_LIMIT = 64_000;
+// After the deadline's SIGTERM, how long a run gets to end on its own terms
+// before SIGKILL. Clio seals the interrupted run's receipt inside its
+// coordinated shutdown, which budgets 500ms per hook across several hooks; a
+// one-second grace killed it mid-seal and the timed-out run left no receipt.
+const TIMEOUT_KILL_GRACE_MS = 5_000;
 
 export async function runExternalCommandRunner(
 	runner: EvalRunnerV2,
@@ -133,8 +138,23 @@ export async function runExternalCommandRunner(
 	};
 }
 
+/**
+ * Run one eval subprocess to completion or to the timeout.
+ *
+ * A string runs through the shell, which is what an operator's
+ * `external-command` line and the verifier commands are. An argv array spawns
+ * the program directly, with no shell between the runner and the process
+ * whose exit code it reports. That distinction matters on the timeout path:
+ * `/bin/sh -c` on dash keeps the shell as the parent, so SIGTERM to the shell
+ * stops the shell alone while the program runs on to completion. A
+ * `clio-coder run` spawned that way finished its turn after the deadline,
+ * sealed a succeeded receipt with exit 0, and exited 0, and this runner
+ * reported the shell's signal death as exit 124 (issue #275). With an argv the
+ * signal reaches Clio itself, which seals the run as canceled with the exit
+ * status it then reports, so the receipt and the exit code agree either way.
+ */
 export function runShellCommand(
-	command: string,
+	command: string | readonly [string, ...string[]],
 	cwd: string,
 	timeoutMs: number,
 	env?: NodeJS.ProcessEnv,
@@ -153,14 +173,12 @@ export function runShellCommand(
 		const callLedgerFold = createEvalCallLedgerFold();
 		let timedOut = false;
 		let settled = false;
-		const child = spawn(command, {
-			cwd,
-			shell: true,
-			stdio: ["ignore", "pipe", "pipe"],
-			// The overlay is additive: an eval item pins where Clio writes its
-			// journal, and inherits everything else the operator's shell provides.
-			env: env === undefined ? process.env : { ...process.env, ...env },
-		});
+		// The overlay is additive: an eval item pins where Clio writes its
+		// journal, and inherits everything else the operator's shell provides.
+		const spawnEnv = env === undefined ? process.env : { ...process.env, ...env };
+		const [file, args, shell] = typeof command === "string" ? [command, [], true] : [command[0], command.slice(1), false];
+		const child = spawn(file, args, { cwd, shell, stdio: ["ignore", "pipe", "pipe"], env: spawnEnv });
+		const commandLine = typeof command === "string" ? command : command.join(" ");
 		child.stdout.setEncoding("utf8");
 		child.stderr.setEncoding("utf8");
 		child.stdout.on("data", (chunk: string) => {
@@ -177,14 +195,14 @@ export function runShellCommand(
 		const timer = setTimeout(() => {
 			timedOut = true;
 			child.kill("SIGTERM");
-			setTimeout(() => child.kill("SIGKILL"), 1000);
+			setTimeout(() => child.kill("SIGKILL"), TIMEOUT_KILL_GRACE_MS);
 		}, timeoutMs);
 		const finish = (exitCode: number): void => {
 			if (settled) return;
 			settled = true;
 			clearTimeout(timer);
 			resolve({
-				command,
+				command: commandLine,
 				exitCode,
 				stdout,
 				metricJsonl: metricCapture.finish(),