@iowarp/clio-coder 0.4.1 → 0.4.3

package/dist/{chunk-XKA2ICR3.js → chunk-AF4YM7Z4.js}

@@ -1,4 +1,16 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  applyTaskWorktree,
+  captureWorkspaceSnapshot,
+  cleanupTaskWorktree,
+  createTaskWorktree,
+  createWriteBoundaryEnforcer,
+  gitCheckoutRoot
+} from "./chunk-B4VEBZKF.js";
+import {
+  executionPlanAncestors,
+  spliceExecutionPlan
+} from "./chunk-E3TPLWFX.js";
 import {
   decideReviewGate,
   materializePendingGateDecision,
@@ -6,7 +18,7 @@ import {
   readGateDecisionArtifactsForRunIds,
   stagePendingGateDecision,
   verifyGateDecisionArtifact
-} from "./chunk-GPPB3JBE.js";
+} from "./chunk-WRBAGUNF.js";
 import {
   RUN_RECEIPT_INTEGRITY_ALGORITHM,
   RUN_RECEIPT_INTEGRITY_VERSION,
@@ -24,40 +36,32 @@ import {
   trustVerdict,
   verifyReceiptIntegrity,
   withReceiptIntegrity
-} from "./chunk-6NJQITNH.js";
+} from "./chunk-IWT4SF4R.js";
 import {
   protectedArtifactFromSessionEntry,
   protectedArtifactStateFromSessionEntries,
   readAuditRows,
   readSessionEntriesForId,
   responseModelIdObservationFromRecord
-} from "./chunk-TVH4ONAM.js";
+} from "./chunk-JKKCYP3C.js";
 import {
-  applyTaskWorktree,
-  captureWorkspaceSnapshot,
-  cleanupTaskWorktree,
-  createTaskWorktree,
-  createWriteBoundaryEnforcer,
-  gitCheckoutRoot
-} from "./chunk-TD3PGPQA.js";
+  loadEvalArtifact,
+  parseEvalArtifactV4,
+  redactArtifactForStorage,
+  sumEvalHarnessMetrics
+} from "./chunk-FTMGRKEF.js";
 import {
-  executionPlanAncestors,
-  spliceExecutionPlan
-} from "./chunk-THYWACCR.js";
+  codeStepDir,
+  writeCodeStepRecord
+} from "./chunk-XRZT5WY5.js";
 import {
   parseRigorOverride,
   resolveRigor
 } from "./chunk-RVG5JXAL.js";
-import {
-  loadEvalArtifact,
-  parseEvalArtifactV4,
-  redactArtifactForStorage,
-  sumEvalHarnessMetrics
-} from "./chunk-6CCS4G3W.js";
 import {
   defaultRunEventJournal,
   removeRunEventJournals
-} from "./chunk-6VC4OV3Z.js";
+} from "./chunk-VIA6RFQZ.js";
 import {
   AdmissionCanceledError,
   EVENT_TEE_LIMIT,
@@ -65,6 +69,10 @@ import {
   durableAssistantTextFromEvent,
   startDispatchEventPump
 } from "./chunk-T56WDKA5.js";
+import {
+  FLEET_COMMAND_BASE_ENV,
+  normalizeWriteBoundary
+} from "./chunk-2VIKGWFZ.js";
 import {
   LOCAL_NODE_ID,
   computeSettingsFingerprint,
@@ -75,11 +83,7 @@ import {
   receiptAttestationFields,
   routeFactVerdict,
   spawnNativeWorker
-} from "./chunk-AFKWHWXF.js";
-import {
-  FLEET_COMMAND_BASE_ENV,
-  normalizeWriteBoundary
-} from "./chunk-CTJ4RNAA.js";
+} from "./chunk-6PTFB5VS.js";
 import {
   AGENT_LEDGER_PROMPT_MAX_CHARS,
   COUNCIL_MIN_MEMBERS,
@@ -103,12 +107,15 @@ import {
   declaredScopeIntent,
   declaredScopeReplacementDiagnostic,
   declaredScopeReplacementNotice,
+  inferredScopeParentTokenDiagnostic,
+  inferredScopeParentTokenNotice,
   isBoundedGateRolePrompt,
   isClaudeCanonicalTool,
   isResponseSchemaRejection,
   isRunOutcomeCode,
   networkToolsDisabled,
   nodeResultContractFilesystem,
+  normalizePromptHint,
   projectExecutionHandoffs,
   renderAgentLedger,
   resolveDispatchPathScope,
@@ -119,7 +126,7 @@ import {
   serializeWorkerRuntimeDescriptor,
   toolPromptHintsForNames,
   validateJobSpec
-} from "./chunk-2VG7KLYV.js";
+} from "./chunk-PAJQJ7BS.js";
 import {
   decideRoute,
   defaultRoutingIntent,
@@ -137,16 +144,16 @@ import {
   routingIntentRejection,
   sameRouteIdentity,
   toRouteCandidate
-} from "./chunk-7EPLI7VL.js";
+} from "./chunk-EKCHAPYA.js";
 import {
   assessFinishContract
-} from "./chunk-PVAMAVBB.js";
+} from "./chunk-RSJ25QSL.js";
 import {
   WRITE_ROOT_REFUSED_TOOLS
-} from "./chunk-IXJT6DCX.js";
+} from "./chunk-XIVNBFZS.js";
 import {
   describeCallAction
-} from "./chunk-TVHHYFHE.js";
+} from "./chunk-NEDJ26B5.js";
 import {
   applyToolProfile,
   assertToolProfileEnforceable
@@ -161,28 +168,11 @@ import {
 } from "./chunk-H7IXIC72.js";
 import {
   compareCodepoints
-} from "./chunk-VN3SHNBN.js";
-import {
-  DEFAULT_AUTONOMY_LEVEL,
-  autonomyDenyRejection,
-  isSkillActivation,
-  mapAutonomy
-} from "./chunk-FSP7CMNU.js";
-import {
-  createRedactionTally,
-  redactSecretsDeep,
-  redactSecretsText
-} from "./chunk-4BJ5BYCE.js";
-import {
-  truncateUtf8
-} from "./chunk-6XLNIQDB.js";
+} from "./chunk-7DICMOS6.js";
 import {
-  canonicalJson,
-  endpointIdentityHash,
-  parseAgentLedgerBody
-} from "./chunk-VAVR4IJY.js";
-import {
-  pathBoundaryCovers
+  PATH_BOUNDARY_MAX_ENTRIES,
+  pathBoundaryCovers,
+  resolvePathBoundary
 } from "./chunk-HHV2GANA.js";
 import {
   agentSpecFingerprint,
@@ -194,10 +184,10 @@ import {
   resolveAgentToolCompatibility,
   resultContractAuthorship,
   validateRecipeResult
-} from "./chunk-IG7BCQBA.js";
+} from "./chunk-B4OAX3SI.js";
 import {
   detectValidationCommand
-} from "./chunk-GCSMB2KY.js";
+} from "./chunk-I7ZPNEJM.js";
 import {
   isProjectVerifierCheckId,
   isVerificationScriptName
@@ -205,17 +195,39 @@ import {
 import {
   canonicalizeExistingPath
 } from "./chunk-ECH6PKUQ.js";
+import {
+  truncateUtf8
+} from "./chunk-6XLNIQDB.js";
+import {
+  canonicalJson,
+  endpointIdentityHash,
+  parseAgentLedgerBody
+} from "./chunk-VAVR4IJY.js";
+import {
+  DEFAULT_AUTONOMY_LEVEL,
+  autonomyDenyRejection,
+  isSkillActivation,
+  mapAutonomy
+} from "./chunk-JGRC33J2.js";
+import {
+  createRedactionTally,
+  redactSecretsDeep,
+  redactSecretsText
+} from "./chunk-4BJ5BYCE.js";
 import {
   ToolNames,
   isBuiltinToolName
 } from "./chunk-K6BSR66V.js";
 import {
+  canonicalEndpointKey,
   canonicalizeWireModelId,
   endpointCapacityFor,
   endpointCapacityForStatus,
   endpointLabel,
   firstRuntimeResolutionError,
   foregroundStreamUsage,
+  gatewayRoutingObservationFromRecord,
+  gatewayRoutingObservationLabel,
   isDispatchEligibleRuntime,
   normalizeCostProvenance,
   resolveEndpointCapacities,
@@ -223,36 +235,23 @@ import {
   resolveRuntimeTarget,
   runtimeResolutionWarnings,
   runtimeTargetSnapshot
-} from "./chunk-UEDMSP56.js";
+} from "./chunk-XPWWI35G.js";
 import {
   ceilChars
-} from "./chunk-CWVRRIEI.js";
+} from "./chunk-NZMNUPZZ.js";
 import {
   atomicWrite
-} from "./chunk-MQXIVJ35.js";
+} from "./chunk-HAXOFFRH.js";
 import {
   assertSafeId
 } from "./chunk-R346GLFC.js";
-import {
-  BusChannels
-} from "./chunk-HLW2MRKE.js";
 import {
   normalizeClioCoderEventRecord,
   normalizeClioCoderEventType
 } from "./chunk-BTK3SSSK.js";
 import {
-  attributeCommitMessage,
-  gitCommitAttributionEnabled,
-  reportCommitAttributionDiagnostic,
-  withManagedGitCommitAttributionEnvironment
-} from "./chunk-JIEGK6UF.js";
-import {
-  MAX_TIMER_DELAY_MS,
-  rawDurationMs
-} from "./chunk-EBY63B7G.js";
-import {
-  AI_AGENT_NAME
-} from "./chunk-6EJMN2Y3.js";
+  BusChannels
+} from "./chunk-F4EKGO4N.js";
 import {
   readClioVersion,
   readPiMonoVersion,
@@ -263,14 +262,27 @@ import {
   DEFAULT_DELEGATION_TURN_TIMEOUT_MS,
   DEFAULT_SETTINGS,
   THINKING_LEVELS
-} from "./chunk-BWW4HLO4.js";
+} from "./chunk-UXCU4E3T.js";
 import {
   GUARDRAIL_DEFAULTS,
   resolveGuardrail
-} from "./chunk-NLFAQR7Z.js";
+} from "./chunk-S66XZJOF.js";
+import {
+  attributeCommitMessage,
+  gitCommitAttributionEnabled,
+  reportCommitAttributionDiagnostic,
+  withManagedGitCommitAttributionEnvironment
+} from "./chunk-JIEGK6UF.js";
+import {
+  MAX_TIMER_DELAY_MS,
+  rawDurationMs
+} from "./chunk-EBY63B7G.js";
+import {
+  AI_AGENT_NAME
+} from "./chunk-6EJMN2Y3.js";
 import {
   targetRequiresAuth
-} from "./chunk-WNP7O5WZ.js";
+} from "./chunk-ID64D7PE.js";
 import {
   FILE_LOCK_ACQUIRE_TIMEOUT_MS,
   withStateFileLock,
@@ -281,14 +293,15 @@ import {
   processAlive,
   processBirthToken
 } from "./chunk-3I7MS7N2.js";
+import {
+  resolveEffectivePricing
+} from "./chunk-5OIVVPHF.js";
 import {
   clioDataDir,
   clioStateDir,
+  resolveClioDirs,
   stateRootRemoved
 } from "./chunk-BYP5D4HI.js";
-import {
-  resolveEffectivePricing
-} from "./chunk-O42A54GG.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -1228,6 +1241,19 @@ function capacityLeaseUsage(options) {
   }
   return { global: leases.length, nodes, endpoints, endpointHolders };
 }
+function endpointCapacityUsage() {
+  return withStateFileLockSync(capacityStateLockPath(), () => {
+    const file = readCapacityStateUnsafe();
+    reclaim(file, Date.now(), defaultProbe);
+    const held2 = heldReservationUsage(file.reservations);
+    const usage = { ...foregroundStreamUsage() };
+    for (const [key, count] of Object.entries(held2.endpoints)) usage[key] = (usage[key] ?? 0) + count;
+    for (const lease of file.leases) {
+      if (lease.endpointKey !== void 0) usage[lease.endpointKey] = (usage[lease.endpointKey] ?? 0) + 1;
+    }
+    return usage;
+  });
+}
 function createNodeLeaseUsageReader(options) {
   const cacheMs = options.cacheMs ?? 200;
   let cache = null;
@@ -1407,6 +1433,12 @@ function renderDispatchIntentRequirements(intent) {
     "# Declared Result Requirements",
     "These entries are requirements to satisfy and verify. They are not evidence that an output exists or a check passed."
   ];
+  if (intent.writeRoots.length > 0) {
+    lines.push(
+      "",
+      "This run is confined to its write roots and has no bash or verify tool, so you cannot run tests, scripts, or the checks below yourself. Write the code and the tests, re-read them, and report what you wrote; the host runs the declared checks after you finish and records the result on the receipt."
+    );
+  }
   if (intent.expectedOutputs.length > 0) {
     lines.push("", "Expected outputs:", ...intent.expectedOutputs.map((output) => `- ${output}`));
   }
@@ -1442,7 +1474,7 @@ init_esm_shims();
 // src/domains/evidence/build.ts
 init_esm_shims();
 import { mkdir, readFile as readFile2, writeFile } from "node:fs/promises";
-import { join as join16 } from "node:path";
+import { join as join15 } from "node:path";
 
 // src/domains/dispatch/index.ts
 init_esm_shims();
@@ -2437,7 +2469,6 @@ function startAcpDelegationRun(input) {
 // src/domains/prompts/compiler.ts
 init_esm_shims();
 import { join as join3 } from "node:path";
-var FLEET_ROUTING_GUIDANCE = 'Fleet routing: pin the `agent` id from the Fleet section; agent:"auto" baselines from the task text and is a fallback, not a router.';
 var WORKER_CLAIM_GUIDANCE = 'Never claim a completion, a validation, or a file change that no tool call in this run supports. If you did not run it or write it here, say "not verified" and report what you did do.';
 function lookupFragment(table, id, role) {
   const frag = table.byId.get(id);
@@ -2487,16 +2518,32 @@ function renderRuntimeBlock(inputs) {
 }
 function sessionCanDispatch(inputs) {
   if (inputs.providerSupportsTools === false) return false;
-  return toolSurfaceHasTool(inputs.toolNames, inputs.toolPromptHints, "dispatch");
+  return toolSurfaceHasTool(inputs.toolNames, "dispatch");
 }
 function sessionHasContext(inputs) {
   if (inputs.providerSupportsTools === false) return false;
-  return toolSurfaceHasTool(inputs.toolNames, inputs.toolPromptHints, "context");
+  return toolSurfaceHasTool(inputs.toolNames, "context");
 }
-function toolSurfaceHasTool(toolNames, toolPromptHints, tool) {
+function toolSurfaceHasTool(toolNames, tool) {
   const names = new Set((toolNames ?? []).map((name) => name.trim()));
-  const hinted = new Set((toolPromptHints ?? []).map((entry) => entry.tool.trim()));
-  return names.has(tool) || hinted.has(tool);
+  return names.has(tool);
+}
+function canonicalToolPromptHints(entries, admitted) {
+  const normalized = entries.map((entry) => ({
+    tool: entry.tool.trim(),
+    hint: normalizePromptHint(entry.hint) ?? ""
+  })).filter((entry) => admitted.has(entry.tool) && entry.hint.length > 0).sort((a, b) => {
+    if (a.tool !== b.tool) return a.tool < b.tool ? -1 : 1;
+    return a.hint < b.hint ? -1 : a.hint > b.hint ? 1 : 0;
+  });
+  const seenTools = /* @__PURE__ */ new Set();
+  const seenHints = /* @__PURE__ */ new Set();
+  return normalized.filter((entry) => {
+    if (seenTools.has(entry.tool) || seenHints.has(entry.hint)) return false;
+    seenTools.add(entry.tool);
+    seenHints.add(entry.hint);
+    return true;
+  });
 }
 function renderFleetBlock(inputs) {
   if (!sessionCanDispatch(inputs)) return "";
@@ -2515,36 +2562,43 @@ function renderToolContractBlock(inputs) {
   ].sort();
   const canDispatch = sessionCanDispatch(inputs);
   const canListSkills = sessionHasContext(inputs);
+  const admitted = new Set(names);
   const inventoryGuidance = [
-    // Asked twice in one session which tools it had, a live model gave two
-    // different answers and invented `web_find`. The authoritative list is one
-    // line above; pointing at it beats letting the model recall the schemas.
-    "When answering capability-inventory questions, copy the Direct tools line above verbatim rather than recalling the attached schemas, and make no calls",
-    ...canDispatch ? ["add dispatch(list:true) only if agents or the fleet are requested"] : [],
-    ...canListSkills ? ['add context(scope="skills") only if skills are requested (it lists installed and marketplace skills)'] : []
+    "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'] : []
   ].join("; ");
+  const capabilityKinds = [
+    "direct tools are attached schemas",
+    ...canDispatch ? ["fleet agents are workers behind dispatch"] : [],
+    ...canListSkills ? ["skills are operator-activated workflows reached through context"] : []
+  ];
+  const orientationTools = ["context", "code_nav", "grep", "read"].filter((name) => admitted.has(name));
+  const validationTools = ["verify", "git"].filter((name) => admitted.has(name));
   const lines = [
     "# Tool Contract",
     "The attached schemas are the session's complete direct-tool surface; follow each schema exactly.",
     ...names.length > 0 ? [`Direct tools: ${names.map((name) => `\`${name}\``).join(", ")}.`] : [],
-    "Harness model: direct tools are attached schemas; fleet agents are workers behind dispatch; skills are operator-activated workflows reached through context. Keep these capability sets distinct.",
+    `Harness model: ${capabilityKinds.join("; ")}. Keep these capability sets distinct.`,
     `${inventoryGuidance}.`,
-    "Call tools only for concrete inspection or changes the task requires. If the user asks for a tool-free answer, simply answer without calling tools.",
+    "Call tools only for concrete inspection or changes the task requires; a tool-free question gets a tool-free answer.",
     // The tool-specific instantiation of the operating contract's "narrow
     // work: inspect directly" rule; the contract cannot name tools.
     // Delegation, the tasks board, and skills are not restated here: the
-    // Delegation and Skills passages and the registry hints carry them, and
-    // each renders exactly when its tool does.
-    'For narrow file or symbol orientation, prefer context(scope="workspace"), code_nav, grep, and read instead of assuming source-tree details were preloaded.',
-    "Validate with verify or git diff before final claims.",
-    `When a tool call fails or is rejected, do not retry the same shape blindly: re-read the schema, adjust the arguments, or query context(scope="docs") for that tool's usage.`
+    // Delegation, Fleet, and Skills passages and the registry hints carry
+    // them, and each renders exactly when its tool does.
+    ...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((name) => name === "git" ? "git diff" : name).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` : ""}.`
   ];
-  const seen = /* @__PURE__ */ new Set();
-  const hints = [...inputs.toolPromptHints ?? []].map((entry) => ({ tool: entry.tool.trim(), hint: entry.hint.trim() })).filter((entry) => entry.tool.length > 0 && entry.hint.length > 0).sort((a, b) => a.tool < b.tool ? -1 : a.tool > b.tool ? 1 : 0);
-  if (hints.some((entry) => entry.tool === "dispatch")) lines.push(FLEET_ROUTING_GUIDANCE);
+  const hints = canonicalToolPromptHints(inputs.toolPromptHints ?? [], new Set(names));
   for (const entry of hints) {
-    if (seen.has(entry.tool)) continue;
-    seen.add(entry.tool);
     lines.push(entry.hint);
   }
   return lines.join("\n");
@@ -2596,15 +2650,8 @@ function renderWorkerToolContractBlock(inputs) {
     "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."
   ];
-  const admitted = new Set(names);
-  const seen = /* @__PURE__ */ new Set();
-  const hints = [...inputs.toolPromptHints].map((entry) => ({ tool: entry.tool.trim(), hint: entry.hint.trim() })).filter((entry) => admitted.has(entry.tool) && entry.hint.length > 0).sort((a, b) => {
-    if (a.tool !== b.tool) return a.tool < b.tool ? -1 : 1;
-    return a.hint < b.hint ? -1 : a.hint > b.hint ? 1 : 0;
-  });
+  const hints = canonicalToolPromptHints(inputs.toolPromptHints, new Set(names));
   for (const entry of hints) {
-    if (seen.has(entry.tool)) continue;
-    seen.add(entry.tool);
     lines.push(entry.hint);
   }
   return lines.join("\n");
@@ -2638,8 +2685,7 @@ function renderRetrievalHintsBlock(inputs) {
   }
   return [
     "# Retrieval Hints",
-    "Compact CLIO-CODER.md project instructions may be preloaded above; everything else about the repository must be fetched, not assumed.",
-    "Never invent file paths, automatic tool behavior, or mutable repo details from the system prompt."
+    "Repository details not included above must be fetched, never invented; compact CLIO-CODER.md instructions may be preloaded."
   ].join("\n");
 }
 function renderProjectBlock(contextFiles) {
@@ -2706,7 +2752,8 @@ function compile(table, inputs) {
   const docsRouting = selfAwareness && sessionHasContext(session) ? table.byId.get("identity.docs-routing") : void 0;
   if (selfAwareness) {
     const packageRoot = resolvePackageRoot();
-    const rendered2 = selfAwareness.body.replace("{CLIO_DOCS_PATH}", join3(packageRoot, "docs")).replace("{CLIO_SRC_PATH}", join3(packageRoot, "src")).replace("{CLIO_CODEWIKI_PATH}", join3(packageRoot, "dist", "assets", "codewiki.json"));
+    const clioDirs = resolveClioDirs();
+    const rendered2 = selfAwareness.body.replace("{CLIO_DOCS_PATH}", join3(packageRoot, "docs")).replace("{CLIO_SRC_PATH}", join3(packageRoot, "src")).replace("{CLIO_CODEWIKI_PATH}", join3(packageRoot, "dist", "assets", "codewiki.json")).replace("{CLIO_SETTINGS_PATH}", join3(clioDirs.config, "settings.yaml")).replace("{CLIO_STATE_PATH}", clioDirs.state);
     identityBody = [identity.body.trim(), rendered2.trim(), ...docsRouting ? [docsRouting.body.trim()] : []].join(
       "\n\n"
     );
@@ -3683,6 +3730,19 @@ function createLeaseSlotGuard(controller, leaseId, ownedByAssignment) {
 }
 var PUMP_MIN_MS = 10;
 var PUMP_MAX_MS = 500;
+function foregroundEndpointBlock(input) {
+  if (input.endpointKey === void 0) return null;
+  const limit = input.limits.endpoints[input.endpointKey];
+  const active = input.usage.endpoints[input.endpointKey] ?? 0;
+  const holders = input.usage.endpointHolders?.[input.endpointKey];
+  if (limit === void 0 || active < limit || !holders || holders.foregroundStreams < 1) return null;
+  return [
+    `dispatch: admission denied: endpoint '${endpointLabel(input.endpointKey)}' cannot open a worker slot`,
+    ` while ${describeEndpointCapacityHolders(holders)} (${active}/${limit} slots).`,
+    " The foreground agent cannot release its slot until this tool call returns, so waiting here would deadlock.",
+    " Point workers at a second endpoint or raise this target's maxConcurrentRequests to the server's actual slot count."
+  ].join("");
+}
 function describeAdmissionFailure(input) {
   if (input.state === "canceled") return "dispatch: admission canceled before a capacity slot opened";
   if (input.endpointKey !== void 0) {
@@ -3773,6 +3833,14 @@ function createCapacityAdmissionController(options) {
   const controller = {
     async admit(input) {
       if (draining) throw new Error("dispatch: admission denied: this process is shutting down");
+      const limits = options.limits();
+      const usage = options.usage?.() ?? capacityLeaseUsage({ nowMs: now() });
+      const foregroundBlock = foregroundEndpointBlock({
+        ...input.endpointKey !== void 0 ? { endpointKey: input.endpointKey } : {},
+        limits,
+        usage
+      });
+      if (foregroundBlock !== null) throw new Error(foregroundBlock);
       const queuedAt = now();
       const requestId = `admit-${queuedAt.toString(36)}-${randomBytes3(5).toString("hex")}`;
       pending.set(input.assignmentId, requestId);
@@ -4335,6 +4403,7 @@ var REPORTING_CONTRACT_KINDS = /* @__PURE__ */ new Set([
   "scout-report",
   "verifier-report",
   "research-report",
+  "world-knowledge-report",
   "provenance-report",
   "debugger-report",
   "oracle-report"
@@ -4358,6 +4427,7 @@ function suggestedSpecialist(taskType, specs) {
 }
 function assessCapabilityMismatch(input) {
   if (!READ_ONLY_CAPABILITY_CLASSES.has(input.capabilityClass)) return null;
+  if (input.intent && input.intent.writeRoots.length === 0 && input.intent.expectedOutputs.length === 0) return null;
   const features = classifyAgentTask(input.task);
   if (!MUTATING_TASK_TYPES.has(features.taskType)) return null;
   const readShaped = READ_SHAPED_PATTERNS.some((pattern) => pattern.test(input.task));
@@ -4844,6 +4914,9 @@ ${spawned.spawnError}
 // src/domains/dispatch/host-verification.ts
 var OUTPUT_TAIL_BYTES = 2048;
 var MEMO_VERSION = 1;
+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;
 function sha2563(value) {
   return createHash4("sha256").update(value, "utf8").digest("hex");
 }
@@ -4915,6 +4988,52 @@ function hostVerificationRejection(verification) {
     detail: failedCheck === void 0 ? "host verification rejected" : `host verification check '${failedCheck.check}' rejected with exit code ${failedCheck.exitCode}`
   };
 }
+async function runResolvedCheck(input) {
+  const resolvedCheck = input.resolvedCheck;
+  const command = {
+    id: resolvedCheck.check,
+    argv: [...resolvedCheck.argv],
+    cwd: "",
+    timeoutMs: resolvedCheck.timeoutMs,
+    env: [],
+    description: `Host verification check ${resolvedCheck.check}.`
+  };
+  const fingerprint = workspaceFingerprint(resolvedCheck.cwd);
+  const key = fingerprint === null ? null : memoKey({ ...command, cwd: resolve3(resolvedCheck.cwd) }, fingerprint, input.env);
+  const hit = key === null ? void 0 : readMemo(input.stateDir).entries.find((entry) => entry.key === key && entry.check.exitCode === 0);
+  if (hit !== void 0) {
+    return {
+      check: { ...hit.check, argv: [...hit.check.argv], memo: true, evidenceRunId: hit.runId },
+      outputExcerpt: ""
+    };
+  }
+  const outcome = await runCodeStep({
+    stepId: `verification-${input.index + 1}-${resolvedCheck.check.replace(/[^a-z0-9._-]/giu, "_")}`,
+    command,
+    workspaceRoot: resolvedCheck.cwd,
+    artifactDir: join8(input.stateDir, "artifacts", input.runId, "verification"),
+    env: input.env
+  });
+  const artifactPath = outcome.record.artifactPaths[0];
+  const check = {
+    check: resolvedCheck.check,
+    argv: [...outcome.record.argv],
+    cwd: outcome.record.cwd,
+    exitCode: outcome.record.exitCode,
+    durationMs: outcome.record.durationMs,
+    memo: false,
+    outputTail: outputTail(outcome.report.outputExcerpt),
+    ...artifactPath !== void 0 ? { artifactPath } : {}
+  };
+  if (check.exitCode === 0 && key !== null) {
+    try {
+      storeMemoEntry(input.stateDir, { key, runId: input.runId, check });
+    } catch (error) {
+      input.onDiagnostic?.(error);
+    }
+  }
+  return { check, outputExcerpt: outcome.report.outputExcerpt };
+}
 async function runHostVerification(input) {
   const checks = input.request.resolvedVerification;
   if (checks === void 0 || checks.length === 0) return void 0;
@@ -4923,51 +5042,220 @@ async function runHostVerification(input) {
   const env = input.env ?? process.env;
   const results = [];
   for (const [index, resolvedCheck] of checks.entries()) {
-    const command = {
-      id: resolvedCheck.check,
+    const outcome = await runResolvedCheck({
+      runId: input.runId,
+      index,
+      resolvedCheck,
+      stateDir,
+      env,
+      ...input.onDiagnostic !== void 0 ? { onDiagnostic: input.onDiagnostic } : {}
+    });
+    results.push(outcome.check);
+  }
+  return {
+    status: results.every((check) => check.exitCode === 0) ? "verified" : "rejected",
+    checks: results
+  };
+}
+function implicatedPaths(outputExcerpt, checkCwd) {
+  const withoutUrls = outputExcerpt.replace(HTTP_URL_RE, (url) => " ".repeat(url.length));
+  const paths = /* @__PURE__ */ new Set();
+  for (const match of withoutUrls.matchAll(CHECK_OUTPUT_PATH_RE)) paths.add(resolve3(checkCwd, match[0]));
+  return [...paths].sort();
+}
+function checkDedupeKey(resolvedCheck) {
+  return sha2563(
+    JSON.stringify({
+      check: resolvedCheck.check,
       argv: [...resolvedCheck.argv],
-      cwd: "",
-      timeoutMs: resolvedCheck.timeoutMs,
-      env: [],
-      description: `Host verification check ${resolvedCheck.check}.`
-    };
-    const fingerprint = workspaceFingerprint(resolvedCheck.cwd);
-    const key = fingerprint === null ? null : memoKey({ ...command, cwd: resolve3(resolvedCheck.cwd) }, fingerprint, env);
-    const hit = key === null ? void 0 : readMemo(stateDir).entries.find((entry) => entry.key === key && entry.check.exitCode === 0);
-    if (hit !== void 0) {
-      results.push({ ...hit.check, argv: [...hit.check.argv], memo: true, evidenceRunId: hit.runId });
+      cwd: resolve3(resolvedCheck.cwd),
+      timeoutMs: resolvedCheck.timeoutMs
+    })
+  );
+}
+function memberBoundary(participant) {
+  const writeRoots = participant.request.intent?.writeRoots ?? [];
+  return writeRoots.map((root) => resolvePathBoundary(participant.request.cwd ?? process.cwd(), root));
+}
+function attributeFailure(input) {
+  const declared = new Set(input.declarers.map((member) => member.runId));
+  const implicatedDeclarers = /* @__PURE__ */ new Set();
+  const unconfined = /* @__PURE__ */ new Set();
+  const decisive = /* @__PURE__ */ new Set();
+  for (const member of input.declarers) {
+    const boundary = memberBoundary(member);
+    if (boundary.length === 0) {
+      unconfined.add(member.runId);
       continue;
     }
-    const outcome = await runCodeStep({
-      stepId: `verification-${index + 1}-${resolvedCheck.check.replace(/[^a-z0-9._-]/giu, "_")}`,
-      command,
-      workspaceRoot: resolvedCheck.cwd,
-      artifactDir: join8(stateDir, "artifacts", input.runId, "verification"),
-      env
-    });
-    const artifactPath = outcome.record.artifactPaths[0];
-    const check = {
-      check: resolvedCheck.check,
-      argv: [...outcome.record.argv],
-      cwd: outcome.record.cwd,
-      exitCode: outcome.record.exitCode,
-      durationMs: outcome.record.durationMs,
-      memo: false,
-      outputTail: outputTail(outcome.report.outputExcerpt),
-      ...artifactPath !== void 0 ? { artifactPath } : {}
-    };
-    results.push(check);
-    if (check.exitCode === 0 && key !== null) {
-      try {
-        storeMemoEntry(stateDir, { key, runId: input.runId, check });
-      } catch (error) {
-        input.onDiagnostic?.(error);
+    const hits = input.implicated.filter((path2) => pathBoundaryCovers(boundary, path2));
+    if (hits.length === 0) continue;
+    implicatedDeclarers.add(member.runId);
+    for (const hit of hits) decisive.add(hit);
+  }
+  const others = input.wave.filter((member) => !declared.has(member.runId));
+  const ownedElsewhere = input.implicated.length > 0 && input.implicated.every((path2) => others.some((member) => pathBoundaryCovers(memberBoundary(member), path2)));
+  const localized = implicatedDeclarers.size > 0 || ownedElsewhere;
+  const charged = localized ? new Set(implicatedDeclarers) : new Set(declared);
+  for (const runId of unconfined) charged.add(runId);
+  return {
+    charged,
+    basis: !localized || unconfined.size > 0 ? "unattributable" : implicatedDeclarers.size > 0 ? "write_roots" : "attributed_elsewhere",
+    decisive: [...decisive].sort()
+  };
+}
+function createBatchVerificationGate(options = {}) {
+  const stateDir = options.stateDir ?? clioStateDir();
+  const env = options.env ?? process.env;
+  const liveMembers = /* @__PURE__ */ new Set();
+  const parked = /* @__PURE__ */ new Map();
+  let settling = false;
+  const perRun = (participant) => runHostVerification({
+    runId: participant.runId,
+    request: participant.request,
+    workerSuccessful: participant.workerSuccessful,
+    stateDir,
+    env,
+    ...participant.onDiagnostic !== void 0 ? { onDiagnostic: participant.onDiagnostic } : {}
+  });
+  const nothingToRun = (participant) => {
+    const checks = participant.request.resolvedVerification;
+    if (checks === void 0 || checks.length === 0) return void 0;
+    return { status: "skipped", reason: "worker_not_successful", checks: [] };
+  };
+  async function settleBatch(wave) {
+    const members = wave.map((entry) => entry.participant);
+    const contributors = members.filter(
+      (member) => member.workerSuccessful && (member.request.resolvedVerification?.length ?? 0) > 0
+    );
+    const distinct = /* @__PURE__ */ new Map();
+    for (const member of contributors) {
+      for (const resolvedCheck of member.request.resolvedVerification ?? []) {
+        const key = checkDedupeKey(resolvedCheck);
+        if (!distinct.has(key)) distinct.set(key, { resolvedCheck, owner: member, index: distinct.size });
+      }
+    }
+    const ran = /* @__PURE__ */ new Map();
+    for (const [key, entry] of distinct) {
+      const outcome = await runResolvedCheck({
+        runId: entry.owner.runId,
+        index: entry.index,
+        resolvedCheck: entry.resolvedCheck,
+        stateDir,
+        env,
+        // The owning member's callback, because the artifact directory is
+        // named for that same run and the diagnostic text is closed over the
+        // run id it was built for (`extension.ts:5534`); any other member's
+        // callback would name a run whose artifacts the failure is not under.
+        ...entry.owner.onDiagnostic !== void 0 ? { onDiagnostic: entry.owner.onDiagnostic } : {}
+      });
+      ran.set(key, { check: outcome.check, owner: entry.owner.runId, outputExcerpt: outcome.outputExcerpt });
+    }
+    const attribution = [];
+    const chargedByKey = /* @__PURE__ */ new Map();
+    for (const [key, entry] of ran) {
+      if (entry.check.exitCode === 0) continue;
+      const declarers = contributors.filter(
+        (member) => (member.request.resolvedVerification ?? []).some((candidate) => checkDedupeKey(candidate) === key)
+      );
+      const implicated = implicatedPaths(entry.outputExcerpt, entry.check.cwd);
+      const verdict = attributeFailure({ implicated, declarers, wave: members });
+      chargedByKey.set(key, verdict.charged);
+      const decisive = new Set(verdict.decisive);
+      attribution.push({
+        check: entry.check.check,
+        // The paths that decided the charge lead the capped list. A large
+        // suite names more than 32 files and the sealed evidence has to
+        // contain the path a receipt was charged on, or it documents nothing.
+        implicated: [...verdict.decisive, ...implicated.filter((path2) => !decisive.has(path2))].slice(
+          0,
+          IMPLICATED_PATH_CAP
+        ),
+        charged: [...verdict.charged].sort(),
+        basis: verdict.basis
+      });
+    }
+    attribution.sort((first, second) => first.check < second.check ? -1 : first.check > second.check ? 1 : 0);
+    for (const entry of wave) {
+      const member = entry.participant;
+      if (!contributors.includes(member)) {
+        entry.settle(nothingToRun(member));
+        continue;
       }
+      const own = [];
+      let rejected = false;
+      let unimplicated = false;
+      for (const resolvedCheck of member.request.resolvedVerification ?? []) {
+        const key = checkDedupeKey(resolvedCheck);
+        const shared = ran.get(key);
+        if (shared === void 0) continue;
+        own.push(
+          shared.owner === member.runId || shared.check.evidenceRunId !== void 0 ? { ...shared.check, argv: [...shared.check.argv] } : { ...shared.check, argv: [...shared.check.argv], evidenceRunId: shared.owner }
+        );
+        if (shared.check.exitCode === 0) continue;
+        if (chargedByKey.get(key)?.has(member.runId) === true) rejected = true;
+        else unimplicated = true;
+      }
+      entry.settle({
+        // `verified` states that every declared check passed, which is what
+        // `trust-status.ts:619` certifies and what the board and
+        // `worker-evidence.ts:161` print. An exculpated member's checks array
+        // still carries a non-zero exit code, so it seals its own status
+        // instead of borrowing that claim.
+        status: rejected ? "rejected" : unimplicated ? "not_implicated" : "verified",
+        ...!rejected && unimplicated ? { reason: "batch_settled_not_implicated" } : {},
+        checks: own,
+        strategy: "batch-settled",
+        // Copied per receipt so no two members of the batch share a mutable array.
+        ...attribution.length > 0 ? {
+          attribution: attribution.map((record) => ({
+            ...record,
+            implicated: [...record.implicated],
+            charged: [...record.charged]
+          }))
+        } : {}
+      });
+    }
+  }
+  function maybeSettle() {
+    if (settling || parked.size === 0) return;
+    for (const runId of liveMembers) {
+      if (!parked.has(runId)) return;
     }
+    settling = true;
+    const wave = [...parked.values()];
+    for (const runId of parked.keys()) liveMembers.delete(runId);
+    parked.clear();
+    void settleBatch(wave).catch(async (error) => {
+      for (const entry of wave) {
+        entry.participant.onDiagnostic?.(error);
+        try {
+          entry.settle(await perRun(entry.participant));
+        } catch (fallbackError) {
+          entry.fail(fallbackError);
+        }
+      }
+    }).finally(() => {
+      settling = false;
+      maybeSettle();
+    });
   }
   return {
-    status: results.every((check) => check.exitCode === 0) ? "verified" : "rejected",
-    checks: results
+    live(runId) {
+      liveMembers.add(runId);
+    },
+    abandon(runId) {
+      if (parked.has(runId) || !liveMembers.delete(runId)) return;
+      maybeSettle();
+    },
+    arrive(input) {
+      liveMembers.add(input.runId);
+      const parkedPromise = new Promise((settle, fail) => {
+        parked.set(input.runId, { participant: input, settle, fail });
+      });
+      maybeSettle();
+      return parkedPromise;
+    }
   };
 }
 
@@ -6278,6 +6566,11 @@ function receiptResponseModelIdObservationLabel(receipt) {
   });
   return `response_model_id_observation=${labels.join(",")}`;
 }
+function receiptGatewayRoutingLabel(receipt) {
+  const observations = (receipt.upstreamResponses ?? []).map((response) => gatewayRoutingObservationFromRecord(response)).filter((observation) => observation !== null);
+  if (observations.length === 0) return null;
+  return observations.map(gatewayRoutingObservationLabel).join(" | ");
+}
 
 // src/tools/dispatch-run-events.ts
 var RUN_TAIL_ENTRY_LIMIT = 100;
@@ -6974,6 +7267,36 @@ function describeUngroundedValidations(grounding) {
   return grounding.basis === "no-command-executed" ? `unverifiable validation: this run claimed ${named} passed and executed no command at all (${grounding.grounded}/${grounding.claimed} claims grounded)` : `unmatched validation: this run claimed ${named} passed; it did run commands, but none the harness recognizes as that check (${grounding.grounded}/${grounding.claimed} claims grounded)`;
 }
 
+// src/domains/dispatch/worker-model-metadata.ts
+init_esm_shims();
+async function prepareWorkerModelMetadata(providers, targetId, deadlineAt, signal, now = Date.now) {
+  signal?.throwIfAborted();
+  const status = providers.list().find((entry) => entry.target.id === targetId);
+  if (status?.target.runtime !== "litellm" || status.health.lastCheckAt !== null) return;
+  const remainingMs = deadlineAt - now();
+  const deadlineError = new Error("dispatch: admission deadline expired during worker model metadata preparation");
+  if (remainingMs <= 0) throw deadlineError;
+  const controller = new AbortController();
+  const abort = () => controller.abort(signal?.reason);
+  signal?.addEventListener("abort", abort, { once: true });
+  const timer = setTimeout(() => controller.abort(deadlineError), Math.min(remainingMs, 2147483647));
+  let rejectAborted;
+  const aborted = new Promise((_resolve, reject) => {
+    rejectAborted = reject;
+  });
+  const onAbort = () => rejectAborted(controller.signal.reason);
+  controller.signal.addEventListener("abort", onAbort, { once: true });
+  try {
+    await Promise.race([providers.probeTarget(targetId, { reasoning: false, signal: controller.signal }), aborted]);
+    controller.signal.throwIfAborted();
+    if (now() >= deadlineAt) throw deadlineError;
+  } finally {
+    clearTimeout(timer);
+    signal?.removeEventListener("abort", abort);
+    controller.signal.removeEventListener("abort", onAbort);
+  }
+}
+
 // src/domains/dispatch/extension.ts
 var DEFAULT_HEARTBEAT_INTERVAL_MS = 1e3;
 var DEFAULT_RESILIENCE_COOLDOWN_MS = 15e3;
@@ -7499,6 +7822,13 @@ function runtimeLimitations(runtimeKind, runtimeId) {
       "Claude CLI subprocess executes Claude Code tools; Clio constrains permission mode and forbids dangerous bypass unless explicitly gated"
     ];
   }
+  if (runtimeKind === "subprocess" && runtimeId === "antigravity-code") {
+    return [
+      "Antigravity CLI owns its internal tools, network activity, prompts, and approvals; Clio observes only structured stream output and does not provide per-tool mediation or complete tool telemetry",
+      "Antigravity conversation ids are recorded only as opaque provider observations; Clio does not resume them",
+      "Antigravity runs are one-shot and never retried automatically"
+    ];
+  }
   return [];
 }
 function assertRuntimeCanHonorWorkerPermissionMode(runtime, onPermission) {
@@ -7521,12 +7851,6 @@ function assertWriteRootsEnforceable(runtime, writeRoots) {
     `dispatch: runtime '${runtime.id}' cannot enforce writeRoots: subprocess workers run their own tool surface without Clio per-tool mediation. Dispatch to a native or claude-sdk worker.`
   );
 }
-function assertWorkerBudgetEnforceable(runtime, hasDeclaredBudget) {
-  if (!hasDeclaredBudget || runtime.kind !== "subprocess") return;
-  throw new Error(
-    `dispatch: runtime '${runtime.id}' cannot enforce an explicit dispatch budget because subprocess workers do not expose per-tool mediation; choose a native or claude-sdk worker`
-  );
-}
 var TOOL_CARRYING_API_FAMILIES = /* @__PURE__ */ new Set([
   "openai-completions",
   "openai-responses",
@@ -7575,11 +7899,19 @@ function assertPostRuntimeToolCompatibility(agentId, spec, effectiveTools, targe
   );
 }
 function workerToolCallHardCap(settings) {
-  const rawEnvCap = process.env.CLIO_CODER_WORKER_TOOL_CALL_CAP?.trim();
-  const parsedEnvCap = rawEnvCap && /^[1-9]\d*$/.test(rawEnvCap) ? Number(rawEnvCap) : Number.NaN;
-  return Number.isSafeInteger(parsedEnvCap) ? parsedEnvCap : settings?.fleet.limits.toolCallsPerRun ?? GUARDRAIL_DEFAULTS.workerToolCallCap;
+  return settings?.fleet.limits.toolCallsPerRun ?? GUARDRAIL_DEFAULTS.workerToolCallCap;
+}
+function assertWorkerBudgetEnforceable(runtime, hasDeclaredBudget) {
+  if (!hasDeclaredBudget || runtime.kind !== "subprocess" || runtime.externalAgentLoop !== void 0) return;
+  throw new Error(
+    `dispatch: runtime '${runtime.id}' cannot enforce an explicit dispatch budget because subprocess workers do not expose per-tool mediation; choose a native or claude-sdk worker`
+  );
+}
+function budgetEnforcementForRuntime(runtime) {
+  return runtime.kind === "subprocess" ? "external-one-shot" : "native-per-tool";
 }
 function resolveEffectiveWorkerBudget(input) {
+  assertWorkerBudgetEnforceable(input.runtime, input.declared !== null || input.req.budget !== void 0);
   const hardCap = workerToolCallHardCap(input.settings);
   const declared = input.declared ?? {
     toolCalls: hardCap,
@@ -7593,7 +7925,8 @@ function resolveEffectiveWorkerBudget(input) {
     hardCap,
     hasReadTool: input.allowedTools.includes(ToolNames.Read),
     retry: (input.req.lineage?.attempt ?? 0) > 0,
-    revision: input.req.gate?.role === "builder" && input.req.gate.cycle > 1 && input.req.gate.verdict === "revise"
+    revision: input.req.gate?.role === "builder" && input.req.gate.cycle > 1 && input.req.gate.verdict === "revise",
+    enforcement: budgetEnforcementForRuntime(input.runtime)
   });
 }
 function frozenProtectedArtifactState(state) {
@@ -7851,6 +8184,9 @@ function clampWorkerAutonomy(session, requested) {
   if (requested === void 0) return session;
   return AUTONOMY_ORDER[requested] < AUTONOMY_ORDER[session] ? requested : session;
 }
+function effectiveWorkerAutonomy(session, requested, capabilityClass) {
+  return clampWorkerAutonomy(session, capabilityClass === "read-only" ? "read-only" : requested);
+}
 function requestedAutonomyEvidence(sessionAutonomy, requestedAutonomy) {
   return requestedAutonomy === void 0 ? {} : { requestedAutonomy, sessionAutonomy };
 }
@@ -8267,6 +8603,17 @@ function createDispatchBundle(context, options) {
   function configuredEndpointLimits() {
     return Object.fromEntries(Object.entries(configuredEndpointCapacities()).map(([key, value]) => [key, value.limit]));
   }
+  const probedDefaultBoundEndpoints = /* @__PURE__ */ new Set();
+  function probeEndpointsAtDefaultBound() {
+    const capacities = configuredEndpointCapacities();
+    for (const target of getEffectiveSettings()?.targets ?? []) {
+      const key = canonicalEndpointKey(target);
+      if (key === null || capacities[key]?.source !== "local-native-default") continue;
+      if (probedDefaultBoundEndpoints.has(key)) continue;
+      probedDefaultBoundEndpoints.add(key);
+      void providers.probeTarget(target.id, { reasoning: false }).catch(() => void 0);
+    }
+  }
   function endpointCapacityForTarget(targetId) {
     const status = providers.list().find((entry) => entry.target.id === targetId);
     const target = status?.target ?? providers.getTarget(targetId);
@@ -8364,7 +8711,7 @@ function createDispatchBundle(context, options) {
       reason: outcome
     });
   }
-  async function admitAssignmentCapacity(req, nodeId, timing, endpoint) {
+  async function admitAssignmentCapacity(req, nodeId, timing, endpoint, signal) {
     const queuedAt = now();
     timing.queuedAt = new Date(queuedAt).toISOString();
     const assignmentId = req.lineage?.rootRunId ?? req.runIdHint ?? `pending-${queuedAt.toString(36)}-${randomBytes5(6).toString("hex")}`;
@@ -8376,7 +8723,12 @@ function createDispatchBundle(context, options) {
       req.reservation.memberId,
       (error) => reportDispatchDiagnostic("read plan queue identity", error)
     );
+    const cancel = () => {
+      capacityAdmission.cancel(assignmentId);
+    };
+    signal?.addEventListener("abort", cancel, { once: true });
     try {
+      signal?.throwIfAborted();
       const admitted = await capacityAdmission.admit({
         assignmentId,
         nodeId,
@@ -8397,6 +8749,8 @@ function createDispatchBundle(context, options) {
         else await failQueuedAssignment(assignmentId);
       }
       throw error;
+    } finally {
+      signal?.removeEventListener("abort", cancel);
     }
   }
   function rebindReservationSlot(req, nodeId, endpoint, costUsd, settings) {
@@ -8489,6 +8843,13 @@ function createDispatchBundle(context, options) {
     if (draining) return { scheduled: false };
     const rootRunId = run.lineage.rootRunId;
     if (!retryChainIsLive(run)) return { scheduled: false };
+    if (providers.getRuntime(run.runtimeId)?.externalAgentLoop?.generatingRetry === "forbidden") {
+      retryBackoff.delete(rootRunId);
+      return {
+        scheduled: false,
+        settlementDetail: "automatic retry suppressed because this external agent loop is one-shot and Clio cannot prove replay is side-effect-free"
+      };
+    }
     if (!RETRYABLE_OUTCOMES.has(outcome)) {
       retryBackoff.delete(rootRunId);
       return { scheduled: false };
@@ -8783,6 +9144,7 @@ function createDispatchBundle(context, options) {
     const tickMonotonic = monotonicNow();
     for (const run of active.values()) {
       if (run.aborted || run.stallKilled || !run.heartbeatAt) continue;
+      if (ledger.get(run.runId)?.endedAt !== null) continue;
       const heartbeatMonotonic = heartbeatMonotonicAt(run.heartbeatAt);
       if (!Number.isFinite(heartbeatMonotonic) || !Number.isFinite(run.heartbeatAt.current)) continue;
       if (run.runtimeKind === "acp-delegation") {
@@ -8920,8 +9282,19 @@ function createDispatchBundle(context, options) {
         agentId: req.agentId
       });
     }
+    const parentTokenDiagnostic = inferredScopeParentTokenDiagnostic(pathScope);
+    if (parentTokenDiagnostic !== null) {
+      reportDispatchDiagnostic("inferred scope parent tokens", new Error(parentTokenDiagnostic));
+    }
+    const parentTokenNotice = inferredScopeParentTokenNotice(pathScope);
+    if (parentTokenNotice !== null) {
+      context.bus.emit(BusChannels.DispatchScopeNotice, {
+        ...parentTokenNotice,
+        agentId: req.agentId
+      });
+    }
   }
-  async function resolveLifecycle(req, settings) {
+  async function resolveLifecycle(req, settings, metadataDeadlineAt, signal) {
     const recipe = agents.get(req.agentId);
     if (!recipe) {
       throw new Error(`dispatch: unknown agent recipe: ${req.agentId}`);
@@ -8941,14 +9314,15 @@ function createDispatchBundle(context, options) {
       task: req.task,
       autoSelected: req.agentSelection?.mode === "auto",
       resultContractKind: spec.resultContract.kind,
-      specs: agents.listSpecs()
+      specs: agents.listSpecs(),
+      intent: req.intent ?? null
     });
     if (capabilityMismatch?.verdict === "refuse") throw new Error(capabilityMismatch.detail);
     const pathScope = resolveDispatchPathScope(req);
     publishDispatchPathScope(req, pathScope);
     const admission = resolveDispatchAdmissionStage(req, recipe, safety, pathScope);
     const targets = readWorkerTargets(settings);
-    const target = resolveDispatchTarget(
+    const resolveTarget = () => resolveDispatchTarget(
       req,
       recipe,
       targets.workerDefault,
@@ -8957,12 +9331,24 @@ function createDispatchBundle(context, options) {
       targets.targetOrder,
       providers
     );
+    let target = resolveTarget();
+    const identity = (resolved) => JSON.stringify([
+      resolved.target.id,
+      resolved.runtime.id,
+      resolved.wireModelId,
+      endpointIdentityHash(resolved.target.url)
+    ]);
+    const selectedIdentity = identity(target);
+    await prepareWorkerModelMetadata(providers, target.target.id, metadataDeadlineAt, signal, now);
+    target = resolveTarget();
+    if (identity(target) !== selectedIdentity) {
+      throw new Error("dispatch: worker route changed during model metadata preparation; request a fresh admission");
+    }
     enforceCapabilityGate(target.target.id, target.modelCapabilities, req.requiredCapabilities);
     assertRuntimeCanHonorWorkerPermissionMode(target.runtime, settings?.fleet.permissions.mode ?? "deny");
-    assertWorkerBudgetEnforceable(target.runtime, spec.budget !== null || req.budget !== void 0);
     const cwd = req.cwd ?? process.cwd();
     const sessionAutonomy = settings?.safety.autonomy ?? "auto-edit";
-    const effectiveAutonomy = clampWorkerAutonomy(sessionAutonomy, req.autonomy);
+    const effectiveAutonomy = effectiveWorkerAutonomy(sessionAutonomy, req.autonomy, spec.capabilityClass);
     const effectiveTools = withLedgerToolNarrowing(
       effectiveToolNames(admission.allowedTools, target, pathScope.writeBoundaries.length > 0, deniedToolNames(req)),
       req
@@ -8973,13 +9359,15 @@ function createDispatchBundle(context, options) {
       allowedTools: effectiveTools
     };
     const personaBody = workerPersonaBody(req, recipe, effectiveTools);
+    const hasCanonicalContext = effectiveTools.includes(ToolNames.Context);
+    const hasBoundSkills = hasCanonicalContext && recipe.skills !== void 0 && recipe.skills.length > 0 && req.noSkills !== true;
     const compiledWorkerPrompt = await prompts.compileWorkerPrompt({
       autonomy: effectiveAutonomy,
       providerSupportsTools: target.runtime.kind === "subprocess" ? null : targetToolCapability(target),
       toolNames: effectiveTools,
-      toolPromptHints: toolPromptHintsForNames(effectiveTools),
-      hasCanonicalContext: effectiveTools.includes(ToolNames.Context),
-      hasBoundSkills: effectiveTools.includes(ToolNames.Context) && recipe.skills !== void 0 && recipe.skills.length > 0 && req.noSkills !== true,
+      toolPromptHints: toolPromptHintsForNames(effectiveTools, hasBoundSkills ? "bound-worker" : "worker"),
+      hasCanonicalContext,
+      hasBoundSkills,
       onPermission: settings?.fleet.permissions.mode ?? "deny",
       persona: {
         id: `persona.${recipe.id}`,
@@ -8997,7 +9385,8 @@ function createDispatchBundle(context, options) {
       recipeId: recipe.id,
       declared: spec.budget,
       allowedTools: effectiveTools,
-      settings
+      settings,
+      runtime: target.runtime
     });
     const tier = spec.projectContextTier;
     const project = projectContext && tier === "bounded" ? projectContext.projectStructuredContext(cwd) : null;
@@ -9247,11 +9636,13 @@ function createDispatchBundle(context, options) {
         const responseModelIdObservation = responseModelIdObservationFromRecord(event.message, "not-observed");
         const differingResponseModelId = readStringOrNull(event.message.responseModel);
         const providerResponseId = readStringOrNull(event.message.responseId);
+        const gatewayRouting = gatewayRoutingObservationFromRecord(event.message);
         upstreamResponses.push({
           requestedModelId,
           responseModelIdObservation,
           differingResponseModelId,
-          providerResponseId
+          providerResponseId,
+          ...gatewayRouting !== null ? { gatewayRouting } : {}
         });
         if (event.message.stopReason === "error") {
           const message = readStringOrNull(event.message.errorMessage);
@@ -9757,7 +10148,7 @@ function createDispatchBundle(context, options) {
       finalPromise
     };
   }
-  async function dispatchAttempt(req, observer) {
+  async function dispatchAttempt(req, observer, preparation, settlement) {
     const requestedAt = new Date(now()).toISOString();
     const timing = { requestedAt, decisionStartedAt: requestedAt };
     const settings = getEffectiveSettings();
@@ -9838,13 +10229,14 @@ function createDispatchBundle(context, options) {
       }
       rebindReservationSlot(req, "local", null, UNKNOWN_PRICING_ADMISSION_ESTIMATE_USD, settings);
       routeObservation = observeShadowRoute(req, void 0, settings);
-      return attachRouteObservation({
-        ...await dispatchAcpDelegation(req, settings, timing, routeObservation.decision, observer),
-        effectiveRequest: req
-      });
+      const delegated = await dispatchAcpDelegation(req, settings, timing, routeObservation.decision, observer);
+      settlement?.live(delegated.runId);
+      return attachRouteObservation({ ...delegated, effectiveRequest: req });
     }
     req = routeAroundCoolingTarget(req, settings) ?? req;
-    const lifecycle = await resolveLifecycle(req, settings);
+    const metadataDeadlineAt = req.assignmentDeadlineAt ?? Date.parse(requestedAt) + (req.routingIntent?.deadlineMs ?? 6e4);
+    const lifecycle = await resolveLifecycle(req, settings, metadataDeadlineAt, preparation?.signal);
+    preparation?.signal?.throwIfAborted();
     timing.decisionCompletedAt = new Date(now()).toISOString();
     assertResponseSchemaEnforceable(
       lifecycle.target.runtime,
@@ -9911,7 +10303,13 @@ function createDispatchBundle(context, options) {
     if (queuedIdentity !== null) publishCapacityQueued(queuedIdentity, timing, placement?.node ?? null);
     let capacityLease;
     try {
-      capacityLease = await admitAssignmentCapacity(req, placement?.node.id ?? "local", timing, endpoint);
+      capacityLease = await admitAssignmentCapacity(
+        req,
+        placement?.node.id ?? "local",
+        timing,
+        endpoint,
+        preparation?.signal
+      );
     } catch (error) {
       if (queuedIdentity !== null) publishCapacityAdmissionFailure(queuedIdentity, error);
       throw error;
@@ -9921,6 +10319,7 @@ function createDispatchBundle(context, options) {
     const leaseSlot = createLeaseSlotGuard(capacityAdmission, capacityLease.leaseId, req.lineage !== void 0);
     const ledgerRef = (() => {
       try {
+        preparation?.signal?.throwIfAborted();
         return requireLedger();
       } catch (error) {
         leaseSlot.release();
@@ -9973,6 +10372,7 @@ function createDispatchBundle(context, options) {
     };
     let worker;
     try {
+      preparation?.signal?.throwIfAborted();
       worker = (placement?.spawn ?? spawnWorker)(spec, {
         cwd: lifecycle.cwd,
         now,
@@ -10130,11 +10530,13 @@ function createDispatchBundle(context, options) {
         const responseModelIdObservation = responseModelIdObservationFromRecord(event.message, "not-observed");
         const differingResponseModelId = readStringOrNull(event.message.responseModel);
         const providerResponseId = readStringOrNull(event.message.responseId);
+        const gatewayRouting = gatewayRoutingObservationFromRecord(event.message);
         upstreamResponses.push({
           requestedModelId,
           responseModelIdObservation,
           differingResponseModelId,
-          providerResponseId
+          providerResponseId,
+          ...gatewayRouting !== null ? { gatewayRouting } : {}
         });
         if (event.message.stopReason === "error") {
           const message = readStringOrNull(event.message.errorMessage);
@@ -10590,6 +10992,7 @@ function createDispatchBundle(context, options) {
       }
       return { assessment, rigor };
     };
+    settlement?.live(envelope.id);
     const finalPromise = (async () => {
       try {
         const result = await workerDone;
@@ -10652,7 +11055,7 @@ function createDispatchBundle(context, options) {
           reachedTerminalResult: resultContractWasDue(finalOutcome, outcomeCode),
           output: capturedOutput?.state === "final" ? capturedOutput.text : null,
           cwd: lifecycle.cwd,
-          networkAllowed: lifecycle.admission.allowedTools.includes(ToolNames.WebFetch),
+          networkAllowed: lifecycle.admission.allowedTools.includes(ToolNames.WebFetch) || lifecycle.target.runtime.externalAgentLoop?.network === "externally-governed-unobserved",
           observedRunEffects,
           filesystem: nodeResultContractFilesystem()
         });
@@ -10686,12 +11089,13 @@ function createDispatchBundle(context, options) {
           finalDetail = WORKER_FINAL_OUTPUT_MISSING_DETAIL;
           failureMessage = finalDetail;
         }
-        const hostVerification = await runHostVerification({
+        const hostVerificationInput = {
           runId: envelope.id,
           request: req,
           workerSuccessful: finalOutcome === "succeeded",
           onDiagnostic: (error) => reportDispatchDiagnostic(`write host verification memo for ${envelope.id}`, error)
-        });
+        };
+        const hostVerification = settlement === void 0 ? await runHostVerification(hostVerificationInput) : await settlement.arrive(hostVerificationInput);
         const hostRejection = hostVerificationRejection(hostVerification);
         if (hostRejection !== null && finalOutcome === "succeeded") {
           finalOutcome = "failed";
@@ -10854,8 +11258,11 @@ function createDispatchBundle(context, options) {
       effectiveRequest: req
     });
   }
-  async function dispatch(req, observer) {
-    let prepared = req;
+  async function dispatch(req, observer, preparation, settlement) {
+    let prepared = preparation?.deadlineAt === void 0 ? req : {
+      ...req,
+      assignmentDeadlineAt: Math.min(req.assignmentDeadlineAt ?? Number.POSITIVE_INFINITY, preparation.deadlineAt)
+    };
     let createdWorktree;
     let writerLease;
     const writerRecipe = agents.get(req.agentId);
@@ -10887,7 +11294,7 @@ function createDispatchBundle(context, options) {
         return rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute2(rel) ? entry : resolvePath(taskWorktree.path, rel);
       });
       prepared = {
-        ...req,
+        ...prepared,
         runIdHint: runId,
         taskWorktree,
         cwd: workerCwd,
@@ -10897,7 +11304,8 @@ function createDispatchBundle(context, options) {
     }
     let handle;
     try {
-      handle = await dispatchAttempt(prepared, observer);
+      preparation?.signal?.throwIfAborted();
+      handle = await dispatchAttempt(prepared, observer, preparation, settlement);
     } catch (error) {
       writerLease?.release();
       if (createdWorktree !== void 0) {
@@ -10912,6 +11320,10 @@ function createDispatchBundle(context, options) {
       }
       throw error;
     }
+    if (settlement !== void 0) {
+      const release = () => settlement.abandon(handle.runId);
+      handle.finalPromise.then(release, release);
+    }
     if (req.lineage) return { ...handle, finalPromise: handle.finalPromise.finally(() => writerLease?.release()) };
     const assignment = assignments.open(handle.runId, assignmentPolicyFor(handle.effectiveRequest));
     persistAssignment(registerAssignment(assignment.id), `${assignment.id}:open`);
@@ -10999,7 +11411,6 @@ function createDispatchBundle(context, options) {
     );
     assertPostRuntimeToolCompatibility(req.agentId, agentSpec, effectiveTools, target);
     assertRuntimeCanHonorWorkerPermissionMode(target.runtime, settings?.fleet.permissions.mode ?? "deny");
-    assertWorkerBudgetEnforceable(target.runtime, agentSpec.budget !== null || req.budget !== void 0);
     assertResponseSchemaEnforceable(target.runtime, target.modelCapabilities, req.responseSchema, effectiveTools.length);
     assertWriteRootsEnforceable(target.runtime, pathScope.writeBoundaries);
     assertProtectedArtifactsEnforceable(
@@ -11012,7 +11423,8 @@ function createDispatchBundle(context, options) {
       recipeId: recipe.id,
       declared: agentSpec.budget,
       allowedTools: effectiveTools,
-      settings
+      settings,
+      runtime: target.runtime
     });
     const endpoint = endpointCapacityForTarget(target.target.id);
     return {
@@ -11215,12 +11627,13 @@ function createDispatchBundle(context, options) {
       yield { type: "batch_events_drained", batch: snapshotBatch(batchRef.current) };
     })();
   }
-  async function dispatchBatch(reqs) {
+  async function dispatchBatch(reqs, preparation) {
     if (reqs.length === 0) throw new Error("dispatch: batch requires at least one request");
+    const settlement = reqs.length > 1 && reqs.some((req) => (req.resolvedVerification?.length ?? 0) > 0) ? createBatchVerificationGate() : void 0;
     const handles = [];
     try {
       for (const req of reqs) {
-        const handle = await dispatch(req);
+        const handle = await dispatch(req, void 0, preparation, settlement);
         handles.push({ ...handle, agentId: req.agentId });
       }
     } catch (err) {
@@ -11407,6 +11820,7 @@ function createDispatchBundle(context, options) {
       } catch {
       }
       startHeartbeatWatchdog();
+      probeEndpointsAtDefaultBound();
     },
     async stop() {
       draining = true;
@@ -11733,22 +12147,6 @@ var DispatchManifest = {
   dependsOn: ["config", "safety", "agents", "providers", "middleware", "prompts", "scheduling"]
 };
 
-// src/domains/dispatch/code-step-store.ts
-init_esm_shims();
-import { join as join13 } from "node:path";
-function codeStepDir(rootId) {
-  return join13(clioStateDir(), "code-steps", rootId);
-}
-function codeStepRecordPath(rootId, runId) {
-  return join13(codeStepDir(rootId), `${runId}.json`);
-}
-async function writeCodeStepRecord(rootId, record) {
-  const path2 = codeStepRecordPath(rootId, record.runId);
-  await atomicWrite(path2, `${JSON.stringify(record, null, 2)}
-`);
-  return path2;
-}
-
 // src/domains/dispatch/delegation-plan.ts
 init_esm_shims();
 import { createHash as createHash8 } from "node:crypto";
@@ -12289,7 +12687,7 @@ function gateFailureLines(output) {
 init_esm_shims();
 import { createHash as createHash9 } from "node:crypto";
 import { readFileSync as readFileSync12 } from "node:fs";
-import { join as join14 } from "node:path";
+import { join as join13 } from "node:path";
 
 // src/domains/observability/cost.ts
 init_esm_shims();
@@ -12573,7 +12971,7 @@ async function executeFleetRun(input) {
   for (const [stepId, replayedResult] of replayed) {
     try {
       const receipt = JSON.parse(
-        readFileSync12(join14(clioStateDir(), "receipts", `${replayedResult.terminalRunId}.json`), "utf8")
+        readFileSync12(join13(clioStateDir(), "receipts", `${replayedResult.terminalRunId}.json`), "utf8")
       );
       receiptsByStep.set(stepId, receipt);
     } catch {
@@ -12760,7 +13158,7 @@ async function executeFleetRun(input) {
             if (step.gate !== void 0 && succeeded) {
               let gateBytes = "";
               try {
-                gateBytes = readFileSync12(join14(workspaceRoot, step.gate.path), "utf8");
+                gateBytes = readFileSync12(join13(workspaceRoot, step.gate.path), "utf8");
               } catch {
                 gateBytes = "";
               }
@@ -13329,7 +13727,7 @@ function latestGateDecisionForRun(decisions, runId) {
 // src/domains/evidence/store.ts
 init_esm_shims();
 import { readdir, readFile } from "node:fs/promises";
-import { join as join15 } from "node:path";
+import { join as join14 } from "node:path";
 var EVIDENCE_FILES = [
   "overview.json",
   "transcript.md",
@@ -13345,11 +13743,11 @@ var EVIDENCE_FILES = [
   "findings.md"
 ];
 function evidenceRoot(dataDir) {
-  return join15(dataDir, "evidence");
+  return join14(dataDir, "evidence");
 }
 function evidenceDirectory(dataDir, evidenceId) {
   assertSafeId(evidenceId, "evidence");
-  return join15(evidenceRoot(dataDir), evidenceId);
+  return join14(evidenceRoot(dataDir), evidenceId);
 }
 var EvidenceNotFoundError = class extends Error {
   constructor(evidenceId) {
@@ -13365,7 +13763,7 @@ function isMissingFile(error) {
 async function loadEvidenceOverview(dataDir, evidenceId) {
   let raw;
   try {
-    raw = await readFile(join15(evidenceDirectory(dataDir, evidenceId), "overview.json"), "utf8");
+    raw = await readFile(join14(evidenceDirectory(dataDir, evidenceId), "overview.json"), "utf8");
   } catch (error) {
     if (isMissingFile(error)) throw new EvidenceNotFoundError(evidenceId);
     throw error;
@@ -13377,7 +13775,7 @@ async function inspectEvidence(dataDir, evidenceId) {
   const overview = await loadEvidenceOverview(dataDir, evidenceId);
   let findingsRaw;
   try {
-    findingsRaw = await readFile(join15(evidenceDirectory(dataDir, evidenceId), "findings.json"), "utf8");
+    findingsRaw = await readFile(join14(evidenceDirectory(dataDir, evidenceId), "findings.json"), "utf8");
   } catch (error) {
     if (isMissingFile(error)) throw new Error(`evidence artifact ${evidenceId} is missing findings.json`);
     throw error;
@@ -13389,7 +13787,7 @@ async function inspectEvidence(dataDir, evidenceId) {
 async function loadEvidenceTrustStatus(dataDir, evidenceId) {
   let raw;
   try {
-    raw = await readFile(join15(evidenceDirectory(dataDir, evidenceId), "trust-status.json"), "utf8");
+    raw = await readFile(join14(evidenceDirectory(dataDir, evidenceId), "trust-status.json"), "utf8");
   } catch (error) {
     if (isMissingFile(error)) {
       return { version: 1, evidenceId, projection: "historical_format", runs: [] };
@@ -13422,7 +13820,7 @@ async function loadEvidenceTrustStatus(dataDir, evidenceId) {
 async function loadEvidenceRunProvenance(dataDir, evidenceId) {
   let raw;
   try {
-    raw = await readFile(join15(evidenceDirectory(dataDir, evidenceId), "receipt.json"), "utf8");
+    raw = await readFile(join14(evidenceDirectory(dataDir, evidenceId), "receipt.json"), "utf8");
   } catch (error) {
     const err = error;
     if (err.code === "ENOENT") return [];
@@ -13997,22 +14395,22 @@ function finding(index, severity, tag, runId, message) {
 }
 async function writeEvidenceFiles(directory, overview, runSources, findings, sessionLinks, auditLinks, toolEventRows, gateDecisions, trustStatus, protectedArtifacts, transcript) {
   await mkdir(directory, { recursive: true });
-  await writeJson(join16(directory, "overview.json"), overview);
+  await writeJson(join15(directory, "overview.json"), overview);
   await writeFile(
-    join16(directory, "transcript.md"),
+    join15(directory, "transcript.md"),
     transcript ?? renderTranscript(overview, runSources, sessionLinks, trustStatus),
     "utf8"
   );
-  await writeJsonl(join16(directory, "trace.raw.jsonl"), rawTraceRows(runSources));
-  await writeJsonl(join16(directory, "trace.cleaned.jsonl"), cleanedTraceRows(runSources, findings, toolEventRows));
-  await writeJsonl(join16(directory, "tool-events.jsonl"), toolEventRows);
-  await writeJsonl(join16(directory, "audit-linked.jsonl"), auditLinks.rows);
-  await writeJson(join16(directory, "receipt.json"), receiptsFile(runSources));
-  await writeJson(join16(directory, "gate-decisions.json"), gateDecisions);
-  await writeJson(join16(directory, "trust-status.json"), trustStatus);
-  await writeJson(join16(directory, "protected-artifacts.json"), protectedArtifacts);
-  await writeJson(join16(directory, "findings.json"), findingsFile(overview.evidenceId, [...findings]));
-  await writeFile(join16(directory, "findings.md"), renderEvidenceFindingsMarkdown(findings, trustStatus), "utf8");
+  await writeJsonl(join15(directory, "trace.raw.jsonl"), rawTraceRows(runSources));
+  await writeJsonl(join15(directory, "trace.cleaned.jsonl"), cleanedTraceRows(runSources, findings, toolEventRows));
+  await writeJsonl(join15(directory, "tool-events.jsonl"), toolEventRows);
+  await writeJsonl(join15(directory, "audit-linked.jsonl"), auditLinks.rows);
+  await writeJson(join15(directory, "receipt.json"), receiptsFile(runSources));
+  await writeJson(join15(directory, "gate-decisions.json"), gateDecisions);
+  await writeJson(join15(directory, "trust-status.json"), trustStatus);
+  await writeJson(join15(directory, "protected-artifacts.json"), protectedArtifacts);
+  await writeJson(join15(directory, "findings.json"), findingsFile(overview.evidenceId, [...findings]));
+  await writeFile(join15(directory, "findings.md"), renderEvidenceFindingsMarkdown(findings, trustStatus), "utf8");
 }
 function rawTraceRows(runSources) {
   const rows = [];
@@ -14692,7 +15090,7 @@ function axisFindings(offset, source, status) {
   return out;
 }
 async function readRunLedger(stateDir) {
-  const target = join16(stateDir, "runs.json");
+  const target = join15(stateDir, "runs.json");
   let raw;
   try {
     raw = await readFile2(target, "utf8");
@@ -14713,7 +15111,7 @@ function selectRunEnvelopes(ledger, source) {
   });
 }
 async function readReceipt(stateDir, envelope) {
-  const receiptPath = envelope.receiptPath ?? join16(stateDir, "receipts", `${envelope.id}.json`);
+  const receiptPath = envelope.receiptPath ?? join15(stateDir, "receipts", `${envelope.id}.json`);
   let raw;
   try {
     raw = await readFile2(receiptPath, "utf8");
@@ -15006,7 +15404,7 @@ function sanitizeEvidenceId(value) {
 // src/domains/evidence/eval.ts
 init_esm_shims();
 import { mkdir as mkdir2, readdir as readdir2, readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
-import { join as join17 } from "node:path";
+import { join as join16 } from "node:path";
 
 // src/domains/eval/index.ts
 init_esm_shims();
@@ -15207,19 +15605,19 @@ async function writeEvalEvidenceFiles(directory, artifact, overview, findings, t
   };
   const redactedArtifact = redactArtifactForStorage(artifact);
   await mkdir2(directory, { recursive: true });
-  await writeJson2(join17(directory, "overview.json"), overview);
-  await writeFile2(join17(directory, "transcript.md"), renderEvalTranscript(redactedArtifact, overview), "utf8");
-  await writeJsonl2(join17(directory, "trace.raw.jsonl"), rawEvalTraceRows(redactedArtifact));
-  await writeJsonl2(join17(directory, "trace.cleaned.jsonl"), cleanedEvalTraceRows(redactedArtifact, findings));
-  await writeJsonl2(join17(directory, "tool-events.jsonl"), redactArtifactForStorage(toolEventRows));
-  await writeJsonl2(join17(directory, "audit-linked.jsonl"), linkedRuns.auditRows);
-  await writeJson2(join17(directory, "receipt.json"), receiptsFile2);
-  await writeJson2(join17(directory, "gate-decisions.json"), gateDecisions);
-  await writeJson2(join17(directory, "trust-status.json"), trustStatus);
-  await writeJson2(join17(directory, "protected-artifacts.json"), emptyProtected);
-  await writeJson2(join17(directory, "eval-result.json"), redactedArtifact);
-  await writeJson2(join17(directory, "findings.json"), findingsFile(overview.evidenceId, [...findings]));
-  await writeFile2(join17(directory, "findings.md"), renderEvidenceFindingsMarkdown(findings, trustStatus), "utf8");
+  await writeJson2(join16(directory, "overview.json"), overview);
+  await writeFile2(join16(directory, "transcript.md"), renderEvalTranscript(redactedArtifact, overview), "utf8");
+  await writeJsonl2(join16(directory, "trace.raw.jsonl"), rawEvalTraceRows(redactedArtifact));
+  await writeJsonl2(join16(directory, "trace.cleaned.jsonl"), cleanedEvalTraceRows(redactedArtifact, findings));
+  await writeJsonl2(join16(directory, "tool-events.jsonl"), redactArtifactForStorage(toolEventRows));
+  await writeJsonl2(join16(directory, "audit-linked.jsonl"), linkedRuns.auditRows);
+  await writeJson2(join16(directory, "receipt.json"), receiptsFile2);
+  await writeJson2(join16(directory, "gate-decisions.json"), gateDecisions);
+  await writeJson2(join16(directory, "trust-status.json"), trustStatus);
+  await writeJson2(join16(directory, "protected-artifacts.json"), emptyProtected);
+  await writeJson2(join16(directory, "eval-result.json"), redactedArtifact);
+  await writeJson2(join16(directory, "findings.json"), findingsFile(overview.evidenceId, [...findings]));
+  await writeFile2(join16(directory, "findings.md"), renderEvidenceFindingsMarkdown(findings, trustStatus), "utf8");
 }
 function rawEvalTraceRows(artifact) {
   return artifact.results.map((result) => ({
@@ -15360,7 +15758,7 @@ async function linkEvalRuns(stateDir, artifact) {
 }
 async function readRunLedger2(stateDir) {
   try {
-    const raw = await readFile3(join17(stateDir, "runs.json"), "utf8");
+    const raw = await readFile3(join16(stateDir, "runs.json"), "utf8");
     const parsed = JSON.parse(raw);
     return Array.isArray(parsed) ? parsed.filter(isRecord12) : [];
   } catch {
@@ -15371,7 +15769,7 @@ function evalRunMatches(artifact, envelope) {
   return artifact.results.some((result) => result.runId === envelope.id);
 }
 async function readReceiptForRun(stateDir, envelope) {
-  const path2 = envelope.receiptPath ?? join17(stateDir, "receipts", `${envelope.id}.json`);
+  const path2 = envelope.receiptPath ?? join16(stateDir, "receipts", `${envelope.id}.json`);
   try {
     const parsed = JSON.parse(await readFile3(path2, "utf8"));
     return isRecord12(parsed) ? parsed : null;
@@ -15400,7 +15798,7 @@ async function countSessionEntries(stateDir, sessionIds) {
   return count;
 }
 async function findSessionLedgerPath(stateDir, sessionId) {
-  const root = join17(stateDir, "sessions");
+  const root = join16(stateDir, "sessions");
   let cwdHashes;
   try {
     cwdHashes = await readdir2(root);
@@ -15408,7 +15806,7 @@ async function findSessionLedgerPath(stateDir, sessionId) {
     return null;
   }
   for (const cwdHash of cwdHashes) {
-    const path2 = join17(root, cwdHash, sessionId, "current.jsonl");
+    const path2 = join16(root, cwdHash, sessionId, "current.jsonl");
     try {
       await readFile3(path2, "utf8");
       return path2;
@@ -15418,7 +15816,7 @@ async function findSessionLedgerPath(stateDir, sessionId) {
   return null;
 }
 async function linkedEvalAuditRows(stateDir, runIds, artifact) {
-  const root = join17(stateDir, "audit");
+  const root = join16(stateDir, "audit");
   let files;
   try {
     files = await readdir2(root);
@@ -15427,7 +15825,7 @@ async function linkedEvalAuditRows(stateDir, runIds, artifact) {
   }
   const rows = [];
   for (const file of files.filter((name) => name.endsWith(".jsonl")).sort(compareCodepoints)) {
-    const raw = await readFile3(join17(root, file), "utf8").catch(() => "");
+    const raw = await readFile3(join16(root, file), "utf8").catch(() => "");
     const lines = raw.split("\n");
     for (let index = 0; index < lines.length; index += 1) {
       const line = lines[index];
@@ -15676,6 +16074,7 @@ export {
   setCapacityDraining,
   capacityDrain,
   capacityLeaseUsage,
+  endpointCapacityUsage,
   openAgentLedger,
   renderAgentLedgerBoard,
   closeAgentLedger,
@@ -15684,6 +16083,7 @@ export {
   UNVERIFIABLE_RECEIPT_VERIFICATION,
   assistantTextFromEvent,
   receiptResponseModelIdObservationLabel,
+  receiptGatewayRoutingLabel,
   createDispatchRunEventRegistry,
   readFleetRun,
   listFleetRuns,
@@ -15715,4 +16115,4 @@ export {
   summarizeEvalResults,
   buildEvalEvidence
 };
-//# sourceMappingURL=chunk-XKA2ICR3.js.map
+//# sourceMappingURL=chunk-AF4YM7Z4.js.map