@iowarp/clio-coder 0.4.7 → 0.4.9

package/dist/{chunk-WN552PKN.js → chunk-F2YM3JY4.js}

@@ -2,20 +2,6 @@ import { createRequire as __clioCreateRequire } from "node:module"; const requir
 import {
   planWikiGeneration
 } from "./chunk-PECBKCDK.js";
-import {
-  applyTaskWorktree,
-  captureWorkspaceCheckpoint,
-  captureWorkspaceSnapshot,
-  cleanupTaskWorktree,
-  createTaskWorktree,
-  createWriteBoundaryEnforcer,
-  gitCheckoutRoot,
-  workspaceCheckpointRef
-} from "./chunk-UA3W4FGC.js";
-import {
-  executionPlanAncestors,
-  spliceExecutionPlan
-} from "./chunk-RTLNFZMD.js";
 import {
   decideReviewGate,
   materializePendingGateDecision,
@@ -23,7 +9,7 @@ import {
   readGateDecisionArtifactsForRunIds,
   stagePendingGateDecision,
   verifyGateDecisionArtifact
-} from "./chunk-EUEXGXXR.js";
+} from "./chunk-NMBEW4PP.js";
 import {
   RUN_RECEIPT_INTEGRITY_ALGORITHM,
   RUN_RECEIPT_INTEGRITY_VERSION,
@@ -43,14 +29,32 @@ import {
   trustVerdict,
   verifyReceiptIntegrity,
   withReceiptIntegrity
-} from "./chunk-IQCNVLO6.js";
+} from "./chunk-IALZJE37.js";
 import {
   protectedArtifactFromSessionEntry,
   protectedArtifactStateFromSessionEntries,
   readAuditRows,
   readSessionEntriesForId,
   responseModelIdObservationFromRecord
-} from "./chunk-D2T66PDV.js";
+} from "./chunk-3SUDBGEI.js";
+import {
+  codeStepDir,
+  writeCodeStepRecord
+} from "./chunk-LGTVWPRN.js";
+import {
+  applyTaskWorktree,
+  captureWorkspaceCheckpoint,
+  captureWorkspaceSnapshot,
+  cleanupTaskWorktree,
+  createTaskWorktree,
+  createWriteBoundaryEnforcer,
+  gitCheckoutRoot,
+  workspaceCheckpointRef
+} from "./chunk-KRJQG47M.js";
+import {
+  executionPlanAncestors,
+  spliceExecutionPlan
+} from "./chunk-DIAJYJYG.js";
 import {
   loadEvalArtifact,
   parseEvalArtifactV4,
@@ -58,13 +62,34 @@ import {
   sumEvalHarnessMetrics
 } from "./chunk-U44YYLVV.js";
 import {
-  codeStepDir,
-  writeCodeStepRecord
-} from "./chunk-P5SC4DLJ.js";
+  parseRigorOverride,
+  resolveRigor
+} from "./chunk-GREYLTZ5.js";
+import {
+  describeValidationContract,
+  loadValidationContract
+} from "./chunk-PTFISXQO.js";
+import {
+  filterEntriesToActivePath
+} from "./chunk-O5F25NIE.js";
 import {
   defaultRunEventJournal,
   removeRunEventJournals
 } from "./chunk-UQIVHSE4.js";
+import {
+  createTomlFileReader,
+  tomlTableAt
+} from "./chunk-LQTKDAUO.js";
+import {
+  AdmissionCanceledError,
+  EVENT_TEE_LIMIT,
+  activeDecisionRefs,
+  createWorkerOutputCapture,
+  durableAssistantTextFromEvent,
+  foldDecisionBoard,
+  startDispatchEventPump,
+  workerOutputCaptureBytes
+} from "./chunk-K3XN4LZ4.js";
 import {
   changedPathsSince,
   computeWikiContentHash,
@@ -77,7 +102,7 @@ import {
   wikiStaleness,
   writeWikiMeta,
   writeWikiMetaInDir
-} from "./chunk-USZA7GWL.js";
+} from "./chunk-YQ3GFEUY.js";
 import {
   readClioState,
   statePath,
@@ -88,7 +113,7 @@ import {
   coordinateCodewikiExclusive,
   coordinateCodewikiWrite,
   drainCodewikiWrites
-} from "./chunk-XR3XJN2M.js";
+} from "./chunk-WWRV5RJI.js";
 import {
   WIKI_INDEX,
   WIKI_PLAN_FILE,
@@ -107,24 +132,17 @@ import {
   wikiMarkdownFilesInDir,
   wikiSourcesMatch,
   writeWikiPlanFile
-} from "./chunk-LVFANMOH.js";
-import {
-  filterEntriesToActivePath
-} from "./chunk-O5F25NIE.js";
+} from "./chunk-BHJMMCXS.js";
 import {
-  AdmissionCanceledError,
-  EVENT_TEE_LIMIT,
-  activeDecisionRefs,
-  createWorkerOutputCapture,
-  durableAssistantTextFromEvent,
-  foldDecisionBoard,
-  startDispatchEventPump,
-  workerOutputCaptureBytes
-} from "./chunk-CULVKYTK.js";
+  FLEET_COMMAND_BASE_ENV,
+  normalizeWriteBoundary,
+  validateFleetCommandArgs
+} from "./chunk-7QQRPB2E.js";
 import {
+  JUDGED_CHECK_MAX_OUTPUT_BYTES,
   judgeNumericTexts,
   judgePerfTexts
-} from "./chunk-TLTGZTXI.js";
+} from "./chunk-QI72X67S.js";
 import {
   LOCAL_NODE_ID,
   computeSettingsFingerprint,
@@ -135,19 +153,11 @@ import {
   receiptAttestationFields,
   routeFactVerdict,
   spawnNativeWorker
-} from "./chunk-N37QC5FV.js";
+} from "./chunk-A6DULIMH.js";
 import {
-  createTomlFileReader,
-  tomlTableAt
-} from "./chunk-LQTKDAUO.js";
-import {
-  parseRigorOverride,
-  resolveRigor
-} from "./chunk-NCCQ6DVS.js";
-import {
-  describeValidationContract,
-  loadValidationContract
-} from "./chunk-T52TPHYC.js";
+  AcpTimeoutError,
+  createStdioTransport
+} from "./chunk-XNZWWDC3.js";
 import {
   AGENT_LEDGER_PROMPT_MAX_CHARS,
   COUNCIL_MIN_MEMBERS,
@@ -189,7 +199,7 @@ import {
   serializeWorkerRuntimeDescriptor,
   toolPromptHintsForNames,
   validateJobSpec
-} from "./chunk-NO7J45X6.js";
+} from "./chunk-4ATBOFRP.js";
 import {
   WORKER_CONTEXT_MAX_BYTES,
   completeHistoryLength,
@@ -212,31 +222,29 @@ import {
   routingIntentRejection,
   sameRouteIdentity,
   toRouteCandidate
-} from "./chunk-T4TY5GG3.js";
+} from "./chunk-MO65K5CH.js";
 import {
-  describeCallAction
-} from "./chunk-2GPGAE5W.js";
+  assessFinishContract
+} from "./chunk-AY4XE6GN.js";
 import {
   isLoadableExtension
 } from "./chunk-OH3YYA3B.js";
 import {
   extensionToolName,
   listInstalledExtensions
-} from "./chunk-24S3DN22.js";
+} from "./chunk-6TKOFFGE.js";
 import {
-  networkToolsDisabled
-} from "./chunk-SL2RDHKO.js";
-import {
-  compileGlobRegex,
-  normalizeGlobInput
-} from "./chunk-V552WL53.js";
+  directSurfaceNames,
+  effectiveToolCall,
+  withGatewayForCapabilities
+} from "./chunk-2JBZYUPY.js";
 import {
-  TOOL_RESULT_TRUST_CONTRACT
-} from "./chunk-WXA2CFJO.js";
+  describeCallAction
+} from "./chunk-XNIZBOFV.js";
 import {
   applyToolProfile,
   assertToolProfileEnforceable
-} from "./chunk-GEVQNST4.js";
+} from "./chunk-XZWSP67B.js";
 import {
   dispatchResultContract,
   gateRouteCorrelation,
@@ -244,37 +252,7 @@ import {
   requestExecutionRole,
   routeCorrelationFactsForRun,
   withAttemptRole
-} from "./chunk-3LXJOICS.js";
-import {
-  declaredScopeIntent,
-  declaredScopeReplacementDiagnostic,
-  declaredScopeReplacementNotice,
-  inferredScopeParentTokenDiagnostic,
-  inferredScopeParentTokenNotice,
-  resolveDispatchPathScope
-} from "./chunk-L4N3DWNW.js";
-import {
-  WORKER_STDIN_FRAME_MAX_BYTES,
-  canonicalJson,
-  endpointIdentityHash,
-  parseAgentLedgerBody
-} from "./chunk-VQD7NH7Z.js";
-import {
-  createRedactionTally,
-  redactSecretsDeep,
-  redactSecretsText
-} from "./chunk-O3VV6IVK.js";
-import {
-  decisionRef,
-  isDecisionRecord,
-  isSkillActivation
-} from "./chunk-KAFMW7WM.js";
-import {
-  assessFinishContract
-} from "./chunk-BQQ5MXUC.js";
-import {
-  WRITE_ROOT_REFUSED_TOOLS
-} from "./chunk-DLIYANB7.js";
+} from "./chunk-H6IUCY6Q.js";
 import {
   canonicalEndpointKey,
   canonicalizeWireModelId,
@@ -293,59 +271,27 @@ import {
   resolveRuntimeTarget,
   runtimeResolutionWarnings,
   runtimeTargetSnapshot
-} from "./chunk-WT5TRMO4.js";
+} from "./chunk-4HFJKRGZ.js";
 import {
   ceilChars,
   estimateAgentMessageTokens
-} from "./chunk-77CZRFTE.js";
-import {
-  DEFAULT_AUTONOMY_LEVEL,
-  autonomyDenyRejection,
-  mapAutonomy
-} from "./chunk-EM2WNQS2.js";
-import {
-  atomicWrite
-} from "./chunk-FQOOGXBH.js";
-import {
-  assertSafeId
-} from "./chunk-UHW5V7HC.js";
-import {
-  compareCodepoints
-} from "./chunk-B6UM3OZC.js";
-import {
-  truncateUtf8
-} from "./chunk-MYI32N4R.js";
-import {
-  normalizeClioCoderEventRecord,
-  normalizeClioCoderEventType
-} from "./chunk-KMF54VH3.js";
+} from "./chunk-SJMNU4ZS.js";
 import {
   BusChannels
-} from "./chunk-6CB2IL4N.js";
+} from "./chunk-W5RM7YAH.js";
 import {
-  computeFingerprintCached,
-  isStale
-} from "./chunk-VHKTOLEW.js";
-import {
-  codewikiPath
-} from "./chunk-W2RJEH6Q.js";
-import {
-  detectProjectType
-} from "./chunk-CVDAFGPW.js";
-import {
-  enumerateWorkspaceFiles
-} from "./chunk-PPEZJWUG.js";
+  networkToolsDisabled
+} from "./chunk-SL2RDHKO.js";
 import {
-  targetRequiresAuth
-} from "./chunk-6TAATXXH.js";
+  compileGlobRegex,
+  normalizeGlobInput
+} from "./chunk-IZZI3SKQ.js";
 import {
-  resolveEffectivePricing
-} from "./chunk-TN5FW4XY.js";
+  WRITE_ROOT_REFUSED_TOOLS
+} from "./chunk-IC7JXLOM.js";
 import {
-  FLEET_COMMAND_BASE_ENV,
-  normalizeWriteBoundary,
-  validateFleetCommandArgs
-} from "./chunk-KKEYGFX4.js";
+  TOOL_RESULT_TRUST_CONTRACT
+} from "./chunk-WXA2CFJO.js";
 import {
   agentSpecFingerprint,
   assertAgentSpecPolicy,
@@ -355,19 +301,33 @@ import {
   resolveAgentToolCompatibility,
   resultContractAuthorship,
   validateRecipeResult
-} from "./chunk-34XHRVKG.js";
+} from "./chunk-I47EJPYL.js";
 import {
   INTEROP_AGENT_KINDS
 } from "./chunk-5EQO5NWP.js";
 import {
   classify
-} from "./chunk-HOX4YZ2K.js";
+} from "./chunk-H2WSCZZT.js";
 import {
   detectValidationCommand
-} from "./chunk-2O2LVQQK.js";
+} from "./chunk-SQBT46OF.js";
 import {
   canonicalizeExistingPath
 } from "./chunk-KQ6IDQIB.js";
+import {
+  declaredScopeIntent,
+  declaredScopeReplacementDiagnostic,
+  declaredScopeReplacementNotice,
+  inferredScopeParentTokenDiagnostic,
+  inferredScopeParentTokenNotice,
+  resolveDispatchPathScope
+} from "./chunk-L4N3DWNW.js";
+import {
+  compareCodepoints
+} from "./chunk-2KUBKL63.js";
+import {
+  truncateUtf8
+} from "./chunk-MYI32N4R.js";
 import {
   PATH_BOUNDARY_MAX_ENTRIES,
   pathBoundaryCovers,
@@ -381,25 +341,32 @@ import {
   ToolNames,
   isBuiltinToolName,
   isHarnessExtensionToolName
-} from "./chunk-WLHX3MM5.js";
-import {
-  readClioVersion,
-  readPiMonoVersion,
-  resolvePackageRoot
-} from "./chunk-E3LEPLQ2.js";
+} from "./chunk-V4XJWDHR.js";
 import {
   DEFAULT_DELEGATION_CONNECT_TIMEOUT_MS,
   DEFAULT_DELEGATION_TURN_TIMEOUT_MS,
   DEFAULT_SETTINGS,
   THINKING_LEVELS
-} from "./chunk-3XE4NRLF.js";
+} from "./chunk-ZKJU55MX.js";
 import {
   GUARDRAIL_DEFAULTS,
   resolveGuardrail
 } from "./chunk-C27U2TYG.js";
 import {
-  buildSafeToolEnv
-} from "./chunk-GJ24ODAX.js";
+  targetRequiresAuth
+} from "./chunk-ZKVMDNAN.js";
+import {
+  require_dist
+} from "./chunk-B5GGDIHT.js";
+import {
+  resolveEffectivePricing
+} from "./chunk-JIYWMQZ5.js";
+import {
+  WORKER_STDIN_FRAME_MAX_BYTES,
+  canonicalJson,
+  endpointIdentityHash,
+  parseAgentLedgerBody
+} from "./chunk-VQD7NH7Z.js";
 import {
   attributeCommitMessage,
   gitCommitAttributionEnabled,
@@ -407,34 +374,75 @@ import {
   withManagedGitCommitAttributionEnvironment
 } from "./chunk-LTR5QCLS.js";
 import {
-  MAX_TIMER_DELAY_MS,
   rawDurationMs
 } from "./chunk-6EXUUOSN.js";
 import {
   AI_AGENT_NAME
 } from "./chunk-ZTNFYMIO.js";
+import {
+  decisionRef,
+  isDecisionRecord,
+  isSkillActivation
+} from "./chunk-NBPA5QM6.js";
+import {
+  DEFAULT_AUTONOMY_LEVEL,
+  autonomyDenyRejection,
+  isAutonomyLevel,
+  mapAutonomy,
+  modelMayActivateSkills
+} from "./chunk-EM2WNQS2.js";
+import {
+  createRedactionTally,
+  redactSecretsDeep,
+  redactSecretsText
+} from "./chunk-O3VV6IVK.js";
 import {
   FILE_LOCK_ACQUIRE_TIMEOUT_MS,
   withStateFileLock,
   withStateFileLockSync
 } from "./chunk-DVJL77SO.js";
+import {
+  atomicWrite
+} from "./chunk-3RDHGNU7.js";
+import {
+  assertSafeId
+} from "./chunk-UHW5V7HC.js";
+import {
+  normalizeClioCoderEventRecord,
+  normalizeClioCoderEventType
+} from "./chunk-KMF54VH3.js";
 import {
   BIRTH_TOKEN_SOURCE_AVAILABLE,
   processAlive,
   processBirthToken
 } from "./chunk-TK2BMCBZ.js";
-import {
-  require_dist
-} from "./chunk-B5GGDIHT.js";
-import {
-  safeResourceWrite
-} from "./chunk-ZZFWWYLX.js";
 import {
   clioDataDir,
   clioStateDir,
   resolveClioDirs,
   stateRootRemoved
 } from "./chunk-CTTI7G3T.js";
+import {
+  computeFingerprintCached,
+  isStale
+} from "./chunk-VHKTOLEW.js";
+import {
+  codewikiPath
+} from "./chunk-W2RJEH6Q.js";
+import {
+  detectProjectType
+} from "./chunk-CVDAFGPW.js";
+import {
+  enumerateWorkspaceFiles
+} from "./chunk-PPEZJWUG.js";
+import {
+  safeResourceWrite
+} from "./chunk-ZZFWWYLX.js";
+import {
+  readClioVersion,
+  readPiMonoVersion,
+  resolvePackageRoot
+} from "./chunk-E3LEPLQ2.js";
 import {
   __toESM,
   init_esm_shims
@@ -1161,7 +1169,7 @@ function normalizeNestedMarkdown(value) {
   let cursor = 0;
   for (const match of mask.matchAll(/^(#{1,2})(\s+)/gm)) {
     if (match.index === void 0) continue;
-    out3 += body.slice(cursor, match.index) + "###" + (match[2] ?? "");
+    out3 += `${body.slice(cursor, match.index)}###${match[2] ?? ""}`;
     cursor = match.index + match[0].length;
   }
   return out3 + body.slice(cursor);
@@ -5275,7 +5283,7 @@ function persistWorkerContextSeed(input) {
 import { createHash as createHash13, randomBytes as randomBytes5 } from "node:crypto";
 import { readdirSync as readdirSync8, readFileSync as readFileSync22 } from "node:fs";
 import { isAbsolute as isAbsolute6, relative as relative6, resolve as resolvePath, sep as sep3 } from "node:path";
-import { performance as performance5 } from "node:perf_hooks";
+import { performance as performance4 } from "node:perf_hooks";
 
 // src/core/residency-protection.ts
 init_esm_shims();
@@ -5296,72 +5304,7 @@ function protectedResidencyModels(settings) {
 
 // src/engine/acp/adapter.ts
 init_esm_shims();
-import { performance as performance4 } from "node:perf_hooks";
-
-// src/engine/acp/errors.ts
-init_esm_shims();
-var AcpError = class extends Error {
-  code;
-  data;
-  constructor(code, message, data) {
-    super(message);
-    this.name = "AcpError";
-    this.code = code;
-    this.data = data;
-  }
-};
-var AcpProtocolError = class extends AcpError {
-  constructor(message, data) {
-    super("acp_protocol_error", message, data);
-    this.name = "AcpProtocolError";
-  }
-};
-var AcpTimeoutError = class extends AcpError {
-  constructor(message, data) {
-    super("acp_timeout", message, data);
-    this.name = "AcpTimeoutError";
-  }
-};
-var AcpProcessError = class extends AcpError {
-  constructor(message, data) {
-    super("acp_process_error", message, data);
-    this.name = "AcpProcessError";
-  }
-};
-var ACP_MAX_ERROR_MESSAGE_CHARS = 256;
-var ACP_TURN_FAILED_MESSAGE = "the prompt turn failed";
-var ACP_INTERNAL_ERROR_MESSAGE = "internal error";
-var ACP_METHOD_NOT_FOUND_MESSAGE = "method not found";
-var ACP_ERROR_META_KEY = "clio-coder/error";
-var ACP_ERROR_META_VERSION = 1;
-var AcpRequestError = class extends Error {
-  constructor(rpcCode, message, detail) {
-    super(message);
-    this.rpcCode = rpcCode;
-    this.detail = detail;
-    this.name = "AcpRequestError";
-  }
-  rpcCode;
-  detail;
-};
-function acpErrorData(detail) {
-  return {
-    _meta: {
-      [ACP_ERROR_META_KEY]: {
-        version: ACP_ERROR_META_VERSION,
-        code: detail.code,
-        ...detail.reason !== void 0 ? { reason: detail.reason } : {},
-        ...detail.supported !== void 0 ? { supported: [...detail.supported] } : {}
-      }
-    }
-  };
-}
-function acpErrorMessage(value) {
-  const raw = value instanceof Error ? value.message : String(value);
-  const collapsed = raw.replace(/\s+/g, " ").trim();
-  if (collapsed.length <= ACP_MAX_ERROR_MESSAGE_CHARS) return collapsed;
-  return `${collapsed.slice(0, ACP_MAX_ERROR_MESSAGE_CHARS - 1)}\u2026`;
-}
+import { performance as performance3 } from "node:perf_hooks";
 
 // src/engine/acp/event-mapper.ts
 init_esm_shims();
@@ -5944,677 +5887,84 @@ var AcpToolMediator = class {
     } else if (this.input.toolGovernance === "deny-all") {
       decision = "denied";
       reason = "deny-all governance";
-    } else if (!mapped.known) {
-      decision = "denied";
-      reason = `unknown ACP tool: ${mapped.displayTool}`;
-    } else {
-      const safetyDecisions = mapped.evaluations.map(
-        (evaluation) => this.input.safety.evaluate({ tool: evaluation.tool, args: evaluation.args })
-      );
-      const blocking = safetyDecisions.find((candidate) => candidate.kind === "block");
-      const asking = safetyDecisions.find((candidate) => candidate.kind === "ask");
-      safetyDecision = blocking ?? asking ?? safetyDecisions[0];
-      if (blocking !== void 0) {
-        decision = "denied";
-        reason = blocking.policy?.reasonCode ?? blocking.kind;
-      } else if (asking !== void 0) {
-        decision = "denied";
-        reason = "permission_required: denied by non-stall policy (no interactive operator in delegation context)";
-      } else if (safetyDecisions.length > 0) {
-        const level = this.input.autonomy ?? DEFAULT_AUTONOMY_LEVEL;
-        const dispositions = safetyDecisions.map((candidate) => ({
-          candidate,
-          disposition: mapAutonomy(level, candidate.classification.actionClass, {
-            executeRecognized: candidate.policy?.execRecognition !== "unrecognized"
-          })
-        }));
-        const deniedDisposition = dispositions.find((candidate) => candidate.disposition === "deny");
-        const askDisposition = dispositions.find((candidate) => candidate.disposition === "ask");
-        if (deniedDisposition !== void 0) {
-          safetyDecision = deniedDisposition.candidate;
-          decision = "denied";
-          reason = autonomyDenyRejection(level, mapped.tool, deniedDisposition.candidate.classification.actionClass).short;
-        } else if (askDisposition !== void 0) {
-          safetyDecision = askDisposition.candidate;
-          decision = "denied";
-          reason = `permission_required: autonomy ${level} requires approval for ${askDisposition.candidate.classification.actionClass}; denied by non-stall policy (no interactive operator in delegation context)`;
-        } else {
-          decision = "approved";
-          reason = safetyDecision?.policy?.reasonCode ?? "allowed";
-        }
-      } else {
-        decision = "denied";
-        reason = "ACP tool produced no policy-evaluable arguments";
-      }
-    }
-    if (decision === "approved") this.approved += 1;
-    else this.denied += 1;
-    const loggedSafety = logSafety(safetyDecision);
-    const callId = toolCall?.toolCallId ?? `permission-${this.requested}`;
-    this.log.push({
-      callId,
-      tool: mapped.tool,
-      arguments: { ...mapped.args },
-      decision,
-      ...reason !== void 0 ? { reason } : {},
-      ...loggedSafety !== void 0 ? { safetyDecision: loggedSafety } : {},
-      durationMs: Math.round(performance2.now() - startedAt),
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    });
-    if (decision === "denied" && reason?.startsWith("permission_required:")) {
-      this.input.onPermissionResolved?.({
-        requestId: callId,
-        tool: mapped.tool,
-        actionClass: safetyDecision?.classification.actionClass ?? "unknown",
-        mode: "deny",
-        source: "policy",
-        reason
-      });
-    }
-    return responseFor(decision, options);
-  }
-  snapshot() {
-    return {
-      toolCallsRequested: this.requested,
-      toolCallsApproved: this.approved,
-      toolCallsDenied: this.denied,
-      toolCallLog: [...this.log]
-    };
-  }
-};
-
-// src/engine/acp/transport.ts
-init_esm_shims();
-import { spawn } from "node:child_process";
-import { performance as performance3 } from "node:perf_hooks";
-var ACP_MAX_INPUT_LINE_BYTES = 1024 * 1024;
-function exceedsInputLineBytes(value) {
-  if (value.length <= ACP_MAX_INPUT_LINE_BYTES / 3) return false;
-  return Buffer.byteLength(value, "utf8") > ACP_MAX_INPUT_LINE_BYTES;
-}
-function isRecord7(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isSuccess(value) {
-  return "id" in value && "result" in value;
-}
-function isFailure(value) {
-  return "id" in value && isRecord7(value.error);
-}
-function errorMessage(value) {
-  return value instanceof Error ? value.message : String(value);
-}
-function errorCode(value) {
-  return isRecord7(value) && typeof value.code === "string" ? value.code : void 0;
-}
-function boundedMilliseconds(value, fallback) {
-  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : fallback;
-}
-function validateRequestTimeout(method, timeoutMs) {
-  if (timeoutMs === void 0) return void 0;
-  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0 || timeoutMs > MAX_TIMER_DELAY_MS) {
-    throw new AcpTimeoutError(`ACP request timeout must be between 1 and ${MAX_TIMER_DELAY_MS} ms: ${method}`);
-  }
-  return timeoutMs;
-}
-function jsonRpcError(id, code, message, data) {
-  return {
-    jsonrpc: "2.0",
-    id,
-    error: data === void 0 ? { code, message } : { code, message, data }
-  };
-}
-function handlerErrorFrame(id, err, diagnostics) {
-  if (err instanceof AcpRequestError) {
-    const message = err.detail.code === "internal_error" ? ACP_INTERNAL_ERROR_MESSAGE : acpErrorMessage(err.message);
-    return jsonRpcError(id, err.rpcCode, message, acpErrorData(err.detail));
-  }
-  diagnostics?.(`internal error: ${acpErrorMessage(err)}`);
-  return jsonRpcError(id, -32e3, ACP_INTERNAL_ERROR_MESSAGE, acpErrorData({ code: "internal_error" }));
-}
-var StdioJsonRpcTransport = class {
-  child;
-  terminationScope = process.platform === "win32" ? "child" : "process-group";
-  nextId = 1;
-  buffer = "";
-  isClosed = false;
-  inputEnded = false;
-  childHandlesClosed = false;
-  forceTermination = null;
-  terminationGraceMs;
-  terminationWaitMs;
-  childClosePromise;
-  resolveChildClose = null;
-  pending = /* @__PURE__ */ new Map();
-  notificationHandlers = /* @__PURE__ */ new Map();
-  requestHandlers = /* @__PURE__ */ new Map();
-  stderrHandlers = /* @__PURE__ */ new Set();
-  constructor(command, args, options = {}) {
-    this.terminationGraceMs = boundedMilliseconds(options.terminationGraceMs, 500);
-    this.terminationWaitMs = boundedMilliseconds(options.terminationWaitMs, 2e3);
-    this.childClosePromise = new Promise((resolve11) => {
-      this.resolveChildClose = resolve11;
-    });
-    const childEnvironment = buildSafeToolEnv(options.env);
-    const attribution = withManagedGitCommitAttributionEnvironment(childEnvironment, {
-      cwd: options.cwd ?? process.cwd(),
-      enabled: gitCommitAttributionEnabled(process.env),
-      evidence: { materiallyAssisted: true }
-    });
-    reportCommitAttributionDiagnostic(attribution.diagnostic);
-    this.child = spawn(command, args, {
-      cwd: options.cwd,
-      env: attribution.env,
-      stdio: ["pipe", "pipe", "pipe"],
-      // POSIX detached children lead a new session/process group whose id is
-      // the child pid. That makes negative-pid signaling safe for this owned
-      // group. Windows detached semantics do not provide an equivalent
-      // killable tree, so the explicit fallback there is the direct child.
-      detached: process.platform !== "win32"
-    });
-    this.child.stdout.setEncoding("utf8");
-    this.child.stderr.setEncoding("utf8");
-    this.child.stdout.on("data", (chunk) => this.consumeStdout(chunk));
-    this.child.stderr.on("data", (chunk) => {
-      for (const handler of this.stderrHandlers) handler(chunk);
-    });
-    this.child.on("error", (err) => {
-      this.closeChannel(new AcpProcessError(`ACP process error: ${errorMessage(err)}`));
-    });
-    this.child.on("exit", (code, signal) => {
-      this.isClosed = true;
-      if (this.pending.size === 0) return;
-      const reason = new AcpProcessError(
-        `ACP process exited before replying (code=${code ?? "null"}, signal=${signal ?? "null"})`
-      );
-      this.failAll(reason);
-    });
-    this.child.on("close", () => {
-      this.childHandlesClosed = true;
-      this.isClosed = true;
-      this.resolveChildClose?.();
-      this.resolveChildClose = null;
-    });
-    this.child.stdin.on("error", (err) => {
-      if (!this.isClosed) this.closeChannel(new AcpProcessError(`ACP stdin error: ${errorMessage(err)}`));
-    });
-  }
-  get closed() {
-    return this.isClosed || this.child.exitCode !== null || this.child.signalCode !== null;
-  }
-  get pid() {
-    return this.child.pid ?? null;
-  }
-  request(method, params, timeoutMs) {
-    if (this.closed) throw new AcpProcessError(`ACP process is closed; cannot request ${method}`);
-    const requestTimeoutMs = validateRequestTimeout(method, timeoutMs);
-    const id = this.nextId++;
-    const message = { jsonrpc: "2.0", id, method, params };
-    const promise = new Promise((resolve11, reject) => {
-      const pending = {
-        method,
-        resolve: (value) => resolve11(value),
-        reject
-      };
-      if (requestTimeoutMs !== void 0) {
-        pending.timer = setTimeout(() => {
-          this.pending.delete(id);
-          reject(new AcpTimeoutError(`ACP request timed out after ${requestTimeoutMs}ms: ${method}`));
-        }, requestTimeoutMs);
-      }
-      this.pending.set(id, pending);
-    });
-    this.write(message);
-    return promise;
-  }
-  notify(method, params) {
-    if (this.closed) return;
-    this.write({ jsonrpc: "2.0", method, params });
-  }
-  onNotification(method, handler) {
-    const handlers = this.notificationHandlers.get(method) ?? /* @__PURE__ */ new Set();
-    handlers.add(handler);
-    this.notificationHandlers.set(method, handlers);
-    return () => {
-      handlers.delete(handler);
-    };
-  }
-  onRequest(method, handler) {
-    this.requestHandlers.set(method, handler);
-    return () => {
-      if (this.requestHandlers.get(method) === handler) this.requestHandlers.delete(method);
-    };
-  }
-  onStderr(handler) {
-    this.stderrHandlers.add(handler);
-    return () => {
-      this.stderrHandlers.delete(handler);
-    };
-  }
-  close() {
-    this.closeChannel(new AcpProcessError("ACP transport closed"));
-  }
-  terminate() {
-    this.closeChannel(new AcpProcessError("ACP transport terminated"));
-    this.signalOwnedScope("SIGTERM");
-  }
-  forceTerminate() {
-    if (this.forceTermination !== null) return this.forceTermination;
-    this.forceTermination = this.runForceTermination();
-    return this.forceTermination;
-  }
-  waitForExit(timeoutMs) {
-    return this.waitForTermination(boundedMilliseconds(timeoutMs, 0));
-  }
-  write(message) {
-    if (this.closed || !this.child.stdin.writable || this.child.stdin.destroyed) return;
-    try {
-      this.child.stdin.write(`${JSON.stringify(message)}
-`);
-    } catch (err) {
-      this.closeChannel(new AcpProcessError(`ACP stdin write failed: ${errorMessage(err)}`));
-    }
-  }
-  consumeStdout(chunk) {
-    this.buffer += chunk;
-    for (; ; ) {
-      const idx = this.buffer.indexOf("\n");
-      if (idx === -1) break;
-      const line = this.buffer.slice(0, idx).trimEnd();
-      this.buffer = this.buffer.slice(idx + 1);
-      if (line.length === 0) continue;
-      this.handleLine(line);
-    }
-  }
-  handleLine(line) {
-    const trimmed = line.trimStart();
-    if (!trimmed.startsWith("{")) {
-      return;
-    }
-    let parsed;
-    try {
-      parsed = JSON.parse(trimmed);
-    } catch (err) {
-      this.failAll(new AcpProtocolError(`ACP stdout contained invalid JSON: ${errorMessage(err)}`, { line }));
-      return;
-    }
-    if (!isRecord7(parsed) || parsed.jsonrpc !== "2.0") {
-      return;
-    }
-    if (isSuccess(parsed) || isFailure(parsed)) {
-      this.handleResponse(parsed);
-      return;
-    }
-    const method = typeof parsed.method === "string" ? parsed.method : "";
-    if (!method) {
-      this.failAll(new AcpProtocolError("ACP request/notification missing method", parsed));
-      return;
-    }
-    if ("id" in parsed) {
-      void this.handleIncomingRequest(parsed.id, method, parsed.params);
-      return;
-    }
-    const handlers = this.notificationHandlers.get(method);
-    if (!handlers) return;
-    for (const handler of handlers) handler(parsed.params);
-  }
-  handleResponse(message) {
-    const pending = this.pending.get(message.id ?? "");
-    if (!pending) return;
-    this.pending.delete(message.id ?? "");
-    if (pending.timer) clearTimeout(pending.timer);
-    if ("error" in message) {
-      pending.reject(new AcpProtocolError(`ACP ${pending.method} failed: ${message.error.message}`, message.error));
-      return;
-    }
-    pending.resolve(message.result);
-  }
-  async handleIncomingRequest(id, method, params) {
-    const handler = this.requestHandlers.get(method);
-    if (!handler) {
-      this.write({
-        jsonrpc: "2.0",
-        id,
-        error: { code: -32601, message: `method not found: ${method}` }
-      });
-      return;
-    }
-    try {
-      const result = await handler(params);
-      this.write({ jsonrpc: "2.0", id, result });
-    } catch (err) {
-      this.write(handlerErrorFrame(id, err));
-    }
-  }
-  closeChannel(reason) {
-    if (!this.isClosed) {
-      this.isClosed = true;
-      this.failAll(reason);
-    }
-    if (this.inputEnded) return;
-    this.inputEnded = true;
-    try {
-      this.child.stdin.end();
-    } catch {
-    }
-  }
-  directChildAlive() {
-    return !this.childHandlesClosed && this.child.exitCode === null && this.child.signalCode === null;
-  }
-  processGroupAlive() {
-    if (this.terminationScope !== "process-group") return this.directChildAlive();
-    const pid = this.pid;
-    if (pid === null) return this.directChildAlive();
-    try {
-      process.kill(-pid, 0);
-      return true;
-    } catch (err) {
-      const code = errorCode(err);
-      if (code === "ESRCH") return false;
-      return true;
-    }
-  }
-  terminationObserved() {
-    return this.childHandlesClosed && !this.processGroupAlive();
-  }
-  signalOwnedScope(signal) {
-    const pid = this.pid;
-    if (this.terminationScope === "process-group" && pid !== null) {
-      try {
-        process.kill(-pid, signal);
-        return true;
-      } catch {
-      }
-    }
-    if (!this.directChildAlive()) return false;
-    try {
-      return this.child.kill(signal);
-    } catch {
-      return false;
-    }
-  }
-  async waitForTermination(timeoutMs) {
-    const deadline = performance3.now() + timeoutMs;
-    while (!this.terminationObserved()) {
-      const remaining = deadline - performance3.now();
-      if (remaining <= 0) return this.terminationObserved();
-      const interval = Math.min(10, remaining);
-      if (this.childHandlesClosed) {
-        await new Promise((resolve11) => setTimeout(resolve11, interval));
-      } else {
-        await Promise.race([this.childClosePromise, new Promise((resolve11) => setTimeout(resolve11, interval))]);
-      }
-    }
-    return true;
-  }
-  async runForceTermination() {
-    this.closeChannel(new AcpProcessError("ACP transport force-terminated"));
-    if (this.terminationObserved()) {
-      return { exited: true, escalated: false, scope: this.terminationScope };
-    }
-    this.signalOwnedScope("SIGTERM");
-    if (await this.waitForExit(this.terminationGraceMs)) {
-      return { exited: true, escalated: false, scope: this.terminationScope };
-    }
-    const escalated = this.signalOwnedScope("SIGKILL");
-    const exited = await this.waitForExit(this.terminationWaitMs);
-    return { exited, escalated, scope: this.terminationScope };
-  }
-  failAll(reason) {
-    for (const [id, pending] of this.pending.entries()) {
-      if (pending.timer) clearTimeout(pending.timer);
-      pending.reject(reason);
-      this.pending.delete(id);
-    }
-  }
-};
-function createStdioTransport(command, args = [], options = {}) {
-  if (command.trim().length === 0) {
-    throw new AcpProcessError("ACP stdio command must not be empty");
-  }
-  return new StdioJsonRpcTransport(command, args, options);
-}
-var StreamJsonRpcPeerTransport = class {
-  outputPaused = false;
-  queuedOutputBytes = 0;
-  sinkOutputBytes = 0;
-  outputQueue = [];
-  nextId = 1;
-  buffer = "";
-  /** True while the bytes of an oversized line are being dropped up to its terminating newline. */
-  discardingLine = false;
-  isClosed = false;
-  pending = /* @__PURE__ */ new Map();
-  notificationHandlers = /* @__PURE__ */ new Map();
-  requestHandlers = /* @__PURE__ */ new Map();
-  closeHandlers = /* @__PURE__ */ new Set();
-  input;
-  output;
-  writeOverride;
-  diagnostics;
-  constructor(options = {}) {
-    this.input = options.input ?? process.stdin;
-    this.output = options.output ?? process.stdout;
-    if (options.write !== void 0) this.writeOverride = options.write;
-    if (options.diagnostics !== void 0) this.diagnostics = options.diagnostics;
-    this.input.setEncoding("utf8");
-    this.input.on("data", (chunk) => this.consume(chunk));
-    this.input.on("end", () => this.markClosed(new AcpProcessError("ACP input closed")));
-    this.input.on("error", (err) => this.markClosed(new AcpProcessError(`ACP input error: ${errorMessage(err)}`)));
-    this.output.on?.("error", (err) => this.markClosed(new AcpProcessError(`ACP output error: ${errorMessage(err)}`)));
-  }
-  get closed() {
-    return this.isClosed;
-  }
-  request(method, params, timeoutMs) {
-    if (this.closed) throw new AcpProcessError(`ACP transport is closed; cannot request ${method}`);
-    const requestTimeoutMs = validateRequestTimeout(method, timeoutMs);
-    const id = this.nextId++;
-    const message = { jsonrpc: "2.0", id, method, params };
-    const promise = new Promise((resolve11, reject) => {
-      const pending = {
-        method,
-        resolve: (value) => resolve11(value),
-        reject
-      };
-      if (requestTimeoutMs !== void 0) {
-        pending.timer = setTimeout(() => {
-          this.pending.delete(id);
-          reject(new AcpTimeoutError(`ACP request timed out after ${requestTimeoutMs}ms: ${method}`));
-        }, requestTimeoutMs);
-      }
-      this.pending.set(id, pending);
-    });
-    this.write(message);
-    return promise;
-  }
-  notify(method, params) {
-    if (this.closed) return;
-    this.write({ jsonrpc: "2.0", method, params });
-  }
-  onNotification(method, handler) {
-    const handlers = this.notificationHandlers.get(method) ?? /* @__PURE__ */ new Set();
-    handlers.add(handler);
-    this.notificationHandlers.set(method, handlers);
-    return () => {
-      handlers.delete(handler);
-    };
-  }
-  onRequest(method, handler) {
-    this.requestHandlers.set(method, handler);
-    return () => {
-      if (this.requestHandlers.get(method) === handler) this.requestHandlers.delete(method);
-    };
-  }
-  onClose(handler) {
-    this.closeHandlers.add(handler);
-    return () => {
-      this.closeHandlers.delete(handler);
-    };
-  }
-  close() {
-    this.markClosed(new AcpProcessError("ACP transport closed"));
-  }
-  write(message) {
-    if (this.closed) return;
-    const line = `${JSON.stringify(message)}
-`;
-    if (this.outputPaused) {
-      const bytes = Buffer.byteLength(line, "utf8");
-      if (this.queuedOutputBytes + this.sinkOutputBytes + bytes > ACP_MAX_INPUT_LINE_BYTES) {
-        this.markClosed(new AcpProcessError("ACP output buffer exceeded byte limit"));
-        return;
-      }
-    }
-    this.outputQueue.push(line);
-    this.queuedOutputBytes += Buffer.byteLength(line, "utf8");
-    if (!this.outputPaused) this.flushOutput();
-  }
-  flushOutput = () => {
-    this.outputPaused = false;
-    while (!this.closed && !this.outputPaused && this.outputQueue.length > 0) {
-      const line = this.outputQueue.shift();
-      if (line === void 0) break;
-      this.queuedOutputBytes -= Buffer.byteLength(line, "utf8");
-      try {
-        this.sinkOutputBytes = Math.min(this.sinkOutputBytes, this.output.writableLength * 3);
-        let ready;
-        if (this.writeOverride) {
-          this.writeOverride(line);
-          ready = !this.output.writableNeedDrain;
+    } else if (!mapped.known) {
+      decision = "denied";
+      reason = `unknown ACP tool: ${mapped.displayTool}`;
+    } else {
+      const safetyDecisions = mapped.evaluations.map(
+        (evaluation) => this.input.safety.evaluate({ tool: evaluation.tool, args: evaluation.args })
+      );
+      const blocking = safetyDecisions.find((candidate) => candidate.kind === "block");
+      const asking = safetyDecisions.find((candidate) => candidate.kind === "ask");
+      safetyDecision = blocking ?? asking ?? safetyDecisions[0];
+      if (blocking !== void 0) {
+        decision = "denied";
+        reason = blocking.policy?.reasonCode ?? blocking.kind;
+      } else if (asking !== void 0) {
+        decision = "denied";
+        reason = "permission_required: denied by non-stall policy (no interactive operator in delegation context)";
+      } else if (safetyDecisions.length > 0) {
+        const level = this.input.autonomy ?? DEFAULT_AUTONOMY_LEVEL;
+        const dispositions = safetyDecisions.map((candidate) => ({
+          candidate,
+          disposition: mapAutonomy(level, candidate.classification.actionClass, {
+            executeRecognized: candidate.policy?.execRecognition !== "unrecognized"
+          })
+        }));
+        const deniedDisposition = dispositions.find((candidate) => candidate.disposition === "deny");
+        const askDisposition = dispositions.find((candidate) => candidate.disposition === "ask");
+        if (deniedDisposition !== void 0) {
+          safetyDecision = deniedDisposition.candidate;
+          decision = "denied";
+          reason = autonomyDenyRejection(level, mapped.tool, deniedDisposition.candidate.classification.actionClass).short;
+        } else if (askDisposition !== void 0) {
+          safetyDecision = askDisposition.candidate;
+          decision = "denied";
+          reason = `permission_required: autonomy ${level} requires approval for ${askDisposition.candidate.classification.actionClass}; denied by non-stall policy (no interactive operator in delegation context)`;
         } else {
-          ready = this.output.write(line);
-        }
-        this.sinkOutputBytes = this.output.writableLength === 0 ? 0 : this.sinkOutputBytes + Buffer.byteLength(line, "utf8");
-        if (!ready && !this.closed) {
-          if (this.queuedOutputBytes + this.sinkOutputBytes > ACP_MAX_INPUT_LINE_BYTES) {
-            this.markClosed(new AcpProcessError("ACP output buffer exceeded byte limit"));
-            return;
-          }
-          this.outputPaused = true;
-          this.output.once("drain", this.flushOutput);
+          decision = "approved";
+          reason = safetyDecision?.policy?.reasonCode ?? "allowed";
         }
-      } catch (err) {
-        this.markClosed(new AcpProcessError(`ACP output write failed: ${errorMessage(err)}`));
-      }
-    }
-  };
-  consume(chunk) {
-    this.buffer += chunk;
-    for (; ; ) {
-      const idx = this.buffer.indexOf("\n");
-      if (idx === -1) break;
-      const line = this.buffer.slice(0, idx).trimEnd();
-      this.buffer = this.buffer.slice(idx + 1);
-      if (this.discardingLine) {
-        this.discardingLine = false;
-        continue;
-      }
-      if (line.length === 0) continue;
-      if (exceedsInputLineBytes(line)) {
-        this.reportOversizedLine();
-        continue;
-      }
-      this.handleLine(line);
-    }
-    if (this.discardingLine) {
-      this.buffer = "";
-      return;
-    }
-    if (exceedsInputLineBytes(this.buffer)) {
-      this.buffer = "";
-      this.discardingLine = true;
-      this.reportOversizedLine();
-    }
-  }
-  /** One error frame per oversized line. The transport stays open and parseable. */
-  reportOversizedLine() {
-    this.write(
-      jsonRpcError(null, -32600, "input line exceeds the maximum size", acpErrorData({ code: "input_line_too_large" }))
-    );
-  }
-  handleLine(line) {
-    let parsed;
-    try {
-      parsed = JSON.parse(line);
-    } catch {
-      this.write(jsonRpcError(null, -32700, "parse error", acpErrorData({ code: "parse_error" })));
-      return;
-    }
-    if (!isRecord7(parsed) || parsed.jsonrpc !== "2.0") {
-      this.write(jsonRpcError(null, -32600, "invalid JSON-RPC message", acpErrorData({ code: "invalid_request" })));
-      return;
-    }
-    if (isSuccess(parsed) || isFailure(parsed)) {
-      this.handleResponse(parsed);
-      return;
-    }
-    const method = typeof parsed.method === "string" ? parsed.method : "";
-    const id = "id" in parsed ? parsed.id : void 0;
-    if (!method) {
-      if (id !== void 0) {
-        this.write(
-          jsonRpcError(id, -32600, "request/notification missing method", acpErrorData({ code: "invalid_request" }))
-        );
+      } else {
+        decision = "denied";
+        reason = "ACP tool produced no policy-evaluable arguments";
       }
-      return;
-    }
-    if (id !== void 0) {
-      void this.handleRequest(id, method, parsed.params);
-      return;
     }
-    const handlers = this.notificationHandlers.get(method);
-    if (!handlers) return;
-    for (const handler of handlers) handler(parsed.params);
-  }
-  handleResponse(message) {
-    const pending = this.pending.get(message.id ?? "");
-    if (!pending) return;
-    this.pending.delete(message.id ?? "");
-    if (pending.timer) clearTimeout(pending.timer);
-    if ("error" in message) {
-      pending.reject(new AcpProtocolError(`ACP ${pending.method} failed: ${message.error.message}`, message.error));
-      return;
-    }
-    pending.resolve(message.result);
-  }
-  async handleRequest(id, method, params) {
-    if (id === null) {
-      this.write(jsonRpcError(null, -32600, "request id must not be null", acpErrorData({ code: "invalid_request_id" })));
-      return;
-    }
-    const handler = this.requestHandlers.get(method);
-    if (!handler) {
-      this.write(jsonRpcError(id, -32601, ACP_METHOD_NOT_FOUND_MESSAGE, acpErrorData({ code: "method_not_found" })));
-      return;
-    }
-    try {
-      const result = await handler(params);
-      this.write({ jsonrpc: "2.0", id, result });
-    } catch (err) {
-      this.write(handlerErrorFrame(id, err, this.diagnostics));
+    if (decision === "approved") this.approved += 1;
+    else this.denied += 1;
+    const loggedSafety = logSafety(safetyDecision);
+    const callId = toolCall?.toolCallId ?? `permission-${this.requested}`;
+    this.log.push({
+      callId,
+      tool: mapped.tool,
+      arguments: { ...mapped.args },
+      decision,
+      ...reason !== void 0 ? { reason } : {},
+      ...loggedSafety !== void 0 ? { safetyDecision: loggedSafety } : {},
+      durationMs: Math.round(performance2.now() - startedAt),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    if (decision === "denied" && reason?.startsWith("permission_required:")) {
+      this.input.onPermissionResolved?.({
+        requestId: callId,
+        tool: mapped.tool,
+        actionClass: safetyDecision?.classification.actionClass ?? "unknown",
+        mode: "deny",
+        source: "policy",
+        reason
+      });
     }
+    return responseFor(decision, options);
   }
-  markClosed(reason) {
-    if (this.isClosed) return;
-    this.isClosed = true;
-    this.output.removeListener("drain", this.flushOutput);
-    this.outputQueue.length = 0;
-    this.queuedOutputBytes = 0;
-    this.failAll(reason);
-    for (const handler of this.closeHandlers) handler();
-  }
-  failAll(reason) {
-    for (const [id, pending] of this.pending.entries()) {
-      if (pending.timer) clearTimeout(pending.timer);
-      pending.reject(reason);
-      this.pending.delete(id);
-    }
+  snapshot() {
+    return {
+      toolCallsRequested: this.requested,
+      toolCallsApproved: this.approved,
+      toolCallsDenied: this.denied,
+      toolCallLog: [...this.log]
+    };
   }
 };
-function createStdioServerTransport(options = {}) {
-  return new StreamJsonRpcPeerTransport(options);
-}
 
 // src/engine/acp/types.ts
 init_esm_shims();
@@ -6659,22 +6009,22 @@ var AsyncEventQueue = class {
     }
   }
 };
-function isRecord8(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function sessionIdFrom(value) {
   if (typeof value === "string" && value.length > 0) return value;
-  if (!isRecord8(value)) return null;
+  if (!isRecord7(value)) return null;
   const sessionId = value.sessionId ?? value.id;
   return typeof sessionId === "string" && sessionId.length > 0 ? sessionId : null;
 }
 function supportsSessionClose(init) {
   const caps = init?.agentCapabilities;
-  if (!isRecord8(caps)) return false;
-  const meta = isRecord8(caps._meta) ? caps._meta[ACP_SESSION_META_KEY] : void 0;
-  if (isRecord8(meta) && meta.close === true) return true;
+  if (!isRecord7(caps)) return false;
+  const meta = isRecord7(caps._meta) ? caps._meta[ACP_SESSION_META_KEY] : void 0;
+  if (isRecord7(meta) && meta.close === true) return true;
   const sessionCaps = caps.sessionCapabilities;
-  return isRecord8(sessionCaps) && isRecord8(sessionCaps.close);
+  return isRecord7(sessionCaps) && isRecord7(sessionCaps.close);
 }
 function flattenPrompt(input) {
   const parts = [
@@ -6704,7 +6054,7 @@ function nonnegative(value) {
   return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
 }
 function mergeUsage(into, raw) {
-  if (!isRecord8(raw)) return;
+  if (!isRecord7(raw)) return;
   const tokensReported = [
     raw.input,
     raw.inputTokens,
@@ -6736,7 +6086,7 @@ function mergeUsage(into, raw) {
   into.reasoningTokens += finite(raw.reasoning) + finite(raw.reasoningTokens) + finite(raw.reasoning_tokens);
   const explicitTotal = nonnegative(raw.totalTokens) ?? nonnegative(raw.total_tokens);
   into.totalTokens += explicitTotal ?? input + output + cacheRead + cacheWrite;
-  const cost = (isRecord8(raw.cost) ? nonnegative(raw.cost.total) : void 0) ?? nonnegative(raw.costUsd);
+  const cost = (isRecord7(raw.cost) ? nonnegative(raw.cost.total) : void 0) ?? nonnegative(raw.costUsd);
   into.costUsd += cost ?? 0;
   if (tokensReported || cost !== void 0) {
     const provenance = cost === void 0 ? "unknown" : resolveCostProvenance(raw.costProvenance, "unknown");
@@ -6747,7 +6097,7 @@ function mergeUsage(into, raw) {
     else into.costProvenance = "known";
   }
 }
-function errorMessage2(value) {
+function errorMessage(value) {
   return value instanceof Error ? value.message : String(value);
 }
 function cancelGraceMs(value) {
@@ -6767,7 +6117,7 @@ function startAcpDelegationRun(input) {
   const connectTimeoutMs = input.agent.connectTimeoutMs ?? DEFAULT_DELEGATION_CONNECT_TIMEOUT_MS;
   const turnTimeoutMs = input.agent.turnTimeoutMs ?? DEFAULT_DELEGATION_TURN_TIMEOUT_MS;
   const now = input.now ?? Date.now;
-  const monotonicNow = input.monotonicNow ?? (() => performance4.now());
+  const monotonicNow = input.monotonicNow ?? (() => performance3.now());
   const heartbeatWallAnchor = now();
   const heartbeatMonotonicAnchor = monotonicNow();
   const heartbeatAt = {
@@ -6886,7 +6236,7 @@ function startAcpDelegationRun(input) {
         },
         turnTimeoutMs === 0 ? void 0 : turnTimeoutMs
       );
-      const metaUsage = isRecord8(promptResponse?._meta) ? promptResponse._meta[ACP_USAGE_META_KEY] : void 0;
+      const metaUsage = isRecord7(promptResponse?._meta) ? promptResponse._meta[ACP_USAGE_META_KEY] : void 0;
       if (metaUsage !== void 0) {
         mergeUsage(usage, metaUsage);
       } else {
@@ -6912,7 +6262,7 @@ function startAcpDelegationRun(input) {
       };
     } catch (err) {
       const termination = await beginForceTermination();
-      const baseMessage = `ACP delegation failed: ${errorMessage2(err)}`;
+      const baseMessage = `ACP delegation failed: ${errorMessage(err)}`;
       const message = termination.exited ? baseMessage : `${baseMessage}; ACP ${termination.scope} exit was not observed within the force-termination bound`;
       for (const event of errorEvents(message)) emit(event);
       const toolSnapshot = mediator.snapshot();
@@ -7076,26 +6426,33 @@ function renderToolContractBlock(inputs) {
       "This target cannot call tools; answer from the visible user request and compact context only."
     ].join("\n");
   }
-  const names = [
+  const capabilityNames = [
     ...new Set((inputs.toolNames ?? []).map((name2) => name2.trim()).filter((name2) => name2.length > 0))
   ].sort();
+  const names = directSurfaceNames(capabilityNames).sort();
   const canDispatch = sessionCanDispatch(inputs);
   const canListSkills = sessionHasContext(inputs);
   const admitted = new Set(names);
+  const hasGateway = admitted.has("gateway");
   const inventoryGuidance = [
     "When asked what tools you have, copy the Direct tools line verbatim and call nothing",
     ...canDispatch ? [
       "dispatch(list:true) answers a question about agents, the fleet, or which target and model run this session and its workers"
     ] : [],
-    ...canListSkills ? ['context(scope="skills") answers only a question about skills'] : []
+    ...canListSkills ? ['context(scope="skills") lists skills for discovery or skill questions'] : [],
+    ...hasGateway ? ['gateway(op="find") answers a question about secondary capabilities'] : []
   ].join("; ");
   const capabilityKinds = [
     "direct tools are attached schemas",
+    ...hasGateway ? ["secondary capabilities are reached through gateway find, describe, and call"] : [],
     ...canDispatch ? ["fleet agents are workers behind dispatch"] : [],
-    ...canListSkills ? ["skills are operator-activated workflows reached through context"] : []
+    ...canListSkills ? ["skills are workflows reached through context"] : []
   ];
   const orientationTools = ["context", "code_nav", "grep", "read"].filter((name2) => admitted.has(name2));
-  const validationTools = ["verify", "git"].filter((name2) => admitted.has(name2));
+  const validationTools = [
+    ...admitted.has("verify") ? ["verify"] : [],
+    ...admitted.has("git") ? ["git diff"] : hasGateway ? ['gateway(op="call", capability="git") diff'] : []
+  ];
   const lines = [
     "# Tool Contract",
     TOOL_RESULT_TRUST_CONTRACT,
@@ -7112,12 +6469,10 @@ function renderToolContractBlock(inputs) {
     ...orientationTools.length > 0 ? [
       `For narrow file or symbol orientation, prefer ${orientationTools.join(", ")} instead of assuming source-tree details were preloaded.`
     ] : [],
-    ...validationTools.length > 0 ? [
-      `Validate with ${validationTools.map((name2) => name2 === "git" ? "git diff" : name2).join(" or ")} before final claims.`
-    ] : [],
-    `When a tool call fails or is rejected, do not retry the same shape blindly: re-read the schema and adjust the arguments${canListSkills ? `, or query context(scope="docs") for that tool's usage` : ""}.`
+    ...validationTools.length > 0 ? [`Validate with ${validationTools.join(" or ")} before final claims.`] : [],
+    `When a tool call fails or is rejected, do not retry the same shape blindly: re-read the schema and adjust the arguments${hasGateway ? `, or read that tool's usage with gateway(op="call", capability="clio_docs", args={query})` : ""}.`
   ];
-  const hints = canonicalToolPromptHints(inputs.toolPromptHints ?? [], new Set(names));
+  const hints = canonicalToolPromptHints(inputs.toolPromptHints ?? [], /* @__PURE__ */ new Set([...capabilityNames, ...names]));
   for (const entry of hints) {
     lines.push(entry.hint);
   }
@@ -7170,7 +6525,7 @@ function renderWorkerToolContractBlock(inputs) {
     TOOL_RESULT_TRUST_CONTRACT,
     "The attached schemas are this worker's complete canonical tool surface; follow each schema exactly.",
     `Admitted canonical tools: ${names.map((name2) => `\`${name2}\``).join(", ")}.`,
-    "This worker surface is distinct from the parent session's tools, fleet agents, and operator-activated skills.",
+    "This worker surface is distinct from the parent session's tools, fleet agents, and skills.",
     "Tool authority is limited to this list. Persona and bound-skill instructions never add tools.",
     "Call tools only for concrete inspection or changes the assigned task requires. If the task requests an exact or tool-free response, answer without calling tools."
   ];
@@ -7273,7 +6628,7 @@ function compile(table, inputs) {
   };
   let identityBody = identity.body;
   const selfAwareness = identity.id === "identity.clio" ? table.byId.get("identity.self-awareness") : void 0;
-  const docsRouting = selfAwareness && sessionHasContext(session) ? table.byId.get("identity.docs-routing") : void 0;
+  const docsRouting = selfAwareness && session.providerSupportsTools !== false && toolSurfaceHasTool(session.toolNames, "gateway") ? table.byId.get("identity.docs-routing") : void 0;
   if (selfAwareness) {
     const packageRoot = resolvePackageRoot();
     const clioDirs = resolveClioDirs();
@@ -7284,12 +6639,13 @@ function compile(table, inputs) {
   }
   const delegation = sessionCanDispatch(session) ? table.byId.get("operating.delegation") : void 0;
   const skills = sessionHasContext(session) ? table.byId.get("operating.skills") : void 0;
+  const skillActivation = isAutonomyLevel(autonomyLevel) && modelMayActivateSkills(autonomyLevel) ? 'Load matching installed skills with context(scope="skills", name="<name>") and continue the task; skill restrictions still apply.' : "Suggest matching skills as /skill <name> (in order when several compose), then continue without them; only the operator activates skills.";
   const legacy = inputs.sectionOrder === "legacy-0.3.8";
   const rendered = /* @__PURE__ */ new Map([
     ["identity", identityBody],
     ["operating-contract", operatingContract.body],
     ["delegation", delegation?.body ?? ""],
-    ["skills", skills?.body ?? ""],
+    ["skills", skills?.body.replace("{SKILL_ACTIVATION_POLICY}", skillActivation) ?? ""],
     ["safety", renderSafetySection(safety, autonomyLevel)],
     ["runtime", renderRuntimeBlock(session)],
     ["tool-contract", renderToolContractBlock(session)],
@@ -9699,7 +9055,7 @@ import { dirname as dirname7, join as join19, resolve as resolve9 } from "node:p
 
 // src/domains/dispatch/code-step.ts
 init_esm_shims();
-import { execFileSync as execFileSync2, spawn as spawn2 } from "node:child_process";
+import { execFileSync as execFileSync2, spawn } from "node:child_process";
 import { createHash as createHash8 } from "node:crypto";
 import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync3 } from "node:fs";
 import { isAbsolute as isAbsolute5, join as join18, resolve as resolve8 } from "node:path";
@@ -9777,6 +9133,9 @@ function newCodeRunId() {
 }
 async function spawnCommand(input, cwd, argv) {
   const command = input.command;
+  const captureMaxBytes = input.maxOutputBytes ?? CODE_STEP_CAPTURE_MAX_BYTES;
+  if (!Number.isSafeInteger(captureMaxBytes) || captureMaxBytes <= 0)
+    throw new Error("code step: maxOutputBytes must be a positive safe integer");
   const [executable, ...args] = argv;
   if (executable === void 0) throw new Error(`code step: command '${command.id}' has no executable`);
   return await new Promise((resolvePromise) => {
@@ -9793,7 +9152,7 @@ async function spawnCommand(input, cwd, argv) {
     let settled = false;
     let timedOut = false;
     let spawnError = null;
-    const child = spawn2(executable, args, {
+    const child = spawn(executable, args, {
       cwd,
       env: attribution.env,
       stdio: ["ignore", "pipe", "pipe"],
@@ -9803,8 +9162,8 @@ async function spawnCommand(input, cwd, argv) {
     });
     const collect = (chunk, stdout) => {
       outputBytes += chunk.length;
-      if (captured >= CODE_STEP_CAPTURE_MAX_BYTES) return;
-      const room = CODE_STEP_CAPTURE_MAX_BYTES - captured;
+      if (captured >= captureMaxBytes) return;
+      const room = captureMaxBytes - captured;
       const slice = chunk.length <= room ? chunk : chunk.subarray(0, room);
       chunks.push(slice);
       if (stdout) stdoutChunks.push(slice);
@@ -9944,7 +9303,7 @@ ${spawned.spawnError}
 
 // src/domains/dispatch/host-verification.ts
 var OUTPUT_TAIL_BYTES = 2048;
-var MEMO_VERSION = 2;
+var MEMO_VERSION = 3;
 var HTTP_URL_RE = /\bhttps?:\/\/\S+/gu;
 var CHECK_OUTPUT_PATH_RE = /\/?(?:[A-Za-z0-9_.@+-]+\/)+[A-Za-z0-9_.@+-]*\.(?:[cm]?[jt]sx?|json|ya?ml|md|txt|py|go|rs|c|h|cc|cpp|hpp|java|rb|sh|toml|css|html|sql)\b/gu;
 var IMPLICATED_PATH_CAP = PATH_BOUNDARY_MAX_ENTRIES;
@@ -10037,7 +9396,8 @@ function judgeResolvedCheck(resolvedCheck, exitCode, durationMs2, stdout) {
       stdout,
       referenceText,
       resolvedCheck.numeric.tolerance,
-      `reference '${resolvedCheck.numeric.reference}'`
+      `reference '${resolvedCheck.numeric.reference}'`,
+      resolvedCheck.numeric.reference
     );
     if (report instanceof Error) return { exitCode: 1, outputTail: `numeric-compare: ${report.message}` };
     return { exitCode: report.passed ? 0 : 1, report, outputTail: outputTail(report.summary) };
@@ -10075,20 +9435,21 @@ async function runResolvedCheck(input) {
       outputExcerpt: ""
     };
   }
+  const judged = resolvedCheck.kind === "numeric-compare" || resolvedCheck.kind === "perf-budget";
+  const captureMaxBytes = judged ? JUDGED_CHECK_MAX_OUTPUT_BYTES : CODE_STEP_CAPTURE_MAX_BYTES;
   const outcome = await runCodeStep({
     stepId: `verification-${input.index + 1}-${resolvedCheck.check.replace(/[^a-z0-9._-]/giu, "_")}`,
     command,
     workspaceRoot: resolvedCheck.cwd,
     artifactDir: join19(input.stateDir, "artifacts", input.runId, "verification"),
-    env: input.env
+    env: input.env,
+    maxOutputBytes: captureMaxBytes
   });
   const artifactPath = outcome.record.artifactPaths[0];
-  const judgement = judgeResolvedCheck(
-    resolvedCheck,
-    outcome.record.exitCode,
-    outcome.record.durationMs,
-    outcome.stdout
-  );
+  const judgement = judged && outcome.record.outputTruncated && outcome.record.outputBytes > captureMaxBytes ? {
+    exitCode: 1,
+    outputTail: `verify: ${resolvedCheck.kind} command output exceeded ${captureMaxBytes} bytes before judgement; captured output was truncated`
+  } : judgeResolvedCheck(resolvedCheck, outcome.record.exitCode, outcome.record.durationMs, outcome.stdout);
   const check = {
     check: resolvedCheck.check,
     argv: [...outcome.record.argv],
@@ -10151,11 +9512,7 @@ function checkDedupeKey(resolvedCheck) {
       numeric: numeric === void 0 ? void 0 : {
         reference: numeric.reference,
         referenceDigest: sha2564(JSON.stringify(readSealedFile(numeric.reference) ?? null)),
-        tolerance: {
-          absolute: numeric.tolerance.absolute,
-          relative: numeric.tolerance.relative,
-          ulp: numeric.tolerance.ulp
-        }
+        tolerance: numeric.tolerance
       },
       perf: perf === void 0 ? void 0 : {
         budget: perf.budget === void 0 ? void 0 : {
@@ -10710,6 +10067,7 @@ function envelopeFromReceipt(receipt, status, receiptPath) {
   };
   if (receipt.cacheReadTokenCount !== void 0) envelope.cacheReadTokenCount = receipt.cacheReadTokenCount;
   if (receipt.cacheWriteTokenCount !== void 0) envelope.cacheWriteTokenCount = receipt.cacheWriteTokenCount;
+  if (receipt.cacheWrite1hTokenCount !== void 0) envelope.cacheWrite1hTokenCount = receipt.cacheWrite1hTokenCount;
   if (receipt.reasoningTokenCount !== void 0) envelope.reasoningTokenCount = receipt.reasoningTokenCount;
   if (receipt.inputTokenCount !== void 0) envelope.inputTokenCount = receipt.inputTokenCount;
   if (receipt.outputTokenCount !== void 0) envelope.outputTokenCount = receipt.outputTokenCount;
@@ -11247,7 +10605,7 @@ function compareRecords(left, right) {
   return left.settledAt.localeCompare(right.settledAt) || left.receiptDigest.localeCompare(right.receiptDigest);
 }
 function validateRecord(value) {
-  if (!isRecord9(value) || value.version !== ROUTE_HISTORY_VERSION)
+  if (!isRecord8(value) || value.version !== ROUTE_HISTORY_VERSION)
     throw new Error("route history record has unsupported version");
   if (!isDigest(value.receiptDigest)) throw new Error("route history receipt digest invalid");
   if (typeof value.assignmentId !== "string" || value.assignmentId.length === 0)
@@ -11300,7 +10658,7 @@ function readHistory(path2) {
   } catch (error) {
     throw new Error(`route history unreadable: ${error instanceof Error ? error.message : String(error)}`);
   }
-  if (!isRecord9(parsed) || !Array.isArray(parsed.records)) throw new Error("route history has unsupported format");
+  if (!isRecord8(parsed) || !Array.isArray(parsed.records)) throw new Error("route history has unsupported format");
   if (parsed.version !== ROUTE_HISTORY_VERSION) {
     retireHistory(path2, parsed.version);
     return [];
@@ -11360,14 +10718,14 @@ function createRouteHistoryStore(options = {}) {
     }
   };
 }
-function isRecord9(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isDigest(value) {
   return typeof value === "string" && /^[0-9a-f]{64}$/u.test(value);
 }
 function isRouteCandidate(value) {
-  if (!isRecord9(value)) return false;
+  if (!isRecord8(value)) return false;
   if (!isExecutionRole(value.executionRole)) return false;
   return [
     value.agentId,
@@ -11383,7 +10741,7 @@ function isRouteCandidate(value) {
   ].every((field) => typeof field === "string");
 }
 function isPhaseTiming(value) {
-  if (!isRecord9(value)) return false;
+  if (!isRecord8(value)) return false;
   return [
     "requestToDecisionMs",
     "decisionMs",
@@ -11860,15 +11218,15 @@ function receiptGatewayRoutingLabel(receipt) {
 var RUN_TAIL_ENTRY_LIMIT = 100;
 var RUN_TAIL_RUN_LIMIT = 64;
 var RUN_TAIL_TEXT_LIMIT = 600;
-function isRecord10(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function eventDetail(event) {
-  const normalized = isRecord10(event) ? normalizeClioCoderEventRecord(event) : event;
+  const normalized = isRecord9(event) ? normalizeClioCoderEventRecord(event) : event;
   const text = assistantTextFromEvent(normalized);
   if (text.length > 0) return truncateUtf8(text, RUN_TAIL_TEXT_LIMIT, "...");
-  if (!isRecord10(normalized)) return void 0;
-  if (normalized.type === "clio_coder_tool_finish" && isRecord10(normalized.payload)) {
+  if (!isRecord9(normalized)) return void 0;
+  if (normalized.type === "clio_coder_tool_finish" && isRecord9(normalized.payload)) {
     const tool = typeof normalized.payload.tool === "string" ? normalized.payload.tool : "tool";
     const outcome = typeof normalized.payload.outcome === "string" ? normalized.payload.outcome : "";
     return `${tool} ${outcome}`.trim();
@@ -11882,7 +11240,7 @@ function eventDetail(event) {
   return void 0;
 }
 function runTailEntryFromEvent(event, at = (/* @__PURE__ */ new Date()).toISOString()) {
-  const type = isRecord10(event) && typeof event.type === "string" ? normalizeClioCoderEventType(event.type) : "unknown";
+  const type = isRecord9(event) && typeof event.type === "string" ? normalizeClioCoderEventType(event.type) : "unknown";
   if (type === "heartbeat" || type === "message_update") return null;
   const entry = { at, type };
   const detail = eventDetail(event);
@@ -11900,7 +11258,7 @@ function createDispatchRunEventRegistry(options = {}) {
   const activeBatches = /* @__PURE__ */ new Set();
   const journal = options.journal === void 0 ? defaultRunEventJournal() : options.journal;
   const journalSeal = (logicalRunId, receipt) => {
-    if (journal === null || !isRecord10(receipt)) return;
+    if (journal === null || !isRecord9(receipt)) return;
     const digest = receipt.integrity?.digest;
     const outcome = typeof receipt.outcome === "string" ? receipt.outcome : REGISTRY_UNKNOWN_OUTCOME;
     journal.receipt(logicalRunId, {
@@ -11959,7 +11317,7 @@ function createDispatchRunEventRegistry(options = {}) {
     };
     for await (const event of events) {
       summary.count += 1;
-      const type = isRecord10(event) && typeof event.type === "string" ? event.type : "unknown";
+      const type = isRecord9(event) && typeof event.type === "string" ? event.type : "unknown";
       summary.types.push(type);
       if (type === "attempt_start") summary.lastAssistantText = "";
       const text = durableAssistantTextFromEvent(event);
@@ -11972,7 +11330,7 @@ function createDispatchRunEventRegistry(options = {}) {
   const drainBatch = async (batchId, events, bus) => {
     const summaries = /* @__PURE__ */ new Map();
     for await (const event of events) {
-      if (!isRecord10(event) || event.type !== "batch_run_event") continue;
+      if (!isRecord9(event) || event.type !== "batch_run_event") continue;
       const runId = typeof event.runId === "string" ? event.runId : batchId;
       const agentId = typeof event.agentId === "string" ? event.agentId : "batch";
       const inner = event.event;
@@ -11983,7 +11341,7 @@ function createDispatchRunEventRegistry(options = {}) {
         terminalAttemptRunId: runId
       };
       summary.count += 1;
-      const type = isRecord10(inner) && typeof inner.type === "string" ? inner.type : "unknown";
+      const type = isRecord9(inner) && typeof inner.type === "string" ? inner.type : "unknown";
       summary.types.push(type);
       const text = durableAssistantTextFromEvent(inner);
       if (text.trim().length > 0) summary.lastAssistantText = text;
@@ -12089,11 +11447,11 @@ function createDispatchRunEventRegistry(options = {}) {
 
 // src/domains/dispatch/run-event-journal-bridge.ts
 var OPENED_RUN_LIMIT = 512;
-function isRecord11(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function runIdentity(payload) {
-  if (!isRecord11(payload)) return null;
+  if (!isRecord10(payload)) return null;
   if (typeof payload.runId !== "string" || payload.runId.length === 0) return null;
   return { runId: payload.runId, agentId: typeof payload.agentId === "string" ? payload.agentId : "unknown" };
 }
@@ -12114,7 +11472,7 @@ function attachRunEventJournalBridge(bus, options = {}) {
     const identity = runIdentity(payload);
     if (identity === null) return;
     ensureOpen(identity.runId, identity.agentId);
-    const exitCode = isRecord11(payload) && typeof payload.exitCode === "number" ? payload.exitCode : null;
+    const exitCode = isRecord10(payload) && typeof payload.exitCode === "number" ? payload.exitCode : null;
     journal.receipt(identity.runId, { outcome, exitCode });
     journal.terminal(identity.runId, outcome, detail ?? void 0);
     opened.delete(identity.runId);
@@ -12126,7 +11484,7 @@ function attachRunEventJournalBridge(bus, options = {}) {
       const entry = runTailEntryFromEvent(payload.event);
       if (entry === null) return;
       ensureOpen(identity.runId, identity.agentId);
-      const message = isRecord11(payload.event) && typeof payload.event.message === "string" ? payload.event.message : void 0;
+      const message = isRecord10(payload.event) && typeof payload.event.message === "string" ? payload.event.message : void 0;
       journal.append(
         identity.runId,
         entry.detail === void 0 && message !== void 0 ? { ...entry, detail: message } : entry
@@ -12246,7 +11604,7 @@ function listFleetRuns(limit = MAX_FLEET_RUN_SCAN) {
   records.sort((a, b) => (Date.parse(b.startedAt) || 0) - (Date.parse(a.startedAt) || 0));
   return records.slice(0, Math.max(0, limit));
 }
-function isRecord12(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function readRuns() {
@@ -12258,7 +11616,7 @@ function readRuns() {
   if (!Array.isArray(parsed)) return [];
   const envelopes = [];
   for (const entry of parsed) {
-    if (!isRecord12(entry)) continue;
+    if (!isRecord11(entry)) continue;
     const version = entry.version === void 0 ? 1 : entry.version;
     if (version !== 1) continue;
     envelopes.push({ ...entry, version: 1 });
@@ -12310,7 +11668,6 @@ function capRuns(all, maxRuns) {
   return kept;
 }
 function openLedger(opts) {
-  const maxRuns = resolveMaxRuns(opts?.maxRuns);
   let runs = readRuns();
   const dirty = /* @__PURE__ */ new Set();
   function findIndex(id) {
@@ -12416,7 +11773,7 @@ function openLedger(opts) {
         if (stateRootRemoved()) return;
         const diskRuns = readRuns();
         const merged = mergeRunsById(diskRuns, runs, dirty);
-        const capped = capRuns(merged, maxRuns);
+        const capped = capRuns(merged, resolveMaxRuns(opts?.maxRuns));
         runs = capped;
         atomicWrite(target, JSON.stringify(capped, null, 2));
         if (merged.length > capped.length) {
@@ -12606,9 +11963,30 @@ function sealRouteDecision(draft, decision) {
 }
 var UNKNOWN_PRICING_ADMISSION_ESTIMATE_USD = 1;
 function calculateUsageCostUsd(meter, pricing) {
+  if (meter.costUsd !== void 0) return meter.costUsd;
   if (pricing === null) return 0;
   return (meter.inputTokens * pricing.input + meter.outputTokens * pricing.output + meter.cacheReadTokens * pricing.cacheRead + meter.cacheWriteTokens * pricing.cacheWrite) / 1e6;
 }
+function accumulateNativeUsage(meter, usage, pricing) {
+  const count = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
+  const call = {
+    inputTokens: count(usage.input),
+    outputTokens: count(usage.output),
+    cacheReadTokens: count(usage.cacheRead),
+    cacheWriteTokens: count(usage.cacheWrite),
+    reasoningTokens: extractReasoningTokenCount(usage)
+  };
+  const reported = isRecord12(usage.cost) ? usage.cost.total : void 0;
+  const callCost = typeof reported === "number" && Number.isFinite(reported) && reported >= 0 ? reported : calculateUsageCostUsd(call, pricing);
+  meter.costUsd = (meter.costUsd ?? 0) + callCost;
+  meter.inputTokens += call.inputTokens;
+  meter.outputTokens += call.outputTokens;
+  meter.cacheReadTokens += call.cacheReadTokens;
+  meter.cacheWriteTokens += call.cacheWriteTokens;
+  if (typeof usage.cacheWrite1h === "number" && usage.cacheWrite1h >= 0 && usage.cacheWrite1h <= call.cacheWriteTokens)
+    meter.cacheWrite1hTokens = (meter.cacheWrite1hTokens ?? 0) + usage.cacheWrite1h;
+  meter.reasoningTokens += call.reasoningTokens;
+}
 function admissionMaxOutputTokens(settings) {
   return settings?.chat.maxOutputTokens ?? DEFAULT_SETTINGS.chat.maxOutputTokens;
 }
@@ -12633,12 +12011,12 @@ function promptCompositionHash(parts) {
 function toolSignature(tools) {
   return sha2566(JSON.stringify([...tools].sort()));
 }
-function isRecord13(value) {
+function isRecord12(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function eventContainsFirstModelToken(event) {
   if (event.type === "message_end") return true;
-  const assistantEvent = isRecord13(event.assistantMessageEvent) ? event.assistantMessageEvent : null;
+  const assistantEvent = isRecord12(event.assistantMessageEvent) ? event.assistantMessageEvent : null;
   return assistantEvent?.type === "text_delta" || assistantEvent?.type === "thinking_delta" || assistantEvent?.type === "toolcall_start" || assistantEvent?.type === "toolcall_delta";
 }
 function eventStartsTool(event) {
@@ -12650,13 +12028,13 @@ function finitePositive(value) {
 function nestedFinitePositive(record, path2) {
   let cursor = record;
   for (const key of path2) {
-    if (!isRecord13(cursor)) return void 0;
+    if (!isRecord12(cursor)) return void 0;
     cursor = cursor[key];
   }
   return finitePositive(cursor);
 }
 function extractReasoningTokenCount(usage) {
-  if (!isRecord13(usage)) return 0;
+  if (!isRecord12(usage)) return 0;
   const direct = finitePositive(usage.reasoningTokens) ?? finitePositive(usage.reasoning_tokens) ?? finitePositive(usage.reasoning);
   if (direct !== void 0) return direct;
   const paths = [
@@ -12682,14 +12060,14 @@ function readStringArrayOrNull(value) {
   return strings.length === value.length ? strings : null;
 }
 function messageText(value) {
-  const record = isRecord13(value) ? value : null;
+  const record = isRecord12(value) ? value : null;
   if (record === null) return "";
   const content = record.content;
   if (typeof content === "string") return content;
   if (Array.isArray(content)) {
     return content.map((part) => {
       if (typeof part === "string") return part;
-      if (!isRecord13(part)) return "";
+      if (!isRecord12(part)) return "";
       const text2 = part.text;
       return typeof text2 === "string" ? text2 : "";
     }).join("");
@@ -12731,7 +12109,7 @@ function appendDispatchFinishContractEntry(entries, event) {
     return null;
   }
   if (eventType !== "message_end") return null;
-  const message = isRecord13(event.message) ? event.message : null;
+  const message = isRecord12(event.message) ? event.message : null;
   if (message === null) return null;
   const role = readStringOrNull(message.role);
   if (role !== "user" && role !== "assistant") return null;
@@ -12754,7 +12132,7 @@ function recordWorkerRunEffect(recorder, event) {
   if (event.type === "tool_execution_start") {
     const toolName = readStringOrNull(event.toolName) ?? readStringOrNull(event.tool);
     if (toolName === null) return;
-    recorder.start(toolCallId, toolName, isRecord13(event.args) ? event.args : void 0);
+    recorder.start(toolCallId, toolName, isRecord12(event.args) ? event.args : void 0);
     return;
   }
   if (event.type === "tool_execution_end") recorder.finish(toolCallId, event.isError === true);
@@ -13209,21 +12587,25 @@ function effectiveToolNames(allowedTools, target, writeConfined = false, denied
   const networkStripped = networkToolsDisabled();
   const harnessTools = target.runtime.kind === "http" && !writeConfined && allowedTools.some(isHarnessExtensionToolName) ? enabledHarnessExtensionToolNames(cwd) : /* @__PURE__ */ new Set();
   const names = allowedTools.filter(
-    (tool) => (isBuiltinToolName(tool) || harnessTools.has(tool)) && tool !== ToolNames.AskUser && !(networkStripped && tool === ToolNames.WebFetch) && !denied.has(tool) && !(writeConfined && WRITE_ROOT_REFUSED_TOOLS.has(tool)) && (target.runtime.id !== "claude-sdk" || isClaudeCanonicalTool(tool))
+    (tool) => (isBuiltinToolName(tool) || harnessTools.has(tool)) && tool !== ToolNames.AskUser && !(networkStripped && (tool === ToolNames.WebFetch || tool === ToolNames.WebRead)) && !denied.has(tool) && !(writeConfined && WRITE_ROOT_REFUSED_TOOLS.has(tool)) && (target.runtime.id !== "claude-sdk" || isClaudeCanonicalTool(tool))
   );
-  return [...new Set(names)].sort();
+  const mediated = target.runtime.kind === "http" && target.runtime.id !== "claude-sdk";
+  const surface = mediated ? withGatewayForCapabilities(names) : [...new Set(names)];
+  return surface.sort();
 }
 function deniedToolNames(req) {
   if (!req.denyTools || req.denyTools.length === 0) return /* @__PURE__ */ new Set();
   return new Set(req.denyTools.map((tool) => tool.trim().toLowerCase()));
 }
-function assertPostRuntimeToolCompatibility(agentId, spec, effectiveTools, target) {
+function assertPostRuntimeToolCompatibility(agentId, spec, effectiveTools, target, writeConfined) {
   const compatibility = resolveAgentToolCompatibility(spec, effectiveTools, {
     mediatesDispatch: WORKER_RUNTIME_MEDIATES_CLIO_DISPATCH
   });
   if (compatibility.compatible) return;
+  const confined = writeConfined ? compatibility.missingRequired.filter((tool) => WRITE_ROOT_REFUSED_TOOLS.has(tool)) : [];
+  const cause = confined.length > 0 ? `; declared write roots remove ${confined.join(", ")}, so omit write roots (use autonomy: "read-only" or worktree: true) for this agent` : "";
   throw new Error(
-    `dispatch: admission denied: agent '${agentId}' is incompatible with runtime '${target.runtime.id}' after tool narrowing; missing required tools: ${compatibility.missingRequired.join(", ")}`
+    `dispatch: admission denied: agent '${agentId}' is incompatible with runtime '${target.runtime.id}' after tool narrowing; missing required tools: ${compatibility.missingRequired.join(", ")}${cause}`
   );
 }
 function workerToolCallHardCap(settings) {
@@ -13877,7 +13259,7 @@ function createDispatchBundle(context, options) {
     return DEFAULT_RESILIENCE_COOLDOWN_MS;
   };
   const now = options?.now ?? (() => Date.now());
-  const monotonicNow = options?.monotonicNow ?? (() => performance5.now());
+  const monotonicNow = options?.monotonicNow ?? (() => performance4.now());
   const routeObserver = options?.routeObserver ?? createRouteObserver({});
   let ledger = null;
   let heartbeatTimer = null;
@@ -14080,6 +13462,21 @@ function createDispatchBundle(context, options) {
   const retryBackoff = /* @__PURE__ */ new Map();
   const retryReasons = /* @__PURE__ */ new Map();
   const assignmentRootsByAttempt = /* @__PURE__ */ new Map();
+  const controlRootsByAttempt = /* @__PURE__ */ new Map();
+  const controlAttempts = /* @__PURE__ */ new Map();
+  const canceledControlRoots = /* @__PURE__ */ new Set();
+  const memberWork = /* @__PURE__ */ new Map();
+  function trackMemberWork(runId, operation) {
+    const root = controlRootsByAttempt.get(runId) ?? runId;
+    const work = memberWork.get(root) ?? /* @__PURE__ */ new Set();
+    memberWork.set(root, work);
+    work.add(operation);
+    const settled = () => {
+      work.delete(operation);
+      if (work.size === 0) memberWork.delete(root);
+    };
+    operation.then(settled, settled);
+  }
   const assignments = new AssignmentRegistry({
     onStreamError: (error) => reportDispatchDiagnostic("assignment event stream", error)
   });
@@ -14105,6 +13502,11 @@ function createDispatchBundle(context, options) {
   function lineageFor(req, runId) {
     const lineage = req.lineage ? { ...req.lineage } : { parentRunId: null, rootRunId: runId, attempt: 0, depth: 0 };
     assignmentRootsByAttempt.set(runId, lineage.rootRunId);
+    const parent = lineage.parentRunId === null ? void 0 : controlAttempts.get(lineage.parentRunId);
+    const continuesParent = parent !== void 0 && parent.lineage.rootRunId === lineage.rootRunId && parent.lineage.depth === lineage.depth && parent.lineage.attempt + 1 === lineage.attempt && parent.reservation?.ownerId === req.reservation?.ownerId && parent.reservation?.memberId === req.reservation?.memberId;
+    const priorControl = continuesParent && lineage.parentRunId !== null ? controlRootsByAttempt.get(lineage.parentRunId) : void 0;
+    controlRootsByAttempt.set(runId, priorControl ?? runId);
+    controlAttempts.set(runId, { lineage, reservation: req.reservation });
     return lineage;
   }
   function publishedLineage(lineage, hostRun) {
@@ -14148,7 +13550,8 @@ function createDispatchBundle(context, options) {
     capacityAdmission.releaseAssignment(rootRunId);
   }
   function retryChainIsLive(run) {
-    if (run.aborted) return false;
+    if (run.aborted || canceledControlRoots.has(controlRootsByAttempt.get(run.runId) ?? run.lineage.rootRunId))
+      return false;
     const reservation = run.req.reservation;
     if (reservation === void 0) return assignments.get(run.lineage.rootRunId)?.status === "running";
     try {
@@ -14207,9 +13610,16 @@ function createDispatchBundle(context, options) {
     const attempt = run.lineage.attempt + 1;
     const reason = detail !== null ? `${outcome}: ${detail}` : outcome;
     const dueAt = now() + delayMs;
+    let settleCanceled;
+    let rejectContinuation;
+    const continuation = new Promise((resolve11, reject) => {
+      settleCanceled = resolve11;
+      rejectContinuation = reject;
+    });
+    trackMemberWork(run.runId, continuation);
     const timer = setTimeout(() => {
       retryQueue.delete(run.runId);
-      void executeRetry(run, attempt, reason, decision);
+      executeRetry(run, attempt, reason, decision).then(settleCanceled, rejectContinuation);
     }, delayMs);
     retryQueue.set(run.runId, {
       runId: run.runId,
@@ -14221,7 +13631,8 @@ function createDispatchBundle(context, options) {
       excludedRouteParts: [...decision.excludedRouteParts],
       rootRunId,
       terminalCandidate: receipt,
-      timer
+      timer,
+      settleCanceled
     });
     context.bus.emit(BusChannels.DispatchProgress, {
       runId: run.runId,
@@ -14294,6 +13705,7 @@ function createDispatchBundle(context, options) {
       }
     };
     delete retryReq.runIdHint;
+    let terminal;
     const reasonKey = retryReasonKey(run.lineage.rootRunId, attempt);
     retryReasons.set(reasonKey, reason);
     try {
@@ -14357,6 +13769,9 @@ function createDispatchBundle(context, options) {
         if (decision.excludedRouteParts.includes("runtime")) delete retryReq.workerRuntime;
       }
       const handle = await dispatch(retryReq, void 0, run.hostRun === void 0 ? void 0 : { hostRun: run.hostRun });
+      if (canceledControlRoots.has(controlRootsByAttempt.get(run.runId) ?? run.lineage.rootRunId)) {
+        contract.abort(handle.runId);
+      }
       const marker = {
         type: "attempt_start",
         attempt,
@@ -14377,6 +13792,7 @@ function createDispatchBundle(context, options) {
         runtimeKind: run.runtimeKind,
         event: marker
       });
+      terminal = handle.finalPromise;
       handle.finalPromise.catch((error) => {
         assignments.reject(asAssignmentId(run.lineage.rootRunId), error);
         reportDispatchDiagnostic(`finalize retry run ${handle.runId}`, error);
@@ -14407,6 +13823,7 @@ function createDispatchBundle(context, options) {
         outcomeDetail: denial
       });
     }
+    await terminal;
   }
   function requireLedger() {
     if (!ledger) throw new Error("dispatch: ledger not initialised");
@@ -14701,7 +14118,7 @@ function createDispatchBundle(context, options) {
       ),
       req
     );
-    assertPostRuntimeToolCompatibility(req.agentId, spec, effectiveTools, target);
+    assertPostRuntimeToolCompatibility(req.agentId, spec, effectiveTools, target, pathScope.writeBoundaries.length > 0);
     const effectiveAdmission = {
       ...admission,
       allowedTools: effectiveTools
@@ -14954,7 +14371,13 @@ function createDispatchBundle(context, options) {
       throw error;
     }
     timing.workerSpawnedAt = new Date(now()).toISOString();
-    const tokenMeter = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, reasoningTokens: 0 };
+    const tokenMeter = {
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheReadTokens: 0,
+      cacheWriteTokens: 0,
+      reasoningTokens: 0
+    };
     const safetyDecisionCounts = { allowed: 0, blocked: 0, permissionRequested: 0 };
     const blockedAttempts = [];
     const toolStats = /* @__PURE__ */ new Map();
@@ -14987,7 +14410,7 @@ function createDispatchBundle(context, options) {
     const foldAcpEvent = (raw) => {
       outputCapture.observe(raw);
       const event = raw;
-      if (isRecord13(event)) {
+      if (isRecord12(event)) {
         if (eventContainsFirstModelToken(event)) markObservedPhase("firstModelTokenAt");
         if (eventStartsTool(event)) markObservedPhase("firstToolAt");
       }
@@ -14998,14 +14421,14 @@ function createDispatchBundle(context, options) {
         reportedSpoofedOutcome = true;
         reportDispatchDiagnostic("ACP outcome event", new Error("ignored untrusted clio_coder_run_outcome assertion"));
       }
-      if (isRecord13(event)) {
+      if (isRecord12(event)) {
         const finishEntry = appendDispatchFinishContractEntry(finishContractEntries, event);
         if (finishEntry !== null) {
           finishContractAssistantText = finishEntry.assistantText;
           finishContractAssistantTurnId = finishEntry.assistantTurnId;
         }
       }
-      if (event.type === "message_end" && event.message?.role === "assistant" && isRecord13(event.message.usage)) {
+      if (event.type === "message_end" && event.message?.role === "assistant" && isRecord12(event.message.usage)) {
         const u = event.message.usage;
         tokenMeter.inputTokens += typeof u.input === "number" ? u.input : 0;
         tokenMeter.outputTokens += typeof u.output === "number" ? u.output : 0;
@@ -15166,7 +14589,7 @@ function createDispatchBundle(context, options) {
     }
     const eventPump = startDispatchEventPump(acp.events, foldAcpEvent, {
       onEvent: (event) => {
-        if (isRecord13(event) && event.type === "heartbeat") return;
+        if (isRecord12(event) && event.type === "heartbeat") return;
         context.bus.emit(BusChannels.DispatchProgress, {
           runId: envelope.id,
           agentId: req.agentId,
@@ -15284,6 +14707,7 @@ function createDispatchBundle(context, options) {
         outputTokenCount: tokenMeter.outputTokens,
         cacheReadTokenCount: tokenMeter.cacheReadTokens,
         cacheWriteTokenCount: tokenMeter.cacheWriteTokens,
+        ...tokenMeter.cacheWrite1hTokens === void 0 ? {} : { cacheWrite1hTokenCount: tokenMeter.cacheWrite1hTokens },
         reasoningTokenCount: tokenMeter.reasoningTokens,
         ...upstreamResponses.length > 0 ? { upstreamResponses: [...upstreamResponses] } : {},
         ...capturedOutput !== void 0 ? { output: capturedOutput } : {},
@@ -15368,6 +14792,7 @@ function createDispatchBundle(context, options) {
         outputTokenCount: receipt.outputTokenCount ?? 0,
         cacheReadTokenCount: receipt.cacheReadTokenCount ?? 0,
         cacheWriteTokenCount: receipt.cacheWriteTokenCount ?? 0,
+        ...receipt.cacheWrite1hTokenCount === void 0 ? {} : { cacheWrite1hTokenCount: receipt.cacheWrite1hTokenCount },
         reasoningTokenCount: receipt.reasoningTokenCount ?? 0,
         staticShellHash: receipt.staticShellHash ?? null,
         sessionShellHash: receipt.sessionShellHash ?? null,
@@ -15482,6 +14907,7 @@ function createDispatchBundle(context, options) {
           dynamicHash: receiptDraft.dynamicHash ?? null,
           cacheReadTokenCount: receiptDraft.cacheReadTokenCount ?? 0,
           cacheWriteTokenCount: receiptDraft.cacheWriteTokenCount ?? 0,
+          ...receiptDraft.cacheWrite1hTokenCount === void 0 ? {} : { cacheWrite1hTokenCount: receiptDraft.cacheWrite1hTokenCount },
           reasoningTokenCount: receiptDraft.reasoningTokenCount ?? 0,
           heartbeatAt: heartbeatIso(acp.heartbeatAt)
         };
@@ -15727,7 +15153,13 @@ function createDispatchBundle(context, options) {
         throw error;
       }
     })();
-    const tokenMeter = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, reasoningTokens: 0 };
+    const tokenMeter = {
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheReadTokens: 0,
+      cacheWriteTokens: 0,
+      reasoningTokens: 0
+    };
     const safetyDecisionCounts = { allowed: 0, blocked: 0, permissionRequested: 0 };
     const escalationCounts = { requested: 0, approved: 0, denied: 0, timedOut: 0 };
     const blockedAttempts = [];
@@ -15871,7 +15303,7 @@ function createDispatchBundle(context, options) {
     const foldWorkerEvent = (raw) => {
       outputCapture.observe(raw);
       const event = raw;
-      if (isRecord13(event)) {
+      if (isRecord12(event)) {
         if (eventContainsFirstModelToken(event)) markObservedPhase("firstModelTokenAt");
         if (eventStartsTool(event)) markObservedPhase("firstToolAt");
       }
@@ -15890,7 +15322,7 @@ function createDispatchBundle(context, options) {
           );
         }
       }
-      if (isRecord13(event)) {
+      if (isRecord12(event)) {
         const finishEntry = appendDispatchFinishContractEntry(finishContractEntries, event);
         if (finishEntry !== null) {
           finishContractAssistantText = finishEntry.assistantText;
@@ -15900,9 +15332,9 @@ function createDispatchBundle(context, options) {
       }
       if (event.type === "clio_coder_permission_escalated" && event.payload && typeof event.payload.requestId === "string") {
         escalationCounts.requested += 1;
-        const ctx = isRecord13(event.payload.decision) ? event.payload.decision : null;
-        const classification = ctx !== null && isRecord13(ctx.classification) ? ctx.classification : null;
-        const policy = ctx !== null && isRecord13(ctx.policy) ? ctx.policy : null;
+        const ctx = isRecord12(event.payload.decision) ? event.payload.decision : null;
+        const classification = ctx !== null && isRecord12(ctx.classification) ? ctx.classification : null;
+        const policy = ctx !== null && isRecord12(ctx.policy) ? ctx.policy : null;
         const actionClass = readStringOrNull(classification?.actionClass) ?? readStringOrNull(ctx?.actionClass) ?? readStringOrNull(event.payload.actionClass) ?? "unknown";
         const reasons = readStringArrayOrNull(ctx?.reasons) ?? readStringArrayOrNull(classification?.reasons);
         const reasonCode = readStringOrNull(ctx?.reasonCode) ?? readStringOrNull(policy?.reasonCode);
@@ -15929,13 +15361,9 @@ function createDispatchBundle(context, options) {
           escalation: true
         });
       }
-      if (event.type === "message_end" && event.message?.role === "assistant" && isRecord13(event.message.usage)) {
+      if (event.type === "message_end" && event.message?.role === "assistant" && isRecord12(event.message.usage)) {
         const u = event.message.usage;
-        tokenMeter.inputTokens += typeof u.input === "number" ? u.input : 0;
-        tokenMeter.outputTokens += typeof u.output === "number" ? u.output : 0;
-        tokenMeter.cacheReadTokens += typeof u.cacheRead === "number" ? u.cacheRead : 0;
-        tokenMeter.cacheWriteTokens += typeof u.cacheWrite === "number" ? u.cacheWrite : 0;
-        tokenMeter.reasoningTokens += extractReasoningTokenCount(u);
+        accumulateNativeUsage(tokenMeter, u, lifecycle.target.effectivePricing.rates);
         const requestedModelId = readStringOrNull(event.message.model);
         const responseModelIdObservation = responseModelIdObservationFromRecord(event.message, "not-observed");
         const differingResponseModelId = readStringOrNull(event.message.responseModel);
@@ -16287,11 +15715,12 @@ function createDispatchBundle(context, options) {
         outputTokenCount: tokenMeter.outputTokens,
         cacheReadTokenCount: tokenMeter.cacheReadTokens,
         cacheWriteTokenCount: tokenMeter.cacheWriteTokens,
+        ...tokenMeter.cacheWrite1hTokens === void 0 ? {} : { cacheWrite1hTokenCount: tokenMeter.cacheWrite1hTokens },
         reasoningTokenCount: tokenMeter.reasoningTokens,
         ...upstreamResponses.length > 0 ? { upstreamResponses: [...upstreamResponses] } : {},
         ...capturedOutput !== void 0 ? { output: capturedOutput } : {},
         costUsd,
-        costProvenance: lifecycle.target.effectivePricing.provenance,
+        costProvenance: lifecycle.target.effectivePricing.provenance === "unknown" && costUsd > 0 ? "estimated" : lifecycle.target.effectivePricing.provenance,
         compiledPromptHash: lifecycle.compiledPromptHash,
         staticCompositionHash: lifecycle.staticCompositionHash,
         staticShellHash: lifecycle.staticCompositionHash,
@@ -16373,6 +15802,7 @@ function createDispatchBundle(context, options) {
         outputTokenCount: receipt.outputTokenCount ?? 0,
         cacheReadTokenCount: receipt.cacheReadTokenCount ?? 0,
         cacheWriteTokenCount: receipt.cacheWriteTokenCount ?? 0,
+        ...receipt.cacheWrite1hTokenCount === void 0 ? {} : { cacheWrite1hTokenCount: receipt.cacheWrite1hTokenCount },
         reasoningTokenCount: receipt.reasoningTokenCount ?? 0,
         staticShellHash: receipt.staticShellHash ?? null,
         sessionShellHash: receipt.sessionShellHash ?? null,
@@ -16476,7 +15906,7 @@ function createDispatchBundle(context, options) {
           output: capturedOutput?.state === "final" ? capturedOutput.text : null,
           outputTruncated: capturedOutput?.truncated === true,
           cwd: lifecycle.cwd,
-          networkAllowed: lifecycle.admission.allowedTools.includes(ToolNames.WebFetch) || lifecycle.target.runtime.externalAgentLoop?.network === "externally-governed-unobserved",
+          networkAllowed: lifecycle.admission.allowedTools.includes(ToolNames.WebFetch) || lifecycle.admission.allowedTools.includes(ToolNames.WebRead) || lifecycle.target.runtime.externalAgentLoop?.network === "externally-governed-unobserved",
           observedRunEffects,
           filesystem: nodeResultContractFilesystem()
         });
@@ -16569,6 +15999,7 @@ function createDispatchBundle(context, options) {
           sessionShellHash: receiptDraft.sessionShellHash ?? null,
           dynamicHash: receiptDraft.dynamicHash ?? null,
           ...receiptDraft.cacheReadTokenCount !== void 0 ? { cacheReadTokenCount: receiptDraft.cacheReadTokenCount } : {},
+          ...receiptDraft.cacheWrite1hTokenCount === void 0 ? {} : { cacheWrite1hTokenCount: receiptDraft.cacheWrite1hTokenCount },
           ...receiptDraft.cacheWriteTokenCount !== void 0 ? { cacheWriteTokenCount: receiptDraft.cacheWriteTokenCount } : {},
           ...activeRun.heartbeatAt ? { heartbeatAt: heartbeatIso(activeRun.heartbeatAt) } : {}
         };
@@ -16745,7 +16176,11 @@ function createDispatchBundle(context, options) {
       const release = () => settlement.abandon(handle.runId);
       handle.finalPromise.then(release, release);
     }
-    if (req.lineage) return { ...handle, finalPromise: handle.finalPromise.finally(() => writerLease?.release()) };
+    if (req.lineage) {
+      const finalPromise = handle.finalPromise.finally(() => writerLease?.release());
+      trackMemberWork(handle.runId, finalPromise);
+      return { ...handle, finalPromise };
+    }
     const assignment = assignments.open(handle.runId, assignmentPolicyFor(handle.effectiveRequest));
     persistAssignment(registerAssignment(assignment.id), `${assignment.id}:open`);
     assignments.attachAttempt(assignment.id, handle.events);
@@ -16832,7 +16267,13 @@ function createDispatchBundle(context, options) {
       ),
       req
     );
-    assertPostRuntimeToolCompatibility(req.agentId, agentSpec, effectiveTools, target);
+    assertPostRuntimeToolCompatibility(
+      req.agentId,
+      agentSpec,
+      effectiveTools,
+      target,
+      pathScope.writeBoundaries.length > 0
+    );
     assertRuntimeCanHonorWorkerPermissionMode(target.runtime, settings?.fleet.permissions.mode ?? "deny");
     assertResponseSchemaEnforceable(target.runtime, target.modelCapabilities, req.responseSchema, effectiveTools.length);
     assertWriteRootsEnforceable(target.runtime, pathScope.writeBoundaries);
@@ -17206,7 +16647,11 @@ function createDispatchBundle(context, options) {
     async start() {
       if (options?.journalRunEvents === true) journalBridge = attachRunEventJournalBridge(context.bus);
       cleanupDispatchReservations({ startup: true, nowMs: now() });
-      ledger = openLedger();
+      ledger = openLedger({
+        get maxRuns() {
+          return getEffectiveSettings()?.fleet?.history?.maxRuns ?? resolveGuardrail("maxDispatchRuns");
+        }
+      });
       try {
         const recovery = recoverOrphanReceipts(ledger);
         if (recovery.recovered > 0 || recovery.corrupt > 0 || recovery.abandoned > 0 || recovery.sealed > 0) {
@@ -17315,6 +16760,7 @@ function createDispatchBundle(context, options) {
       const meter = run.meter;
       const totalTokens = meter.inputTokens + meter.outputTokens + meter.cacheReadTokens + meter.cacheWriteTokens;
       const costUsd = calculateUsageCostUsd(meter, run.pricing);
+      const costProvenance = run.costProvenance === "unknown" && costUsd > 0 ? "estimated" : run.costProvenance;
       const startedMs = Date.parse(run.startedAt);
       const elapsedMs = Number.isFinite(startedMs) ? Math.max(0, tickNow - startedMs) : 0;
       const timing = deriveRunPhaseDurations(run.timing, run.startedAt, new Date(tickNow).toISOString());
@@ -17332,14 +16778,14 @@ function createDispatchBundle(context, options) {
         timing,
         tokens: { input: meter.inputTokens, output: meter.outputTokens, total: totalTokens },
         costUsd,
-        costProvenance: run.costProvenance,
+        costProvenance,
         node: run.node !== null ? { ...run.node } : null
       });
       totals.inputTokens += meter.inputTokens;
       totals.outputTokens += meter.outputTokens;
       totals.totalTokens += totalTokens;
       totals.costUsd += costUsd;
-      costAmounts.push({ usd: costUsd, provenance: run.costProvenance });
+      costAmounts.push({ usd: costUsd, provenance: costProvenance });
       totals.runtimeSeconds += elapsedMs / 1e3;
     }
     const retrying = [...retryQueue.values()].map((entry) => ({
@@ -17370,6 +16816,7 @@ function createDispatchBundle(context, options) {
   function settleQueuedAssignmentsForShutdown() {
     for (const [finishedRunId, entry] of retryQueue) {
       clearTimeout(entry.timer);
+      entry.settleCanceled();
       if (assignments.get(entry.rootRunId)?.status === "running") {
         settleAssignmentDurably(asAssignmentId(entry.rootRunId), entry.terminalCandidate, "canceled");
       }
@@ -17409,11 +16856,25 @@ function createDispatchBundle(context, options) {
     const stored = listStoredAssignments().find((record) => record.assignmentId === id || record.attempts.includes(id));
     return stored?.assignmentId ?? ledger?.get(id)?.lineage?.rootRunId ?? id;
   }
+  function controlRootFor(id) {
+    const exact = controlRootsByAttempt.get(id);
+    if (exact !== void 0) return exact;
+    const roots = /* @__PURE__ */ new Set();
+    for (const [attempt, root] of assignmentRootsByAttempt) {
+      if (root === id) roots.add(controlRootsByAttempt.get(attempt) ?? root);
+    }
+    if (roots.size > 1) {
+      throw new Error(`dispatch: '${id}' names multiple fleet members; use a concrete member or assignment id`);
+    }
+    return roots.values().next().value ?? assignmentRootFor(id);
+  }
   function currentAssignmentRun(id) {
-    const rootRunId = assignmentRootFor(id);
+    const exact = active.get(id);
+    if (exact !== void 0) return exact;
+    const rootRunId = controlRootFor(id);
     let current = null;
     for (const run of active.values()) {
-      if (run.lineage.rootRunId !== rootRunId) continue;
+      if ((controlRootsByAttempt.get(run.runId) ?? run.lineage.rootRunId) !== rootRunId) continue;
       if (current === null || run.lineage.attempt > current.lineage.attempt) current = run;
     }
     return current;
@@ -17464,8 +16925,25 @@ function createDispatchBundle(context, options) {
         await Promise.allSettled([...assignmentWrites]);
       }
     },
+    async drainMember(runId) {
+      const root = controlRootFor(runId);
+      const errors = [];
+      while (true) {
+        const pending = [...memberWork.get(root) ?? []];
+        const live = currentAssignmentRun(runId);
+        if (live !== null) pending.push(live.finalPromise);
+        if (pending.length === 0) break;
+        for (const result of await Promise.allSettled(pending)) {
+          if (result.status === "rejected" && !errors.includes(result.reason)) errors.push(result.reason);
+        }
+      }
+      if (errors.length === 1) throw errors[0];
+      if (errors.length > 1) throw new AggregateError(errors, "dispatch member drain failed", { cause: errors[0] });
+    },
     abort(runId, reason) {
-      const rootRunId = assignmentRootFor(runId);
+      const rootRunId = controlRootFor(runId);
+      const run = currentAssignmentRun(runId);
+      canceledControlRoots.add(rootRunId);
       const queued = pendingCapacity.get(rootRunId);
       if (queued !== void 0 && capacityAdmission.cancel(rootRunId)) {
         persistAssignment(cancelStoredAssignment(rootRunId), `${rootRunId}:cancel-queued`);
@@ -17483,10 +16961,13 @@ function createDispatchBundle(context, options) {
         persistAssignment(cancelStoredAssignment(rootRunId), `${rootRunId}:cancel`);
       }
       for (const [finishedRunId, retry] of retryQueue) {
-        if (retry.rootRunId !== rootRunId) continue;
+        if ((controlRootsByAttempt.get(finishedRunId) ?? retry.rootRunId) !== rootRunId) continue;
         clearTimeout(retry.timer);
+        retry.settleCanceled();
         retryQueue.delete(finishedRunId);
-        settleAssignmentDurably(asAssignmentId(rootRunId), retry.terminalCandidate, "canceled");
+        if (retry.rootRunId === rootRunId) {
+          settleAssignmentDurably(asAssignmentId(rootRunId), retry.terminalCandidate, "canceled");
+        }
         context.bus.emit(BusChannels.RunAborted, {
           source: "dispatch_abort",
           runId: finishedRunId,
@@ -17501,7 +16982,6 @@ function createDispatchBundle(context, options) {
           event: { type: "retry_canceled", attempt: retry.attempt }
         });
       }
-      const run = currentAssignmentRun(rootRunId);
       if (!run) return;
       emitRunAborted(run, "dispatch_abort");
       run.aborted = true;
@@ -17729,7 +17209,6 @@ async function executePlan(initialPlan, adapter, signal) {
   }
   const ledgerId = agentSteps.length >= 2 ? `ledger-plan-${plan.hash.slice(0, 12)}-${Date.now().toString(36)}` : null;
   const ledger = ledgerId === null ? void 0 : { id: ledgerId, sequence: 0 };
-  if (ledgerId !== null) await openAgentLedger(ledgerId);
   const admissions = agentSteps.map((step) => adapter.preflight(step));
   const reservation = adapter.reserve(plan, admissions);
   const reservationOwners = /* @__PURE__ */ new Set([reservation.ownerId]);
@@ -17739,6 +17218,9 @@ async function executePlan(initialPlan, adapter, signal) {
   const unneeded = /* @__PURE__ */ new Set();
   const needsDecision = [];
   const running = /* @__PURE__ */ new Map();
+  const cleanupErrors = [];
+  const memberIds = /* @__PURE__ */ new Set();
+  const canceledSteps = /* @__PURE__ */ new Set();
   const checkPassed = /* @__PURE__ */ new Map();
   const loopFindings = /* @__PURE__ */ new Map();
   const attemptsRun = /* @__PURE__ */ new Map();
@@ -17751,11 +17233,19 @@ async function executePlan(initialPlan, adapter, signal) {
   let lastMutationSeq = 0;
   let stopped = false;
   const codeAbort = new AbortController();
+  const cancelOne = (owned) => {
+    if (owned.assignmentId === null || owned.canceled) return;
+    owned.canceled = true;
+    try {
+      adapter.cancel(owned.assignmentId);
+    } catch (error) {
+      cleanupErrors.push(error);
+    }
+  };
   const cancelOwned = () => {
     stopped = true;
-    for (const owned of running.values()) if (owned.assignmentId !== null) adapter.cancel(owned.assignmentId);
     codeAbort.abort();
-    for (const ownerId of reservationOwners) adapter.releaseUnconsumed(ownerId);
+    for (const owned of running.values()) cancelOne(owned);
   };
   signal?.addEventListener("abort", cancelOwned, { once: true });
   const loopOf = (step) => step.loop === void 0 ? null : loopsById.get(step.loop.loopId) ?? null;
@@ -17766,42 +17256,44 @@ async function executePlan(initialPlan, adapter, signal) {
     results.set(step.id, result);
     if (isWorkspaceMutator(step)) lastMutationSeq = sequence;
   };
-  for (const step of plan.steps) {
-    const result = replayed.get(step.id);
-    if (result === void 0) continue;
-    if (!result.succeeded || !result.integrityValid) {
-      throw new Error(`execution plan: replayed step '${step.id}' is not a completed successful step`);
-    }
-    recordCompletion(step, result);
-    if (step.loop?.role === "check" && step.kind === "code") {
-      checkPassed.set(step.id, result.succeeded);
-      attemptsRun.set(step.loop.loopId, (attemptsRun.get(step.loop.loopId) ?? 0) + 1);
-    }
-    if (step.loop?.role === "check" && step.kind === "agent") {
-      const loop = loopsById.get(step.loop.loopId);
-      const decide = adapter.decideLoop;
-      if (loop === void 0 || decide === void 0) {
-        throw new Error(`execution plan: replayed loop check '${step.id}' has no decider`);
+  const replayPrefix = async () => {
+    for (const step of plan.steps) {
+      const result = replayed.get(step.id);
+      if (result === void 0) continue;
+      if (!result.succeeded || !result.integrityValid) {
+        throw new Error(`execution plan: replayed step '${step.id}' is not a completed successful step`);
       }
-      const decision = await decide({
-        loop,
-        step,
-        attempt: step.loop.attempt,
-        terminalAttempt: step.loop.attempt >= loop.maxAttempts,
-        result,
-        priorResults: results
-      });
-      checkPassed.set(step.id, decision.resolved);
-      attemptsRun.set(step.loop.loopId, (attemptsRun.get(step.loop.loopId) ?? 0) + 1);
-      if (decision.findings !== null) loopFindings.set(`${loop.id}:${step.loop.attempt}`, decision.findings);
-      if (decision.needsDecision !== void 0 && decision.needsDecision !== null) {
-        needsDecision.push(decision.needsDecision);
+      recordCompletion(step, result);
+      if (step.loop?.role === "check" && step.kind === "code") {
+        checkPassed.set(step.id, result.succeeded);
+        attemptsRun.set(step.loop.loopId, (attemptsRun.get(step.loop.loopId) ?? 0) + 1);
+      }
+      if (step.loop?.role === "check" && step.kind === "agent") {
+        const loop = loopsById.get(step.loop.loopId);
+        const decide = adapter.decideLoop;
+        if (loop === void 0 || decide === void 0) {
+          throw new Error(`execution plan: replayed loop check '${step.id}' has no decider`);
+        }
+        const decision = await decide({
+          loop,
+          step,
+          attempt: step.loop.attempt,
+          terminalAttempt: step.loop.attempt >= loop.maxAttempts,
+          result,
+          priorResults: results
+        });
+        checkPassed.set(step.id, decision.resolved);
+        attemptsRun.set(step.loop.loopId, (attemptsRun.get(step.loop.loopId) ?? 0) + 1);
+        if (decision.findings !== null) loopFindings.set(`${loop.id}:${step.loop.attempt}`, decision.findings);
+        if (decision.needsDecision !== void 0 && decision.needsDecision !== null) {
+          needsDecision.push(decision.needsDecision);
+        }
+      }
+      if (step.loop?.role === "repair") {
+        repairsRun.set(step.loop.loopId, (repairsRun.get(step.loop.loopId) ?? 0) + 1);
       }
     }
-    if (step.loop?.role === "repair") {
-      repairsRun.set(step.loop.loopId, (repairsRun.get(step.loop.loopId) ?? 0) + 1);
-    }
-  }
+  };
   const dependencyBlocks = (dependency, dependent) => {
     if (unneeded.has(dependency)) return false;
     if (skipped.has(dependency)) return true;
@@ -17842,10 +17334,10 @@ async function executePlan(initialPlan, adapter, signal) {
   const closeBoundary = async (window, enforced, settled) => {
     const verify = adapter.verifyWriteBoundary;
     if (enforced === null || verify === void 0) return [...settled];
-    const outcome = await verify(window, enforced);
-    writeBoundaries.push(outcome);
-    if (!outcome.violated) return [...settled];
-    const blamed = new Set(outcome.failedStepIds);
+    const outcome2 = await verify(window, enforced);
+    writeBoundaries.push(outcome2);
+    if (!outcome2.violated) return [...settled];
+    const blamed = new Set(outcome2.failedStepIds);
     return settled.map(
       ({ step, result }) => blamed.has(step.id) ? { step, result: { ...result, succeeded: false, boundaryViolated: true } } : { step, result }
     );
@@ -17853,7 +17345,10 @@ async function executePlan(initialPlan, adapter, signal) {
   const runCodeStepNode = async (step, handoffs) => {
     const runCode = adapter.runCode;
     if (runCode === void 0) throw new Error(`execution plan: no runner for code step '${step.id}'`);
-    return await runCode(step, handoffs, codeAbort.signal, results);
+    const result = await runCode(step, handoffs, codeAbort.signal, results);
+    if (!codeAbort.signal.aborted) return result;
+    canceledSteps.add(step.id);
+    return { ...result, succeeded: false, failureReason: result.failureReason ?? "execution plan canceled this step" };
   };
   const revalidateFor = async (wave) => {
     const candidates = /* @__PURE__ */ new Set();
@@ -17871,6 +17366,7 @@ async function executePlan(initialPlan, adapter, signal) {
     }
     let halt = false;
     for (const id of [...candidates].sort()) {
+      if (stopped || signal?.aborted) return true;
       const step = stepsById.get(id);
       if (step?.kind !== "code") continue;
       const spent = revalidations.get(id) ?? 0;
@@ -17896,7 +17392,6 @@ async function executePlan(initialPlan, adapter, signal) {
         if (plan.onFailure === "stop") {
           stopped = true;
           codeAbort.abort();
-          for (const ownerId of reservationOwners) adapter.releaseUnconsumed(ownerId);
           halt = true;
         }
       }
@@ -17956,7 +17451,12 @@ async function executePlan(initialPlan, adapter, signal) {
     const reason = !brokenMember && ran >= loop.maxAttempts ? "loop_bound_exhausted" : "loop_step_failed";
     return { loopId: loop.id, resolved: false, attempts, repairs, reason };
   });
+  let outcome;
+  let primaryError;
+  let failed2 = false;
   try {
+    if (ledgerId !== null) await openAgentLedger(ledgerId);
+    await replayPrefix();
     let waveIndex = 0;
     while (waveIndex < plan.waves.length) {
       const wave = plan.waves[waveIndex];
@@ -18000,58 +17500,107 @@ async function executePlan(initialPlan, adapter, signal) {
           boundaryWindow,
           group.map((entry) => entry.step)
         );
-        const started = await Promise.all(
-          launch.map(async ({ step, handoffs }) => ({
-            step,
-            handle: await adapter.run(
-              step,
-              handoffs,
-              { ownerId: reservationByStep.get(step.id) ?? reservation.ownerId, memberId: step.id },
-              ledger
-            )
-          }))
-        );
-        for (const { step, handle } of started) running.set(step.id, { assignmentId: handle.assignmentId });
+        const failures = [];
+        const fail = (error) => {
+          failures.push(error);
+          cancelOwned();
+        };
         const onSettled = (step, result) => {
-          if (isPlanFailure(step, result) && plan.onFailure === "stop") {
-            stopped = true;
-            for (const [runningStepId, owned] of running) {
-              if (runningStepId !== step.id && owned.assignmentId !== null) adapter.cancel(owned.assignmentId);
-            }
-            codeAbort.abort();
-            for (const ownerId of reservationOwners) adapter.releaseUnconsumed(ownerId);
-          }
+          if (isPlanFailure(step, result) && plan.onFailure === "stop") cancelOwned();
         };
-        const ran = await Promise.all([
-          ...started.map(async ({ step, handle }) => {
-            const result = await handle.result;
-            onSettled(step, result);
-            return { step, result };
-          }),
-          ...codeWork.map(async ({ step, handoffs }) => {
+        const terminals = [];
+        await Promise.allSettled(
+          launch.map(async ({ step, handoffs }) => {
+            if (stopped || signal?.aborted) return;
+            const owned = { assignmentId: null, canceled: false };
+            running.set(step.id, owned);
+            try {
+              const handle = await adapter.run(
+                step,
+                handoffs,
+                { ownerId: reservationByStep.get(step.id) ?? reservation.ownerId, memberId: step.id },
+                ledger
+              );
+              owned.assignmentId = handle.assignmentId;
+              memberIds.add(handle.assignmentId);
+              const terminal = handle.result.then(
+                (result) => {
+                  if (owned.canceled) canceledSteps.add(step.id);
+                  const settled2 = owned.canceled ? { ...result, succeeded: false, failureReason: result.failureReason ?? "execution plan canceled this step" } : result;
+                  onSettled(step, settled2);
+                  if (settled2.succeeded) running.delete(step.id);
+                  return { step, result: settled2 };
+                },
+                (error) => {
+                  fail(error);
+                  throw error;
+                }
+              );
+              terminals.push(Promise.allSettled([terminal]));
+              if (stopped || signal?.aborted) cancelOne(owned);
+            } catch (error) {
+              running.delete(step.id);
+              fail(error);
+            }
+            return;
+          })
+        );
+        const codeTerminals = stopped || signal?.aborted ? [] : codeWork.map(async ({ step, handoffs }) => {
+          try {
             const result = await runCodeStepNode(step, handoffs);
             onSettled(step, result);
             return { step, result };
-          })
-        ]);
-        const settled = await closeBoundary(boundaryWindow, enforced, ran);
+          } catch (error) {
+            fail(error);
+            throw error;
+          }
+        });
+        const outcomes = (await Promise.all([...terminals, Promise.allSettled(codeTerminals)])).flat();
+        for (const id of memberIds) {
+          try {
+            await adapter.drainMember?.(id);
+            memberIds.delete(id);
+          } catch (error) {
+            fail(error);
+          }
+        }
+        const ran = outcomes.flatMap((outcome2) => outcome2.status === "fulfilled" ? [outcome2.value] : []);
+        const settlementOrder = [...launch, ...codeWork].map(({ step }) => step.id);
+        ran.sort((a, b) => settlementOrder.indexOf(a.step.id) - settlementOrder.indexOf(b.step.id));
+        let settled;
+        try {
+          settled = await closeBoundary(boundaryWindow, enforced, ran);
+        } catch (error) {
+          if (failures.length === 0) throw error;
+          throw new AggregateError([...failures, error], "execution plan failure and boundary verification failed", {
+            cause: failures[0]
+          });
+        }
         for (const { step, result } of settled) {
-          running.set(step.id, { assignmentId: result.assignmentId });
           recordCompletion(step, result);
-          await adapter.onStepSettled?.(step, result);
+          try {
+            await adapter.onStepSettled?.(step, result);
+          } catch (error) {
+            failures.push(error);
+            cancelOwned();
+          }
           if (step.loop?.role === "repair") {
             repairsRun.set(step.loop.loopId, (repairsRun.get(step.loop.loopId) ?? 0) + 1);
           }
           running.delete(step.id);
         }
-        for (const { step, result } of settled) await settleCheck(step, result);
+        if (failures.length === 1) throw failures[0];
+        if (failures.length > 1)
+          throw new AggregateError(failures, "execution plan launch or result failed", { cause: failures[0] });
+        for (const { step, result } of settled) {
+          if (!signal?.aborted && !canceledSteps.has(step.id)) await settleCheck(step, result);
+        }
         const exhausted = settled.some(({ step }) => {
           const loop = step.loop?.role === "check" ? loopOf(step) : null;
           return loop !== null && step.loop !== void 0 && step.loop.attempt >= loop.maxAttempts && !loopResolved(loop);
         });
         if ((exhausted || settled.some(({ step, result }) => isPlanFailure(step, result))) && plan.onFailure === "stop") {
           stopped = true;
-          for (const ownerId of reservationOwners) adapter.releaseUnconsumed(ownerId);
         }
       }
       if (!stopped && adapter.spliceAfter !== void 0) {
@@ -18080,7 +17629,7 @@ async function executePlan(initialPlan, adapter, signal) {
       }
       waveIndex += 1;
     }
-    return {
+    outcome = {
       planHash: plan.hash,
       results,
       skipped: [...skipped],
@@ -18091,13 +17640,50 @@ async function executePlan(initialPlan, adapter, signal) {
       writeBoundaries: [...writeBoundaries]
     };
   } catch (error) {
+    failed2 = true;
+    primaryError = error;
     cancelOwned();
-    throw error;
   } finally {
     signal?.removeEventListener("abort", cancelOwned);
-    for (const ownerId of reservationOwners) adapter.release(ownerId);
-    if (ledgerId !== null) await closeAgentLedger(ledgerId);
+    for (const id of memberIds) {
+      try {
+        await adapter.drainMember?.(id);
+      } catch (error) {
+        cleanupErrors.push(error);
+      }
+    }
+    for (const ownerId of reservationOwners) {
+      if (stopped || signal?.aborted) {
+        try {
+          adapter.releaseUnconsumed(ownerId);
+        } catch (error) {
+          cleanupErrors.push(error);
+        }
+      }
+      try {
+        adapter.release(ownerId);
+      } catch (error) {
+        cleanupErrors.push(error);
+      }
+    }
+    if (ledgerId !== null) {
+      try {
+        await closeAgentLedger(ledgerId);
+      } catch (error) {
+        cleanupErrors.push(error);
+      }
+    }
+  }
+  if (cleanupErrors.length > 0) {
+    throw new AggregateError(
+      failed2 ? [primaryError, ...cleanupErrors] : cleanupErrors,
+      "execution plan cleanup failed",
+      failed2 ? { cause: primaryError } : void 0
+    );
   }
+  if (failed2) throw primaryError;
+  if (outcome === void 0) throw new Error("execution plan did not produce an outcome");
+  return outcome;
 }
 
 // src/domains/dispatch/fleet-gate.ts
@@ -18195,6 +17781,7 @@ function createCostTracker() {
         output,
         cacheRead,
         cacheWrite,
+        ...breakdown?.cacheWrite1h === void 0 ? {} : { cacheWrite1h: breakdown.cacheWrite1h },
         reasoningTokens,
         ...apiCalls !== void 0 ? { apiCalls } : {},
         ...label !== void 0 ? { label } : {}
@@ -18204,6 +17791,7 @@ function createCostTracker() {
       totals.output += output;
       totals.cacheRead += cacheRead;
       totals.cacheWrite += cacheWrite;
+      if (breakdown?.cacheWrite1h !== void 0) totals.cacheWrite1h = (totals.cacheWrite1h ?? 0) + breakdown.cacheWrite1h;
       totals.reasoningTokens += reasoningTokens;
       totals.totalTokens += tokens2;
       return resolvedUsd;
@@ -18227,6 +17815,7 @@ function createCostTracker() {
       totals.output = 0;
       totals.cacheRead = 0;
       totals.cacheWrite = 0;
+      delete totals.cacheWrite1h;
       totals.reasoningTokens = 0;
       totals.totalTokens = 0;
     }
@@ -18774,6 +18363,7 @@ async function executeFleetRun(input) {
       beginWriteBoundary: (window, stepIds) => boundaryEnforcer.begin(window, stepIds),
       verifyWriteBoundary: (window, stepIds) => boundaryEnforcer.verify(window, stepIds),
       cancel: (assignmentId) => dispatch.abort(assignmentId),
+      drainMember: (assignmentId) => dispatch.drainMember?.(assignmentId) ?? Promise.resolve(),
       release: (ownerId) => {
         if (ownerId === NO_WORKER_RESERVATION) return;
         dispatch.reservations?.release(ownerId);
@@ -18961,7 +18551,7 @@ function hasRunProvenance(view) {
   return view.pipeline !== void 0 || view.personaOverride !== void 0 || view.escalation !== void 0 || view.autonomyEnforcement !== void 0;
 }
 function runProvenanceFromUnknown(value) {
-  if (!isRecord14(value)) return {};
+  if (!isRecord13(value)) return {};
   const view = {};
   const pipeline = pipelineFromUnknown(value.pipeline);
   if (pipeline !== null) view.pipeline = pipeline;
@@ -18973,14 +18563,14 @@ function runProvenanceFromUnknown(value) {
   if (autonomyEnforcement !== null) view.autonomyEnforcement = autonomyEnforcement;
   return view;
 }
-function isRecord14(value) {
+function isRecord13(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function finiteNumber(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
 function pipelineFromUnknown(value) {
-  if (!isRecord14(value)) return null;
+  if (!isRecord13(value)) return null;
   const position = finiteNumber(value.position);
   const inputBytes = finiteNumber(value.inputBytes);
   if (position === null || inputBytes === null) return null;
@@ -18988,11 +18578,11 @@ function pipelineFromUnknown(value) {
   return { fromRunId, position, inputBytes, inputTruncated: value.inputTruncated === true };
 }
 function personaOverrideFromUnknown(value) {
-  if (!isRecord14(value) || typeof value.promptHash !== "string" || value.promptHash.length === 0) return null;
+  if (!isRecord13(value) || typeof value.promptHash !== "string" || value.promptHash.length === 0) return null;
   return { promptHash: value.promptHash };
 }
 function autonomyEnforcementFromUnknown(value) {
-  if (!isRecord14(value)) return null;
+  if (!isRecord13(value)) return null;
   if (value.grade !== "mediated" && value.grade !== "approximated" && value.grade !== "bypassed") return null;
   if (typeof value.autonomy !== "string" || value.autonomy.length === 0) return null;
   const view = { grade: value.grade, autonomy: value.autonomy };
@@ -19001,9 +18591,9 @@ function autonomyEnforcementFromUnknown(value) {
   return view;
 }
 function escalationFromUnknown(safety) {
-  if (!isRecord14(safety)) return null;
+  if (!isRecord13(safety)) return null;
   const decisions = safety.decisions;
-  if (!isRecord14(decisions)) return null;
+  if (!isRecord13(decisions)) return null;
   const requested = finiteNumber(decisions.escalationRequested);
   if (requested === null) return null;
   return {
@@ -19245,7 +18835,7 @@ async function loadEvidenceTrustStatus(dataDir, evidenceId) {
   }
   const source = `${evidenceId}/trust-status.json`;
   const parsed = parseJson2(raw, source);
-  if (!isRecord15(parsed)) throw new Error(`${source}: expected object`);
+  if (!isRecord14(parsed)) throw new Error(`${source}: expected object`);
   if (parsed.version !== 1) throw new Error(`${source}: expected version 1`);
   if (readString2(parsed, source, "evidenceId") !== evidenceId) {
     throw new Error(`${source}.evidenceId: expected ${evidenceId}`);
@@ -19258,7 +18848,7 @@ async function loadEvidenceTrustStatus(dataDir, evidenceId) {
     projection: "canonical",
     runs: parsed.runs.map((entry, index) => {
       const entrySource = `${source}.runs[${index}]`;
-      if (!isRecord15(entry)) throw new Error(`${entrySource}: expected object`);
+      if (!isRecord14(entry)) throw new Error(`${entrySource}: expected object`);
       return {
         runId: readString2(entry, entrySource, "runId"),
         status: normalizeTrustStatus(entry.status)
@@ -19276,10 +18866,10 @@ async function loadEvidenceRunProvenance(dataDir, evidenceId) {
     throw error;
   }
   const parsed = parseJson2(raw, `${evidenceId}/receipt.json`);
-  if (!isRecord15(parsed) || !Array.isArray(parsed.receipts)) return [];
+  if (!isRecord14(parsed) || !Array.isArray(parsed.receipts)) return [];
   const out3 = [];
   for (const entry of parsed.receipts) {
-    if (!isRecord15(entry) || typeof entry.runId !== "string") continue;
+    if (!isRecord14(entry) || typeof entry.runId !== "string") continue;
     const view = runProvenanceFromUnknown(entry);
     if (hasRunProvenance(view)) out3.push({ runId: entry.runId, view });
   }
@@ -19295,9 +18885,9 @@ async function loadEvidenceGateDecisions(dataDir, evidenceId) {
     throw error;
   }
   const parsed = parseJson2(raw, `${evidenceId}/gate-decisions.json`);
-  if (!isRecord15(parsed) || !Array.isArray(parsed.decisions)) return [];
+  if (!isRecord14(parsed) || !Array.isArray(parsed.decisions)) return [];
   return parsed.decisions.filter((entry) => {
-    if (!isRecord15(entry)) return false;
+    if (!isRecord14(entry)) return false;
     return verifyGateDecisionArtifact(entry).ok;
   });
 }
@@ -19320,7 +18910,7 @@ async function listEvidenceOverviews(dataDir) {
   return overviews;
 }
 function parseOverview(value, source) {
-  if (!isRecord15(value)) throw new Error(`${source}: expected object`);
+  if (!isRecord14(value)) throw new Error(`${source}: expected object`);
   if (value.version !== 1) throw new Error(`${source}: expected version 1`);
   const evidenceId = readString2(value, source, "evidenceId");
   const sourceValue = readSource(value.source, `${source}.source`);
@@ -19364,13 +18954,13 @@ function parseOverview(value, source) {
   };
 }
 function parseFindingsFile(value, source) {
-  if (!isRecord15(value)) throw new Error(`${source}: expected object`);
+  if (!isRecord14(value)) throw new Error(`${source}: expected object`);
   if (value.version !== 1) throw new Error(`${source}: expected version 1`);
   if (!Array.isArray(value.findings)) throw new Error(`${source}.findings: expected array`);
   return value.findings.map((entry, index) => parseFinding(entry, `${source}.findings[${index}]`));
 }
 function parseFinding(value, source) {
-  if (!isRecord15(value)) throw new Error(`${source}: expected object`);
+  if (!isRecord14(value)) throw new Error(`${source}: expected object`);
   const severity = readString2(value, source, "severity");
   if (severity !== "info" && severity !== "warn") throw new Error(`${source}.severity: expected info or warn`);
   const tag = readString2(value, source, "tag");
@@ -19383,14 +18973,14 @@ function parseFinding(value, source) {
   };
 }
 function readSource(value, source) {
-  if (!isRecord15(value)) throw new Error(`${source}: expected object`);
+  if (!isRecord14(value)) throw new Error(`${source}: expected object`);
   if (value.kind === "run") return { kind: "run", runId: readString2(value, source, "runId") };
   if (value.kind === "session") return { kind: "session", sessionId: readString2(value, source, "sessionId") };
   if (value.kind === "eval") return { kind: "eval", evalId: readString2(value, source, "evalId") };
   throw new Error(`${source}.kind: expected run, session, or eval`);
 }
 function readTotals(value, source) {
-  if (!isRecord15(value)) throw new Error(`${source}: expected object`);
+  if (!isRecord14(value)) throw new Error(`${source}: expected object`);
   return {
     runs: readNumber2(value, source, "runs"),
     receipts: readNumber2(value, source, "receipts"),
@@ -19448,7 +19038,7 @@ function parseJson2(raw, source) {
     throw new Error(`${source}: invalid JSON: ${message}`);
   }
 }
-function isRecord15(value) {
+function isRecord14(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function findingsFile(evidenceId, findings) {
@@ -19458,7 +19048,7 @@ function readDecisions(value, source) {
   if (!Array.isArray(value)) throw new Error(`${source}: expected array`);
   return value.map((entry, index) => {
     const path2 = `${source}[${index}]`;
-    if (!isRecord15(entry) || !isDecisionRecord(entry.record)) throw new Error(`${path2}: expected recorded decision`);
+    if (!isRecord14(entry) || !isDecisionRecord(entry.record)) throw new Error(`${path2}: expected recorded decision`);
     return {
       runId: readString2(entry, path2, "runId"),
       sessionId: readString2(entry, path2, "sessionId"),
@@ -19848,7 +19438,10 @@ function isValidationProtectedArtifact(entry) {
 }
 function validationToolCallCandidate(entry, linked, runSources) {
   const call = extractSessionToolCall(entry, linked);
-  if (validationToolCallSummary(call.tool, call.args) === null) return null;
+  const effective = effectiveToolCall(call.tool, call.args);
+  if (validationToolCallSummary(effective.toolName, effective.viaGateway ? effective.args : call.args) === null) {
+    return null;
+  }
   return {
     toolCallId: call.id,
     runId: validationRunIdFor(linked, runSources),
@@ -19857,7 +19450,7 @@ function validationToolCallCandidate(entry, linked, runSources) {
 }
 function validationToolCallSummary(toolName, args) {
   const parsed = parseMaybeJson(args);
-  const argRecord = isRecord16(parsed) ? parsed : null;
+  const argRecord = isRecord15(parsed) ? parsed : null;
   if (toolName === "bash") {
     const command = readOptionalString(argRecord?.command);
     if (command === null) return null;
@@ -19879,8 +19472,8 @@ function validationToolCallSummary(toolName, args) {
 }
 function isSuccessfulSessionToolResult(result) {
   if (result.isError) return false;
-  const obj = isRecord16(result.result) ? result.result : null;
-  const details = isRecord16(obj?.details) ? obj.details : null;
+  const obj = isRecord15(result.result) ? result.result : null;
+  const details = isRecord15(obj?.details) ? obj.details : null;
   return details?.kind !== "error";
 }
 function finding(index, severity, tag, runId, message) {
@@ -20055,7 +19648,7 @@ function attributionWindows(ledger, runSources, sessionIds) {
   }
   const linkedSessions = new Set(sessionIds);
   for (const row of ledger.rows) {
-    if (!isRecord16(row)) continue;
+    if (!isRecord15(row)) continue;
     const id = readOptionalString(row.id);
     const startedAt = readOptionalString(row.startedAt);
     const sessionId = readOptionalString(row.sessionId);
@@ -20180,7 +19773,15 @@ function extractSessionToolCall(entry, linked) {
   const id = readOptionalString(payload?.id) ?? readOptionalString(payload?.toolCallId) ?? readOptionalString(payload?.tool_call_id) ?? readOptionalString(block?.id) ?? entry.turnId;
   const tool = readOptionalString(payload?.name) ?? readOptionalString(payload?.toolName) ?? readOptionalString(payload?.tool) ?? readOptionalString(fn?.name) ?? readOptionalString(block?.name) ?? "tool";
   const args = payload?.arguments ?? payload?.args ?? payload?.input ?? parseMaybeJson(fn?.arguments) ?? block?.arguments ?? block?.args ?? void 0;
-  return { id, tool, args, timestamp: entry.timestamp, link: linked.link, sessionId: linked.sessionId };
+  const effective = effectiveToolCall(tool, args);
+  return {
+    id,
+    tool: effective.toolName,
+    args: effective.args ?? args,
+    timestamp: entry.timestamp,
+    link: linked.link,
+    sessionId: linked.sessionId
+  };
 }
 function extractSessionToolResult(entry, linked) {
   const payload = payloadObject(entry.payload);
@@ -20188,10 +19789,18 @@ function extractSessionToolResult(entry, linked) {
   const id = readOptionalString(payload?.toolCallId) ?? readOptionalString(payload?.tool_call_id) ?? readOptionalString(payload?.id) ?? null;
   const tool = readOptionalString(payload?.toolName) ?? readOptionalString(payload?.name) ?? readOptionalString(payload?.tool) ?? "tool";
   const result = payload?.result ?? payload?.output ?? payload?.out ?? payload?.content ?? (contentText.length > 0 ? contentText : entry.payload);
+  const effective = effectiveToolCall(tool, void 0, payloadObject(result)?.details ?? payload?.details);
+  const resultObject = payloadObject(result);
+  const details = payloadObject(resultObject?.details);
+  let projectedResult = result;
+  if (effective.viaGateway && resultObject && details) {
+    const { capability: _capability, ...innerDetails } = details;
+    projectedResult = { ...resultObject, details: innerDetails };
+  }
   return {
     id,
-    tool,
-    result,
+    tool: effective.toolName,
+    result: projectedResult,
     isError: payload?.isError === true || payload?.error === true,
     timestamp: entry.timestamp,
     link: linked.link,
@@ -20439,8 +20048,13 @@ function renderTranscript(overview, runSources, sessionLinks, trustStatus, findi
   }
   if (sessionLinks.entries.length > 0) {
     lines.push("", "## Linked Session Transcript");
+    const calls = /* @__PURE__ */ new Map();
     for (const linked of sessionLinks.entries) {
-      lines.push(...renderSessionTranscriptEntry(linked));
+      if (linked.entry.kind === "message" && linked.entry.role === "tool_call") {
+        const call = extractSessionToolCall(linked.entry, linked);
+        calls.set(call.id, call.tool);
+      }
+      lines.push(...renderSessionTranscriptEntry(linked, calls));
     }
   }
   lines.push("");
@@ -20460,7 +20074,7 @@ function transcriptRunLink(link) {
   }
   return "";
 }
-function renderSessionTranscriptEntry(linked) {
+function renderSessionTranscriptEntry(linked, calls) {
   const entry = linked.entry;
   const prefix = `- ${entry.timestamp} session=${linked.sessionId}${transcriptRunLink(linked.link)}`;
   if (entry.kind === "message") {
@@ -20472,7 +20086,8 @@ function renderSessionTranscriptEntry(linked) {
       const result = extractSessionToolResult(entry, linked);
       const id = result.id === null ? "" : ` id=${result.id}`;
       const error = result.isError ? " error=true" : "";
-      return [`${prefix} tool_result ${result.tool}${id}${error}: ${previewUnknown(result.result)}`];
+      const tool = result.id === null ? result.tool : calls.get(result.id) ?? result.tool;
+      return [`${prefix} tool_result ${tool}${id}${error}: ${previewUnknown(result.result)}`];
     }
     const text = collapseWhitespace(extractTextFromPayload(entry.payload));
     const rendered = text.length > 0 ? truncateText(text, TRANSCRIPT_TEXT_MAX_CHARS) : previewUnknown(entry.payload);
@@ -20623,7 +20238,7 @@ async function readRunLedger(stateDir) {
 }
 function selectRunEnvelopes(ledger, source) {
   return ledger.rows.flatMap((entry, index) => {
-    if (!isRecord16(entry)) return [];
+    if (!isRecord15(entry)) return [];
     const selected = source.kind === "run" ? entry.id === source.runId : entry.sessionId === source.sessionId;
     return selected ? [parseRunEnvelope(entry, `${ledger.path}[${index}]`)] : [];
   });
@@ -20664,7 +20279,7 @@ function readExecutionRole(value, source) {
   return role;
 }
 function parseRunEnvelope(value, source) {
-  if (!isRecord16(value)) throw new Error(`${source}: expected object`);
+  if (!isRecord15(value)) throw new Error(`${source}: expected object`);
   const reasoningTokenCount = readOptionalNumber2(value, source, "reasoningTokenCount");
   return {
     ...value,
@@ -20692,9 +20307,9 @@ function parseRunEnvelope(value, source) {
   };
 }
 function parseRunReceipt(value, source) {
-  if (!isRecord16(value)) throw new Error(`${source}: expected object`);
+  if (!isRecord15(value)) throw new Error(`${source}: expected object`);
   const integrity = value.integrity;
-  if (!isRecord16(integrity)) throw new Error(`${source}.integrity: expected object`);
+  if (!isRecord15(integrity)) throw new Error(`${source}.integrity: expected object`);
   const reasoningTokenCount = readOptionalNumber2(value, source, "reasoningTokenCount");
   const failureMessage = readOptionalString(value.failureMessage);
   return {
@@ -20738,7 +20353,7 @@ function readToolStats(record, source, field) {
   if (!Array.isArray(value)) throw new Error(`${source}.${field}: expected array`);
   return value.map((entry, index) => {
     const itemSource = `${source}.${field}[${index}]`;
-    if (!isRecord16(entry)) throw new Error(`${itemSource}: expected object`);
+    if (!isRecord15(entry)) throw new Error(`${itemSource}: expected object`);
     return {
       tool: readString3(entry, itemSource, "tool"),
       count: readNumber3(entry, itemSource, "count"),
@@ -20803,11 +20418,11 @@ function parseJson3(raw, source) {
     throw new Error(`${source}: invalid JSON: ${message}`);
   }
 }
-function isRecord16(value) {
+function isRecord15(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function payloadObject(payload) {
-  return isRecord16(payload) ? payload : null;
+  return isRecord15(payload) ? payload : null;
 }
 function parseMaybeJson(value) {
   if (typeof value !== "string") return value;
@@ -20824,7 +20439,7 @@ function firstContentBlock(payload, type) {
   const content = obj?.content;
   if (!Array.isArray(content)) return null;
   for (const block of content) {
-    if (!isRecord16(block)) continue;
+    if (!isRecord15(block)) continue;
     if (block.type === type) return block;
   }
   return null;
@@ -20837,7 +20452,7 @@ function extractTextFromPayload(payload) {
   if (Array.isArray(obj.content)) {
     const parts = [];
     for (const block of obj.content) {
-      if (!isRecord16(block)) continue;
+      if (!isRecord15(block)) continue;
       if (block.type === "text" && typeof block.text === "string") parts.push(block.text);
     }
     return parts.join("\n");
@@ -21324,7 +20939,7 @@ async function readRunLedger2(stateDir) {
   try {
     const raw = await readFile4(join27(stateDir, "runs.json"), "utf8");
     const parsed = JSON.parse(raw);
-    return Array.isArray(parsed) ? parsed.filter(isRecord17) : [];
+    return Array.isArray(parsed) ? parsed.filter(isRecord16) : [];
   } catch {
     return [];
   }
@@ -21336,7 +20951,7 @@ async function readReceiptForRun(stateDir, envelope) {
   const path2 = envelope.receiptPath ?? join27(stateDir, "receipts", `${envelope.id}.json`);
   try {
     const parsed = JSON.parse(await readFile4(path2, "utf8"));
-    return isRecord17(parsed) ? parsed : null;
+    return isRecord16(parsed) ? parsed : null;
   } catch {
     return null;
   }
@@ -21351,7 +20966,7 @@ async function countSessionEntries(stateDir, sessionIds) {
       count += raw.split("\n").filter((line) => line.trim().length > 0).filter((line) => {
         try {
           const parsed = JSON.parse(line);
-          return isRecord17(parsed) && parsed.type !== "session";
+          return isRecord16(parsed) && parsed.type !== "session";
         } catch {
           return false;
         }
@@ -21400,7 +21015,7 @@ async function linkedEvalAuditRows(stateDir, runIds, artifact) {
       } catch {
         continue;
       }
-      if (!isRecord17(parsed)) continue;
+      if (!isRecord16(parsed)) continue;
       const directRunId = typeof parsed.runId === "string" ? parsed.runId : null;
       if (directRunId !== null && runIds.has(directRunId)) {
         rows.push(evalAuditRow(parsed, directRunId, "run-id", "exact", ["audit runId matched nested eval run"]));
@@ -21471,7 +21086,7 @@ function sanitizeEvidenceId2(value) {
   const sanitized = value.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
   return sanitized.length === 0 ? "unknown" : sanitized;
 }
-function isRecord17(value) {
+function isRecord16(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -21753,7 +21368,7 @@ function parseTaskMemoryHandoffSnapshot(text) {
   } catch {
     return null;
   }
-  if (!isRecord18(raw) || raw.version !== 1 && raw.version !== TASK_MEMORY_HANDOFF_VERSION) return null;
+  if (!isRecord17(raw) || raw.version !== 1 && raw.version !== TASK_MEMORY_HANDOFF_VERSION) return null;
   if (raw.version === 1 && !hasExactKeys(raw, ["version", "knowledge", "procedural"])) return null;
   if (raw.version === TASK_MEMORY_HANDOFF_VERSION && !hasExactKeys(raw, ["version", "source", "redaction", "knowledge", "procedural"])) {
     return null;
@@ -21840,7 +21455,7 @@ function parseEntries(value, maxEntries, version) {
   const entries = [];
   for (const raw of value) {
     const expectedKeys = version === 1 ? ["id", "content", "injectionCount"] : ["id", "content", "injectionCount", "createdAt", "lastTouchedAt"];
-    if (!isRecord18(raw) || !hasExactKeys(raw, expectedKeys)) return null;
+    if (!isRecord17(raw) || !hasExactKeys(raw, expectedKeys)) return null;
     if (!nonEmptyString(raw.id) || !nonEmptyString(raw.content) || raw.content.length > TASK_MEMORY_CONTENT_MAX_CHARS)
       return null;
     if (!Number.isInteger(raw.injectionCount) || raw.injectionCount < 0) return null;
@@ -21857,7 +21472,7 @@ function parseEntries(value, maxEntries, version) {
   return entries;
 }
 function parseSource(value) {
-  if (!isRecord18(value) || !hasExactKeys(value, ["sessionId", "evidenceRefs", "runtimeIds", "agentIds"])) return null;
+  if (!isRecord17(value) || !hasExactKeys(value, ["sessionId", "evidenceRefs", "runtimeIds", "agentIds"])) return null;
   if (!validSourceValue2(value.sessionId)) return null;
   const evidenceRefs = parseSourceValues(value.evidenceRefs, false);
   const runtimeIds = parseNamedIdentities(value.runtimeIds);
@@ -21866,7 +21481,7 @@ function parseSource(value) {
   return { sessionId: value.sessionId, evidenceRefs, runtimeIds, agentIds };
 }
 function parseRedaction(value) {
-  if (!isRecord18(value) || !hasExactKeys(value, ["replacementCount", "sourceFields"])) return null;
+  if (!isRecord17(value) || !hasExactKeys(value, ["replacementCount", "sourceFields"])) return null;
   if (!Number.isInteger(value.replacementCount) || value.replacementCount < 0) return null;
   const sourceFields = parseSourceValues(value.sourceFields, true);
   if (sourceFields === null) return null;
@@ -21913,7 +21528,7 @@ function cloneSource(source) {
     agentIds: [...source.agentIds]
   };
 }
-function isRecord18(value) {
+function isRecord17(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function hasExactKeys(value, keys) {
@@ -22815,11 +22430,6 @@ export {
   buildMemoryPromptSection,
   selectWorkerContext,
   protectedResidencyModels,
-  AcpTimeoutError,
-  ACP_TURN_FAILED_MESSAGE,
-  AcpRequestError,
-  acpErrorMessage,
-  createStdioServerTransport,
   ACP_USAGE_META_KEY,
   ACP_SESSION_META_KEY,
   ACP_AGENT_META_KEY,
@@ -22900,4 +22510,4 @@ export {
   buildWikiPlanPrompt,
   buildWikiPagePrompt
 };
-//# sourceMappingURL=chunk-WN552PKN.js.map
+//# sourceMappingURL=chunk-F2YM3JY4.js.map