@tangle-network/agent-runtime 0.264.0 → 0.271.0

package/dist/{runtime-CUZC75EX.js → runtime-DVjIH1eo.js}

@@ -1,16 +1,16 @@
-import { $i as stringifySafe, A as settledToIteration, An as canonicalObservedModelParts, Bi as notifySandboxEventObserver, Cn as createSandboxLineage, Di as executableAgentSpecSnapshot, Dn as readPromptOptions, Ei as executableAgentProfileSnapshot, En as assertBoxlessPromptOptions, Et as insideCursorNamespace, Gi as chargedTokens, Ji as hasCompleteCacheBreakdown, Ki as cloneSpend, Nt as isTraceAnalysisStore, Oi as detachedFrozen, On as routerBrain, Qi as sleep, Rn as createPushTraceSource, Sn as runAgentRounds, Tt as InMemorySpawnJournal, Wi as addSpend, Yi as isAbortError, Zi as randomSuffix, ai as prepareJsonlAppend, bn as defaultSelectWinner, fa as armDeadlineTimer, gt as createExecutorRegistry, ht as createExecutor, ia as zeroSpend, kn as runBrainLoop, n as createSupervisor, oi as readCommittedJsonLines, or as contentAddress, si as writeAllBytes, ut as rollingDispatch, vt as createWorktreeCliExecutor, wn as probeSandboxCapabilities, wt as InMemoryResultBlobStore, y as withDriverExecutor } from "./supervisor-C26k7X5-.js";
+import { At as insideCursorNamespace, Dn as runAgentRounds, Dt as SpawnEventIndex, Et as InMemorySpawnJournal, Fn as canonicalObservedModelParts, Gn as unavailableSignalOfFailure, Gr as harnessInvocation, Ii as executableAgentProfileSnapshot, Kn as createPushTraceSource, Li as executableAgentSpecSnapshot, Lt as isTraceAnalysisStore, M as settledToIteration, Mn as readPromptOptions, Nn as routerBrain, On as createSandboxLineage, Ot as assertContentAddress, Pn as runBrainLoop, Ri as detachedFrozen, Rn as LEAF_CONTINUATION_TASK, Sa as armDeadlineTimer, Tn as defaultSelectWinner, Tt as InMemoryResultBlobStore, Un as sandboxClientAsProvider, Wn as unavailablePauseMs, Xi as notifySandboxEventObserver, _i as writeAllBytes, _t as createExecutorRegistry, aa as isAbortError, b as withDriverExecutor, ca as sleep, dt as rollingDispatch, ea as addSpend, gi as readCommittedJsonLines, gt as createExecutor, hi as prepareJsonlAppend, hr as contentAddress, ia as hasCompleteCacheBreakdown, jn as assertBoxlessPromptOptions, kn as probeSandboxCapabilities, kt as encodeResultBlob, la as stringifySafe, ma as zeroSpend, na as cloneSpend, r as createSupervisor, sa as randomSuffix, ta as chargedTokens, yt as createWorktreeCliExecutor, zi as detachedSnapshot } from "./supervisor-Cvd5mf7x.js";
 import { m as ValidationError, n as AnalystError, s as PlannerError } from "./errors-DodWX-cb.js";
-import { E as profileChatClient, S as ObservationError, T as renderReport, b as sample, k as strategyAuthorMethod, v as refine, w as observe, x as sampleThenRefine, y as runAgentic } from "./structural-rollout-D17I5CwF.js";
-import { c as profileModelExecutionSettings, i as concreteModelId, l as profileProviderModel, o as enforceTokenLimits, t as assertExecutableAgentProfile } from "./model-policy-BbSCSak0.js";
+import { E as profileChatClient, S as ObservationError, T as renderReport, b as sample, k as strategyAuthorMethod, v as refine, w as observe, x as sampleThenRefine, y as runAgentic } from "./structural-rollout-I92sIfNl.js";
+import { a as concreteProfileModel, c as profileModelExecutionSettings, i as concreteModelId, l as profileProviderModel, o as enforceTokenLimits, t as assertExecutableAgentProfile } from "./model-policy-BbSCSak0.js";
 import { C as canonicalCandidateDigest$1, D as immutableCandidateValue, k as sha256Bytes$1, m as captureMaterializedWorkspace } from "./workspace-archive-C9lgf77y.js";
 import { i as notifyRuntimeHookEvent } from "./runtime-hooks-tXpAarhW.js";
 import { i as redactProtectedValue, r as redactProtectedReason } from "./protected-redaction--F3v1oo8.js";
-import { C as gateOnDeliverable, r as supervise, w as mapExecutorResult } from "./supervise-_DTVHXPC.js";
-import "./coordination-driver-Bz-H17bC.js";
+import "./coordination-driver-iBGMKDvB.js";
+import { C as gateOnDeliverable, r as supervise, w as mapExecutorResult } from "./supervise-DJ_1i9vj.js";
 import "./run-layout-vwd4SwX_.js";
-import "./provision-supervisor-BZ6_uBGR.js";
-import "./delegate-CwbWhX5W.js";
-import "./graph-5NrpTg0h.js";
+import "./provision-supervisor-Cy8pqE95.js";
+import "./delegate-DOqUvaIz.js";
+import "./graph-DnMcepkN.js";
 import { agentProfileSchema, canonicalAgentProfileDigest, canonicalCandidateDigest, validateAgentProfileSecurity } from "@tangle-network/agent-interface";
 import { CODING_HARNESSES, DEFAULT_TRACE_ANALYST_KINDS, InMemoryTraceStore, OUTPUT_VALUE, benjaminiHochberg, buildTrajectory, computeFindingId as computeFindingId$1, confidenceInterval, createTraceAnalyst, expandProfileAxes, makeFinding as makeFinding$1, pairedBootstrap, paretoFrontier, wilcoxonSignedRank, wilson } from "@tangle-network/agent-eval";
 import { createAgentRunOutcomeTracker } from "@tangle-network/sandbox/runtime";
@@ -19,11 +19,13 @@ import { execFile, execFileSync, spawn, spawnSync } 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 { cp, mkdir, mkdtemp, readFile, realpath, stat, writeFile } from "node:fs/promises";
+import { materializeProfile } from "@tangle-network/agent-profile-materialize";
 import { tmpdir } from "node:os";
 import { isDeepStrictEqual, promisify } from "node:util";
 import { collectAgentResponseText } from "@tangle-network/sandbox";
 import { heldoutSignificance, runProfileMatrix } from "@tangle-network/agent-eval/campaign";
 import { createInterface } from "node:readline";
+import { harnessSystemPromptIntents as harnessSystemPromptIntents$1 } from "@tangle-network/agent-interface/harness-capabilities";
 import { pathToFileURL } from "node:url";
 import { gzipSync } from "node:zlib";
 import { createContext, runInContext } from "node:vm";
@@ -846,6 +848,173 @@ async function materializeLocalMcp(profile, opts = {}) {
 	};
 }
 //#endregion
+//#region src/durable/spawn-journal-sql.ts
+/**
+* SQL-backed durable stores for supervised runs — `SqlSpawnJournal` and `SqlResultBlobStore`
+* over the same minimal statement seam `SqlConversationJournal` uses (D1, postgres, sqlite,
+* libSQL; positional `?` placeholders). This closes the orchestration-durability gap recorded in
+* `conformance/durability/STATUS.md`: until now the spawn layer was file-only.
+*
+* Parity with the JSONL file stores, by construction:
+*   • same corruption guards — `beginTree` precedes events (enforced by the schema: an event row
+*     names a tree row), duplicate cursor seqs and duplicate materialization receipts are refused
+*     by the same `SpawnEventIndex` the file journal replays through, on both append and load;
+*   • same content-address law for blobs — a `put` whose ref does not hash to the artifact is
+*     refused, a re-put of the same ref asserts the identical bytes;
+*   • load order is insertion order (`INTEGER PRIMARY KEY AUTOINCREMENT`), the SQL analogue of
+*     the JSONL append-only spine.
+*
+* Durability note: this suite and its process-kill test run against `node:sqlite`, whose
+* autocommit commits survive SIGKILL (process death, not OS crash). A deployment that must
+* survive power loss sets its driver's synchronous mode (`PRAGMA synchronous=FULL` + WAL) at the
+* adapter; agent-runtime takes no opinion.
+*
+* @experimental — draft: cross-process ownership is single-writer by convention (the same
+* limitation `createFileRunContext` documents); a machine-visible ownership lease is follow-up.
+*/
+const TREES_DDL = (table) => `
+  CREATE TABLE IF NOT EXISTS ${table}_trees (
+    root TEXT PRIMARY KEY,
+    begun_at TEXT NOT NULL
+  )
+`;
+const EVENTS_DDL = (table) => `
+  CREATE TABLE IF NOT EXISTS ${table}_events (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    root TEXT NOT NULL REFERENCES ${table}_trees (root),
+    body TEXT NOT NULL
+  )
+`;
+const BLOBS_DDL = (table) => `
+  CREATE TABLE IF NOT EXISTS ${table}_blobs (
+    ref TEXT PRIMARY KEY,
+    body TEXT NOT NULL
+  )
+`;
+/** SQL-backed `SpawnJournal`. One row per event; insertion order is replay order. */
+var SqlSpawnJournal = class {
+	db;
+	table;
+	cache = /* @__PURE__ */ new Map();
+	appendTail = Promise.resolve();
+	constructor(db, table = "runtime_spawn_journal") {
+		this.db = db;
+		this.table = table;
+	}
+	/** Create the journal's tables if absent. Idempotent. */
+	async migrate() {
+		await this.db.exec(TREES_DDL(this.table));
+		await this.db.exec(EVENTS_DDL(this.table));
+	}
+	async loadTree(root) {
+		if ((await this.db.query(`SELECT begun_at FROM ${this.table}_trees WHERE root = ?`, [root])).length === 0) return void 0;
+		const rows = await this.db.query(`SELECT id, body FROM ${this.table}_events WHERE root = ? ORDER BY id`, [root]);
+		const index = new SpawnEventIndex(root);
+		const events = [];
+		for (const row of rows) {
+			const event = JSON.parse(row.body);
+			index.assert(event);
+			index.add(event);
+			events.push(event);
+		}
+		return events;
+	}
+	async beginTree(root, at) {
+		return this.serializeAppend(async () => {
+			await this.ensureMigrated();
+			const existing = await this.db.query(`SELECT begun_at FROM ${this.table}_trees WHERE root = ?`, [root]);
+			if (existing.length > 0) {
+				const begunAt = existing[0]?.begun_at;
+				if (begunAt !== at) throw new Error(`spawn tree '${root}' already begun in SQL at ${begunAt}; refusing to overwrite with ${at}`);
+				return;
+			}
+			await this.db.exec(`INSERT INTO ${this.table}_trees (root, begun_at) VALUES (?, ?)`, [root, at]);
+			this.cache.set(root, {
+				maxId: 0,
+				index: new SpawnEventIndex(root)
+			});
+		});
+	}
+	async appendEvent(root, ev) {
+		const event = detachedSnapshot(ev, "spawn event");
+		return this.serializeAppend(async () => {
+			await this.ensureMigrated();
+			const state = await this.validationIndex(root);
+			state.index.assert(event);
+			if ((await this.db.exec(`INSERT INTO ${this.table}_events (root, body) VALUES (?, ?)`, [root, JSON.stringify(event)])).rowsAffected !== 1) throw new Error(`spawn journal SQL: append of an event for tree '${root}' affected no rows`);
+			state.index.add(event);
+			state.maxId = await this.maxEventId(root);
+		});
+	}
+	async validationIndex(root) {
+		if ((await this.db.query(`SELECT begun_at FROM ${this.table}_trees WHERE root = ?`, [root])).length === 0) throw new Error(`appendEvent called for unknown spawn tree '${root}'; call beginTree first`);
+		const max = await this.maxEventId(root);
+		const cached = this.cache.get(root);
+		if (cached && cached.maxId === max) return cached;
+		const index = new SpawnEventIndex(root);
+		if (max > 0) {
+			const rows = await this.db.query(`SELECT body FROM ${this.table}_events WHERE root = ? ORDER BY id`, [root]);
+			for (const row of rows) {
+				const event = JSON.parse(row.body);
+				index.assert(event);
+				index.add(event);
+			}
+		}
+		const state = {
+			maxId: max,
+			index
+		};
+		this.cache.set(root, state);
+		return state;
+	}
+	async maxEventId(root) {
+		return (await this.db.query(`SELECT MAX(id) AS max FROM ${this.table}_events WHERE root = ?`, [root]))[0]?.max ?? 0;
+	}
+	migrated = false;
+	async ensureMigrated() {
+		if (this.migrated) return;
+		await this.migrate();
+		this.migrated = true;
+	}
+	serializeAppend(operation) {
+		const append = this.appendTail.then(operation);
+		this.appendTail = append.catch(() => void 0);
+		return append;
+	}
+};
+/** SQL-backed `ResultBlobStore`. One content-addressed row per settled result. */
+var SqlResultBlobStore = class {
+	db;
+	table;
+	migrated = false;
+	constructor(db, table = "runtime_result_blobs") {
+		this.db = db;
+		this.table = table;
+	}
+	async migrate() {
+		await this.db.exec(BLOBS_DDL(this.table));
+	}
+	async put(outRef, artifact) {
+		await this.ensureMigrated();
+		const { text } = encodeResultBlob(outRef, artifact);
+		if ((await this.db.exec(`INSERT OR IGNORE INTO ${this.table}_blobs (ref, body) VALUES (?, ?)`, [outRef, text])).rowsAffected === 1) return;
+		assertContentAddress(outRef, await this.get(outRef));
+	}
+	async get(outRef) {
+		await this.ensureMigrated();
+		const rows = await this.db.query(`SELECT body FROM ${this.table}_blobs WHERE ref = ?`, [outRef]);
+		if (rows.length === 0) return void 0;
+		const artifact = JSON.parse(rows[0]?.body ?? "null");
+		assertContentAddress(outRef, artifact);
+		return artifact;
+	}
+	async ensureMigrated() {
+		if (this.migrated) return;
+		await this.migrate();
+		this.migrated = true;
+	}
+};
+//#endregion
 //#region src/runtime/audit-intent.ts
 /** Default system instruction for intent-auditor agents: diagnose diverged/drifting trajectories. */
 const defaultAuditorInstruction = "You audit whether an AI agent is on the RIGHT ROUTE — not whether it works hard, but whether its actions serve the stated intents. Infer the REVEALED intent from the action pattern (what the trajectory is actually optimizing). Compare against the declared task intent, the user intent when given, and the meta-intent when given. Flawless execution down the wrong route is DIVERGED. Busy-work that neither advances nor harms is DRIFTING. Judge only from the trajectory — be specific about which actions ground your verdict. Recommend abort only when continuing cannot serve the intent.";
@@ -3192,7 +3361,7 @@ function fanout(items, opts) {
 					if (res.ok) opened += 1;
 					else rejected.push(`${unit.opts.label}: not admitted (${res.reason})`);
 				}
-				drained = opened === 0 ? emptyRound() : await drain(scope);
+				drained = opened === 0 ? emptyRound() : await drain$1(scope);
 			}
 			if (opened === 0) return blocked(rejected.length > 0 ? rejected : ["fanout: budget admitted no item (fanout fully rejected)"]);
 			if (drained.done.length === 0) return blocked(orderedBlockers(drained.blockers, rejected, "fanout: every item settled without a usable result"));
@@ -3454,7 +3623,7 @@ function splitOnce(text, sep) {
 	if (at < 0) return [text, ""];
 	return [text.slice(0, at), text.slice(at + sep.length)];
 }
-async function drain(scope) {
+async function drain$1(scope) {
 	const iterations = [];
 	const done = [];
 	const blockers = [];
@@ -3894,7 +4063,7 @@ async function runPersonified(options) {
 		executors,
 		...options.rootIdentity !== void 0 ? { rootIdentity: options.rootIdentity } : {},
 		...options.maxDepth !== void 0 ? { maxDepth: options.maxDepth } : {},
-		...options.maxLiveWorkers !== void 0 ? { maxLiveWorkers: options.maxLiveWorkers } : {},
+		...options.workerSlots !== void 0 ? { workerSlots: options.workerSlots } : {},
 		...options.maxRestarts !== void 0 ? { maxRestarts: options.maxRestarts } : {},
 		...options.withinMs !== void 0 ? { withinMs: options.withinMs } : {},
 		...options.teardownConfirmMs !== void 0 ? { teardownConfirmMs: options.teardownConfirmMs } : {},
@@ -4731,7 +4900,7 @@ async function openSandboxRun(client, options, deliverable) {
 			eventTypes: eventTypeCounts(result.events),
 			...result.readError !== void 0 ? { readError: result.readError } : {}
 		} : {},
-		...error !== void 0 ? { error: errorMessage(error) } : {}
+		...error !== void 0 ? { error: errorMessage$1(error) } : {}
 	});
 	async function settle(box, events, turnIndex, turnKind) {
 		const collected = [];
@@ -4839,7 +5008,7 @@ async function openSandboxRun(client, options, deliverable) {
 					payload: {
 						...runPayload(),
 						turnCount,
-						error: errorMessage(error)
+						error: errorMessage$1(error)
 					}
 				});
 				throw error;
@@ -4883,7 +5052,7 @@ async function openSandboxRun(client, options, deliverable) {
 					payload: {
 						...runPayload(),
 						turnCount,
-						error: errorMessage(error)
+						error: errorMessage$1(error)
 					}
 				});
 				throw error;
@@ -4921,10 +5090,958 @@ function hashText(value) {
 	}
 	return (hash >>> 0).toString(16).padStart(8, "0");
 }
-function errorMessage(error) {
+function errorMessage$1(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 //#endregion
+//#region src/runtime/shared-box.ts
+/**
+* Shared-box placement: many harness workers in one Sandbox box, each as its own process.
+*
+* The default provider placement gives every worker its own Sandbox box. A box costs a create
+* call, a sidecar, an egress proxy, a preview link and a memory reservation sized for the box,
+* while one opencode worker uses about half a gigabyte. This module packs workers into a small
+* pool of boxes instead. Each worker runs `opencode run` as a separate process with its own
+* working directory and its own HOME, so each worker has its own harness session, its own
+* materialized profile and its own transcript files.
+*
+* Why processes and not sidecar sessions: the sidecar serves every session in one box from one
+* workspace and writes each session's profile into the same files. Measured 2026-09-24 on
+* sandbox-ff52a989e7c9: eight concurrent sessions with different instructions, and seven of eight
+* answered with another session's instructions. A process with its own directory, its own HOME and
+* `OPENCODE_DISABLE_PROJECT_CONFIG` reads only its own configuration: sixteen of sixteen concurrent
+* workers answered with their own instructions and wrote only into their own directory.
+*
+* The boundary is cooperative, not a security boundary. Every worker runs as the same Linux user,
+* so a worker can read a co-tenant's files through its shell. A profile that writes a repository,
+* runs untrusted code, holds a credential of its own, or must stay blind to its siblings keeps a
+* dedicated box: {@link SharedBoxPlacement.refusal} names the profile features this placement
+* cannot carry, and Runtime then uses the dedicated provider.
+*
+* A worker whose model provider refuses a turn for capacity keeps its process's session and
+* directory, pauses by the driver's rule, and continues the same opencode session, the way a
+* dedicated leaf does (`ProviderExecutorOptions.unavailablePause`). Measured 2026-09-24: 15 of 23
+* down children of play anomaly-referee-v3d ended on `provider_quota_exhausted`, and opencode
+* itself gives up on a refused model after about 70 seconds of its own retries.
+*
+* The workers of one box share the box's router key. Each worker names itself to the router with
+* the `x-tangle-client` header, which the router stores as `clientName` on every usage row, so a
+* keeper can price one worker from the key's per-client rows (`tangle-admin router-spend --key
+* <box key>`). A request without the header stays charged to the box.
+*
+* `workersPerBox` is the one structural cap, and it protects the box. A Tangle box has a fixed
+* 512-task pids limit. An idle box uses about 118 tasks and one opencode worker about 34, so
+* twelve workers reach the limit. At that limit the sidecar's own process spawn fails with EAGAIN
+* and the sidecar restarts, which ends every worker in the box (measured on the same box: 28
+* workers crashed the sidecar twice; 16 workers crashed it once).
+*/
+/**
+* The most workers one default box carries at once.
+*
+* It keeps a worker count that the 512-task pids limit of a Tangle box can hold with headroom
+* for the sidecar's own processes and the workers' tool shells: 118 idle tasks plus 8 workers at
+* about 34 tasks each is 390. Memory is not the binding limit: 8 workers used about 4 GB in a
+* 16 GB box. Raise it only for a box whose pids limit was raised with it.
+*/
+const DEFAULT_SHARED_BOX_WORKERS = 8;
+/** The box shape the default placement creates: memory for 8 workers at about 0.5 GB each plus
+*  the sidecar, and 4 cores, because the workers wait on the model most of the time. */
+const DEFAULT_SHARED_BOX_RESOURCES = Object.freeze({
+	cpuCores: 4,
+	memoryMB: 8192
+});
+const DEFAULT_WORKER_ROOT = "/home/agent/workers";
+const HARNESS = "opencode";
+const SHARED_PROVIDER_NAME = "tangle-shared-box";
+const DEFAULT_EXEC_TIMEOUT_MS = 12e4;
+/** The request header the router records as a usage row's `clientName`. */
+const ROUTER_CLIENT_HEADER = "x-tangle-client";
+/**
+* The router client name of the worker that runs supervised node `nodeId`.
+*
+* The node id is already in the spawn journal, so a keeper joins a router row to a node without
+* a new record: the row whose `clientName` is `agent-runtime-node/<nodeId>` is that node's spend.
+*/
+function sharedWorkerClientName(nodeId) {
+	if (!/^[!-~]+$/u.test(nodeId)) throw new ValidationError("sharedWorkerClientName: a node id must be visible ASCII");
+	return `agent-runtime-node/${nodeId}`;
+}
+/**
+* Attempts for one Sandbox API call that failed on the way to the box.
+*
+* Every call re-verifies the API key with the platform, and a burst of workers makes that check
+* time out: 8 of 64 workers failed with `502 platform_unavailable` (reason `platform_timeout`) in
+* one burst on 2026-09-24, and 3 more lost their transcript enumeration the same way. The check
+* refuses the request before it reaches the box, so repeating it is safe; five attempts over about
+* fifteen seconds rode out every such failure measured.
+*/
+const TRANSIENT_ATTEMPTS = 5;
+const TRANSIENT_BASE_DELAY_MS = 1e3;
+/** A failure that a repeated request can change: the platform, the gateway or the network. */
+function isTransientSandboxFailure(error) {
+	if (error === null || typeof error !== "object") return false;
+	const record = error;
+	if (typeof record.status === "number" && [
+		408,
+		425,
+		429,
+		500,
+		502,
+		503,
+		504
+	].includes(record.status)) return true;
+	const text = `${String(record.code ?? "")} ${String(record.name ?? "")} ${String(record.message ?? "")}`;
+	return /platform_unavailable|platform_timeout|platform_unreachable|fetch failed|ECONNRESET|ETIMEDOUT|EAI_AGAIN|socket hang up|UND_ERR|bad gateway|gateway timeout/iu.test(text);
+}
+async function transientRetry(operation, options = {}) {
+	const delayMs = options.delayMs ?? TRANSIENT_BASE_DELAY_MS;
+	for (let attempt = 1;; attempt += 1) try {
+		return await operation(attempt);
+	} catch (error) {
+		if (attempt >= TRANSIENT_ATTEMPTS || !isTransientSandboxFailure(error)) throw error;
+		options.signal?.throwIfAborted();
+		await sleep(delayMs * 2 ** (attempt - 1), options.signal);
+	}
+}
+/**
+* Why a shared box cannot carry `profile`, or `undefined` when it can.
+*
+* A shared box carries a profile whose whole behavior reaches an opencode process through its own
+* working directory, its own configuration and the box's own model credential. Everything else
+* keeps a dedicated box: another harness, a model the box credential cannot reach, a replaced
+* system prompt, MCP servers, connections, hooks, subagents, extensions, tool grants, and any
+* resource the materializer does not lower into the worker's directory.
+*/
+function sharedBoxRefusal(profile) {
+	if (profile.harness !== HARNESS) return `harness ${String(profile.harness)} is not ${HARNESS}`;
+	if (concreteProfileModel(profile) === void 0) return "profile names no concrete model";
+	if (profile.model?.provider === void 0) return "profile names no model provider";
+	if (profile.model?.reasoningEffort !== void 0) {
+		if (tryInvocation(profile) === void 0) return "model.reasoningEffort has no opencode variant";
+	}
+	if (profile.prompt?.systemPrompt !== void 0) return "prompt.systemPrompt replaces a system prompt";
+	for (const field of [
+		"mcp",
+		"connections",
+		"hooks",
+		"subagents",
+		"extensions",
+		"confidential",
+		"modes"
+	]) if (profile[field] !== void 0) return `profile declares ${field}`;
+	if (profile.tools !== void 0 && Object.keys(profile.tools).length > 0) return "profile grants tools";
+	const resources = profile.resources;
+	if (resources !== void 0) {
+		for (const field of [
+			"skills",
+			"agents",
+			"commands",
+			"tools"
+		]) if (resources[field] !== void 0) return `profile declares resources.${field}`;
+		for (const file of resources.files ?? []) if (file.resource.kind !== "inline") return `resource file ${file.path} is not inline`;
+		if (resources.instructions !== void 0 && typeof resources.instructions !== "string" && resources.instructions.kind !== "inline") return "resources.instructions is not inline";
+	}
+	let plan;
+	try {
+		plan = materializeProfile(profile, HARNESS);
+	} catch (error) {
+		return `opencode materialization failed: ${error instanceof Error ? error.message : String(error)}`;
+	}
+	if (plan.unsupported.length > 0) return `opencode cannot carry ${plan.unsupported.map((row) => row.dimension).join(", ")}`;
+	if (Object.keys(plan.env).length > 0 || plan.flags.length > 0) return "profile needs launch environment or flags";
+	for (const file of plan.files) {
+		if (file.root === "agent") return `profile writes ${file.relPath} into the harness home`;
+		if ((file.secretSlots?.length ?? 0) > 0) return `profile file ${file.relPath} carries a secret`;
+		if (isUnsafeRelativePath(file.relPath)) return `profile file ${file.relPath} leaves its directory`;
+	}
+}
+function tryInvocation(profile) {
+	try {
+		return harnessInvocation(HARNESS, invocationProfile(profile), "probe").args;
+	} catch {
+		return;
+	}
+}
+/**
+* The profile the invocation table reads. The prompt reaches opencode through its configuration
+* and the model through the provider this placement declares, so only the reasoning effort is
+* left for the table to lower into `--variant`.
+*/
+function invocationProfile(profile) {
+	const { prompt: _prompt, model, ...rest } = profile;
+	return {
+		...rest,
+		...model?.reasoningEffort === void 0 ? {} : { model: { reasoningEffort: model.reasoningEffort } }
+	};
+}
+function isUnsafeRelativePath(path) {
+	return path.length === 0 || path.startsWith("/") || path.split("/").some((segment) => segment === ".." || segment === "");
+}
+/**
+* Place accepted workers as processes in a pool of shared Sandbox boxes.
+*
+* The pool fills a box before it creates the next one and deletes a box when its last worker
+* releases it. Runtime reaches this placement through `createExecutor({ backend: 'provider',
+* shared })`: a profile that {@link SharedBoxPlacement.refusal} accepts runs here, and every other
+* profile keeps the dedicated provider.
+*/
+function sharedBoxPlacement(options) {
+	const workersPerBox = options.workersPerBox ?? 8;
+	if (!Number.isSafeInteger(workersPerBox) || workersPerBox < 1) throw new ValidationError("sharedBoxPlacement: workersPerBox must be a positive integer");
+	const workerRoot = options.workerRoot ?? DEFAULT_WORKER_ROOT;
+	if (!workerRoot.startsWith("/") || isUnsafeRelativePath(workerRoot.slice(1))) throw new ValidationError("sharedBoxPlacement: workerRoot must be an absolute, normalized path");
+	const boxOptions = {
+		resources: { ...DEFAULT_SHARED_BOX_RESOURCES },
+		...options.box ?? {}
+	};
+	if (boxOptions.backend !== void 0) throw new ValidationError("sharedBoxPlacement: box.backend is owned by Runtime");
+	const identity = {
+		id: "shared-box",
+		digest: canonicalCandidateDigest({
+			kind: "shared-box-placement.v1",
+			harness: HARNESS,
+			workersPerBox,
+			workerRoot,
+			box: publicBoxOptions(boxOptions)
+		})
+	};
+	const retryDelayMs = options.retryDelayMs ?? TRANSIENT_BASE_DELAY_MS;
+	const pool = createBoxPool(options.client, boxOptions, workersPerBox, retryDelayMs);
+	const providerFor = (worker = {}) => {
+		const clientName = worker.nodeId === void 0 ? void 0 : sharedWorkerClientName(worker.nodeId);
+		return sandboxClientAsProvider({ async create(createOptions) {
+			const profile = workerProfile(createOptions);
+			const refusal = sharedBoxRefusal(profile);
+			if (refusal !== void 0) throw new ValidationError(`sharedBoxPlacement: ${refusal}`);
+			assertWorkerCreateOptions(createOptions);
+			const lease = await pool.acquire();
+			try {
+				return await createWorker(lease, workerRoot, profile, {
+					retryDelayMs,
+					clientName,
+					unavailablePause: options.unavailablePause ?? {}
+				});
+			} catch (error) {
+				await lease.release();
+				throw error;
+			}
+		} }, {
+			name: SHARED_PROVIDER_NAME,
+			capabilities: sharedBoxCapabilities()
+		});
+	};
+	return {
+		providerFor,
+		identity,
+		refusal: sharedBoxRefusal,
+		stats: () => pool.stats(),
+		close: () => pool.close()
+	};
+}
+function publicBoxOptions(box) {
+	const { env, secrets, ...rest } = box;
+	return {
+		...rest,
+		...env === void 0 ? {} : { environmentVariableNames: Object.keys(env).sort() },
+		...secrets === void 0 ? {} : { secrets }
+	};
+}
+function sharedBoxCapabilities() {
+	return {
+		profile: {
+			namedProfiles: false,
+			systemPrompt: {
+				...harnessSystemPromptIntents$1(HARNESS),
+				replace: false
+			},
+			instructions: true,
+			tools: false,
+			permissions: true,
+			mcp: false,
+			subagents: false,
+			resources: {
+				files: true,
+				instructions: true
+			},
+			runtimeUpdate: false,
+			validation: false
+		},
+		streaming: {
+			live: true,
+			replay: false,
+			detach: false,
+			turnIdempotency: false
+		},
+		sessions: {
+			continue: false,
+			list: false,
+			messages: false
+		},
+		workspace: {
+			read: true,
+			write: true,
+			exec: true,
+			git: false,
+			upload: false,
+			download: false
+		},
+		branching: {
+			checkpoint: false,
+			fork: false
+		},
+		placement: true,
+		usage: true,
+		confidential: false
+	};
+}
+function workerProfile(createOptions) {
+	const raw = (createOptions?.backend)?.profile;
+	const parsed = agentProfileSchema.safeParse(raw);
+	if (!parsed.success) throw new ValidationError("sharedBoxPlacement: an exact AgentProfile is required at create");
+	return parsed.data;
+}
+/**
+* A worker create carries only what a slot in a shared box can honor. Box-level settings belong
+* to the placement's own box options, and a per-worker request for them is refused rather than
+* dropped: a worker that asked for an environment variable, a repository or its own resources
+* would otherwise run without them and report nothing.
+*/
+function assertWorkerCreateOptions(createOptions) {
+	const options = createOptions ?? {};
+	for (const key of [
+		"git",
+		"fromSnapshot",
+		"fromSandboxId",
+		"environment",
+		"cwd",
+		"resources"
+	]) if (options[key] !== void 0) throw new ValidationError(`sharedBoxPlacement: a shared worker cannot set ${key}`);
+	const env = options.env;
+	if (env !== void 0 && Object.keys(env).length > 0) throw new ValidationError("sharedBoxPlacement: a shared worker cannot set env");
+	const secrets = options.secrets;
+	if (Array.isArray(secrets) && secrets.length > 0) throw new ValidationError("sharedBoxPlacement: a shared worker cannot request secrets");
+	const backend = options.backend;
+	if (backend?.runtimeAttachments !== void 0) throw new ValidationError("sharedBoxPlacement: a shared worker cannot carry runtime attachments");
+	if (backend?.type !== void 0 && backend.type !== HARNESS) throw new ValidationError(`sharedBoxPlacement: backend ${String(backend.type)} is not ${HARNESS}`);
+}
+function createBoxPool(client, boxOptions, workersPerBox, retryDelayMs) {
+	const poolId = randomUUID();
+	const boxes = [];
+	const history = [];
+	let seq = 0;
+	let placed = 0;
+	let peak = 0;
+	let closing = false;
+	const retire = async (entry) => {
+		if (entry.retired) return void 0;
+		entry.retired = true;
+		const index = boxes.indexOf(entry);
+		if (index >= 0) boxes.splice(index, 1);
+		let handle;
+		try {
+			handle = await entry.ready;
+		} catch {
+			return;
+		}
+		try {
+			await transientRetry(() => handle.delete(), { delayMs: retryDelayMs });
+			entry.deleted = true;
+			return {
+				boxId: handle.id,
+				deleted: true
+			};
+		} catch (error) {
+			return {
+				boxId: handle.id,
+				deleted: false,
+				error: error instanceof Error ? error.message : String(error)
+			};
+		}
+	};
+	return {
+		async acquire() {
+			if (closing) throw new ValidationError("sharedBoxPlacement: the placement is closed");
+			let entry = boxes.find((candidate) => !candidate.retired && candidate.workers < workersPerBox);
+			if (entry === void 0) {
+				const boxSeq = seq++;
+				const request = {
+					...boxOptions,
+					name: boxOptions.name ?? `shared-box-${poolId.slice(0, 8)}-${boxSeq}`,
+					idempotencyKey: `shared-box-${poolId}-${boxSeq}`,
+					backend: {
+						type: HARNESS,
+						profile: {
+							name: "shared-box",
+							harness: HARNESS
+						}
+					}
+				};
+				const requestedAt = Date.now();
+				const created = {
+					seq: boxSeq,
+					ready: transientRetry(() => client.create(request), { delayMs: retryDelayMs }).then((box) => box),
+					workers: 0,
+					served: 0,
+					retired: false,
+					deleted: false
+				};
+				created.ready.then((box) => {
+					created.id = box.id;
+					created.createMs = Date.now() - requestedAt;
+				}, () => {
+					const index = boxes.indexOf(created);
+					if (index >= 0) boxes.splice(index, 1);
+					created.retired = true;
+				});
+				boxes.push(created);
+				history.push(created);
+				entry = created;
+			}
+			const leased = entry;
+			leased.workers += 1;
+			leased.served += 1;
+			placed += 1;
+			peak = Math.max(peak, leased.workers);
+			let box;
+			try {
+				box = await leased.ready;
+			} catch (error) {
+				leased.workers -= 1;
+				throw error;
+			}
+			let released = false;
+			return {
+				box,
+				async release() {
+					if (released) return;
+					released = true;
+					leased.workers -= 1;
+					if (leased.workers === 0 && !closing) await retire(leased);
+				}
+			};
+		},
+		stats() {
+			return {
+				boxesCreated: history.length,
+				boxesLive: history.filter((entry) => !entry.retired).length,
+				workersPlaced: placed,
+				workersLive: history.reduce((sum, entry) => sum + entry.workers, 0),
+				peakWorkersPerBox: peak,
+				boxes: history.filter((entry) => entry.id !== void 0).map((entry) => ({
+					id: entry.id,
+					workersServed: entry.served,
+					deleted: entry.deleted,
+					createMs: entry.createMs ?? 0
+				}))
+			};
+		},
+		async close() {
+			closing = true;
+			return (await Promise.all(history.map((entry) => retire(entry)))).filter((receipt) => receipt !== void 0);
+		}
+	};
+}
+/** The environment one worker's processes see: its own directory, HOME and XDG roots. */
+function workerEnv(paths) {
+	return [
+		"OPENCODE_DISABLE_PROJECT_CONFIG=1",
+		`OPENCODE_CONFIG_DIR=${paths.dir}/.opencode`,
+		`PWD=${paths.dir}`,
+		`HOME=${paths.home}`,
+		`XDG_DATA_HOME=${paths.home}/.local/share`,
+		`XDG_CONFIG_HOME=${paths.home}/.config`,
+		`XDG_STATE_HOME=${paths.home}/.local/state`,
+		`XDG_CACHE_HOME=${paths.cache}`
+	];
+}
+async function createWorker(lease, root, createProfile, placement) {
+	const { clientName, unavailablePause } = placement;
+	const box = resilientBox(lease.box, placement.retryDelayMs);
+	const workerId = `w-${randomUUID()}`;
+	const paths = {
+		dir: `${root}/${workerId}`,
+		home: `${root}/${workerId}/.home`,
+		cache: `${root}/.cache`
+	};
+	const made = await box.exec(`mkdir -p '${paths.home}' '${paths.cache}'`, { timeoutMs: DEFAULT_EXEC_TIMEOUT_MS });
+	if ((made.exitCode ?? 1) !== 0) throw new Error(`sharedBoxPlacement: could not create ${paths.dir}: ${made.stderr ?? ""}`);
+	const env = workerEnv(paths);
+	let running;
+	let turnActive = false;
+	let released = false;
+	const started = /* @__PURE__ */ new Set();
+	const run = async (args, timeoutMs, extraEnv) => {
+		const process = await box.spawnInDirectory("/usr/bin/env", [...env, ...args], {
+			cwd: paths.dir,
+			...extraEnv === void 0 ? {} : { env: extraEnv },
+			timeoutMs
+		}, started);
+		started.add(process.pid);
+		return process;
+	};
+	const collect = async (process) => {
+		const [stdout, stderr, exitCode] = await Promise.all([
+			drain(box.output(process, "stdout")),
+			drain(box.output(process, "stderr")),
+			box.wait(process)
+		]);
+		return {
+			exitCode,
+			stdout,
+			stderr
+		};
+	};
+	const resolvePath = (path) => {
+		if (path.startsWith("/")) return path;
+		if (isUnsafeRelativePath(path)) throw new ValidationError(`sharedBoxPlacement: path ${path} leaves the worker directory`);
+		return `${paths.dir}/${path}`;
+	};
+	/**
+	* One turn: one or more opencode runs of the same session. The first runs `message`; a later run
+	* continues the session after the model provider refused a run for capacity.
+	*/
+	async function* turn(message, turnProfile, options) {
+		const signal = options?.signal;
+		const timeoutMs = options?.timeoutMs ?? 0;
+		const turnDeadline = timeoutMs > 0 ? Date.now() + timeoutMs : void 0;
+		let sessionId;
+		const subagents = /* @__PURE__ */ new Set();
+		let refusalsInARow = 0;
+		let prompt = message;
+		for (let invocation = 1;; invocation += 1) {
+			const launch = await materializeWorker(box, paths, turnProfile, prompt, options?.backend?.model, clientName, sessionId);
+			signal?.throwIfAborted();
+			const remainingMs = turnDeadline === void 0 ? 0 : Math.max(1, turnDeadline - Date.now());
+			const process = await run(launch.args, remainingMs, { OPENCODE_CONFIG_CONTENT: launch.config });
+			running = process;
+			const onAbort = () => {
+				process.kill("SIGKILL", { tree: true }).catch(() => void 0);
+			};
+			signal?.addEventListener("abort", onAbort, { once: true });
+			const stderr = drain(box.output(process, "stderr"));
+			const lines = lineReader();
+			const parsed = createOpencodeEventParser(launch.model);
+			let exitCode;
+			let errorText;
+			try {
+				for await (const chunk of box.output(process, "stdout")) for (const line of lines.push(chunk)) yield* parsed.line(line);
+				for (const line of lines.end()) yield* parsed.line(line);
+				exitCode = await box.wait(process);
+				errorText = (await stderr).slice(-4e3);
+			} finally {
+				signal?.removeEventListener("abort", onAbort);
+				running = void 0;
+			}
+			sessionId = parsed.sessionId() ?? sessionId;
+			for (const child of parsed.subagentSessionIds()) subagents.add(child);
+			const failure = parsed.failure(exitCode, errorText);
+			const refusal = failure === void 0 || unavailablePause === false || signal?.aborted ? void 0 : unavailableSignalOfFailure({ error: failure });
+			refusalsInARow = parsed.madeProgress() ? 1 : refusalsInARow + 1;
+			const pauseMs = refusal === void 0 || unavailablePause === false ? 0 : unavailablePauseMs(refusalsInARow, unavailablePause);
+			if (refusal === void 0 || turnDeadline !== void 0 && Date.now() + pauseMs >= turnDeadline) {
+				if (sessionId !== void 0) await exportSession(run, collect, paths, sessionId);
+				for (const child of subagents) if (child !== sessionId) await exportSession(run, collect, paths, child);
+				signal?.throwIfAborted();
+				yield* parsed.finish(exitCode, errorText, invocation);
+				return;
+			}
+			await sleep(pauseMs, signal);
+			signal?.throwIfAborted();
+			if (released) throw new ValidationError("sharedBoxPlacement: this worker was released");
+			prompt = sessionId === void 0 ? message : LEAF_CONTINUATION_TASK;
+		}
+	}
+	return {
+		id: `${box.id}/${workerId}`,
+		name: workerId,
+		status: "running",
+		metadata: {
+			sharedBoxId: box.id,
+			workerId,
+			workerDir: paths.dir
+		},
+		async *streamPrompt(message, options) {
+			if (released) throw new ValidationError("sharedBoxPlacement: this worker was released");
+			if (turnActive) throw new ValidationError("sharedBoxPlacement: a worker runs one turn at a time");
+			const turnProfile = options?.backend?.profile === void 0 ? createProfile : agentProfileSchema.parse(options.backend.profile);
+			if (canonicalAgentProfileDigest(turnProfile) !== canonicalAgentProfileDigest(createProfile) && sharedBoxRefusal(turnProfile) !== void 0) throw new ValidationError(`sharedBoxPlacement: ${sharedBoxRefusal(turnProfile)}`);
+			if (options?.backend?.type !== void 0 && options.backend.type !== HARNESS) throw new ValidationError(`sharedBoxPlacement: backend ${options.backend.type} is not ${HARNESS}`);
+			turnActive = true;
+			try {
+				yield* turn(message, turnProfile, options);
+			} finally {
+				turnActive = false;
+			}
+		},
+		async exec(command, options) {
+			const process = await run([
+				"/bin/sh",
+				"-c",
+				command
+			], options?.timeoutMs ?? DEFAULT_EXEC_TIMEOUT_MS);
+			return await collect(process);
+		},
+		async read(path) {
+			return await box.fs.read(resolvePath(path));
+		},
+		async write(path, content) {
+			await box.fs.write(resolvePath(path), content);
+		},
+		async refresh() {},
+		async delete() {
+			if (released) return;
+			released = true;
+			try {
+				await running?.kill("SIGKILL", { tree: true });
+				await box.exec(`rm -rf '${paths.dir}'`, { timeoutMs: DEFAULT_EXEC_TIMEOUT_MS });
+			} finally {
+				await lease.release();
+			}
+		}
+	};
+}
+/**
+* The Sandbox calls one worker makes, each repeated on a transient failure.
+*
+* A launch is repeated only after the pool confirms the box did not start it: a failed request
+* may have reached the box before its answer was lost, so the repeat first looks for a process
+* in the worker's own directory that this worker did not start yet, and adopts it. A process log
+* that breaks mid-stream is read again from the start, because the box replays a process's
+* buffered output, and the part already delivered is skipped.
+*/
+function resilientBox(box, delayMs) {
+	const retry = (operation) => transientRetry(operation, { delayMs });
+	return {
+		id: box.id,
+		exec: (command, options) => retry(() => box.exec(command, options)),
+		fs: {
+			read: (path) => retry(() => box.fs.read(path)),
+			write: (path, content) => retry(() => box.fs.write(path, content))
+		},
+		async spawnInDirectory(executable, args, options, known) {
+			return await transientRetry(async (attempt) => {
+				if (attempt > 1) {
+					const launched = (await box.process.list()).find((entry) => entry.cwd === options.cwd && entry.command === executable && !known.has(entry.pid));
+					const adopted = launched === void 0 ? null : await box.process.get(launched.pid);
+					if (adopted !== null) return adopted;
+				}
+				return await box.process.spawnExact(executable, args, options);
+			}, { delayMs });
+		},
+		async wait(process) {
+			return await retry(async () => {
+				try {
+					return await process.wait();
+				} catch (error) {
+					if (!isTransientSandboxFailure(error)) throw error;
+					const again = await box.process.get(process.pid);
+					if (again === null) throw error;
+					return await again.wait();
+				}
+			});
+		},
+		async *output(process, stream) {
+			let delivered = 0;
+			let source = process;
+			for (let attempt = 1;; attempt += 1) {
+				let seen = 0;
+				try {
+					for await (const chunk of source[stream]()) {
+						const fresh = seen + chunk.length <= delivered ? "" : chunk.slice(Math.max(0, delivered - seen));
+						seen += chunk.length;
+						if (fresh.length > 0) {
+							delivered += fresh.length;
+							yield fresh;
+						}
+					}
+					return;
+				} catch (error) {
+					if (attempt >= TRANSIENT_ATTEMPTS || !isTransientSandboxFailure(error)) throw error;
+					await sleep(delayMs * 2 ** (attempt - 1));
+					source = await retry(() => box.process.get(process.pid)) ?? source;
+				}
+			}
+		},
+		delete: () => retry(() => box.delete())
+	};
+}
+async function drain(stream) {
+	let text = "";
+	for await (const chunk of stream) text += chunk;
+	return text;
+}
+function lineReader() {
+	let pending = "";
+	return {
+		push(chunk) {
+			pending += chunk;
+			const lines = pending.split("\n");
+			pending = lines.pop() ?? "";
+			return lines.filter((line) => line.trim().length > 0);
+		},
+		end() {
+			const rest = pending.trim();
+			pending = "";
+			return rest.length > 0 ? [rest] : [];
+		}
+	};
+}
+/**
+* Write the worker's materialized profile into its directory and build its launch.
+*
+* The files come from the same materializer the Sandbox sidecar uses, so a shared worker gets the
+* same instruction file, permissions and resource files a dedicated box would. The generated
+* `opencode.json` is passed as `OPENCODE_CONFIG_CONTENT` with its instruction paths made absolute,
+* because opencode resolves an instruction path in that variable against nothing.
+*/
+async function materializeWorker(box, paths, profile, task, turnModel, clientName, continueSession) {
+	const refusal = sharedBoxRefusal(profile);
+	if (refusal !== void 0) throw new ValidationError(`sharedBoxPlacement: ${refusal}`);
+	if (turnModel?.authFiles !== void 0 || turnModel?.authMode === "oauth") throw new ValidationError("sharedBoxPlacement: a shared worker cannot carry auth files");
+	const plan = materializeProfile(profile, HARNESS);
+	let generated = {};
+	for (const file of plan.files) {
+		if (file.relPath === "opencode.json" && file.source === "generated") {
+			generated = JSON.parse(file.content);
+			continue;
+		}
+		if (continueSession === void 0) await box.fs.write(`${paths.dir}/${file.relPath}`, file.content);
+	}
+	const instructions = Array.isArray(generated.instructions) ? generated.instructions.map((entry) => typeof entry === "string" && !entry.startsWith("/") ? `${paths.dir}/${entry}` : entry) : void 0;
+	const providerId = profile.model.provider;
+	const modelId = profileProviderModel(profile);
+	const apiKeyEnv = typeof turnModel?.apiKeyEnv === "string" ? turnModel.apiKeyEnv : "OPENCODE_MODEL_API_KEY";
+	const baseURL = typeof turnModel?.baseUrl === "string" ? turnModel.baseUrl : "{env:OPENCODE_MODEL_BASE_URL}";
+	const config = {
+		$schema: "https://opencode.ai/config.json",
+		...generated,
+		...instructions === void 0 ? {} : { instructions },
+		permission: {
+			external_directory: {
+				"*": "deny",
+				"/tmp/**": "allow"
+			},
+			...generated.permission ?? {}
+		},
+		provider: { [providerId]: {
+			npm: "@ai-sdk/openai-compatible",
+			name: providerId,
+			options: {
+				baseURL,
+				apiKey: `{env:${apiKeyEnv}}`,
+				...clientName === void 0 ? {} : { headers: { [ROUTER_CLIENT_HEADER]: clientName } }
+			},
+			models: { [modelId]: { name: modelId } }
+		} }
+	};
+	const invocation = harnessInvocation(HARNESS, invocationProfile(profile), task, { dangerouslySkipPermissions: true });
+	const model = `${providerId}/${modelId}`;
+	if (continueSession !== void 0 && !/^[A-Za-z0-9_-]+$/u.test(continueSession)) throw new ValidationError(`sharedBoxPlacement: session id ${continueSession} is not opencode's`);
+	return {
+		args: [
+			invocation.command,
+			...invocation.args,
+			...continueSession === void 0 ? [] : ["--session", continueSession],
+			"--format",
+			"json",
+			"-m",
+			model
+		],
+		config: JSON.stringify(config),
+		model
+	};
+}
+/**
+* Save the harness's own record of the session where the transcript capture reads it.
+*
+* Current opencode keeps sessions in a SQLite database, which the capture cannot carry as text.
+* `opencode export` writes the same session as JSON.
+*/
+async function exportSession(run, collect, paths, sessionId) {
+	if (!SESSION_ID.test(sessionId)) return;
+	await collect(await run([
+		"/bin/sh",
+		"-c",
+		"mkdir -p \"$(dirname \"$2\")\" && exec opencode export \"$1\" > \"$2\"",
+		"export-session",
+		sessionId,
+		`${paths.home}/.local/share/opencode/export/${sessionId}.json`
+	], DEFAULT_EXEC_TIMEOUT_MS));
+}
+const SESSION_ID = /^[A-Za-z0-9_-]+$/u;
+/** A subagent's session id in a `task` result (`<task id="ses_…">`) or failure (`task_id: ses_…`). */
+const TASK_SESSION = /(?:<task id="|task_id: )(ses_[A-Za-z0-9]+)/u;
+/**
+* The session a harness subagent ran in, named by its parent's `task` tool part.
+*
+* opencode starts each subagent in a child session and refuses a nested one unless the
+* configuration raises `subagent_depth` above 1, so under the default the parent's parts name
+* every subagent session. A running part carries the id in `state.metadata.sessionId`; a finished
+* one also carries it in its output, and a failed one in its error.
+*/
+function subagentSessionOf(part) {
+	if (part.type !== "tool" || part.tool !== "task") return void 0;
+	const state = part.state;
+	if (state === void 0 || state === null || typeof state !== "object") return void 0;
+	const { metadata, output, error } = state;
+	const named = metadata !== null && typeof metadata === "object" ? metadata.sessionId : void 0;
+	if (typeof named === "string" && SESSION_ID.test(named)) return named;
+	for (const text of [output, error]) {
+		const match = typeof text === "string" ? TASK_SESSION.exec(text) : null;
+		if (match !== null) return match[1];
+	}
+}
+/**
+* Translate opencode's JSON event lines into the Sandbox event wire the provider executor reads.
+*
+* Every part becomes `message.part.updated`, which is how the sidecar forwards opencode parts, so
+* the existing trace and progress readers decode them unchanged. Each `step-finish` part also
+* becomes one canonical `llm_call` receipt with its token counts. opencode reports no dollar
+* receipt for a custom provider, so every receipt says the cost is unknown and Runtime prices the
+* tokens as an estimate instead of a bill.
+*/
+function createOpencodeEventParser(model) {
+	let sessionId;
+	let finalMessageId;
+	const textByMessage = /* @__PURE__ */ new Map();
+	const subagentSessions = /* @__PURE__ */ new Set();
+	const errors = [];
+	let malformed = 0;
+	let spentTokens = false;
+	const failureOf = (exitCode, stderr) => {
+		if (exitCode !== 0) {
+			const said = [...errors, stderr.trim().slice(-1e3)].filter((text) => text.length > 0);
+			return `opencode exited ${exitCode}${said.length > 0 ? `: ${said.join("; ")}` : ""}`;
+		}
+		return errors.length > 0 && finalMessageId === void 0 ? errors.join("; ") : void 0;
+	};
+	return {
+		sessionId: () => sessionId,
+		subagentSessionIds: () => [...subagentSessions],
+		/** Why this run failed, or `undefined` when it answered. */
+		failure: failureOf,
+		/** Whether this run spent any model tokens before it ended. */
+		madeProgress: () => spentTokens,
+		*line(raw) {
+			let event;
+			try {
+				event = JSON.parse(raw);
+			} catch {
+				malformed += 1;
+				return;
+			}
+			if (typeof event.sessionID === "string") sessionId ??= event.sessionID;
+			if (event.type === "error") {
+				const message = errorMessage(event.error);
+				errors.push(message);
+				yield {
+					type: "error",
+					data: { message }
+				};
+				return;
+			}
+			const part = event.part;
+			if (part === void 0 || part === null || typeof part !== "object") return;
+			const subagent = subagentSessionOf(part);
+			if (subagent !== void 0) subagentSessions.add(subagent);
+			yield {
+				type: "message.part.updated",
+				data: { part }
+			};
+			const messageId = typeof part.messageID === "string" ? part.messageID : void 0;
+			if (part.type === "text" && messageId !== void 0 && typeof part.text === "string") {
+				const texts = textByMessage.get(messageId) ?? [];
+				texts.push(part.text);
+				textByMessage.set(messageId, texts);
+			}
+			if (part.type === "step-finish") {
+				if (messageId !== void 0) finalMessageId = messageId;
+				const receipt = stepReceipt(part, model);
+				if (receipt !== void 0) {
+					const data = receipt.data;
+					if ((data?.tokensIn ?? 0) > 0 || (data?.tokensOut ?? 0) > 0) spentTokens = true;
+					yield receipt;
+				}
+			}
+		},
+		/** The turn's terminal frames, from its last run. `runs` counts the runs of the session. */
+		*finish(exitCode, stderr, runs = 1) {
+			const finalText = (finalMessageId === void 0 ? void 0 : textByMessage.get(finalMessageId)?.join("")) ?? "";
+			const failure = failureOf(exitCode, stderr);
+			const counted = {
+				...malformed > 0 ? { malformedLines: malformed } : {},
+				...runs > 1 ? { sessionRuns: runs } : {}
+			};
+			if (failure !== void 0) {
+				yield {
+					type: "result",
+					data: {
+						success: false,
+						status: "failed",
+						error: failure,
+						finalText,
+						...counted
+					}
+				};
+				yield {
+					type: "done",
+					data: { outcome: { type: "failed" } }
+				};
+				return;
+			}
+			yield {
+				type: "result",
+				data: {
+					success: true,
+					finalText,
+					...counted
+				}
+			};
+			yield {
+				type: "done",
+				data: { outcome: { type: "completed" } }
+			};
+		}
+	};
+}
+function stepReceipt(part, model) {
+	const tokens = part.tokens;
+	if (tokens === void 0 || tokens === null || typeof tokens !== "object") return void 0;
+	const count = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : void 0;
+	const cache = tokens.cache ?? {};
+	const input = count(tokens.input);
+	const output = count(tokens.output);
+	const reasoning = count(tokens.reasoning) ?? 0;
+	const cacheRead = count(cache.read) ?? 0;
+	const cacheWrite = count(cache.write) ?? 0;
+	const known = input !== void 0 && output !== void 0;
+	return {
+		type: "llm_call",
+		...typeof part.id === "string" ? { id: part.id } : {},
+		data: {
+			usageMode: "delta",
+			model,
+			...known ? {
+				tokensIn: input + cacheRead + cacheWrite,
+				tokensOut: output + reasoning,
+				...reasoning > 0 ? { reasoningTokens: reasoning } : {}
+			} : { tokensKnown: false },
+			costKnown: false
+		}
+	};
+}
+function errorMessage(error) {
+	if (typeof error === "string") return error;
+	if (error !== null && typeof error === "object") {
+		const record = error;
+		const data = record.data;
+		const text = typeof data?.message === "string" ? data.message : typeof record.message === "string" ? record.message : typeof record.name === "string" ? record.name : "opencode reported an error";
+		const status = data?.statusCode;
+		return typeof status === "number" && Number.isSafeInteger(status) ? `${text} (status code ${status})` : text;
+	}
+	return "opencode reported an error";
+}
+//#endregion
 //#region src/runtime/authored-code.ts
 /**
 * The ONE lint over model-authored source.
@@ -6081,6 +7198,31 @@ function signalPass(value, required) {
 	return !required;
 }
 //#endregion
+//#region src/runtime/supervise/run-context-sql.ts
+/**
+*
+* `createSqlRunContext` — the SQL-backed durable bundle a `createSupervisor().run` (or a
+* `runGraph`/`supervise` call that accepts injected stores) needs: a `SqlSpawnJournal`, a
+* `SqlResultBlobStore` (both over one `SqlStatements` seam — the same adapter shape
+* `SqlConversationJournal` takes), and a fresh `createExecutorRegistry()`, with `resume: true`
+* so spreading the context makes the run loadTree-first.
+*
+* The SQL analogue of `createFileRunContext`: where that bundle owns a directory, this one owns
+* tables in a database the caller already operates. The durable coordination side-log and
+* cancellation observers remain file-based behind `runDir`; a SQL coordination log is follow-up.
+*
+* @experimental
+*/
+/** Build a durable run context over one SQL statement seam. Tables are created on first use. */
+function createSqlRunContext(db) {
+	return {
+		journal: new SqlSpawnJournal(db),
+		blobs: new SqlResultBlobStore(db),
+		executors: createExecutorRegistry(),
+		resume: true
+	};
+}
+//#endregion
 //#region src/runtime/supervise/trajectory-recorder.ts
 /**
 *
@@ -6727,7 +7869,7 @@ async function superviseSurface(profile, task, opts) {
 		makeWorkerAgent,
 		deliverable,
 		budget,
-		maxLiveWorkers: opts.maxLiveWorkers ?? 1,
+		workerSlots: opts.workerSlots ?? 1,
 		perWorker: {
 			maxIterations: innerTurns + 2,
 			maxTokens: workerMaxTokens
@@ -7364,6 +8506,6 @@ function tail(s) {
 	return s.slice(-400);
 }
 //#endregion
-export { InMemoryCorpus as $, chatWorkerSeam as A, pairwiseSignificance as At, SandboxRunAbortError as B, createMcpEnvironment as Bt, withUntrackedArtifacts as C, loopDispatch as Ct, codeModeSupervisorTools as D, sentinelCompletion as Dt, runCoderChecks as E, deterministicCompletion as Et, selectChampion as F, auditIntent as Ft, equalKOnCost as G, resolveSecretEnv as Gt, printBenchmarkReport as H, envKeyProvider as Ht, assertStrategyContract as I, defaultAuditorInstruction as It, runPersonified as J, trajectoryReport as K, secretEnvOfMcpServer as Kt, authorStrategy as L, McpSpawnFault as Lt, discriminatingMeans as M, renderLeaderboardMarkdown as Mt, pickChampion as N, renderLeaderboardSvg as Nt, unsafeInProcessRunner as O, stopSentinel as Ot, runStrategyEvolution as P, renderPairwiseMarkdown as Pt, FileCorpus as Q, strategyAuthorContract as R, connectStdioMcp as Rt, copyUntrackedIntoClone as S, loopCampaignDispatch as St, patchDelivered as T, completionAuthorizes as Tt, runBenchmark as U, mcpSecretEnvMetadataKey as Ut, openSandboxRun as V, sanitizeMcpToolSchema as Vt, promotionGate as W, resolveMcpServerLaunch as Wt, createShapeRegistry as X, builtinShapes as Y, registerShape as Z, NOTE_MAX_CHARS as _, harvestCorpus as _t, localShell as a, pipeline as at, composeWorkerEvidence as b, localSandboxClient as bt, createVerifierEnvironment as c, widen as ct, harvestSurfaceDiffs as d, createScopeAnalyst as dt, renderCorpusToInstructions as et, analystsFromRegistry as f, registryScopeAnalyst as ft, EVIDENCE_MAX_CHARS as g, HarvestError as gt, worktreeFanout as h, inProcessSandboxClient as ht, jjWorkspace as i, panel as it, createChatSessionStore as j, renderLeaderboardHtml as jt, chatTransportExecutor as k, leaderboard as kt, boxSurfaceReader as l, assertTraceDerivedFindings as lt, superviseSurface as m, runIsolatedCheck as mt, makeFinding$1 as n, flatWidenGate as nt, runInWorkspace as o, selectValidWinner as ot, failuresAnalyst as p, observationFromRegistry as pt, definePersona as q, createTangleSandboxExactProcessProvider as qt, 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, VERIFY_TAIL_CHARS as v, defineLeaderboard as vt, analyzeTrace as w, superviseDispatch as wt, settledWorkerOut as x, inlineSandboxClient as xt, closingWorkerNote as y, resolveSandboxClient as yt, strategyAuthorSystemPrompt as z, materializeLocalMcp as zt };
+export { trajectoryReport as $, resolveMcpServerLaunch as $t, chatTransportExecutor as A, loopDispatch as At, strategyAuthorSystemPrompt as B, renderLeaderboardSvg as Bt, withUntrackedArtifacts as C, HarvestError as Ct, runCoderChecks as D, localSandboxClient as Dt, patchDelivered as E, resolveSandboxClient as Et, runStrategyEvolution as F, stopSentinel as Ft, sharedBoxRefusal as G, SqlSpawnJournal as Gt, DEFAULT_SHARED_BOX_WORKERS as H, auditIntent as Ht, selectChampion as I, leaderboard as It, openSandboxRun as J, materializeLocalMcp as Jt, sharedWorkerClientName as K, McpSpawnFault as Kt, assertStrategyContract as L, pairwiseSignificance as Lt, createChatSessionStore as M, completionAuthorizes as Mt, discriminatingMeans as N, deterministicCompletion as Nt, codeModeSupervisorTools as O, inlineSandboxClient as Ot, pickChampion as P, sentinelCompletion as Pt, equalKOnCost as Q, mcpSecretEnvMetadataKey as Qt, authorStrategy as R, renderLeaderboardHtml as Rt, copyUntrackedIntoClone as S, inProcessSandboxClient as St, createSqlRunContext as T, defineLeaderboard as Tt, ROUTER_CLIENT_HEADER as U, defaultAuditorInstruction as Ut, DEFAULT_SHARED_BOX_RESOURCES as V, renderPairwiseMarkdown as Vt, sharedBoxPlacement as W, SqlResultBlobStore as Wt, runBenchmark as X, sanitizeMcpToolSchema as Xt, printBenchmarkReport as Y, createMcpEnvironment as Yt, promotionGate as Z, envKeyProvider as Zt, NOTE_MAX_CHARS as _, buildSteerContext as _t, localShell as a, FileCorpus as at, composeWorkerEvidence as b, observationFromRegistry as bt, createVerifierEnvironment as c, fanout as ct, harvestSurfaceDiffs as d, panel as dt, resolveSecretEnv as en, definePersona as et, analystsFromRegistry as f, pipeline as ft, EVIDENCE_MAX_CHARS as g, assertTraceDerivedFindings as gt, worktreeFanout as h, widen as ht, jjWorkspace as i, registerShape as it, chatWorkerSeam as j, superviseDispatch as jt, unsafeInProcessRunner as k, loopCampaignDispatch as kt, boxSurfaceReader as l, flatWidenGate as lt, superviseSurface as m, verify as mt, makeFinding$1 as n, createTangleSandboxExactProcessProvider as nn, builtinShapes as nt, runInWorkspace as o, InMemoryCorpus as ot, failuresAnalyst as p, selectValidWinner as pt, SandboxRunAbortError as q, connectStdioMcp as qt, gitWorkspace as r, createShapeRegistry as rt, createWaterfallCollector as s, renderCorpusToInstructions as st, computeFindingId$1 as t, secretEnvOfMcpServer as tn, runPersonified as tt, fsSurfaceReader as u, loopUntil as ut, VERIFY_TAIL_CHARS as v, createScopeAnalyst as vt, analyzeTrace as w, harvestCorpus as wt, settledWorkerOut as x, runIsolatedCheck as xt, closingWorkerNote as y, registryScopeAnalyst as yt, strategyAuthorContract as z, renderLeaderboardMarkdown as zt };
 
-//# sourceMappingURL=runtime-CUZC75EX.js.map
+//# sourceMappingURL=runtime-DVjIH1eo.js.map