@iowarp/clio-coder 0.4.0 → 0.4.2

package/dist/{chunk-BUMFYQFY.js → chunk-I66ZTYNP.js}

@@ -6,7 +6,7 @@ import {
   readGateDecisionArtifactsForRunIds,
   stagePendingGateDecision,
   verifyGateDecisionArtifact
-} from "./chunk-X75E3D2N.js";
+} from "./chunk-ZGNYYXQ6.js";
 import {
   RUN_RECEIPT_INTEGRITY_ALGORITHM,
   RUN_RECEIPT_INTEGRITY_VERSION,
@@ -24,14 +24,18 @@ import {
   trustVerdict,
   verifyReceiptIntegrity,
   withReceiptIntegrity
-} from "./chunk-B7OBL7PK.js";
+} from "./chunk-B74PXLU7.js";
 import {
   protectedArtifactFromSessionEntry,
   protectedArtifactStateFromSessionEntries,
   readAuditRows,
   readSessionEntriesForId,
   responseModelIdObservationFromRecord
-} from "./chunk-QREDIESB.js";
+} from "./chunk-X7IARSHT.js";
+import {
+  codeStepDir,
+  writeCodeStepRecord
+} from "./chunk-KPXDY6QF.js";
 import {
   applyTaskWorktree,
   captureWorkspaceSnapshot,
@@ -39,11 +43,11 @@ import {
   createTaskWorktree,
   createWriteBoundaryEnforcer,
   gitCheckoutRoot
-} from "./chunk-U77AMWDL.js";
+} from "./chunk-W6NIE6OW.js";
 import {
   executionPlanAncestors,
   spliceExecutionPlan
-} from "./chunk-QBJA7R7N.js";
+} from "./chunk-DZAW46HP.js";
 import {
   parseRigorOverride,
   resolveRigor
@@ -53,11 +57,11 @@ import {
   parseEvalArtifactV4,
   redactArtifactForStorage,
   sumEvalHarnessMetrics
-} from "./chunk-NHLBIGRH.js";
+} from "./chunk-5PFYMY2V.js";
 import {
   defaultRunEventJournal,
   removeRunEventJournals
-} from "./chunk-IQ7KR472.js";
+} from "./chunk-VIA6RFQZ.js";
 import {
   AdmissionCanceledError,
   EVENT_TEE_LIMIT,
@@ -75,11 +79,11 @@ import {
   receiptAttestationFields,
   routeFactVerdict,
   spawnNativeWorker
-} from "./chunk-QLFS5GO2.js";
+} from "./chunk-4JDLP6ZS.js";
 import {
   FLEET_COMMAND_BASE_ENV,
   normalizeWriteBoundary
-} from "./chunk-CTJ4RNAA.js";
+} from "./chunk-3F7VUY77.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-J4W7KFM7.js";
+} from "./chunk-IKSLQ4XV.js";
 import {
   decideRoute,
   defaultRoutingIntent,
@@ -137,16 +144,16 @@ import {
   routingIntentRejection,
   sameRouteIdentity,
   toRouteCandidate
-} from "./chunk-SJ5ZKQ4S.js";
+} from "./chunk-HIICAHCJ.js";
 import {
   assessFinishContract
-} from "./chunk-GKF55TAZ.js";
+} from "./chunk-IDNA72AH.js";
 import {
   WRITE_ROOT_REFUSED_TOOLS
-} from "./chunk-32KWKNSF.js";
+} from "./chunk-FVDGR2ZL.js";
 import {
   describeCallAction
-} from "./chunk-TVHHYFHE.js";
+} from "./chunk-NEDJ26B5.js";
 import {
   applyToolProfile,
   assertToolProfileEnforceable
@@ -161,13 +168,13 @@ import {
 } from "./chunk-H7IXIC72.js";
 import {
   compareCodepoints
-} from "./chunk-5LXZXPKX.js";
+} from "./chunk-VN3SHNBN.js";
 import {
   DEFAULT_AUTONOMY_LEVEL,
   autonomyDenyRejection,
   isSkillActivation,
   mapAutonomy
-} from "./chunk-RAPCMZL4.js";
+} from "./chunk-FSP7CMNU.js";
 import {
   createRedactionTally,
   redactSecretsDeep,
@@ -180,9 +187,11 @@ import {
   canonicalJson,
   endpointIdentityHash,
   parseAgentLedgerBody
-} from "./chunk-CMZWFGD2.js";
+} from "./chunk-VAVR4IJY.js";
 import {
-  pathBoundaryCovers
+  PATH_BOUNDARY_MAX_ENTRIES,
+  pathBoundaryCovers,
+  resolvePathBoundary
 } from "./chunk-HHV2GANA.js";
 import {
   agentSpecFingerprint,
@@ -194,10 +203,10 @@ import {
   resolveAgentToolCompatibility,
   resultContractAuthorship,
   validateRecipeResult
-} from "./chunk-DYJP44XW.js";
+} from "./chunk-PGF63K6I.js";
 import {
   detectValidationCommand
-} from "./chunk-GCSMB2KY.js";
+} from "./chunk-IKOZFYBN.js";
 import {
   isProjectVerifierCheckId,
   isVerificationScriptName
@@ -210,6 +219,7 @@ import {
   isBuiltinToolName
 } from "./chunk-K6BSR66V.js";
 import {
+  canonicalEndpointKey,
   canonicalizeWireModelId,
   endpointCapacityFor,
   endpointCapacityForStatus,
@@ -223,29 +233,33 @@ import {
   resolveRuntimeTarget,
   runtimeResolutionWarnings,
   runtimeTargetSnapshot
-} from "./chunk-DQITNCXG.js";
+} from "./chunk-BYMNWQ7O.js";
 import {
   ceilChars
-} from "./chunk-UM7N4G5A.js";
-import {
-  BusChannels
-} from "./chunk-HLW2MRKE.js";
+} from "./chunk-CWVRRIEI.js";
 import {
   atomicWrite
-} from "./chunk-76ONBSIA.js";
+} from "./chunk-MQXIVJ35.js";
 import {
   assertSafeId
 } from "./chunk-R346GLFC.js";
+import {
+  normalizeClioCoderEventRecord,
+  normalizeClioCoderEventType
+} from "./chunk-BTK3SSSK.js";
+import {
+  BusChannels
+} from "./chunk-F4EKGO4N.js";
 import {
   attributeCommitMessage,
   gitCommitAttributionEnabled,
   reportCommitAttributionDiagnostic,
   withManagedGitCommitAttributionEnvironment
-} from "./chunk-BBVJUZHB.js";
+} from "./chunk-JIEGK6UF.js";
 import {
   MAX_TIMER_DELAY_MS,
   rawDurationMs
-} from "./chunk-FQ4SKYE4.js";
+} from "./chunk-EBY63B7G.js";
 import {
   AI_AGENT_NAME
 } from "./chunk-6EJMN2Y3.js";
@@ -259,14 +273,14 @@ import {
   DEFAULT_DELEGATION_TURN_TIMEOUT_MS,
   DEFAULT_SETTINGS,
   THINKING_LEVELS
-} from "./chunk-GXNLGKAB.js";
+} from "./chunk-UXCU4E3T.js";
 import {
   GUARDRAIL_DEFAULTS,
   resolveGuardrail
-} from "./chunk-4ZG3XFUR.js";
+} from "./chunk-S66XZJOF.js";
 import {
   targetRequiresAuth
-} from "./chunk-BBVYXMFO.js";
+} from "./chunk-WNP7O5WZ.js";
 import {
   FILE_LOCK_ACQUIRE_TIMEOUT_MS,
   withStateFileLock,
@@ -280,11 +294,12 @@ import {
 import {
   clioDataDir,
   clioStateDir,
+  resolveClioDirs,
   stateRootRemoved
 } from "./chunk-BYP5D4HI.js";
 import {
   resolveEffectivePricing
-} from "./chunk-VO2LKSTM.js";
+} from "./chunk-O42A54GG.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -298,10 +313,10 @@ function protectedResidencyModels(settings) {
     if (!trimmed || byId.has(trimmed)) return;
     byId.set(trimmed, role);
   };
-  add(settings.orchestrator.model, "chat");
-  add(settings.background.model, "memory");
-  add(settings.workers.default.model, "worker");
-  for (const profile of Object.values(settings.workers.profiles ?? {})) add(profile.model, "worker");
+  add(settings.chat.model, "chat");
+  add(settings.context.memory.model, "memory");
+  add(settings.fleet.default.model, "worker");
+  for (const profile of Object.values(settings.fleet.profiles ?? {})) add(profile.model, "worker");
   for (const target of settings.targets) add(target.defaultModel, "target-default");
   return [...byId].map(([modelId, role]) => ({ modelId, role }));
 }
@@ -1391,7 +1406,7 @@ function agentLedgerContribution(id, runId) {
   if (record === null) return null;
   const contribution = contributionFor(record, runId);
   const mine = record.entries.filter((entry) => entry.runId === runId).sort((left, right) => left.sequence - right.sequence);
-  const digest = createHash("sha256").update(`clio.agentLedger:${canonicalJson(mine)}`, "utf8").digest("hex");
+  const digest = createHash("sha256").update(`clio-coder.agentLedger:${canonicalJson(mine)}`, "utf8").digest("hex");
   return { posted: contribution.posted, refused: contribution.refused, digest };
 }
 
@@ -1403,6 +1418,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}`));
   }
@@ -1438,7 +1459,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();
@@ -1521,7 +1542,7 @@ var AcpEventMapper = class {
       return this.mapToolUpdate(update);
     }
     if (kind === "plan") {
-      return [{ type: "clio_plan_update", payload: update }];
+      return [{ type: "clio_coder_plan_update", payload: update }];
     }
     return [];
   }
@@ -1555,7 +1576,7 @@ var AcpEventMapper = class {
       this.toolStarts.set(toolCallId, performance2.now());
       const action = describeCallAction(update.kind ?? title, update.rawInput);
       out.push({
-        type: "clio_tool_start",
+        type: "clio_coder_tool_start",
         payload: {
           tool: update.kind ?? title,
           toolCallId,
@@ -1584,7 +1605,7 @@ var AcpEventMapper = class {
         isError
       });
       out.push({
-        type: "clio_tool_finish",
+        type: "clio_coder_tool_finish",
         payload: {
           tool: update.kind ?? title,
           toolCallId,
@@ -2021,7 +2042,7 @@ var AcpToolMediator = class {
     let reason;
     let safetyDecision;
     if (mapped.validationError !== void 0) {
-      if (this.input.toolGovernance === "clio-policy") {
+      if (this.input.toolGovernance === "clio-coder-policy") {
         const invalidSafetyDecisions = mapped.evaluations.map(
           (evaluation) => this.input.safety.evaluate({ tool: evaluation.tool, args: evaluation.args })
         );
@@ -2264,10 +2285,10 @@ function startAcpDelegationRun(input) {
   const mediator = new AcpToolMediator({
     safety: input.safety,
     cwd: input.cwd,
-    toolGovernance: input.agent.toolGovernance ?? "clio-policy",
+    toolGovernance: input.agent.toolGovernance ?? "clio-coder-policy",
     ...input.autonomy !== void 0 ? { autonomy: input.autonomy } : {},
     onPermissionResolved: (event) => emit({
-      type: "clio_permission_resolved",
+      type: "clio_coder_permission_resolved",
       payload: event
     })
   });
@@ -2433,7 +2454,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);
@@ -2483,16 +2503,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 "";
@@ -2511,36 +2547,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");
@@ -2592,15 +2635,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");
@@ -2634,8 +2670,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) {
@@ -2702,7 +2737,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"
     );
@@ -2774,7 +2810,7 @@ function compileWorker(table, inputs) {
   if (inputs.hasBoundSkills && !inputs.hasCanonicalContext) {
     throw new Error("prompts/compiler: bound skills require canonical context in the final attached tool surface");
   }
-  const identity = lookupFragment(table, "identity.clio-worker", "worker identity");
+  const identity = lookupFragment(table, "identity.clio-coder-worker", "worker identity");
   const operatingContract = lookupFragment(table, "operating.contract", "operating contract");
   const workerContract = lookupFragment(table, "operating.worker", "worker contract");
   const safety = lookupFragment(table, `safety.${inputs.autonomy}`, "safety");
@@ -2906,7 +2942,7 @@ function asAssignmentId(rootRunId) {
 function activeRoutingEnabled(input) {
   if (input.posture === "manual" || input.failover !== "approved") return false;
   if (input.capabilityClass !== "read-only" && input.capabilityClass !== "verification") return false;
-  return input.settings.activeRoles.includes(input.role) && input.settings.activePostures.includes(input.posture);
+  return input.settings.roles.includes(input.role) && input.settings.postures.includes(input.posture);
 }
 function applyActiveRouteSelection(req, decision) {
   if (decision.mode !== "active") throw new Error("dispatch: cannot apply a non-active route decision");
@@ -3106,7 +3142,7 @@ function routeValidationProjection(request, allowUnenvelopedApproval = false) {
 function enabled(input) {
   const posture = input.request.routingIntent?.posture ?? "balanced";
   if (input.request.agentSelection?.mode === "auto") {
-    return input.settings !== void 0 && posture !== "manual" && input.failover === "approved" && input.settings.activePostures.includes(posture) && input.settings.agentAutomation.activeAgentRoles.length > 0;
+    return input.settings !== void 0 && posture !== "manual" && input.failover === "approved" && input.settings.postures.includes(posture) && input.settings.agentRoles.length > 0;
   }
   return input.settings !== void 0 && input.capabilityClass !== null && activeRoutingEnabled({
     settings: input.settings,
@@ -4354,6 +4390,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));
@@ -4840,6 +4877,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");
 }
@@ -4911,6 +4951,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;
@@ -4919,51 +5005,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;
+    }
   };
 }
 
@@ -5463,9 +5718,9 @@ function completedReroutes(reroutes, toNode) {
 }
 function requestedNodeId(req, settings) {
   if (req.node !== void 0 && req.node.trim().length > 0) return req.node.trim();
-  const workers = settings?.workers;
+  const workers = settings?.fleet;
   if (!workers) return null;
-  const profileName = req.workerProfile ?? workers.agentBindings?.[req.agentId];
+  const profileName = req.workerProfile ?? workers.agentProfiles?.[req.agentId];
   if (!profileName) return null;
   const pin = workers.profiles?.[profileName]?.node;
   return pin !== void 0 && pin.trim().length > 0 ? pin.trim() : null;
@@ -5736,7 +5991,7 @@ function retireHistory(path2, version) {
   const retired = `${path2}.v${String(version)}.${stamp}.retired`;
   renameSync3(path2, retired);
   process.stderr.write(
-    `[clio:dispatch] route history v${String(version)} is retired; starting empty at v${ROUTE_HISTORY_VERSION}. Prior observations: ${retired}
+    `[clio-coder:dispatch] route history v${String(version)} is retired; starting empty at v${ROUTE_HISTORY_VERSION}. Prior observations: ${retired}
 `
   );
 }
@@ -6283,24 +6538,25 @@ function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function eventDetail(event) {
-  const text = assistantTextFromEvent(event);
+  const normalized = isRecord6(event) ? normalizeClioCoderEventRecord(event) : event;
+  const text = assistantTextFromEvent(normalized);
   if (text.length > 0) return truncateUtf8(text, RUN_TAIL_TEXT_LIMIT, "...");
-  if (!isRecord6(event)) return void 0;
-  if (event.type === "clio_tool_finish" && isRecord6(event.payload)) {
-    const tool = typeof event.payload.tool === "string" ? event.payload.tool : "tool";
-    const outcome = typeof event.payload.outcome === "string" ? event.payload.outcome : "";
+  if (!isRecord6(normalized)) return void 0;
+  if (normalized.type === "clio_coder_tool_finish" && isRecord6(normalized.payload)) {
+    const tool = typeof normalized.payload.tool === "string" ? normalized.payload.tool : "tool";
+    const outcome = typeof normalized.payload.outcome === "string" ? normalized.payload.outcome : "";
     return `${tool} ${outcome}`.trim();
   }
-  if (event.type === "attempt_start") {
-    const attempt = typeof event.attempt === "number" ? event.attempt : "?";
-    const runId = typeof event.runId === "string" ? event.runId : "?";
-    const reason = typeof event.reason === "string" ? event.reason : "retry";
+  if (normalized.type === "attempt_start") {
+    const attempt = typeof normalized.attempt === "number" ? normalized.attempt : "?";
+    const runId = typeof normalized.runId === "string" ? normalized.runId : "?";
+    const reason = typeof normalized.reason === "string" ? normalized.reason : "retry";
     return truncateUtf8(`attempt ${attempt} -> ${runId}: ${reason}`, RUN_TAIL_TEXT_LIMIT, "...");
   }
   return void 0;
 }
 function runTailEntryFromEvent(event, at = (/* @__PURE__ */ new Date()).toISOString()) {
-  const type = isRecord6(event) && typeof event.type === "string" ? event.type : "unknown";
+  const type = isRecord6(event) && typeof event.type === "string" ? normalizeClioCoderEventType(event.type) : "unknown";
   if (type === "heartbeat" || type === "message_update") return null;
   const entry = { at, type };
   const detail = eventDetail(event);
@@ -6986,7 +7242,7 @@ function calculateUsageCostUsd(meter, pricing) {
   return (meter.inputTokens * pricing.input + meter.outputTokens * pricing.output + meter.cacheReadTokens * pricing.cacheRead + meter.cacheWriteTokens * pricing.cacheWrite) / 1e6;
 }
 function admissionMaxOutputTokens(settings) {
-  return settings?.defaults.maxTokens ?? DEFAULT_SETTINGS.defaults.maxTokens;
+  return settings?.chat.maxOutputTokens ?? DEFAULT_SETTINGS.chat.maxOutputTokens;
 }
 function conservativeRouteAdmissionEstimateUsd(pricing, maxOutputTokens) {
   if (pricing.provenance === "known_free") return 0;
@@ -7018,7 +7274,7 @@ function eventContainsFirstModelToken(event) {
   return assistantEvent?.type === "text_delta" || assistantEvent?.type === "thinking_delta" || assistantEvent?.type === "toolcall_start" || assistantEvent?.type === "toolcall_delta";
 }
 function eventStartsTool(event) {
-  return event.type === "tool_execution_start" || event.type === "clio_tool_start";
+  return event.type === "tool_execution_start" || event.type === "clio_coder_tool_start";
 }
 function finitePositive(value) {
   return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
@@ -7151,7 +7407,7 @@ async function awaitEventDrain(drained, graceMs = DISPATCH_DRAIN_GRACE_MS) {
 function reportDispatchDiagnostic(scope, error) {
   const message = error instanceof Error ? error.message : String(error);
   try {
-    process.stderr.write(`[clio:dispatch] ${scope}: ${message}
+    process.stderr.write(`[clio-coder:dispatch] ${scope}: ${message}
 `);
   } catch {
   }
@@ -7570,9 +7826,7 @@ 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?.guardrails.workerToolCallCap ?? GUARDRAIL_DEFAULTS.workerToolCallCap;
+  return settings?.fleet.limits.toolCallsPerRun ?? GUARDRAIL_DEFAULTS.workerToolCallCap;
 }
 function resolveEffectiveWorkerBudget(input) {
   const hardCap = workerToolCallHardCap(input.settings);
@@ -7670,13 +7924,13 @@ function acpRuntimeLimitations() {
   ];
 }
 function readWorkerTargets(settings) {
-  const workerDefault = settings?.workers?.default ? {
-    target: settings.workers.default.target ?? null,
-    model: settings.workers.default.model ?? null,
-    thinkingLevel: settings.workers.default.thinkingLevel ?? "off"
+  const workerDefault = settings?.fleet?.default ? {
+    target: settings.fleet.default.target ?? null,
+    model: settings.fleet.default.model ?? null,
+    thinkingLevel: settings.fleet.default.thinkingLevel ?? "off"
   } : null;
   const workerProfiles = {};
-  for (const [name, profile] of Object.entries(settings?.workers?.profiles ?? {})) {
+  for (const [name, profile] of Object.entries(settings?.fleet?.profiles ?? {})) {
     workerProfiles[name] = {
       target: profile.target ?? null,
       model: profile.model ?? null,
@@ -7684,7 +7938,7 @@ function readWorkerTargets(settings) {
     };
   }
   const agentBindings = {};
-  for (const [agentId, profileName] of Object.entries(settings?.workers?.agentBindings ?? {})) {
+  for (const [agentId, profileName] of Object.entries(settings?.fleet?.agentProfiles ?? {})) {
     const id = agentId.trim();
     const profile = profileName.trim();
     if (id.length > 0 && profile.length > 0) agentBindings[id] = profile;
@@ -7821,12 +8075,12 @@ function buildDispatchWorkerSpec(input, config) {
   if (input.req.trustProjectCompatRoots !== void 0) {
     spec.trustProjectCompatRoots = input.req.trustProjectCompatRoots;
   } else if (settings) {
-    spec.trustProjectCompatRoots = settings.skills.trustProjectCompatRoots === true;
+    spec.trustProjectCompatRoots = settings.integrations.projectResources.trustProjectImports === true;
   }
-  spec.gitCommitAttribution = settings?.attribution.gitCommits ?? true;
-  spec.onPermission = settings?.workers.onPermission ?? "deny";
+  spec.gitCommitAttribution = settings?.integrations.git.commitAttribution ?? true;
+  spec.onPermission = settings?.fleet.permissions.mode ?? "deny";
   if (spec.onPermission === "escalate") {
-    const escalation = settings?.workers.escalation;
+    const escalation = settings?.fleet.permissions.escalation;
     if (escalation) spec.escalation = { timeoutMs: escalation.timeoutMs, fallback: escalation.fallback };
   }
   assertRuntimeCanHonorWorkerPermissionMode(input.target.runtime, spec.onPermission);
@@ -8214,7 +8468,7 @@ function createDispatchBundle(context, options) {
   const heartbeatIntervalMs = options?.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_INTERVAL_MS;
   const getResilienceCooldownMs = () => {
     if (options?.resilienceCooldownMs !== void 0) return options.resilienceCooldownMs;
-    const settingsVal = getEffectiveSettings()?.workers?.resilienceCooldownMs;
+    const settingsVal = getEffectiveSettings()?.fleet?.retry.routeCooldownMs;
     if (settingsVal !== void 0 && settingsVal >= 0) return settingsVal;
     return DEFAULT_RESILIENCE_COOLDOWN_MS;
   };
@@ -8262,6 +8516,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);
@@ -8342,7 +8607,7 @@ function createDispatchBundle(context, options) {
     }
   }
   function configuredGlobalCapacity(settings) {
-    const configured = settings?.budget.concurrency;
+    const configured = settings?.fleet.concurrency;
     return scheduling.maxWorkers?.() ?? (configured === "auto" || configured === void 0 ? 4 : Math.max(1, configured));
   }
   function publishCapacityQueued(identity, timing, node) {
@@ -8418,7 +8683,7 @@ function createDispatchBundle(context, options) {
   const finalizedTotals = { inputTokens: 0, outputTokens: 0, totalTokens: 0, costUsd: 0, runtimeSeconds: 0 };
   const finalizedCosts = [];
   function workersMaxRetries(settings = getEffectiveSettings()) {
-    const value = settings?.workers?.maxRetries;
+    const value = settings?.fleet?.retry.maxRetries;
     return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : 2;
   }
   function failoverModeFor(req) {
@@ -8915,6 +9180,17 @@ 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) {
     const recipe = agents.get(req.agentId);
@@ -8936,7 +9212,8 @@ 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);
@@ -8953,10 +9230,10 @@ function createDispatchBundle(context, options) {
       providers
     );
     enforceCapabilityGate(target.target.id, target.modelCapabilities, req.requiredCapabilities);
-    assertRuntimeCanHonorWorkerPermissionMode(target.runtime, settings?.workers.onPermission ?? "deny");
+    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?.autonomy ?? "auto-edit";
+    const sessionAutonomy = settings?.safety.autonomy ?? "auto-edit";
     const effectiveAutonomy = clampWorkerAutonomy(sessionAutonomy, req.autonomy);
     const effectiveTools = withLedgerToolNarrowing(
       effectiveToolNames(admission.allowedTools, target, pathScope.writeBoundaries.length > 0, deniedToolNames(req)),
@@ -8968,14 +9245,16 @@ 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,
-      onPermission: settings?.workers.onPermission ?? "deny",
+      toolPromptHints: toolPromptHintsForNames(effectiveTools, hasBoundSkills ? "bound-worker" : "worker"),
+      hasCanonicalContext,
+      hasBoundSkills,
+      onPermission: settings?.fleet.permissions.mode ?? "deny",
       persona: {
         id: `persona.${recipe.id}`,
         relPath: recipe.filepath,
@@ -9000,7 +9279,7 @@ function createDispatchBundle(context, options) {
       capabilityClass: spec.capabilityClass,
       projectContextTier: tier,
       autonomy: effectiveAutonomy,
-      onPermission: settings?.workers.onPermission ?? "deny",
+      onPermission: settings?.fleet.permissions.mode ?? "deny",
       project,
       workspace: readWorkspaceRootFacts(cwd)
     });
@@ -9013,7 +9292,7 @@ function createDispatchBundle(context, options) {
     const personaOverride = personaOverrideFor(req, staticCompositionHash);
     const currentToolSignature = toolSignature(effectiveTools);
     const auth = targetRequiresAuth(target.target, target.runtime) ? await providers.auth.resolveForTarget(target.target, target.runtime) : null;
-    const apiKey = auth?.apiKey ?? (auth === null ? "clio-local-target" : void 0);
+    const apiKey = auth?.apiKey ?? (auth === null ? "clio-coder-local-target" : void 0);
     const runtimeKind = target.runtime.kind;
     const limitations = runtimeLimitations(runtimeKind, target.runtime.id);
     return {
@@ -9064,16 +9343,16 @@ function createDispatchBundle(context, options) {
       }
     }
     if (!settings) throw new Error("dispatch: effective settings required for ACP delegation");
-    const configured = settings.delegation.agents.find((entry) => entry.id === agentId);
+    const configured = settings.integrations.externalAgents.entries.find((entry) => entry.id === agentId);
     if (!configured) throw new Error(`dispatch: ACP delegation agent '${agentId}' not configured`);
-    const toolGovernance = configured.toolGovernance ?? "clio-policy";
+    const toolGovernance = configured.toolGovernance ?? "clio-coder-policy";
     if (options?.autonomyOverride === true && toolGovernance === "agent-managed") {
       throw new Error(
-        `dispatch: ACP delegation agent '${agentId}' uses toolGovernance='agent-managed', which cannot enforce an explicit one-run autonomy override; choose clio-policy or deny-all governance, or omit --autonomy`
+        `dispatch: ACP delegation agent '${agentId}' uses toolGovernance='agent-managed', which cannot enforce an explicit one-run autonomy override; choose clio-coder-policy or deny-all governance, or omit --autonomy`
       );
     }
     const admission = resolveDelegationAdmissionStage(req, safety);
-    const sessionAutonomy = settings.autonomy ?? "auto-edit";
+    const sessionAutonomy = settings.safety.autonomy ?? "auto-edit";
     const autonomy = clampWorkerAutonomy(sessionAutonomy, req.autonomy);
     if (toolGovernance === "agent-managed" && autonomy !== sessionAutonomy) {
       throw new Error(
@@ -9217,12 +9496,12 @@ function createDispatchBundle(context, options) {
         if (eventContainsFirstModelToken(event)) markObservedPhase("firstModelTokenAt");
         if (eventStartsTool(event)) markObservedPhase("firstToolAt");
       }
-      if (event.type === "clio_tool_start" && event.payload && typeof event.payload.tool === "string") {
+      if (event.type === "clio_coder_tool_start" && event.payload && typeof event.payload.tool === "string") {
         recordToolStart(inFlightTools, event.payload);
       }
-      if (event.type === "clio_run_outcome" && !reportedSpoofedOutcome) {
+      if (event.type === "clio_coder_run_outcome" && !reportedSpoofedOutcome) {
         reportedSpoofedOutcome = true;
-        reportDispatchDiagnostic("ACP outcome event", new Error("ignored untrusted clio_run_outcome assertion"));
+        reportDispatchDiagnostic("ACP outcome event", new Error("ignored untrusted clio_coder_run_outcome assertion"));
       }
       if (isRecord8(event)) {
         const finishEntry = appendDispatchFinishContractEntry(finishContractEntries, event);
@@ -9253,7 +9532,7 @@ function createDispatchBundle(context, options) {
           if (message !== null) failureMessage = message;
         }
       }
-      if (event.type === "clio_permission_resolved" && event.payload && typeof event.payload.tool === "string") {
+      if (event.type === "clio_coder_permission_resolved" && event.payload && typeof event.payload.tool === "string") {
         const requestId = typeof event.payload.requestId === "string" ? event.payload.requestId : `delegation-permission-${Date.now()}`;
         const origin = runIdForPermissionAudit !== null ? `delegation:${runIdForPermissionAudit}` : "delegation:unknown";
         const actionClass = typeof event.payload.actionClass === "string" ? event.payload.actionClass : "unknown";
@@ -9277,7 +9556,7 @@ function createDispatchBundle(context, options) {
           ...runIdForPermissionAudit !== null ? { requestedBy: runIdForPermissionAudit } : {}
         });
       }
-      if (event.type === "clio_tool_finish" && event.payload && typeof event.payload.tool === "string") {
+      if (event.type === "clio_coder_tool_finish" && event.payload && typeof event.payload.tool === "string") {
         recordToolCompletion(inFlightTools, event.payload);
         recordToolFinish(toolStats, event.payload);
         if (event.payload.decision === "allowed") safetyDecisionCounts.allowed += 1;
@@ -9455,7 +9734,7 @@ function createDispatchBundle(context, options) {
       const finalFailureMessage = result.failureMessage ?? failureMessage;
       const finalToolStats = snapshotToolStats(toolStats);
       const unfinished = snapshotUnfinishedTools(inFlightTools);
-      const toolGovernance = lifecycle.agentConfig.toolGovernance ?? "clio-policy";
+      const toolGovernance = lifecycle.agentConfig.toolGovernance ?? "clio-coder-policy";
       return {
         runId: envelope.id,
         agentId: req.agentId,
@@ -9505,7 +9784,7 @@ function createDispatchBundle(context, options) {
         dynamicHash: lifecycle.dynamicHash,
         promptSignature: lifecycle.promptSignature,
         toolSignature: lifecycle.toolSignature,
-        clioVersion: readClioVersion(),
+        clioCoderVersion: readClioVersion(),
         piMonoVersion: readPiMonoVersion(),
         platform: process.platform,
         nodeVersion: process.version,
@@ -9519,7 +9798,7 @@ function createDispatchBundle(context, options) {
         quality: createRunReceiptQuality({ runtimeEnforceable: false, enforcementPassed: null, resultContract: null }),
         autonomyEnforcement: autonomyEnforcementForAcpDelegation(
           lifecycle.autonomy,
-          lifecycle.agentConfig.toolGovernance ?? "clio-policy",
+          lifecycle.agentConfig.toolGovernance ?? "clio-coder-policy",
           lifecycle.sessionAutonomy,
           req.autonomy
         ),
@@ -9549,7 +9828,7 @@ function createDispatchBundle(context, options) {
           toolCallsRequested: result.delegation.toolCallsRequested,
           toolCallsApproved: result.delegation.toolCallsApproved,
           toolCallsDenied: result.delegation.toolCallsDenied,
-          toolGovernance: lifecycle.agentConfig.toolGovernance ?? "clio-policy",
+          toolGovernance: lifecycle.agentConfig.toolGovernance ?? "clio-coder-policy",
           toolCallLog: acp.toolCallLog()
         },
         sessionId: result.delegation.acpSessionId
@@ -9752,11 +10031,11 @@ function createDispatchBundle(context, options) {
       finalPromise
     };
   }
-  async function dispatchAttempt(req, observer) {
+  async function dispatchAttempt(req, observer, settlement) {
     const requestedAt = new Date(now()).toISOString();
     const timing = { requestedAt, decisionStartedAt: requestedAt };
     const settings = getEffectiveSettings();
-    const isAcpAgent = settings?.delegation?.agents?.some((entry) => entry.id === req.agentId) ?? false;
+    const isAcpAgent = settings?.integrations.externalAgents?.entries?.some((entry) => entry.id === req.agentId) ?? false;
     if (isAcpAgent && !req.delegationAgentId) {
       req.delegationAgentId = req.agentId;
     }
@@ -9772,7 +10051,7 @@ function createDispatchBundle(context, options) {
       const recipe = agents.get(req.agentId);
       const activation = consumeActiveRouteApproval({
         request: req,
-        settings: settings?.routing,
+        settings: settings?.fleet.adaptiveRouting,
         capabilityClass: recipe === null ? null : normalizeAgentSpec(recipe).capabilityClass,
         failover: failoverModeFor(req),
         requestedAt,
@@ -9833,10 +10112,9 @@ 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);
@@ -10029,7 +10307,7 @@ function createDispatchBundle(context, options) {
         context.bus.emit(BusChannels.DispatchProgress, {
           runId,
           agentId: req.agentId,
-          event: { type: "clio_write_record_downgraded", payload: downgrade }
+          event: { type: "clio_coder_write_record_downgraded", payload: downgrade }
         });
       }
     });
@@ -10060,11 +10338,11 @@ function createDispatchBundle(context, options) {
         if (eventContainsFirstModelToken(event)) markObservedPhase("firstModelTokenAt");
         if (eventStartsTool(event)) markObservedPhase("firstToolAt");
       }
-      if (event.type === "clio_tool_start" && event.payload && typeof event.payload.tool === "string") {
+      if (event.type === "clio_coder_tool_start" && event.payload && typeof event.payload.tool === "string") {
         recordToolStart(inFlightTools, event.payload);
       }
-      if (event.type === "clio_steer_received") acknowledgeSteer(event.payload?.sequence);
-      if (event.type === "clio_run_outcome" && isRunOutcomeCode(event.payload?.outcomeCode) && event.payload.outcomeCode !== "worker_final_output_missing" && event.payload.outcomeCode !== "host_verification_rejected") {
+      if (event.type === "clio_coder_steer_received") acknowledgeSteer(event.payload?.sequence);
+      if (event.type === "clio_coder_run_outcome" && isRunOutcomeCode(event.payload?.outcomeCode) && event.payload.outcomeCode !== "worker_final_output_missing" && event.payload.outcomeCode !== "host_verification_rejected") {
         if (acceptsOutcomeCodeEvents) {
           trustedOutcomeCodes.add(event.payload.outcomeCode);
         } else if (!reportedUntrustedOutcome) {
@@ -10083,7 +10361,7 @@ function createDispatchBundle(context, options) {
         }
         recordWorkerRunEffect(runEffects, event);
       }
-      if (event.type === "clio_permission_escalated" && event.payload && typeof event.payload.requestId === "string") {
+      if (event.type === "clio_coder_permission_escalated" && event.payload && typeof event.payload.requestId === "string") {
         escalationCounts.requested += 1;
         const ctx = isRecord8(event.payload.decision) ? event.payload.decision : null;
         const classification = ctx !== null && isRecord8(ctx.classification) ? ctx.classification : null;
@@ -10136,7 +10414,7 @@ function createDispatchBundle(context, options) {
           if (message !== null) failureMessage = message;
         }
       }
-      if (event.type === "clio_permission_resolved" && event.payload && typeof event.payload.tool === "string") {
+      if (event.type === "clio_coder_permission_resolved" && event.payload && typeof event.payload.tool === "string") {
         const source = event.payload.source;
         const granted = (source === "operator" || source === "remembered") && event.payload.decision === "approved";
         const decidedBy = source === "operator" ? "operator" : source === "remembered" ? "operator:remembered" : source === "timeout" ? "timeout" : "policy:no-operator";
@@ -10172,7 +10450,7 @@ function createDispatchBundle(context, options) {
           ...runIdForPermissionAudit !== null ? { requestedBy: runIdForPermissionAudit } : {}
         });
       }
-      if (event.type === "clio_tool_finish" && event.payload && typeof event.payload.tool === "string") {
+      if (event.type === "clio_coder_tool_finish" && event.payload && typeof event.payload.tool === "string") {
         recordToolCompletion(inFlightTools, event.payload);
         recordToolFinish(toolStats, event.payload);
         if (isSkillActivation(event.payload.skillActivation)) {
@@ -10471,7 +10749,7 @@ function createDispatchBundle(context, options) {
         dynamicHash: lifecycle.dynamicHash,
         promptSignature: lifecycle.promptSignature,
         toolSignature: lifecycle.toolSignature,
-        clioVersion: readClioVersion(),
+        clioCoderVersion: readClioVersion(),
         piMonoVersion: readPiMonoVersion(),
         platform: process.platform,
         nodeVersion: process.version,
@@ -10493,7 +10771,7 @@ function createDispatchBundle(context, options) {
         ...skillActivations.length > 0 ? { skillActivations: [...skillActivations] } : {},
         autonomyEnforcement: autonomyEnforcementForWorkerSpec(
           spec,
-          lifecycle.settings?.autonomy ?? "auto-edit",
+          lifecycle.settings?.safety.autonomy ?? "auto-edit",
           req.autonomy
         ),
         safety: {
@@ -10585,6 +10863,7 @@ function createDispatchBundle(context, options) {
       }
       return { assessment, rigor };
     };
+    settlement?.live(envelope.id);
     const finalPromise = (async () => {
       try {
         const result = await workerDone;
@@ -10681,12 +10960,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";
@@ -10849,7 +11129,7 @@ function createDispatchBundle(context, options) {
       effectiveRequest: req
     });
   }
-  async function dispatch(req, observer) {
+  async function dispatch(req, observer, settlement) {
     let prepared = req;
     let createdWorktree;
     let writerLease;
@@ -10892,7 +11172,7 @@ function createDispatchBundle(context, options) {
     }
     let handle;
     try {
-      handle = await dispatchAttempt(prepared, observer);
+      handle = await dispatchAttempt(prepared, observer, settlement);
     } catch (error) {
       writerLease?.release();
       if (createdWorktree !== void 0) {
@@ -10907,6 +11187,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`);
@@ -10920,7 +11204,7 @@ function createDispatchBundle(context, options) {
     return { runId: handle.runId, events: assignment.events, finalPromise: terminal };
   }
   function previewFixed(req, settings = getEffectiveSettings()) {
-    const isAcpAgent = settings?.delegation?.agents?.some((entry) => entry.id === req.agentId) ?? false;
+    const isAcpAgent = settings?.integrations.externalAgents?.entries?.some((entry) => entry.id === req.agentId) ?? false;
     if (isAcpAgent && !req.delegationAgentId) req = { ...req, delegationAgentId: req.agentId };
     const validation = routeValidationProjection(req, true);
     const validated = validateJobSpec(validation.jobSpec);
@@ -10993,7 +11277,7 @@ function createDispatchBundle(context, options) {
       req
     );
     assertPostRuntimeToolCompatibility(req.agentId, agentSpec, effectiveTools, target);
-    assertRuntimeCanHonorWorkerPermissionMode(target.runtime, settings?.workers.onPermission ?? "deny");
+    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);
@@ -11048,7 +11332,7 @@ function createDispatchBundle(context, options) {
       specs,
       request: req,
       mode,
-      activeAgentRoles: settings?.routing.agentAutomation.activeAgentRoles ?? [],
+      activeAgentRoles: settings?.fleet.adaptiveRouting.agentRoles ?? [],
       ...agentIntent === void 0 ? {} : { intentOverride: agentIntent }
     });
     const settingsFingerprint = computeSettingsFingerprint(settings ?? null);
@@ -11133,7 +11417,7 @@ function createDispatchBundle(context, options) {
     const recipe = agents.get(req.agentId);
     return planActiveRoute({
       request: req,
-      settings: settings?.routing,
+      settings: settings?.fleet.adaptiveRouting,
       capabilityClass: recipe === null ? null : normalizeAgentSpec(recipe).capabilityClass,
       failover: failoverModeFor(req),
       fixed,
@@ -11212,10 +11496,11 @@ function createDispatchBundle(context, options) {
   }
   async function dispatchBatch(reqs) {
     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, settlement);
         handles.push({ ...handle, agentId: req.agentId });
       }
     } catch (err) {
@@ -11298,7 +11583,7 @@ function createDispatchBundle(context, options) {
       costProvenance: "unknown",
       compiledPromptHash: null,
       staticCompositionHash: null,
-      clioVersion: readClioVersion(),
+      clioCoderVersion: readClioVersion(),
       piMonoVersion: readPiMonoVersion(),
       platform: process.platform,
       nodeVersion: process.version,
@@ -11402,6 +11687,7 @@ function createDispatchBundle(context, options) {
       } catch {
       }
       startHeartbeatWatchdog();
+      probeEndpointsAtDefaultBound();
     },
     async stop() {
       draining = true;
@@ -11728,22 +12014,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";
@@ -12284,7 +12554,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();
@@ -12568,7 +12838,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 {
@@ -12755,7 +13025,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 = "";
               }
@@ -12999,7 +13269,6 @@ async function executeFleetRun(input) {
     planHash: input.plan.hash,
     result,
     receipts,
-    totalCostUsd: receipts.reduce((sum, receipt) => sum + receipt.costUsd, 0),
     totalCost: aggregateCostAmounts(
       receipts.map((receipt) => ({ usd: receipt.costUsd, provenance: receipt.costProvenance }))
     ),
@@ -13325,7 +13594,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",
@@ -13341,11 +13610,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) {
@@ -13361,7 +13630,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;
@@ -13373,7 +13642,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;
@@ -13385,7 +13654,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: [] };
@@ -13418,7 +13687,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 [];
@@ -13592,6 +13861,7 @@ var MAX_TASK_CHARS = 500;
 var TRANSCRIPT_TEXT_MAX_CHARS = 500;
 var TOOL_PREVIEW_MAX_CHARS = 240;
 var TASK_LEDGER_ROW_LIMIT = 200;
+var MODEL_PRIVATE_MARKER = "[not sent to model]";
 async function buildEvidence(options) {
   if (options.runId !== void 0 && options.sessionId !== void 0) {
     throw new Error("build evidence accepts either runId or sessionId, not both");
@@ -13992,22 +14262,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 = [];
@@ -14190,6 +14460,7 @@ function sessionToolEvents(entries) {
   for (const linked of entries) {
     const entry = linked.entry;
     if (entry.kind === "bashExecution") {
+      const contextMarker = entry.excludeFromContext === true ? `${MODEL_PRIVATE_MARKER} ` : "";
       events.push({
         source: "session-entry",
         runId: linked.link.runId,
@@ -14204,8 +14475,8 @@ function sessionToolEvents(entries) {
         timestamp: entry.timestamp,
         linkKind: "session-bash-execution",
         confidence: "exact",
-        argsPreview: truncateText(entry.command, TOOL_PREVIEW_MAX_CHARS),
-        resultPreview: truncateText(entry.output, TOOL_PREVIEW_MAX_CHARS)
+        argsPreview: truncateText(`${contextMarker}${entry.command}`, TOOL_PREVIEW_MAX_CHARS),
+        resultPreview: truncateText(`${contextMarker}${entry.output}`, TOOL_PREVIEW_MAX_CHARS)
       });
       continue;
     }
@@ -14559,9 +14830,10 @@ function renderSessionTranscriptEntry(linked) {
   }
   if (entry.kind === "bashExecution") {
     const status = entry.cancelled ? "cancelled" : entry.exitCode === null ? "exit=?" : `exit=${entry.exitCode}`;
+    const contextMarker = entry.excludeFromContext === true ? ` ${MODEL_PRIVATE_MARKER}` : "";
     return [
-      `${prefix} bash ${status}: $ ${truncateText(entry.command, TRANSCRIPT_TEXT_MAX_CHARS)}`,
-      `  output: ${previewUnknown(entry.output)}`
+      `${prefix} bash ${status}${contextMarker}: $ ${truncateText(entry.command, TRANSCRIPT_TEXT_MAX_CHARS)}`,
+      `  output${contextMarker}: ${previewUnknown(entry.output)}`
     ];
   }
   if (entry.kind === "branchSummary")
@@ -14685,7 +14957,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");
@@ -14706,7 +14978,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");
@@ -14791,7 +15063,7 @@ function parseRunReceipt(value, source) {
     costUsd: readNumber2(value, source, "costUsd"),
     compiledPromptHash: readNullableString2(value, source, "compiledPromptHash"),
     staticCompositionHash: readNullableString2(value, source, "staticCompositionHash"),
-    clioVersion: readString2(value, source, "clioVersion"),
+    clioCoderVersion: readReceiptVersion(value, source),
     piMonoVersion: readString2(value, source, "piMonoVersion"),
     platform: readString2(value, source, "platform"),
     nodeVersion: readString2(value, source, "nodeVersion"),
@@ -14805,6 +15077,10 @@ function parseRunReceipt(value, source) {
     }
   };
 }
+function readReceiptVersion(value, source) {
+  if (typeof value.clioCoderVersion === "string") return value.clioCoderVersion;
+  return readString2(value, source, "clioVersion");
+}
 function readToolStats(record, source, field) {
   const value = record[field];
   if (!Array.isArray(value)) throw new Error(`${source}.${field}: expected array`);
@@ -14995,7 +15271,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();
@@ -15196,19 +15472,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) => ({
@@ -15349,7 +15625,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 {
@@ -15360,7 +15636,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;
@@ -15389,7 +15665,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);
@@ -15397,7 +15673,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;
@@ -15407,7 +15683,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);
@@ -15416,7 +15692,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];
@@ -15704,4 +15980,4 @@ export {
   summarizeEvalResults,
   buildEvalEvidence
 };
-//# sourceMappingURL=chunk-BUMFYQFY.js.map
+//# sourceMappingURL=chunk-I66ZTYNP.js.map