@tangle-network/agent-runtime 0.109.1 → 0.110.0

package/dist/{runtime-BVMyqgct.js → runtime-DSkMJb_X.js}

@@ -1,20 +1,21 @@
 import { n as AnalystError, r as BackendTransportError, s as PlannerError, u as ValidationError } from "./errors-DEAvWQPy.js";
 import { i as normalizeBackendStreamEvent, o as newRuntimeSession, s as nowIso } from "./backends-CiOCyRHb.js";
-import { a as randomSuffix, c as stringifySafe, f as zeroTokenUsage, r as isAbortError, s as sleep, t as addTokenUsage } from "./util-MVgdwuIS.js";
-import { i as InMemorySpawnJournal, r as InMemoryResultBlobStore } from "./spawn-journal-CwPvKUTa.js";
+import { c as sleep, i as isAbortError, l as stringifySafe, n as addTokenUsage, o as randomSuffix, p as zeroTokenUsage } from "./util-Cc9g9Y-o.js";
+import { i as InMemorySpawnJournal, r as InMemoryResultBlobStore } from "./spawn-journal-DLhnom3e.js";
 import { i as redactProtectedValue, r as redactProtectedReason } from "./protected-redaction--F3v1oo8.js";
-import { C as routerChatWithUsage, T as runBrainLoop, d as settledToIteration, l as withDriverExecutor, t as createSupervisor, x as routerBrain } from "./supervisor-sTJC9psT.js";
-import { C as observe, O as strategyAuthorMethod, b as sample, v as refine, x as sampleThenRefine, y as runAgentic } from "./structural-rollout-ASQLr4-v.js";
+import { C as routerChatWithUsage, T as runBrainLoop, d as settledToIteration, l as withDriverExecutor, t as createSupervisor, x as routerBrain } from "./supervisor-ByCPHcp9.js";
+import { C as observe, O as strategyAuthorMethod, b as sample, v as refine, x as sampleThenRefine, y as runAgentic } from "./structural-rollout-CgnNy7_4.js";
 import { i as notifyRuntimeHookEvent } from "./runtime-hooks-C7iJOWm3.js";
 import { a as notifySandboxEventObserver, i as mapSandboxToolEvent, r as mapSandboxEvent, t as createSandboxToolPartState } from "./sandbox-events-DeI5xX8P.js";
-import { Bt as runAgentRounds, Dt as createExecutorRegistry, Et as createExecutor, Ht as createSandboxLineage, Ot as createWorktreeCliExecutor, Ut as probeSandboxCapabilities, bt as rollingDispatch, qt as gateOnDeliverable, t as supervise, zt as defaultSelectWinner } from "./supervise-DyPmmhJ6.js";
+import { Bt as runAgentRounds, Dt as createExecutorRegistry, Et as createExecutor, Ht as createSandboxLineage, Ot as createWorktreeCliExecutor, Ut as probeSandboxCapabilities, bt as rollingDispatch, qt as gateOnDeliverable, t as supervise, zt as defaultSelectWinner } from "./supervise-CeZtA1wu.js";
 import { CODING_HARNESSES, InMemoryTraceStore, benjaminiHochberg, buildTrajectory, computeFindingId as computeFindingId$1, confidenceInterval, expandProfileAxes, harnessAxisOf, makeFinding as makeFinding$1, pairedBootstrap, paretoFrontier, scoreKnowledgeReadiness, wilcoxonSignedRank, wilson } from "@tangle-network/agent-eval";
 import { heldoutSignificance, runProfileMatrix } from "@tangle-network/agent-eval/campaign";
 import { canonicalCandidateDigest, validateAgentProfileSecurity } from "@tangle-network/agent-interface";
+import { randomUUID } from "node:crypto";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { execFileSync, spawn } from "node:child_process";
+import { appendFileSync, chmodSync, constants, copyFileSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readlinkSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { execFileSync, spawn, spawnSync } from "node:child_process";
 import { tmpdir } from "node:os";
 import { createInterface } from "node:readline";
 import { collectAgentResponseText } from "@tangle-network/sandbox";
@@ -62,6 +63,52 @@ async function resolveSecretEnv(secretEnv, keys, label) {
 	}
 	return resolved;
 }
+/** Apply a secret-ref's declared decoration to its resolved raw value. */
+function formatSecretValue(value, format) {
+	return format === "bearer" ? `Bearer ${value}` : value;
+}
+/**
+* Resolve a profile MCP server's `args`/`env` config values (interface ≥0.40
+* `AgentProfileConfigValue`) plus the legacy `metadata.secretEnv` channel into
+* the plain strings a spawn needs.
+*
+* Rules, all fail-closed:
+* - `args` must be public values. A secret-ref in argv is refused: argv is
+*   readable by every host process (/proc/PID/cmdline) and outside the
+*   protected-value redaction channel, so a secret there cannot be contained.
+* - `env` secret-refs resolve through the KeyProvider (missing provider or key
+*   throws, naming the KEY NAME only) and land in `protectedEnv`.
+* - An env var declared secret on BOTH channels (env secret-ref and
+*   metadata.secretEnv) is ambiguous configuration and throws.
+* - A public `env` entry shadowed by a legacy metadata secret keeps the
+*   pre-0.40 spawn precedence: the secret value wins in the child env.
+*/
+async function resolveMcpServerLaunch(server, keys, label) {
+	const args = server.args?.map((value, index) => {
+		if (value.kind !== "public") throw new ValidationError(`${label}.args[${index}] is a secret-ref ('${value.key}') — argv is readable by every host process and exempt from redaction; declare the secret in env instead`);
+		return value.value;
+	});
+	const publicEnv = {};
+	const envSecretRefs = {};
+	const envSecretFormats = {};
+	for (const [envName, value] of Object.entries(server.env ?? {})) if (value.kind === "public") publicEnv[envName] = value.value;
+	else {
+		envSecretRefs[envName] = value.key;
+		envSecretFormats[envName] = value.format;
+	}
+	const legacySecretEnv = secretEnvOfMcpServer(server);
+	for (const envName of Object.keys(legacySecretEnv ?? {})) if (envName in envSecretRefs) throw new ValidationError(`${label}: env ${envName} is declared secret twice — once as an env secret-ref and once in metadata.${mcpSecretEnvMetadataKey}; keep exactly one declaration`);
+	const resolvedRefs = await resolveSecretEnv(envSecretRefs, keys, label);
+	const protectedEnv = {
+		...legacySecretEnv ? await resolveSecretEnv(legacySecretEnv, keys, label) : {},
+		...Object.fromEntries(Object.entries(resolvedRefs).map(([envName, raw]) => [envName, formatSecretValue(raw, envSecretFormats[envName])]))
+	};
+	return {
+		...args ? { args } : {},
+		...server.env ? { env: publicEnv } : {},
+		...Object.keys(protectedEnv).length > 0 ? { protectedEnv } : {}
+	};
+}
 //#endregion
 //#region src/runtime/mcp-environment.ts
 /** POST JSON-RPC and parse a JSON body OR the last `data:` line of an SSE stream.
@@ -385,14 +432,13 @@ async function materializeLocalMcp(profile, opts = {}) {
 			const transport = server.transport ?? "stdio";
 			if (transport !== "stdio") throw new ValidationError(`materializeLocalMcp: profile.mcp['${key}'] has transport '${transport}' — the same-host client only spawns stdio servers; a remote (http/sse) server needs an http MCP client (not yet built here) or the sandbox backend. Failing loud: scoring this profile without its declared server would fake the with/without ablation`);
 			if (!server.command || server.command.trim().length === 0) throw new ValidationError(`materializeLocalMcp: profile.mcp['${key}'] declares a stdio server with no command`);
-			const secretRefs = secretEnvOfMcpServer(server);
-			const provisioned = secretRefs ? await resolveSecretEnv(secretRefs, opts.keys, `materializeLocalMcp: profile.mcp['${key}']`) : void 0;
+			const launch = await resolveMcpServerLaunch(server, opts.keys, `materializeLocalMcp: profile.mcp['${key}']`);
 			const conn = await connectStdioMcp({
 				command: server.command,
-				...server.args ? { args: server.args } : {},
+				...launch.args ? { args: launch.args } : {},
 				...server.cwd ? { cwd: server.cwd } : {},
-				...server.env ? { env: server.env } : {},
-				...provisioned ? { protectedEnv: provisioned } : {},
+				...launch.env ? { env: launch.env } : {},
+				...launch.protectedEnv ? { protectedEnv: launch.protectedEnv } : {},
 				...opts.timeoutMs !== void 0 ? { timeoutMs: opts.timeoutMs } : {}
 			});
 			connections.push(conn);
@@ -3096,13 +3142,12 @@ function requireSpend(rolled, id, root) {
 /**
 * promotionGate — the statistical promotion decision over a holdout benchmark: does the
 * candidate strategy beat the incumbent on held-out tasks by a margin the task noise
-* cannot fake? The statistics are the substrate's (`heldoutSignificance`): a SEEDED
-* paired bootstrap over per-task (candidate − incumbent) deltas — deterministic verdict,
-* a minimum-evidence floor, and the CI lower bound must clear `deltaThreshold`. A raw
-* h1>h0 point comparison on m≈8 holdout tasks certifies false champions at near
-* coin-flip rates; this gate is the instrument-grade replacement.
+* cannot fake? The statistics come from `heldoutSignificance`, which chooses the
+* decision interval that matches the outcome shape, applies a minimum-evidence floor,
+* and requires the interval's lower bound to clear `deltaThreshold`. A raw h1>h0 point
+* comparison on m≈8 holdout tasks certifies false champions at near coin-flip rates.
 */
-/** Statistical promotion decision over a holdout benchmark: a seeded paired bootstrap (`heldoutSignificance`) whose CI lower bound must clear `deltaThreshold`. */
+/** Statistical promotion decision over a holdout benchmark using the outcome-appropriate interval selected by `heldoutSignificance`. */
 function promotionGate(opts) {
 	const mode = opts.mode ?? "superiority";
 	if (opts.candidate === opts.incumbent) return {
@@ -3151,8 +3196,8 @@ function promotionGate(opts) {
 	const lift = {
 		mean: sig.bootstrap.mean,
 		median: sig.bootstrap.median,
-		low: sig.bootstrap.low,
-		high: sig.bootstrap.high
+		low: sig.decision.low,
+		high: sig.decision.high
 	};
 	const latSig = heldoutSignificance({
 		before: incMs,
@@ -3168,8 +3213,8 @@ function promotionGate(opts) {
 	const latency = {
 		mean: latSig.bootstrap.mean,
 		median: latSig.bootstrap.median,
-		low: latSig.bootstrap.low,
-		high: latSig.bootstrap.high
+		low: latSig.decision.low,
+		high: latSig.decision.high
 	};
 	if (mode === "superiority") {
 		if (sig.fewRuns) return {
@@ -3222,8 +3267,8 @@ function promotionGate(opts) {
 	const costSavings = {
 		mean: costSig.bootstrap.mean,
 		median: costSig.bootstrap.median,
-		low: costSig.bootstrap.low,
-		high: costSig.bootstrap.high
+		low: costSig.decision.low,
+		high: costSig.decision.high
 	};
 	if (scoreSig.fewRuns) return {
 		promoted: false,
@@ -4727,6 +4772,123 @@ function signalPass(value, required) {
 	return !required;
 }
 //#endregion
+//#region src/runtime/supervise/run-layout.ts
+/**
+* The on-disk supervisor-run layout: `<root>/.loops/supervisor/<id>`.
+*
+* This is the durable, cross-process face of a supervisor run — the counterpart to the in-process
+* `Inbox` seam in `./inbox`. A run persists its state under one directory so that any OTHER process
+* can find it after the fact: `@tangle-network/traces` reads exactly this layout
+* (`traces analyze --supervisor-run-dir` expects `<runDir>/ws/.loops/supervisor/<id>`), a restarted
+* host can rehydrate a run it no longer holds handles to, and a human can steer a live worker by
+* appending one NDJSON line. Until now the layout was defined only in the unpublished `loops` repo
+* (`src/supervisor-control.ts`) — a published reader depending on an unpublished writer's
+* convention — so the contract is promoted here, names preserved.
+*
+* Layout, relative to `supervisorRunDir(root, id)`:
+*
+*   workers/<label>.inbox.ndjson   down-leg steer/answer requests for one worker (durable inbox);
+*                                  each line is a {@link WorkerSteerRequest}
+*   workers/<label>.ndjson         best-effort per-worker control-event log (delivery bookkeeping)
+*
+* Reads are tolerant by contract: a partial trailing line (a writer mid-append) or a corrupt line
+* never poisons the rest of the file — later valid lines still matter.
+*
+* Promoted from `loops/src/supervisor-control.ts`. The one deliberate difference: the loops version
+* resolved a worker id to its label through the run journal before writing a steer; that resolution
+* stays with the caller (it is journal-format-specific), so `writeWorkerSteer` here takes the worker
+* LABEL directly.
+*
+* @experimental
+*/
+/** The run directory every artifact of one supervisor run lives under. */
+function supervisorRunDir(rootDir, id) {
+	return join(resolve(rootDir), ".loops", "supervisor", id);
+}
+/** A worker label reduced to a safe filename stem. Empty labels get a stable fallback. */
+function safeWorkerFile(label) {
+	const safe = label.replace(/[^A-Za-z0-9._-]/g, "_");
+	return safe.length > 0 ? safe : "worker";
+}
+/** The durable inbox file for one worker of one run. */
+function workerInboxFile(rootDir, supervisorId, worker) {
+	return workerInboxFileFromEventDir(supervisorRunDir(rootDir, supervisorId), worker);
+}
+/** Same, addressed from an already-known run directory (the reader's usual entry point). */
+function workerInboxFileFromEventDir(eventDir, worker) {
+	return join(eventDir, "workers", `${safeWorkerFile(worker)}.inbox.ndjson`);
+}
+/**
+* Durably append one steer request to a worker's inbox and log the delivery attempt.
+*
+* The inbox append is the durable act; the control-event log is best-effort bookkeeping and may
+* silently fail without voiding the steer.
+*/
+function writeWorkerSteer(rootDir, supervisorId, worker, message, source = "human") {
+	const trimmed = message.trim();
+	if (!trimmed) throw new Error("steer message is empty");
+	const dir = supervisorRunDir(rootDir, supervisorId);
+	mkdirSync(join(dir, "workers"), { recursive: true });
+	const request = {
+		id: randomUUID(),
+		at: (/* @__PURE__ */ new Date()).toISOString(),
+		source,
+		worker,
+		message: trimmed
+	};
+	const file = workerInboxFile(rootDir, supervisorId, worker);
+	appendFileSync(file, `${JSON.stringify(request)}\n`, "utf8");
+	appendWorkerControlEvent(dir, worker, {
+		kind: "message",
+		direction: "down",
+		source,
+		requestId: request.id,
+		message: trimmed,
+		queued: true,
+		delivered: false
+	});
+	return {
+		worker,
+		file,
+		request
+	};
+}
+/** Read every valid steer request in a worker's inbox. Corrupt or partial lines are skipped. */
+function readWorkerSteerRequests(eventDir, worker) {
+	const file = workerInboxFileFromEventDir(eventDir, worker);
+	if (!existsSync(file)) return [];
+	const out = [];
+	let raw = "";
+	try {
+		raw = readFileSync(file, "utf8");
+	} catch {
+		return out;
+	}
+	for (const line of raw.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		try {
+			const parsed = JSON.parse(trimmed);
+			if (isWorkerSteerRequest(parsed)) out.push(parsed);
+		} catch {}
+	}
+	return out;
+}
+function appendWorkerControlEvent(eventDir, label, event) {
+	try {
+		const workersDir = join(eventDir, "workers");
+		mkdirSync(workersDir, { recursive: true });
+		appendFileSync(join(workersDir, `${safeWorkerFile(label)}.ndjson`), `${JSON.stringify({
+			at: (/* @__PURE__ */ new Date()).toISOString(),
+			label,
+			...event
+		})}\n`, "utf8");
+	} catch {}
+}
+function isWorkerSteerRequest(value) {
+	return typeof value.id === "string" && typeof value.at === "string" && typeof value.source === "string" && typeof value.worker === "string" && typeof value.message === "string" && value.message.trim().length > 0;
+}
+//#endregion
 //#region src/runtime/supervise/trajectory-recorder.ts
 /**
 *
@@ -4789,6 +4951,232 @@ async function analyzeTrace(source, runId = "worker") {
 	};
 }
 //#endregion
+//#region src/runtime/supervise/untracked-clone.ts
+/**
+* Worker-clone preparation: make each worker's fresh clone a FAITHFUL copy of the
+* shared workspace's working tree, not just of its git history.
+*
+* `runInWorkspace` materializes a worker dir via `git clone`, which carries only
+* COMMITTED files. Real workspaces (SWE-bench instance images: astropy,
+* matplotlib) hold compiled extension modules (.so/.pyd) as UNTRACKED build
+* artifacts — inside a bare clone `import astropy` dies with "cannot import name
+* '_compiler'" before the worker's first edit, so its verify gate is physically
+* unpassable regardless of patch quality (observed: 7/7 astropy and 6/6
+* matplotlib workers failed exactly this way while the shared workspace verified
+* fine). The fix copies the source tree's untracked files — including git-ignored
+* build outputs — into the clone right after materialize and before the worker
+* starts.
+*
+* Isolation is preserved: artifacts are COPIED (copy-on-write via FICLONE where
+* the filesystem supports it — never hardlinked, a worker rebuild opening an
+* artifact with O_TRUNC on a shared inode would corrupt the source workspace for
+* every sibling), and an absolute symlink pointing inside the source tree is
+* rewritten to the clone-local path so no worker holds a live handle back into
+* shared mutable state.
+*
+* Fidelity stops at git history: every copied path is appended to the clone's
+* `.git/info/exclude`, so the clone-side `git add -A` (both the local delegate's
+* diff capture and `gitWorkspace.commit`) can never stage pre-existing build
+* artifacts into the shared ref — in the source they are untracked, and a
+* delivery must not silently start tracking them.
+*
+* Promoted verbatim from `loops/src/worker-clone.ts` (see agent-dev-container#4519): any harness
+* that materializes workers via `git clone` needs the working tree, not just the history.
+*
+* @experimental
+*/
+/** Loop-infra dirs living inside a workspace; orchestration state, never build inputs. */
+const SKIPPED_TOP_LEVEL = /* @__PURE__ */ new Set([
+	".loops",
+	".evolve",
+	".agent-worktrees",
+	".claude"
+]);
+/** Warn (and copy anyway) past this untracked payload size. */
+const DEFAULT_WARN_BYTES = 2 * 1024 * 1024 * 1024;
+/**
+* Copy every untracked file of `sourceDir`'s working tree — including git-ignored
+* build outputs (`git ls-files --others` with NO exclude flags lists both) — into
+* `cloneDir`, then shield the copied paths from the clone's `git add -A` via
+* `.git/info/exclude`. Nested git repos (listed as bare `dir/` entries), any path
+* containing a `.git` segment, and loop-infra dirs are skipped.
+*/
+function copyUntrackedIntoClone(sourceDir, cloneDir, opts = {}) {
+	const warnBytes = opts.warnBytes ?? DEFAULT_WARN_BYTES;
+	const log = opts.log ?? ((message) => console.warn(message));
+	const src = resolve(sourceDir);
+	const dst = resolve(cloneDir);
+	const ls = spawnSync("git", [
+		"-C",
+		src,
+		"ls-files",
+		"--others",
+		"-z"
+	], {
+		encoding: "utf8",
+		maxBuffer: 256 * 1024 * 1024
+	});
+	if (ls.status !== 0) throw new Error(`git ls-files --others failed in ${src}: ${(ls.stderr ?? "").trim() || `exit ${ls.status}`}`);
+	const plan = [];
+	for (const rel of (ls.stdout ?? "").split("\0")) {
+		if (!rel || rel.endsWith("/")) continue;
+		const segments = rel.split("/");
+		if (segments.includes(".git")) continue;
+		if (SKIPPED_TOP_LEVEL.has(segments[0] ?? "")) continue;
+		let stat;
+		try {
+			stat = lstatSync(join(src, rel));
+		} catch {
+			continue;
+		}
+		if (stat.isSymbolicLink()) plan.push({
+			rel,
+			kind: "symlink",
+			size: 0,
+			mode: stat.mode
+		});
+		else if (stat.isFile()) plan.push({
+			rel,
+			kind: "file",
+			size: stat.size,
+			mode: stat.mode
+		});
+	}
+	const bytes = plan.reduce((sum, entry) => sum + entry.size, 0);
+	if (bytes > warnBytes) log(`worker clone: untracked payload in ${src} is ${(bytes / 1024 / 1024).toFixed(0)}MB (> ${(warnBytes / 1024 / 1024).toFixed(0)}MB) — copying anyway so the clone stays runnable`);
+	let copied = 0;
+	const excludeLines = [];
+	for (const entry of plan) {
+		const from = join(src, entry.rel);
+		const to = join(dst, entry.rel);
+		try {
+			mkdirSync(dirname(to), { recursive: true });
+			if (entry.kind === "symlink") {
+				let target = readlinkSync(from);
+				if (isAbsolute(target)) {
+					const resolved = resolve(target);
+					if (resolved === src || resolved.startsWith(src + sep)) target = join(dst, relative(src, resolved));
+				}
+				rmSync(to, { force: true });
+				symlinkSync(target, to);
+			} else {
+				copyFileSync(from, to, constants.COPYFILE_FICLONE);
+				chmodSync(to, entry.mode & 4095);
+			}
+			copied += 1;
+			excludeLines.push(toExcludePattern(entry.rel));
+		} catch (err) {
+			log(`worker clone: failed to copy untracked ${entry.rel}: ${err instanceof Error ? err.message : String(err)}`);
+		}
+	}
+	if (excludeLines.length > 0) {
+		const infoDir = join(dst, ".git", "info");
+		mkdirSync(infoDir, { recursive: true });
+		appendFileSync(join(infoDir, "exclude"), `# untracked artifacts copied from the shared workspace — never commit them back\n${excludeLines.join("\n")}\n`, "utf8");
+	}
+	return {
+		copied,
+		bytes
+	};
+}
+/** Root-anchored literal exclude pattern: glob metachars and trailing spaces escaped. */
+function toExcludePattern(rel) {
+	return `/${rel.replace(/([\\*?[\]])/g, "\\$1").replace(/ +$/, (spaces) => "\\ ".repeat(spaces.length))}`;
+}
+/**
+* Wrap a `Workspace` so every `materialize` (the per-worker `git clone` inside
+* `runInWorkspace`) is followed by the untracked-artifact copy above — the clone
+* the worker starts in matches the source WORKING TREE, not just its history.
+* `commit`/`head` pass through untouched, so delivery semantics are unchanged.
+*/
+function withUntrackedArtifacts(ws, sourceDir, log) {
+	return {
+		ref: ws.ref,
+		materialize: async (dir) => {
+			await ws.materialize(dir);
+			copyUntrackedIntoClone(sourceDir, dir, log ? { log } : {});
+		},
+		commit: (dir, message) => ws.commit(dir, message),
+		head: () => ws.head()
+	};
+}
+//#endregion
+//#region src/runtime/supervise/worker-evidence.ts
+/**
+* Evidence-rich worker settlement.
+*
+* The supervisor BRAIN decides respawn/steer/stop from what a settled worker
+* shows it. A bare `finished passed=false patchBytes=6138` starves that
+* decision: the brain cannot quote the failing assertion, so its next worker
+* goal is authored blind. This module composes the bounded evidence block a
+* settling worker appends to its event stream and — on failure — returns as
+* its output artifact, so `observe_agent` hands the brain the failing verify
+* tail, a diff summary, and the worker's final note instead of counters.
+*/
+/** Hard cap on one worker's evidence block so the brain's context cannot blow up. */
+const EVIDENCE_MAX_CHARS = 3e3;
+/** Tail of the verify output — the failing assertion lives at the END of a test log. */
+const VERIFY_TAIL_CHARS = 1200;
+const PATCH_HEAD_LINES = 40;
+const PATCH_LINE_MAX_CHARS = 200;
+/** Cap on the worker's closing note inside the evidence block. */
+const NOTE_MAX_CHARS = 300;
+/**
+* Compose the settle evidence block. Section order is priority order under the
+* hard cap: the verify tail (what failed) survives before the diff head (what
+* was tried) and the worker note — a truncated diff is recoverable from the
+* persisted patch file, a truncated failing assertion is not recoverable at all.
+*/
+function composeWorkerEvidence(input) {
+	const sections = [];
+	const failures = [...input.testPassed ? [] : ["tests failed"], ...input.typecheckPassed ? [] : ["typecheck failed"]];
+	sections.push(input.passed ? "verify PASSED" : `verify FAILED (${failures.join(", ") || "gate not passed"})`);
+	const testTail = input.testOutput.trim().slice(-1200);
+	if (testTail) sections.push(`--- verify output (tail) ---\n${testTail}`);
+	if (!input.typecheckPassed) {
+		const typecheckTail = input.typecheckOutput.trim().slice(-400);
+		if (typecheckTail) sections.push(`--- typecheck output (tail) ---\n${typecheckTail}`);
+	}
+	sections.push(diffSummary(input.patch));
+	const note = input.reviewerNotes?.trim();
+	if (note) sections.push(`--- worker note ---\n${note.slice(0, 300)}`);
+	return sections.join("\n").slice(0, EVIDENCE_MAX_CHARS);
+}
+/**
+* What a settled worker exposes as its output artifact (the blob the brain's
+* `observe_agent` reads). A passing worker's output is its patch — the
+* deliverable. A failing worker's output is its evidence block. A passing
+* worker with NO edits — the post-delivery read-only reviewer: the workspace
+* already holds a delivered fix, so the gate stays green under an empty diff —
+* would otherwise settle with an EMPTY output and its review would be lost, so
+* it exposes its evidence block instead (the worker note carries the review).
+*/
+function settledWorkerOut(input) {
+	if (input.evidence.length === 0) return input.patch;
+	if (!input.passed) return input.evidence;
+	return input.patch.trim().length > 0 ? input.patch : input.evidence;
+}
+/**
+* The worker's closing commentary off a local harness run: the TAIL of its
+* stdout (falling back to stderr), bounded to the note cap so a reviewer's
+* final verdict line — written last — survives into the evidence block
+* (`composeWorkerEvidence` keeps the note's FIRST `NOTE_MAX_CHARS` chars).
+*/
+function closingWorkerNote(stdout, stderr) {
+	const source = stdout.trim() || stderr.trim();
+	if (!source) return void 0;
+	return source.slice(-300);
+}
+function diffSummary(patch) {
+	const trimmed = patch.trim();
+	if (!trimmed) return "--- diff: EMPTY (the worker produced no edits) ---";
+	const lines = trimmed.split("\n");
+	const filesChanged = lines.filter((line) => line.startsWith("diff --git ")).length;
+	const head = lines.slice(0, PATCH_HEAD_LINES).map((line) => line.length > PATCH_LINE_MAX_CHARS ? `${line.slice(0, PATCH_LINE_MAX_CHARS)}~` : line);
+	const omitted = lines.length - head.length;
+	return `${`--- diff: ${filesChanged} file(s) changed, ${Buffer.byteLength(patch)} bytes; first ${head.length} line(s) ---`}\n${head.join("\n")}${omitted > 0 ? `\n... (${omitted} more patch lines; full patch persisted per worker)` : ""}`;
+}
+//#endregion
 //#region src/runtime/supervise/worktree-fanout.ts
 /**
 * Build the worktree fanout combinator. Run it with `runPersonified({ persona, shape, task, budget })`
@@ -5411,6 +5799,6 @@ function tail(s) {
 	return s.slice(-400);
 }
 //#endregion
-export { defineLeaderboard as $, trajectoryReport as A, flatWidenGate as B, strategyAuthorContract as C, sanitizeMcpToolSchema as Ct, runBenchmark as D, secretEnvOfMcpServer as Dt, printBenchmarkReport as E, resolveSecretEnv as Et, registerShape as F, verify as G, panel as H, FileCorpus as I, buildSteerContext as J, widen as K, InMemoryCorpus as L, runPersonified as M, builtinShapes as N, promotionGate as O, createShapeRegistry as P, harvestCorpus as Q, renderCorpusToInstructions as R, authorStrategy as S, createMcpEnvironment as St, openSandboxRun as T, mcpSecretEnvMetadataKey as Tt, pipeline as U, loopUntil as V, selectValidWinner as W, registryScopeAnalyst as X, createScopeAnalyst as Y, inProcessSandboxClient as Z, discriminatingMeans as _, auditIntent as _t, localShell as a, loopCampaignDispatch as at, selectChampion as b, connectStdioMcp as bt, createVerifierEnvironment as c, deterministicCompletion as ct, worktreeFanout as d, leaderboard as dt, dumbDriver as et, analyzeTrace as f, pairwiseSignificance as ft, streamAgentTurn as g, renderPairwiseMarkdown as gt, collectAgentTurn as h, renderLeaderboardSvg as ht, jjWorkspace as i, inlineSandboxClient as it, definePersona as j, equalKOnCost as k, failuresAnalyst as l, sentinelCompletion as lt, runCoderChecks as m, renderLeaderboardMarkdown as mt, makeFinding$1 as n, resolveSandboxClient as nt, runInWorkspace as o, loopDispatch as ot, patchDelivered as p, renderLeaderboardHtml as pt, assertTraceDerivedFindings as q, gitWorkspace as r, localSandboxClient as rt, createWaterfallCollector as s, completionAuthorizes as st, computeFindingId$1 as t, naiveDriver as tt, superviseSurface as u, stopSentinel as ut, pickChampion as v, defaultAuditorInstruction as vt, SandboxRunAbortError as w, envKeyProvider as wt, assertStrategyContract as x, materializeLocalMcp as xt, runStrategyEvolution as y, McpSpawnFault as yt, fanout as z };
+export { fanout as $, streamAgentTurn as A, renderPairwiseMarkdown as At, printBenchmarkReport as B, resolveMcpServerLaunch as Bt, supervisorRunDir as C, sentinelCompletion as Ct, patchDelivered as D, renderLeaderboardHtml as Dt, writeWorkerSteer as E, pairwiseSignificance as Et, assertStrategyContract as F, materializeLocalMcp as Ft, definePersona as G, promotionGate as H, secretEnvOfMcpServer as Ht, authorStrategy as I, createMcpEnvironment as It, createShapeRegistry as J, runPersonified as K, strategyAuthorContract as L, sanitizeMcpToolSchema as Lt, pickChampion as M, defaultAuditorInstruction as Mt, runStrategyEvolution as N, McpSpawnFault as Nt, runCoderChecks as O, renderLeaderboardMarkdown as Ot, selectChampion as P, connectStdioMcp as Pt, renderCorpusToInstructions as Q, SandboxRunAbortError as R, envKeyProvider as Rt, safeWorkerFile as S, deterministicCompletion as St, workerInboxFileFromEventDir as T, leaderboard as Tt, equalKOnCost as U, runBenchmark as V, resolveSecretEnv as Vt, trajectoryReport as W, FileCorpus as X, registerShape as Y, InMemoryCorpus as Z, settledWorkerOut as _, localSandboxClient as _t, localShell as a, verify as at, analyzeTrace as b, loopDispatch as bt, createVerifierEnvironment as c, buildSteerContext as ct, worktreeFanout as d, inProcessSandboxClient as dt, flatWidenGate as et, EVIDENCE_MAX_CHARS as f, harvestCorpus as ft, composeWorkerEvidence as g, resolveSandboxClient as gt, closingWorkerNote as h, naiveDriver as ht, jjWorkspace as i, selectValidWinner as it, discriminatingMeans as j, auditIntent as jt, collectAgentTurn as k, renderLeaderboardSvg as kt, failuresAnalyst as l, createScopeAnalyst as lt, VERIFY_TAIL_CHARS as m, dumbDriver as mt, makeFinding$1 as n, panel as nt, runInWorkspace as o, widen as ot, NOTE_MAX_CHARS as p, defineLeaderboard as pt, builtinShapes as q, gitWorkspace as r, pipeline as rt, createWaterfallCollector as s, assertTraceDerivedFindings as st, computeFindingId$1 as t, loopUntil as tt, superviseSurface as u, registryScopeAnalyst as ut, copyUntrackedIntoClone as v, inlineSandboxClient as vt, workerInboxFile as w, stopSentinel as wt, readWorkerSteerRequests as x, completionAuthorizes as xt, withUntrackedArtifacts as y, loopCampaignDispatch as yt, openSandboxRun as z, mcpSecretEnvMetadataKey as zt };
 
-//# sourceMappingURL=runtime-BVMyqgct.js.map
+//# sourceMappingURL=runtime-DSkMJb_X.js.map