@iowarp/clio-coder 0.4.1 → 0.4.2

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

@@ -6,7 +6,7 @@ import {
   readGateDecisionArtifactsForRunIds,
   stagePendingGateDecision,
   verifyGateDecisionArtifact
-} from "./chunk-GPPB3JBE.js";
+} from "./chunk-ZGNYYXQ6.js";
 import {
   RUN_RECEIPT_INTEGRITY_ALGORITHM,
   RUN_RECEIPT_INTEGRITY_VERSION,
@@ -24,14 +24,18 @@ import {
   trustVerdict,
   verifyReceiptIntegrity,
   withReceiptIntegrity
-} from "./chunk-6NJQITNH.js";
+} from "./chunk-B74PXLU7.js";
 import {
   protectedArtifactFromSessionEntry,
   protectedArtifactStateFromSessionEntries,
   readAuditRows,
   readSessionEntriesForId,
   responseModelIdObservationFromRecord
-} from "./chunk-TVH4ONAM.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-TD3PGPQA.js";
+} from "./chunk-W6NIE6OW.js";
 import {
   executionPlanAncestors,
   spliceExecutionPlan
-} from "./chunk-THYWACCR.js";
+} from "./chunk-DZAW46HP.js";
 import {
   parseRigorOverride,
   resolveRigor
@@ -53,11 +57,11 @@ import {
   parseEvalArtifactV4,
   redactArtifactForStorage,
   sumEvalHarnessMetrics
-} from "./chunk-6CCS4G3W.js";
+} from "./chunk-5PFYMY2V.js";
 import {
   defaultRunEventJournal,
   removeRunEventJournals
-} from "./chunk-6VC4OV3Z.js";
+} from "./chunk-VIA6RFQZ.js";
 import {
   AdmissionCanceledError,
   EVENT_TEE_LIMIT,
@@ -75,11 +79,11 @@ import {
   receiptAttestationFields,
   routeFactVerdict,
   spawnNativeWorker
-} from "./chunk-AFKWHWXF.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-2VG7KLYV.js";
+} from "./chunk-IKSLQ4XV.js";
 import {
   decideRoute,
   defaultRoutingIntent,
@@ -137,16 +144,16 @@ import {
   routingIntentRejection,
   sameRouteIdentity,
   toRouteCandidate
-} from "./chunk-7EPLI7VL.js";
+} from "./chunk-HIICAHCJ.js";
 import {
   assessFinishContract
-} from "./chunk-PVAMAVBB.js";
+} from "./chunk-IDNA72AH.js";
 import {
   WRITE_ROOT_REFUSED_TOOLS
-} from "./chunk-IXJT6DCX.js";
+} from "./chunk-FVDGR2ZL.js";
 import {
   describeCallAction
-} from "./chunk-TVHHYFHE.js";
+} from "./chunk-NEDJ26B5.js";
 import {
   applyToolProfile,
   assertToolProfileEnforceable
@@ -182,7 +189,9 @@ import {
   parseAgentLedgerBody
 } 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-IG7BCQBA.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,7 +233,7 @@ import {
   resolveRuntimeTarget,
   runtimeResolutionWarnings,
   runtimeTargetSnapshot
-} from "./chunk-UEDMSP56.js";
+} from "./chunk-BYMNWQ7O.js";
 import {
   ceilChars
 } from "./chunk-CWVRRIEI.js";
@@ -233,13 +243,13 @@ import {
 import {
   assertSafeId
 } from "./chunk-R346GLFC.js";
-import {
-  BusChannels
-} from "./chunk-HLW2MRKE.js";
 import {
   normalizeClioCoderEventRecord,
   normalizeClioCoderEventType
 } from "./chunk-BTK3SSSK.js";
+import {
+  BusChannels
+} from "./chunk-F4EKGO4N.js";
 import {
   attributeCommitMessage,
   gitCommitAttributionEnabled,
@@ -263,11 +273,11 @@ 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 {
   targetRequiresAuth
 } from "./chunk-WNP7O5WZ.js";
@@ -284,6 +294,7 @@ import {
 import {
   clioDataDir,
   clioStateDir,
+  resolveClioDirs,
   stateRootRemoved
 } from "./chunk-BYP5D4HI.js";
 import {
@@ -1407,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}`));
   }
@@ -1442,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();
@@ -2437,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);
@@ -2487,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 "";
@@ -2515,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");
@@ -2596,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");
@@ -2638,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) {
@@ -2706,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"
     );
@@ -4358,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));
@@ -4844,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");
 }
@@ -4915,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;
@@ -4923,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;
+    }
   };
 }
 
@@ -7575,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?.fleet.limits.toolCallsPerRun ?? GUARDRAIL_DEFAULTS.workerToolCallCap;
+  return settings?.fleet.limits.toolCallsPerRun ?? GUARDRAIL_DEFAULTS.workerToolCallCap;
 }
 function resolveEffectiveWorkerBudget(input) {
   const hardCap = workerToolCallHardCap(input.settings);
@@ -8267,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);
@@ -8920,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);
@@ -8941,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);
@@ -8973,13 +9245,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}`,
@@ -9757,7 +10031,7 @@ 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();
@@ -9838,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);
@@ -10590,6 +10863,7 @@ function createDispatchBundle(context, options) {
       }
       return { assessment, rigor };
     };
+    settlement?.live(envelope.id);
     const finalPromise = (async () => {
       try {
         const result = await workerDone;
@@ -10686,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";
@@ -10854,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;
@@ -10897,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) {
@@ -10912,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`);
@@ -11217,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) {
@@ -11407,6 +11687,7 @@ function createDispatchBundle(context, options) {
       } catch {
       }
       startHeartbeatWatchdog();
+      probeEndpointsAtDefaultBound();
     },
     async stop() {
       draining = true;
@@ -11733,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";
@@ -12289,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();
@@ -12573,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 {
@@ -12760,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 = "";
               }
@@ -13329,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",
@@ -13345,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) {
@@ -13365,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;
@@ -13377,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;
@@ -13389,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: [] };
@@ -13422,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 [];
@@ -13997,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 = [];
@@ -14692,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");
@@ -14713,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");
@@ -15006,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();
@@ -15207,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) => ({
@@ -15360,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 {
@@ -15371,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;
@@ -15400,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);
@@ -15408,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;
@@ -15418,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);
@@ -15427,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];
@@ -15715,4 +15980,4 @@ export {
   summarizeEvalResults,
   buildEvalEvidence
 };
-//# sourceMappingURL=chunk-XKA2ICR3.js.map
+//# sourceMappingURL=chunk-I66ZTYNP.js.map