@tangle-network/agent-runtime 0.133.2 → 0.133.4

package/dist/{runtime-B6YK6v3I.js → runtime-DRr7g_2C.js}

@@ -6,18 +6,19 @@ import { i as redactProtectedValue, r as redactProtectedReason } from "./protect
 import { a as notifySandboxEventObserver, c as parseCanonicalTransportEvent, s as extractTransportEventIdentity } from "./sandbox-events-vIwmuPdl.js";
 import { c as profileProviderModel, i as concreteModelId, s as profileModelExecutionSettings, t as assertExecutableAgentProfile } from "./model-policy-Bv1DU2fw.js";
 import { T as executableAgentSpecSnapshot, w as executableAgentProfileSnapshot } from "./materialization-D2bdTfkK.js";
-import { $ as defaultSelectWinner, F as createExecutorRegistry, G as createPushTraceSource, L as createWorktreeCliExecutor, P as createExecutor, T as rollingDispatch, at as runBrainLoop, et as runAgentRounds, h as settledToIteration, it as routerBrain, l as withDriverExecutor, n as createSupervisor, nt as probeSandboxCapabilities, ot as canonicalObservedModel, tt as createSandboxLineage } from "./supervisor-C5pAAPb5.js";
+import { $ as defaultSelectWinner, F as createExecutorRegistry, G as createPushTraceSource, L as createWorktreeCliExecutor, P as createExecutor, T as rollingDispatch, at as runBrainLoop, et as runAgentRounds, h as settledToIteration, it as routerBrain, l as withDriverExecutor, n as createSupervisor, nt as probeSandboxCapabilities, ot as canonicalObservedModel, tt as createSandboxLineage } from "./supervisor-D8sBmGYd.js";
 import "./environment-provider-mDsjfGjY.js";
 import { i as notifyRuntimeHookEvent } from "./runtime-hooks-C7iJOWm3.js";
-import { C as observe, O as strategyAuthorMethod, T as profileChatClient, b as sample, v as refine, x as sampleThenRefine, y as runAgentic } from "./structural-rollout-BQh7Rzoa.js";
-import { It as gateOnDeliverable, Lt as mapExecutorResult, n as supervise } from "./supervise-C_P4yxA4.js";
-import "./authoring-CCzHzhCy.js";
-import "./graph-DiFPPTdk.js";
+import { C as observe, O as strategyAuthorMethod, T as profileChatClient, b as sample, v as refine, x as sampleThenRefine, y as runAgentic } from "./structural-rollout-BfOB1pIb.js";
+import { It as gateOnDeliverable, Lt as mapExecutorResult, n as supervise } from "./supervise-C3yRHeDk.js";
+import "./authoring-Da9lWfh7.js";
+import "./graph-TkrwBJCS.js";
 import { CODING_HARNESSES, InMemoryTraceStore, OUTPUT_VALUE, benjaminiHochberg, buildTrajectory, computeFindingId as computeFindingId$1, confidenceInterval, expandProfileAxes, makeFinding as makeFinding$1, pairedBootstrap, paretoFrontier, wilcoxonSignedRank, wilson } from "@tangle-network/agent-eval";
 import { heldoutSignificance, runProfileMatrix } from "@tangle-network/agent-eval/campaign";
 import { AgentEnvironmentCapabilitiesSchema, AgentExactRunControlRefSchema, AgentNativeContextContinuationResultSchema, AgentRunCancellationAcknowledgementSchema, AgentRunCancellationRequestSchema, AgentTurnResultSchema, InteractionAcknowledgementSchema, InteractionResponseCommandSchema, NativeContextBoundaryProofSchema, NativeContextContinuationRequestSchema, RuntimeEventEnvelopeSchema, agentNativeContextContinuationResultMatchesRequest, agentProfileSchema, agentRunCancellationAcknowledgementMatchesRequest, agentRunCancellationRequestDigest, canonicalAgentProfileDigest, canonicalCandidateDigest, nativeContextContinuationTurnDigest, validateAgentProfileSecurity } from "@tangle-network/agent-interface";
+import { createHash } from "node:crypto";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { mkdir, readFile, realpath, writeFile } from "node:fs/promises";
 import { appendFileSync, chmodSync, constants, copyFileSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readlinkSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import { execFileSync, spawn, spawnSync } from "node:child_process";
 import { tmpdir } from "node:os";
@@ -4260,6 +4261,50 @@ function printBenchmarkReport(report) {
 	}
 }
 //#endregion
+//#region src/runtime/box-read-retry.ts
+/**
+* One bounded-retry read over a sandbox box's filesystem, shared by every caller that reads a
+* path the agent may have just written.
+*
+* The box data plane can transiently 404 a file that exists: the write is not yet flushed, or an
+* edge read lands on a stale view. A first-attempt failure is therefore not evidence of absence,
+* and a caller that treats it as such records a lie — "the agent produced nothing" for a
+* deliverable, or "the agent deleted this surface" for a mounted profile file.
+*
+* Retries wait `delayMs × attempt` (linear), so the total wait for n attempts is
+* `delayMs × n(n-1)/2`. Set `delayMs` to 0 to retry without waiting (tests).
+*/
+/** The diagnostic for a failed attempt. `undefined` in, `undefined` out — so a caller can pass the
+*  "no attempt has failed yet" state through without inventing a message for it. */
+function boxReadErrorMessage(error) {
+	if (error === void 0) return void 0;
+	return error instanceof Error ? error.message : String(error);
+}
+async function readBoxPathWithRetry(read, path, options) {
+	const attempts = Math.max(1, options.attempts);
+	let lastError;
+	for (let attempt = 1; attempt <= attempts; attempt += 1) {
+		options.beforeAttempt?.(lastError);
+		if (options.signal?.aborted) {
+			lastError ??= /* @__PURE__ */ new Error(`readBoxPathWithRetry: aborted before reading ${JSON.stringify(path)}`);
+			break;
+		}
+		try {
+			return {
+				succeeded: true,
+				text: await read(path)
+			};
+		} catch (err) {
+			lastError = err;
+			if (attempt < attempts && options.delayMs > 0) await sleep(options.delayMs * attempt, options.signal);
+		}
+	}
+	return {
+		succeeded: false,
+		error: lastError
+	};
+}
+//#endregion
 //#region src/runtime/sandbox-run.ts
 /**
 * Thrown when a turn is aborted/timed-out mid-settle. Carries the events drained
@@ -4358,21 +4403,16 @@ async function openSandboxRun(client, options, deliverable) {
 			events: collected
 		};
 		if (options.signal.aborted) throw new SandboxRunAbortError(collected);
-		let raw = "";
-		let readError;
-		const readAttempts = 4;
-		const readDelayMs = options.readRetryDelayMs ?? 1e3;
-		for (let attempt = 0; attempt < readAttempts; attempt += 1) {
-			if (options.signal.aborted) throw new SandboxRunAbortError(collected, readError);
-			try {
-				raw = await box.fs.read(deliverable.path);
-				readError = void 0;
-				break;
-			} catch (err) {
-				readError = err instanceof Error ? err.message : String(err);
-				if (attempt < readAttempts - 1 && readDelayMs > 0) await sleep(readDelayMs * (attempt + 1), options.signal);
+		const attempted = await readBoxPathWithRetry(box.fs.read.bind(box.fs), deliverable.path, {
+			attempts: 4,
+			delayMs: options.readRetryDelayMs ?? 1e3,
+			signal: options.signal,
+			beforeAttempt: (lastError) => {
+				if (options.signal.aborted) throw new SandboxRunAbortError(collected, boxReadErrorMessage(lastError));
 			}
-		}
+		});
+		const raw = attempted.succeeded ? attempted.text : "";
+		const readError = attempted.succeeded ? void 0 : boxReadErrorMessage(attempted.error);
 		return {
 			out: deliverable.fromArtifact(raw, collected),
 			events: collected,
@@ -5938,6 +5978,205 @@ function profileMaxTokens(profile) {
 	return value;
 }
 //#endregion
+//#region src/runtime/surface-diff.ts
+/**
+*
+* Settle-time surface-diff harvest — the read-back dual of the mount manifest.
+*
+* `RunProvenance.mounts` records what the caller placed INTO a run's workspace before the agent saw
+* it (instructions, skills, memory files — the profile surfaces the substrate materialized). This
+* module answers the reverse question at settle: **which of those mounted surfaces did the agent
+* itself change while working?** Harnesses mutate their own profile-adjacent surfaces as a matter of
+* course — a memory file appended to, an instructions file edited, a skill rewritten — and that
+* self-mutation is improvement-relevant evidence: an OBSERVED, session-scoped edit that may later be
+* lifted into the measured proposal pipeline (`proposeAgentImprovement`), never auto-promoted.
+*
+* The harvest is harness-agnostic by construction: it compares content hashes against the mount
+* manifest, so it needs no harness event format, no refinement protocol, and no knowledge of WHY a
+* surface changed. A harness that additionally reports structured self-edit events can enrich this
+* signal; nothing requires it to.
+*
+* The kernel never reads workspace contents itself — the caller supplies the read seam (a box
+* `fs.read`, a worktree read, a test double), mirroring how `recordMount` keeps mount hashing with
+* the byte owner. Reads return typed outcomes; a failed read is reported as an `unreadable` diff
+* carrying the error, never silently dropped.
+*
+* @experimental
+*/
+const sha256Hex = (bytes) => createHash("sha256").update(bytes).digest("hex");
+/** Contain a reader that violates its typed-outcome contract by THROWING: the module's law is that
+*  a failed read becomes an `unreadable` diff, so one bad path must not reject the whole harvest
+*  and silently drop every other diff. */
+const readOutcome = async (read, path) => {
+	try {
+		return await read(path);
+	} catch (err) {
+		return {
+			succeeded: false,
+			missing: false,
+			error: err instanceof Error ? err.message : String(err)
+		};
+	}
+};
+/** The collision/dedup key for a path: a leading `./` stripped, so `./AGENTS.md` (a mount
+*  recorder's form) and `AGENTS.md` (a file-tree enumeration's form) are one surface. Absolute vs
+*  relative cannot be reconciled here — keep those forms consistent between mounts and watches. */
+const pathKey = (p) => p.replace(/^\.\//, "");
+/**
+* Re-read every mounted (and watched) surface and report the ones whose settled state differs from
+* the manifest — modified, removed, or created. Unchanged surfaces and still-absent watched paths
+* produce no entry; reads run concurrently; output preserves record order, mounts before
+* watch-only paths. Mounts and watches sharing a path key are each collapsed to the LAST entry,
+* and a watched path that was also mounted compares against its mount (never reports `created`).
+*
+* The harvest takes no `AbortSignal`: it is pure fan-out over the read seam and waits on nothing
+* itself, so every cancellable moment belongs to the reader. Pass a signal to the reader instead
+* ({@link BoxSurfaceReaderOptions.signal}, or close over one in a custom {@link SurfaceReader}) —
+* that cuts the backoff waits, and the harvest still returns the diffs it did establish rather
+* than discarding settle-time evidence on a late cancellation.
+*/
+async function harvestSurfaceDiffs(options) {
+	const byPath = /* @__PURE__ */ new Map();
+	for (const entry of options.mounts) byPath.set(pathKey(entry.path), entry);
+	const watchByPath = /* @__PURE__ */ new Map();
+	for (const watched of options.watch ?? []) {
+		if (byPath.has(pathKey(watched.path))) continue;
+		watchByPath.set(pathKey(watched.path), watched);
+	}
+	const mountDiffs = await Promise.all([...byPath.values()].map(async (entry) => {
+		const outcome = await readOutcome(options.read, entry.path);
+		if (!outcome.succeeded) return outcome.missing ? {
+			path: entry.path,
+			status: "removed",
+			mountedSha256: entry.sha256,
+			source: entry.source
+		} : {
+			path: entry.path,
+			status: "unreadable",
+			mountedSha256: entry.sha256,
+			source: entry.source,
+			error: outcome.error
+		};
+		const settledSha256 = sha256Hex(outcome.value);
+		if (settledSha256 === entry.sha256.toLowerCase()) return void 0;
+		return {
+			path: entry.path,
+			status: "modified",
+			mountedSha256: entry.sha256,
+			source: entry.source,
+			settledSha256,
+			settledBytes: outcome.value.byteLength
+		};
+	}));
+	const watchDiffs = await Promise.all([...watchByPath.values()].map(async (watched) => {
+		const outcome = await readOutcome(options.read, watched.path);
+		if (!outcome.succeeded) {
+			if (outcome.missing) return void 0;
+			return {
+				path: watched.path,
+				status: "unreadable",
+				source: watched.source ?? "watched",
+				error: outcome.error
+			};
+		}
+		return {
+			path: watched.path,
+			status: "created",
+			source: watched.source ?? "watched",
+			settledSha256: sha256Hex(outcome.value),
+			settledBytes: outcome.value.byteLength
+		};
+	}));
+	return [...mountDiffs, ...watchDiffs].filter((d) => d !== void 0);
+}
+/**
+* A {@link SurfaceReader} over a sandbox box's filesystem — the same `box.fs.read` seam
+* `openSandboxRun` reads deliverables through, with the same transient-404 posture (bounded
+* retry). The box wire returns UTF-8 TEXT (the SDK's binary path is `download()`), which profile
+* surfaces are; hashes are computed over the UTF-8 encoding, and content the wire had to
+* lossy-decode (a U+FFFD replacement character) is reported `unreadable` rather than hashed as
+* mojibake. The SDK's not-found error is detected structurally (`err.name === 'NotFoundError'`)
+* and maps to `missing: true` — unless its `resourceType` names something other than a file/path
+* (the BOX or session being gone), which is a transport failure, not an absent surface.
+*/
+function boxSurfaceReader(box, options = {}) {
+	return async (path) => {
+		const result = await readBoxPathWithRetry(box.fs.read.bind(box.fs), path, {
+			attempts: options.attempts ?? 3,
+			delayMs: options.retryDelayMs ?? 250,
+			signal: options.signal
+		});
+		if (result.succeeded) {
+			if (result.text.includes("�")) return {
+				succeeded: false,
+				missing: false,
+				error: `boxSurfaceReader: content at ${JSON.stringify(path)} is not valid UTF-8 text (the box text wire lossy-decoded it); binary surfaces need a byte-faithful reader`
+			};
+			return {
+				succeeded: true,
+				value: new TextEncoder().encode(result.text)
+			};
+		}
+		const err = result.error;
+		const notFound = err instanceof Error && err.name === "NotFoundError";
+		const resourceType = err && typeof err === "object" && "resourceType" in err ? String(err.resourceType) : void 0;
+		const transportGone = resourceType !== void 0 && /sandbox|session/i.test(resourceType);
+		return {
+			succeeded: false,
+			missing: notFound && !transportGone,
+			error: err instanceof Error ? err.message : String(err)
+		};
+	};
+}
+/**
+* A {@link SurfaceReader} over the local filesystem, for worktree/local workers. Every path —
+* relative or absolute — must resolve INSIDE `root`: a path that escapes it (`../`, an absolute
+* path elsewhere) fails as a contained non-missing outcome rather than reading outside the
+* worktree, so a persisted or mistyped manifest path cannot turn the harvest into an
+* existence/hash oracle over the host filesystem. Containment is checked twice — once on the
+* lexical path, then again on the symlink-resolved path, because `readFile` follows a link and a
+* link planted inside the root would otherwise read host bytes through a contained-looking name.
+* Absence maps to `missing: true`; every other failure carries the error message.
+*/
+function fsSurfaceReader(root) {
+	const lexicalRoot = resolve(root);
+	let resolvedRoot;
+	const escapes = (candidate, boundary) => candidate !== boundary && !candidate.startsWith(boundary + sep);
+	const outside = (path, boundary) => ({
+		succeeded: false,
+		missing: false,
+		error: `fsSurfaceReader: path ${JSON.stringify(path)} resolves outside the reader root ${JSON.stringify(boundary)}`
+	});
+	return async (path) => {
+		const target = isAbsolute(path) ? resolve(path) : resolve(lexicalRoot, path);
+		if (escapes(target, lexicalRoot)) return outside(path, lexicalRoot);
+		try {
+			resolvedRoot ??= await realpath(lexicalRoot);
+		} catch (err) {
+			return {
+				succeeded: false,
+				missing: false,
+				error: `fsSurfaceReader: reader root ${JSON.stringify(lexicalRoot)} is unreadable (${err instanceof Error ? err.message : String(err)})`
+			};
+		}
+		try {
+			const resolvedTarget = await realpath(target);
+			if (escapes(resolvedTarget, resolvedRoot)) return outside(path, resolvedRoot);
+			return {
+				succeeded: true,
+				value: new Uint8Array(await readFile(resolvedTarget))
+			};
+		} catch (err) {
+			const code = err.code;
+			return {
+				succeeded: false,
+				missing: code === "ENOENT" || code === "ENOTDIR",
+				error: err instanceof Error ? err.message : String(err)
+			};
+		}
+	};
+}
+//#endregion
 //#region src/runtime/verifier-environment.ts
 const submitTool = {
 	type: "function",
@@ -6351,6 +6590,6 @@ function tail(s) {
 	return s.slice(-400);
 }
 //#endregion
-export { flatWidenGate as $, assertStrategyContract as A, defaultAuditorInstruction as At, startRetainedRun as B, secretEnvOfMcpServer as Bt, chatTransportExecutor as C, leaderboard as Ct, pickChampion as D, renderLeaderboardSvg as Dt, discriminatingMeans as E, renderLeaderboardMarkdown as Et, openSandboxRun as F, sanitizeMcpToolSchema as Ft, runPersonified as G, equalKOnCost as H, printBenchmarkReport as I, envKeyProvider as It, registerShape as J, builtinShapes as K, runBenchmark as L, mcpSecretEnvMetadataKey as Lt, strategyAuthorContract as M, connectStdioMcp as Mt, strategyAuthorSystemPrompt as N, materializeLocalMcp as Nt, runStrategyEvolution as O, renderPairwiseMarkdown as Ot, SandboxRunAbortError as P, createMcpEnvironment as Pt, fanout as Q, reconnectRetainedRun as R, resolveMcpServerLaunch as Rt, runCoderChecks as S, stopSentinel as St, createChatSessionStore as T, renderLeaderboardHtml as Tt, trajectoryReport as U, promotionGate as V, definePersona as W, InMemoryCorpus as X, FileCorpus as Y, renderCorpusToInstructions as Z, settledWorkerOut as _, loopDispatch as _t, localShell as a, widen as at, analyzeTrace as b, deterministicCompletion as bt, createVerifierEnvironment as c, createScopeAnalyst as ct, worktreeFanout as d, harvestCorpus as dt, loopUntil as et, EVIDENCE_MAX_CHARS as f, defineLeaderboard as ft, composeWorkerEvidence as g, loopCampaignDispatch as gt, closingWorkerNote as h, inlineSandboxClient as ht, jjWorkspace as i, verify as it, authorStrategy as j, McpSpawnFault as jt, selectChampion as k, auditIntent as kt, failuresAnalyst as l, registryScopeAnalyst as lt, VERIFY_TAIL_CHARS as m, localSandboxClient as mt, makeFinding$1 as n, pipeline as nt, runInWorkspace as o, assertTraceDerivedFindings as ot, NOTE_MAX_CHARS as p, resolveSandboxClient as pt, createShapeRegistry as q, gitWorkspace as r, selectValidWinner as rt, createWaterfallCollector as s, buildSteerContext as st, computeFindingId$1 as t, panel as tt, superviseSurface as u, inProcessSandboxClient as ut, copyUntrackedIntoClone as v, superviseDispatch as vt, chatWorkerSeam as w, pairwiseSignificance as wt, patchDelivered as x, sentinelCompletion as xt, withUntrackedArtifacts as y, completionAuthorizes as yt, recoverRetainedRun as z, resolveSecretEnv as zt };
+export { InMemoryCorpus as $, pickChampion as A, renderLeaderboardSvg as At, runBenchmark as B, mcpSecretEnvMetadataKey as Bt, analyzeTrace as C, deterministicCompletion as Ct, chatWorkerSeam as D, pairwiseSignificance as Dt, chatTransportExecutor as E, leaderboard as Et, strategyAuthorContract as F, connectStdioMcp as Ft, equalKOnCost as G, recoverRetainedRun as H, resolveSecretEnv as Ht, strategyAuthorSystemPrompt as I, materializeLocalMcp as It, runPersonified as J, trajectoryReport as K, SandboxRunAbortError as L, createMcpEnvironment as Lt, selectChampion as M, auditIntent as Mt, assertStrategyContract as N, defaultAuditorInstruction as Nt, createChatSessionStore as O, renderLeaderboardHtml as Ot, authorStrategy as P, McpSpawnFault as Pt, FileCorpus as Q, openSandboxRun as R, sanitizeMcpToolSchema as Rt, withUntrackedArtifacts as S, completionAuthorizes as St, runCoderChecks as T, stopSentinel as Tt, startRetainedRun as U, secretEnvOfMcpServer as Ut, reconnectRetainedRun as V, resolveMcpServerLaunch as Vt, promotionGate as W, createShapeRegistry as X, builtinShapes as Y, registerShape as Z, VERIFY_TAIL_CHARS as _, localSandboxClient as _t, localShell as a, pipeline as at, settledWorkerOut as b, loopDispatch as bt, createVerifierEnvironment as c, widen as ct, harvestSurfaceDiffs as d, createScopeAnalyst as dt, renderCorpusToInstructions as et, failuresAnalyst as f, registryScopeAnalyst as ft, NOTE_MAX_CHARS as g, resolveSandboxClient as gt, EVIDENCE_MAX_CHARS as h, defineLeaderboard as ht, jjWorkspace as i, panel as it, runStrategyEvolution as j, renderPairwiseMarkdown as jt, discriminatingMeans as k, renderLeaderboardMarkdown as kt, boxSurfaceReader as l, assertTraceDerivedFindings as lt, worktreeFanout as m, harvestCorpus as mt, makeFinding$1 as n, flatWidenGate as nt, runInWorkspace as o, selectValidWinner as ot, superviseSurface as p, inProcessSandboxClient as pt, definePersona as q, gitWorkspace as r, loopUntil as rt, createWaterfallCollector as s, verify as st, computeFindingId$1 as t, fanout as tt, fsSurfaceReader as u, buildSteerContext as ut, closingWorkerNote as v, inlineSandboxClient as vt, patchDelivered as w, sentinelCompletion as wt, copyUntrackedIntoClone as x, superviseDispatch as xt, composeWorkerEvidence as y, loopCampaignDispatch as yt, printBenchmarkReport as z, envKeyProvider as zt };
 
-//# sourceMappingURL=runtime-B6YK6v3I.js.map
+//# sourceMappingURL=runtime-DRr7g_2C.js.map