@iowarp/clio-coder 0.4.8 → 0.4.9

package/dist/{chunk-5W4FRA5Q.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-K53E2PTW.js";
-import {
-  executionPlanAncestors,
-  spliceExecutionPlan
-} from "./chunk-L75H5B3B.js";
 import {
   decideReviewGate,
   materializePendingGateDecision,
@@ -23,7 +9,7 @@ import {
   readGateDecisionArtifactsForRunIds,
   stagePendingGateDecision,
   verifyGateDecisionArtifact
-} from "./chunk-H77XBUBM.js";
+} from "./chunk-NMBEW4PP.js";
 import {
   RUN_RECEIPT_INTEGRITY_ALGORITHM,
   RUN_RECEIPT_INTEGRITY_VERSION,
@@ -43,14 +29,32 @@ import {
   trustVerdict,
   verifyReceiptIntegrity,
   withReceiptIntegrity
-} from "./chunk-FB3KTE2J.js";
+} from "./chunk-IALZJE37.js";
 import {
   protectedArtifactFromSessionEntry,
   protectedArtifactStateFromSessionEntries,
   readAuditRows,
   readSessionEntriesForId,
   responseModelIdObservationFromRecord
-} from "./chunk-BIY22UUK.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,9 +62,13 @@ import {
   sumEvalHarnessMetrics
 } from "./chunk-U44YYLVV.js";
 import {
-  codeStepDir,
-  writeCodeStepRecord
-} from "./chunk-QYSAZMSH.js";
+  parseRigorOverride,
+  resolveRigor
+} from "./chunk-GREYLTZ5.js";
+import {
+  describeValidationContract,
+  loadValidationContract
+} from "./chunk-PTFISXQO.js";
 import {
   filterEntriesToActivePath
 } from "./chunk-O5F25NIE.js";
@@ -68,6 +76,10 @@ import {
   defaultRunEventJournal,
   removeRunEventJournals
 } from "./chunk-UQIVHSE4.js";
+import {
+  createTomlFileReader,
+  tomlTableAt
+} from "./chunk-LQTKDAUO.js";
 import {
   AdmissionCanceledError,
   EVENT_TEE_LIMIT,
@@ -77,11 +89,7 @@ import {
   foldDecisionBoard,
   startDispatchEventPump,
   workerOutputCaptureBytes
-} from "./chunk-STC6CWUZ.js";
-import {
-  judgeNumericTexts,
-  judgePerfTexts
-} from "./chunk-RKFNU5UA.js";
+} from "./chunk-K3XN4LZ4.js";
 import {
   changedPathsSince,
   computeWikiContentHash,
@@ -95,6 +103,17 @@ import {
   writeWikiMeta,
   writeWikiMetaInDir
 } from "./chunk-YQ3GFEUY.js";
+import {
+  readClioState,
+  statePath,
+  writeClioState
+} from "./chunk-WTQGRBHV.js";
+import {
+  buildCodewikiCandidate,
+  coordinateCodewikiExclusive,
+  coordinateCodewikiWrite,
+  drainCodewikiWrites
+} from "./chunk-WWRV5RJI.js";
 import {
   WIKI_INDEX,
   WIKI_PLAN_FILE,
@@ -115,16 +134,15 @@ import {
   writeWikiPlanFile
 } from "./chunk-BHJMMCXS.js";
 import {
-  readClioState,
-  statePath,
-  writeClioState
-} from "./chunk-WTQGRBHV.js";
+  FLEET_COMMAND_BASE_ENV,
+  normalizeWriteBoundary,
+  validateFleetCommandArgs
+} from "./chunk-7QQRPB2E.js";
 import {
-  buildCodewikiCandidate,
-  coordinateCodewikiExclusive,
-  coordinateCodewikiWrite,
-  drainCodewikiWrites
-} from "./chunk-WWRV5RJI.js";
+  JUDGED_CHECK_MAX_OUTPUT_BYTES,
+  judgeNumericTexts,
+  judgePerfTexts
+} from "./chunk-QI72X67S.js";
 import {
   LOCAL_NODE_ID,
   computeSettingsFingerprint,
@@ -135,28 +153,11 @@ import {
   receiptAttestationFields,
   routeFactVerdict,
   spawnNativeWorker
-} from "./chunk-JRA6OBHY.js";
-import {
-  createTomlFileReader,
-  tomlTableAt
-} from "./chunk-LQTKDAUO.js";
-import {
-  parseRigorOverride,
-  resolveRigor
-} from "./chunk-2ZWLMA3T.js";
-import {
-  describeValidationContract,
-  loadValidationContract
-} from "./chunk-RFULVPBX.js";
-import {
-  FLEET_COMMAND_BASE_ENV,
-  normalizeWriteBoundary,
-  validateFleetCommandArgs
-} from "./chunk-7QQRPB2E.js";
+} from "./chunk-A6DULIMH.js";
 import {
   AcpTimeoutError,
   createStdioTransport
-} from "./chunk-WS4FOGLY.js";
+} from "./chunk-XNZWWDC3.js";
 import {
   AGENT_LEDGER_PROMPT_MAX_CHARS,
   COUNCIL_MIN_MEMBERS,
@@ -198,7 +199,7 @@ import {
   serializeWorkerRuntimeDescriptor,
   toolPromptHintsForNames,
   validateJobSpec
-} from "./chunk-MWMW53WW.js";
+} from "./chunk-4ATBOFRP.js";
 import {
   WORKER_CONTEXT_MAX_BYTES,
   completeHistoryLength,
@@ -221,7 +222,10 @@ import {
   routingIntentRejection,
   sameRouteIdentity,
   toRouteCandidate
-} from "./chunk-RM3XJX7P.js";
+} from "./chunk-MO65K5CH.js";
+import {
+  assessFinishContract
+} from "./chunk-AY4XE6GN.js";
 import {
   isLoadableExtension
 } from "./chunk-OH3YYA3B.js";
@@ -229,13 +233,18 @@ import {
   extensionToolName,
   listInstalledExtensions
 } from "./chunk-6TKOFFGE.js";
+import {
+  directSurfaceNames,
+  effectiveToolCall,
+  withGatewayForCapabilities
+} from "./chunk-2JBZYUPY.js";
 import {
   describeCallAction
-} from "./chunk-2GPGAE5W.js";
+} from "./chunk-XNIZBOFV.js";
 import {
   applyToolProfile,
   assertToolProfileEnforceable
-} from "./chunk-GEVQNST4.js";
+} from "./chunk-XZWSP67B.js";
 import {
   dispatchResultContract,
   gateRouteCorrelation,
@@ -243,34 +252,7 @@ import {
   requestExecutionRole,
   routeCorrelationFactsForRun,
   withAttemptRole
-} from "./chunk-FNVPQQYT.js";
-import {
-  declaredScopeIntent,
-  declaredScopeReplacementDiagnostic,
-  declaredScopeReplacementNotice,
-  inferredScopeParentTokenDiagnostic,
-  inferredScopeParentTokenNotice,
-  resolveDispatchPathScope
-} from "./chunk-L4N3DWNW.js";
-import {
-  networkToolsDisabled
-} from "./chunk-SL2RDHKO.js";
-import {
-  TOOL_RESULT_TRUST_CONTRACT
-} from "./chunk-WXA2CFJO.js";
-import {
-  compileGlobRegex,
-  normalizeGlobInput
-} from "./chunk-V552WL53.js";
-import {
-  WORKER_STDIN_FRAME_MAX_BYTES,
-  canonicalJson,
-  endpointIdentityHash,
-  parseAgentLedgerBody
-} from "./chunk-VQD7NH7Z.js";
-import {
-  assessFinishContract
-} from "./chunk-MUXNDNMZ.js";
+} from "./chunk-H6IUCY6Q.js";
 import {
   canonicalEndpointKey,
   canonicalizeWireModelId,
@@ -289,29 +271,27 @@ import {
   resolveRuntimeTarget,
   runtimeResolutionWarnings,
   runtimeTargetSnapshot
-} from "./chunk-GVU4CXPJ.js";
+} from "./chunk-4HFJKRGZ.js";
 import {
   ceilChars,
   estimateAgentMessageTokens
-} from "./chunk-OPC4DQD6.js";
+} from "./chunk-SJMNU4ZS.js";
 import {
-  WRITE_ROOT_REFUSED_TOOLS
-} from "./chunk-RAUOKUZV.js";
-import {
-  resolveEffectivePricing
-} from "./chunk-UDAK6GR2.js";
+  BusChannels
+} from "./chunk-W5RM7YAH.js";
 import {
-  compareCodepoints
-} from "./chunk-B6UM3OZC.js";
+  networkToolsDisabled
+} from "./chunk-SL2RDHKO.js";
 import {
-  truncateUtf8
-} from "./chunk-MYI32N4R.js";
+  compileGlobRegex,
+  normalizeGlobInput
+} from "./chunk-IZZI3SKQ.js";
 import {
-  BusChannels
-} from "./chunk-W5RM7YAH.js";
+  WRITE_ROOT_REFUSED_TOOLS
+} from "./chunk-IC7JXLOM.js";
 import {
-  targetRequiresAuth
-} from "./chunk-PAQVETLA.js";
+  TOOL_RESULT_TRUST_CONTRACT
+} from "./chunk-WXA2CFJO.js";
 import {
   agentSpecFingerprint,
   assertAgentSpecPolicy,
@@ -321,24 +301,38 @@ import {
   resolveAgentToolCompatibility,
   resultContractAuthorship,
   validateRecipeResult
-} from "./chunk-ARRUMZ7X.js";
+} from "./chunk-I47EJPYL.js";
 import {
   INTEROP_AGENT_KINDS
 } from "./chunk-5EQO5NWP.js";
 import {
   classify
-} from "./chunk-YXFKLMX2.js";
+} from "./chunk-H2WSCZZT.js";
 import {
   detectValidationCommand
-} from "./chunk-E2NSPYLC.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,
   resolvePathBoundary
 } from "./chunk-R2P2U3ZS.js";
-import {
-  canonicalizeExistingPath
-} from "./chunk-KQ6IDQIB.js";
 import {
   isProjectVerifierCheckId,
   isVerificationScriptName
@@ -347,20 +341,32 @@ import {
   ToolNames,
   isBuiltinToolName,
   isHarnessExtensionToolName
-} from "./chunk-WLHX3MM5.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 {
+  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,
@@ -377,28 +383,30 @@ import {
   decisionRef,
   isDecisionRecord,
   isSkillActivation
-} from "./chunk-6R5MBXBJ.js";
+} 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 {
-  DEFAULT_AUTONOMY_LEVEL,
-  autonomyDenyRejection,
-  mapAutonomy
-} from "./chunk-EM2WNQS2.js";
+  FILE_LOCK_ACQUIRE_TIMEOUT_MS,
+  withStateFileLock,
+  withStateFileLockSync
+} from "./chunk-DVJL77SO.js";
 import {
   atomicWrite
-} from "./chunk-36XSBPXL.js";
+} from "./chunk-3RDHGNU7.js";
 import {
   assertSafeId
 } from "./chunk-UHW5V7HC.js";
-import {
-  FILE_LOCK_ACQUIRE_TIMEOUT_MS,
-  withStateFileLock,
-  withStateFileLockSync
-} from "./chunk-DVJL77SO.js";
 import {
   normalizeClioCoderEventRecord,
   normalizeClioCoderEventType
@@ -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);
@@ -6418,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,
@@ -6454,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);
   }
@@ -6512,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."
   ];
@@ -6615,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();
@@ -6626,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)],
@@ -9119,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) => {
@@ -9145,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);
@@ -9286,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;
@@ -9379,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) };
@@ -9417,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],
@@ -9493,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 : {
@@ -12572,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) {
@@ -13443,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)
   });
@@ -13468,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) {
@@ -13511,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 {
@@ -13570,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,
@@ -13584,7 +13631,8 @@ function createDispatchBundle(context, options) {
       excludedRouteParts: [...decision.excludedRouteParts],
       rootRunId,
       terminalCandidate: receipt,
-      timer
+      timer,
+      settleCanceled
     });
     context.bus.emit(BusChannels.DispatchProgress, {
       runId: run.runId,
@@ -13657,6 +13705,7 @@ function createDispatchBundle(context, options) {
       }
     };
     delete retryReq.runIdHint;
+    let terminal;
     const reasonKey = retryReasonKey(run.lineage.rootRunId, attempt);
     retryReasons.set(reasonKey, reason);
     try {
@@ -13720,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,
@@ -13740,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);
@@ -13770,6 +13823,7 @@ function createDispatchBundle(context, options) {
         outcomeDetail: denial
       });
     }
+    await terminal;
   }
   function requireLedger() {
     if (!ledger) throw new Error("dispatch: ledger not initialised");
@@ -14064,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
@@ -15852,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()
         });
@@ -16122,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);
@@ -16209,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);
@@ -16752,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");
       }
@@ -16791,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;
@@ -16846,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`);
@@ -16865,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,
@@ -16883,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;
@@ -17111,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]);
@@ -17121,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();
@@ -17133,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;
@@ -17148,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;
@@ -17224,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 }
     );
@@ -17235,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();
@@ -17253,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;
@@ -17278,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;
         }
       }
@@ -17338,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];
@@ -17382,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) {
@@ -17462,7 +17629,7 @@ async function executePlan(initialPlan, adapter, signal) {
       }
       waveIndex += 1;
     }
-    return {
+    outcome = {
       planHash: plan.hash,
       results,
       skipped: [...skipped],
@@ -17473,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
@@ -18159,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);
@@ -19233,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),
@@ -19565,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);
@@ -19573,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,
@@ -19824,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("");
@@ -19845,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") {
@@ -19857,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);
@@ -22280,4 +22510,4 @@ export {
   buildWikiPlanPrompt,
   buildWikiPagePrompt
 };
-//# sourceMappingURL=chunk-5W4FRA5Q.js.map
+//# sourceMappingURL=chunk-F2YM3JY4.js.map