@tangle-network/agent-runtime 0.117.0 → 0.120.0

package/dist/{supervisor-CAXiCKnX.js → supervisor-CpT9yAxL.js}

@@ -1,6 +1,6 @@
 import { c as RuntimeRunStateError, u as ValidationError } from "./errors-DEAvWQPy.js";
-import { S as detachedSnapshot, _ as captureWorkerTraceEvidence, c as replaySpawnTree, f as attestNestedDriverTreeOwner, h as runtimeOwnedNestedDriverTreeRoot, m as nestedDriverTreeRoot, o as materializeTreeView, p as driverRuntime, s as pendingWaits, x as contentAddress } from "./spawn-journal-B_mu_oH2.js";
-import { n as addTokenUsage, p as zeroTokenUsage } from "./util-Cc9g9Y-o.js";
+import { S as detachedSnapshot, _ as captureWorkerTraceEvidence, c as replaySpawnTree, f as attestNestedDriverTreeOwner, h as runtimeOwnedNestedDriverTreeRoot, m as nestedDriverTreeRoot, o as materializeTreeView, p as driverRuntime, s as pendingWaits, x as contentAddress } from "./spawn-journal-IeXpidO2.js";
+import { f as zeroTokenUsage, t as addTokenUsage } from "./util-MVgdwuIS.js";
 import { i as notifyRuntimeHookEvent } from "./runtime-hooks-C7iJOWm3.js";
 import { estimateCost, isModelPriced } from "@tangle-network/agent-eval";
 import { AGENT_PROFILE_MATERIALIZATION_AXES, agentProfileSchema, canonicalCandidateDigest, profileMaterializationAxes, sha256DigestSchema } from "@tangle-network/agent-interface";
@@ -140,20 +140,6 @@ function collectStringLeaves(value, output) {
 *
 * @experimental
 */
-const codexReasoningEffort = {
-	none: "none",
-	minimal: "minimal",
-	low: "low",
-	medium: "medium",
-	high: "high",
-	xhigh: "xhigh",
-	ultracode: "xhigh"
-};
-function codexReasoningArgs(reasoningEffort) {
-	const mapped = codexReasoningEffort[reasoningEffort];
-	if (mapped === void 0) throw new Error(`harnessInvocation: unsupported Codex reasoning effort ${String(reasoningEffort)}`);
-	return ["-c", `model_reasoning_effort="${mapped}"`];
-}
 /**
 * Default per-harness command + arg shape. `buildArgs` takes ONLY the task prompt and
 * emits the prompt-only invocation (no model, no system prompt) — the safe default shape
@@ -161,25 +147,94 @@ function codexReasoningArgs(reasoningEffort) {
 * the harness's selector flag (every supported harness takes `-m <model>`). The §1.5
 * profile-aware mapper `harnessInvocation` composes these to thread the full
 * supervisor-authored profile (systemPrompt + model) into argv.
+*
+* Every per-harness difference is a FIELD on this row, never a test on the harness name at a
+* call site: adding harness N+1 is one entry here, and a caller asking for a capability the
+* row does not declare is refused up front instead of silently losing the request.
 */
 const HARNESS_INVOCATIONS = {
-	claude: {
+	"claude-code": {
 		command: "claude",
 		buildArgs: (taskPrompt) => ["-p", taskPrompt],
-		modelArgs: (model) => ["-m", model]
+		modelArgs: (model) => ["-m", model],
+		reasoning: {
+			levels: {
+				low: "low",
+				medium: "medium",
+				high: "high",
+				xhigh: "xhigh",
+				ultracode: "max"
+			},
+			args: (level) => ["--effort", level]
+		},
+		permissionBypassArgs: () => ["--dangerously-skip-permissions"]
 	},
 	codex: {
 		command: "codex",
 		buildArgs: (taskPrompt) => ["exec", taskPrompt],
 		modelArgs: (model) => ["-m", model],
-		reasoningArgs: codexReasoningArgs
+		reasoning: {
+			levels: {
+				none: "none",
+				minimal: "minimal",
+				low: "low",
+				medium: "medium",
+				high: "high",
+				xhigh: "xhigh",
+				ultracode: "xhigh"
+			},
+			args: (level) => ["-c", `model_reasoning_effort="${level}"`]
+		},
+		permissionBypassArgs: () => [
+			"--sandbox",
+			"workspace-write",
+			"-c",
+			"approval_policy=\"never\""
+		]
 	},
 	opencode: {
 		command: "opencode",
 		buildArgs: (taskPrompt) => ["run", taskPrompt],
-		modelArgs: (model) => ["-m", model]
+		modelArgs: (model) => ["-m", model],
+		reasoning: {
+			levels: {
+				minimal: "minimal",
+				low: "low",
+				medium: "medium",
+				high: "high",
+				xhigh: "xhigh",
+				ultracode: "max"
+			},
+			args: (level) => ["--variant", level]
+		}
 	}
 };
+/** Every local harness, in table order — the one list `AGENT_RUNTIME_LOCAL_HARNESSES` and any
+*  other harness enumeration reads, so adding a row above is the only edit a new harness needs. */
+const LOCAL_HARNESSES = Object.keys(HARNESS_INVOCATIONS);
+/** The harness a caller gets when it expresses no preference. A composition-root default, not a
+*  capability claim: one constant so the several entry points cannot drift apart. */
+const DEFAULT_LOCAL_HARNESS = "claude-code";
+/** The CLI binary a harness id runs. The two are NOT the same string (`claude-code` runs `claude`),
+*  so anything spawning a harness — a version probe, a login check — reads it from here rather than
+*  passing the harness id as a command. */
+function localHarnessExecutable(harness) {
+	return HARNESS_INVOCATIONS[harness].command;
+}
+/**
+* Whether the harness's native control can express this reasoning effort. Admission checks read
+* this so a profile the invocation would later refuse is rejected BEFORE any workspace state is
+* created, against the same table that emits the argv.
+*/
+function harnessSupportsReasoningEffort(harness, reasoningEffort) {
+	return HARNESS_INVOCATIONS[harness].reasoning?.levels[reasoningEffort] !== void 0;
+}
+function harnessReasoningArgs(harness, reasoningEffort) {
+	const reasoning = HARNESS_INVOCATIONS[harness].reasoning;
+	const level = reasoning?.levels[reasoningEffort];
+	if (reasoning === void 0 || level === void 0) throw new Error(`harnessInvocation: ${harness} cannot express reasoning effort ${String(reasoningEffort)}`);
+	return reasoning.args(level);
+}
 const CODEX_REPRODUCIBLE_ARGS = [
 	"--ephemeral",
 	"--ignore-rules",
@@ -205,8 +260,9 @@ const CODEX_REPRODUCIBLE_ARGS = [
 	"--strict-config"
 ];
 function buildHarnessArgs(harness, taskPrompt, options = {}) {
-	const args = HARNESS_INVOCATIONS[harness].buildArgs(taskPrompt);
-	if (harness === "claude" && options.dangerouslySkipPermissions) args.push("--dangerously-skip-permissions");
+	const invocation = HARNESS_INVOCATIONS[harness];
+	const args = invocation.buildArgs(taskPrompt);
+	if (options.dangerouslySkipPermissions && !options.codexReproducible) args.push(...invocation.permissionBypassArgs?.() ?? []);
 	if (options.codexReproducible) {
 		if (harness !== "codex") throw new Error("harnessInvocation: codexReproducible requires the Codex harness");
 		args.push(...CODEX_REPRODUCIBLE_ARGS);
@@ -249,7 +305,7 @@ function harnessInvocation(harness, profile, taskPrompt, options = {}) {
 	const model = profile.model?.default;
 	if (typeof model === "string" && model.length > 0) args.push(...invocation.modelArgs(model));
 	const reasoningEffort = profile.model?.reasoningEffort;
-	if (reasoningEffort !== void 0 && invocation.reasoningArgs) args.push(...invocation.reasoningArgs(reasoningEffort));
+	if (reasoningEffort !== void 0) args.push(...harnessReasoningArgs(harness, reasoningEffort));
 	return {
 		command: invocation.command,
 		args,
@@ -1577,9 +1633,6 @@ async function removeWorktree(options) {
 * @experimental
 */
 const defaultCheckOutputCap = 16e3;
-function materializerHarness(harness) {
-	return harness === "claude" ? "claude-code" : harness;
-}
 /** This harness runs public plans only — it has no secret provider, so any
 *  templated argument or secret-ref env value is refused rather than leaked
 *  or silently stringified. */
@@ -1626,7 +1679,7 @@ async function runWorktreeHarness(opts) {
 		if (applied.unsupported.length > 0) throw new Error("runWorktreeHarness: applied profile unexpectedly retained unsupported rows");
 		const invocationProfile = profileWithResourceInstructions(profile, resourceInstructions);
 		const { command, args } = harnessInvocation(opts.harness, invocationProfile, opts.taskPrompt, {
-			dangerouslySkipPermissions: opts.harness === "claude",
+			dangerouslySkipPermissions: true,
 			...opts.codexReproducible ? { codexReproducible: true } : {}
 		});
 		const harnessResult = await runHarness({
@@ -1720,7 +1773,7 @@ function prepareWorktreeProfile(profile, harness) {
 	const workspaceProfile = materializationOnlyProfile(profile);
 	assertSupportedWorktreeProfile(profile, harness);
 	assertSafeProfileResourcePaths(profile);
-	const plan = materializeProfile(workspaceProfile, materializerHarness(harness));
+	const plan = materializeProfile(workspaceProfile, harness);
 	if (plan.unsupported.length > 0) throw new Error(`runWorktreeHarness: profile cannot be materialized for ${harness}: ${plan.unsupported.map(({ dimension, reason }) => `${dimension}: ${reason}`).join("; ")}`);
 	assertSafeMaterializedPaths(plan);
 	return {
@@ -1784,7 +1837,8 @@ function assertSupportedWorktreeProfile(profile, harness) {
 		context: "runWorktreeHarness"
 	});
 	const unsupportedAxes = [];
-	if (profile.model?.reasoningEffort !== void 0 && harness !== "codex") unsupportedAxes.push("model.reasoningEffort");
+	const reasoningEffort = profile.model?.reasoningEffort;
+	if (reasoningEffort !== void 0 && !harnessSupportsReasoningEffort(harness, reasoningEffort)) unsupportedAxes.push("model.reasoningEffort");
 	if (unsupportedAxes.length > 0) throw new Error(`runWorktreeHarness: profile requests unsupported worktree behavior: ${unsupportedAxes.join(", ")}`);
 }
 function assertSafeMaterializedPaths(plan) {
@@ -2971,9 +3025,13 @@ const WORKER_TOKEN_FLOOR = {
 *
 * A `null` harness is the router/inline arm: it holds only coordination verbs and re-sends no
 * harness scaffolding, so it has no floor of this kind.
+*
+* Accepts a bare `string` because `AgentProfile.harness` is not exactly `BackendType` — an
+* unrecognised name resolves to `null` (no floor) rather than throwing, which keeps an unknown
+* harness admissible instead of refusing work on a name this table has not heard of.
 */
 function workerTokenFloor(harness) {
-	if (harness === null) return null;
+	if (harness === null || harness === void 0) return null;
 	return WORKER_TOKEN_FLOOR[harness] ?? null;
 }
 //#endregion
@@ -3210,6 +3268,27 @@ function queueOf(units, budget) {
 *  Deliberately generous: a coding harness routinely spends minutes inside one tool call, and a
 *  false stall that provokes a steer is worse than a late one. */
 const DEFAULT_STALL_AFTER_MS = 18e4;
+/** A short, already-truncated descriptor of a tool call's target — the file/command a driver
+*  needs to tell "editing the right module" from "re-reading the same file for the fifth time",
+*  without pulling the worker's transcript across the wire. Shared by every executor that fills an
+*  `ActivityLog` (pi RPC, sandbox session parts, cli-bridge tool-call deltas) so one harness's
+*  argument naming never reads differently from another's in the same driver's window. */
+function describeToolArgs(argsValue) {
+	if (!argsValue || typeof argsValue !== "object") return void 0;
+	const a = argsValue;
+	for (const key of [
+		"filePath",
+		"file_path",
+		"path",
+		"file",
+		"command",
+		"cmd",
+		"pattern"
+	]) {
+		const v = a[key];
+		if (typeof v === "string" && v.length > 0) return v.length > 120 ? `${v.slice(0, 117)}...` : v;
+	}
+}
 /** Create a bounded activity ring. `limit` caps memory for a worker that runs thousands of tools. */
 function createActivityLog(limit = 12) {
 	const notes = [];
@@ -4464,7 +4543,7 @@ function generateTraceId() {
 * PRECEDENCE, from lowest to highest:
 *   1. the supervisor process's own `process.env` (ambient inheritance),
 *   2. the trace context stamped here,
-*   3. the caller's own seam env (`PiSeam.env`, `CliSeam.env`).
+*   3. the caller's own seam env (`CliSeam.env`).
 * A caller who sets `TRACE_ID` / `PARENT_SPAN_ID` on a seam wins — theirs is a deliberate
 * declaration about the worker. Ambient `process.env` does NOT win: when the supervisor process was
 * itself launched as someone's worker, its inherited ids describe the SUPERVISOR's place in an
@@ -4475,7 +4554,6 @@ function generateTraceId() {
 *
 * WHICH BACKENDS PROPAGATE. Only a backend with a real environment channel to the worker can carry
 * this, and the ones that cannot say so here rather than dropping it silently:
-*   - `pi`            YES — `PiSeam.env` → the `pi --mode rpc` subprocess.
 *   - `cli`           YES — `CliSeam.env` → the spawned subprocess.
 *   - `sandbox`       YES — `CreateSandboxOptions.env` on the box the worker runs in (single-shot
 *                     and steerable). This is the cross-MACHINE case the feature exists for.
@@ -4730,7 +4808,7 @@ function createScope(args) {
 					reason: "invalid-identity"
 				};
 			}
-			const floor = workerTokenFloor(spec.harness);
+			const floor = workerTokenFloor(spec.harness ?? spec.profile.harness ?? null);
 			if (floor !== null && opts.budget.maxTokens < floor) {
 				args.pool.reconcile(reservation.ticket, zeroSpend$1());
 				permit.release();
@@ -7108,6 +7186,6 @@ function isNonEmptySpend(s) {
 	return s.iterations > 0 || s.tokens.input > 0 || s.tokens.output > 0 || s.usd > 0 || s.ms > 0 || s.tokensKnown === false || s.usdKnown === false;
 }
 //#endregion
-export { createBudgetPool as $, loopEventToOtelSpan as A, promptResourceProfileMaterialization as At, timerAt as B, buildLoopSpanNodes as C, controlProfileMaterialization as Ct, exportEvalRuns as D, promptControlProfileMaterialization as Dt, createOtelExporter as E, profileMaterializationAxes as Et, sanitizeKnowledgeReadinessReport as F, harnessInvocation as Ft, readWorkerProgress as G, waitUntil as H, sanitizeRuntimeStreamEvent as I, parseCodexTokenUsage as It, queueOf as J, effectiveConcurrency as K, createWaitProbes as L, runLocalHarness as Lt, createRuntimeEventCollector as M, sandboxActProfileMaterialization as Mt, createRuntimeStreamEventCollector as N, validateProfileMaterialization as Nt, flatOtelSpan as O, promptModelProfileMaterialization as Ot, sanitizeAgentRuntimeEvent as P, worktreeCliProfileMaterialization as Pt, assertValidBudget as Q, isWaitOutcome as R, CodexExecutionDiagnosticError as Rt, buildLoopOtelSpans as S, assertProfileMaterialization as St, createOpenInferenceFileExporter as T, fullProfileMaterialization as Tt, DEFAULT_STALL_AFTER_MS as U, validateWaitSpec as V, createActivityLog as W, DEFAULT_SUCCESSFUL_SHUTDOWN_MS as X, rollingDispatch as Y, teardownExecutor as Z, workerTraceSeamKey as _, worktreeProfileExecutionPlan as _t, pickBestDelivered as a, runtimeOwnedExecutorExecutionBinding as at, traceContextToEnv as b, removeWorktree as bt, driverChild as c, routerBrain as ct, deriveNodeExecutionIdentity as d, routerToolLoop as dt, spendFromUsageEvents as et, recordScopeOwnerMaterialization as f, streamRouterChatWithTools as ft, workerTraceEnv as g, runWorktreeHarness as gt, readWorkerTraceContext as h, runWorktreeChecks as ht, collectDelivered as i, newExecutionAttemptId as it, toOtelAttributes as j, renderProfileMaterializationIssues as jt, generateSpanId as k, promptOnlyProfileMaterialization as kt, withDriverExecutor as l, routerChatWithTools as lt, settledToIteration as m, runSettledCommand as mt, createSupervisor as n, attestRuntimeOwnedScopeOwner as nt, runFinalizer as o, runtimeOwnedExecutorMaterialization as ot, scopeOwnerExecutorNodeContext as p, runBrainLoop as pt, freeSlots as q, bestDelivered as r, inheritRuntimeOwnedExecutorAttestation as rt, runTree as s, runtimeOwnedScopeOwnerRuntime as st, createRootHandle as t, attestRuntimeOwnedExecutor as tt, createScope as u, routerChatWithUsage as ut, createPropagatingTraceEmitter as v, captureWorktreeDiff as vt, buildRuntimeEventOtelSpans as w, defineProfileMaterializationContract as wt, INTELLIGENCE_WIRE_VERSION as x, AGENT_PROFILE_MATERIALIZATION_AXES as xt, readTraceContextFromEnv as y, createWorktree as yt, pollFor as z };
+export { WORKER_TOKEN_FLOOR as $, loopEventToOtelSpan as A, promptControlProfileMaterialization as At, timerAt as B, harnessInvocation as Bt, buildLoopSpanNodes as C, removeWorktree as Ct, exportEvalRuns as D, defineProfileMaterializationContract as Dt, createOtelExporter as E, controlProfileMaterialization as Et, sanitizeKnowledgeReadinessReport as F, sandboxActProfileMaterialization as Ft, describeToolArgs as G, CodexExecutionDiagnosticError as Gt, waitUntil as H, localHarnessExecutable as Ht, sanitizeRuntimeStreamEvent as I, validateProfileMaterialization as It, freeSlots as J, readWorkerProgress as K, createWaitProbes as L, worktreeCliProfileMaterialization as Lt, createRuntimeEventCollector as M, promptOnlyProfileMaterialization as Mt, createRuntimeStreamEventCollector as N, promptResourceProfileMaterialization as Nt, flatOtelSpan as O, fullProfileMaterialization as Ot, sanitizeAgentRuntimeEvent as P, renderProfileMaterializationIssues as Pt, teardownExecutor as Q, isWaitOutcome as R, DEFAULT_LOCAL_HARNESS as Rt, buildLoopOtelSpans as S, createWorktree as St, createOpenInferenceFileExporter as T, assertProfileMaterialization as Tt, DEFAULT_STALL_AFTER_MS as U, parseCodexTokenUsage as Ut, validateWaitSpec as V, harnessSupportsReasoningEffort as Vt, createActivityLog as W, runLocalHarness as Wt, rollingDispatch as X, queueOf as Y, DEFAULT_SUCCESSFUL_SHUTDOWN_MS as Z, workerTraceSeamKey as _, runSettledCommand as _t, pickBestDelivered as a, attestRuntimeOwnedScopeOwner as at, traceContextToEnv as b, worktreeProfileExecutionPlan as bt, driverChild as c, runtimeOwnedExecutorExecutionBinding as ct, deriveNodeExecutionIdentity as d, routerBrain as dt, workerTokenFloor as et, recordScopeOwnerMaterialization as f, routerChatWithTools as ft, workerTraceEnv as g, runBrainLoop as gt, readWorkerTraceContext as h, streamRouterChatWithTools as ht, collectDelivered as i, attestRuntimeOwnedExecutor as it, toOtelAttributes as j, promptModelProfileMaterialization as jt, generateSpanId as k, profileMaterializationAxes as kt, withDriverExecutor as l, runtimeOwnedExecutorMaterialization as lt, settledToIteration as m, routerToolLoop as mt, createSupervisor as n, createBudgetPool as nt, runFinalizer as o, inheritRuntimeOwnedExecutorAttestation as ot, scopeOwnerExecutorNodeContext as p, routerChatWithUsage as pt, effectiveConcurrency as q, bestDelivered as r, spendFromUsageEvents as rt, runTree as s, newExecutionAttemptId as st, createRootHandle as t, assertValidBudget as tt, createScope as u, runtimeOwnedScopeOwnerRuntime as ut, createPropagatingTraceEmitter as v, runWorktreeChecks as vt, buildRuntimeEventOtelSpans as w, AGENT_PROFILE_MATERIALIZATION_AXES as wt, INTELLIGENCE_WIRE_VERSION as x, captureWorktreeDiff as xt, readTraceContextFromEnv as y, runWorktreeHarness as yt, pollFor as z, LOCAL_HARNESSES as zt };
 
-//# sourceMappingURL=supervisor-CAXiCKnX.js.map
+//# sourceMappingURL=supervisor-CpT9yAxL.js.map