@iowarp/clio-coder 0.3.7 → 0.3.9

package/dist/{chunk-UUANF5CR.js → chunk-TEO2TLVN.js}

@@ -1,11 +1,33 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  RUN_RECEIPT_INTEGRITY_ALGORITHM,
+  RUN_RECEIPT_INTEGRITY_VERSION,
+  adaptGateDecisionReviewStatus,
+  adaptGroundedEvidenceValidationStatus,
+  composeTrustStatus,
+  formatTrustAxes,
+  formatTrustSummary,
+  inspectRunReceiptTrustStatus,
+  isReceiptIntegrity,
+  isTrustStatusIdentifier,
+  loadEvalArtifact,
+  normalizeTrustStatus,
+  parseEvalArtifactV4,
+  redactArtifactForStorage,
+  retiredIntegrityVersionOf,
+  sha256,
+  sumEvalHarnessMetrics,
+  trustVerdict,
+  verifyReceiptIntegrity,
+  withReceiptIntegrity
+} from "./chunk-MLOK6ZOS.js";
 import {
   protectedArtifactFromSessionEntry,
   protectedArtifactStateFromSessionEntries,
   readAuditRows,
   readSessionEntriesForId,
   responseModelIdObservationFromRecord
-} from "./chunk-6TUKSZVF.js";
+} from "./chunk-LXPJXFM5.js";
 import {
   applyTaskWorktree,
   captureWorkspaceSnapshot,
@@ -13,26 +35,19 @@ import {
   createTaskWorktree,
   createWriteBoundaryEnforcer,
   gitCheckoutRoot
-} from "./chunk-KZ2H5X4G.js";
+} from "./chunk-ECUO3KDP.js";
 import {
   executionPlanAncestors,
   spliceExecutionPlan
-} from "./chunk-M4AKACEO.js";
+} from "./chunk-HKO36JWF.js";
 import {
   parseRigorOverride,
   resolveRigor
 } from "./chunk-RVG5JXAL.js";
 import {
-  RUN_RECEIPT_INTEGRITY_ALGORITHM,
-  RUN_RECEIPT_INTEGRITY_VERSION,
-  isReceiptIntegrity,
-  loadEvalArtifact,
-  parseEvalArtifactV4,
-  redactArtifactForStorage,
-  sumEvalHarnessMetrics,
-  verifyReceiptIntegrity,
-  withReceiptIntegrity
-} from "./chunk-ZGH7FGS5.js";
+  FLEET_COMMAND_BASE_ENV,
+  normalizeWriteBoundary
+} from "./chunk-HPCTNZM2.js";
 import {
   LOCAL_NODE_ID,
   computeSettingsFingerprint,
@@ -43,11 +58,7 @@ import {
   receiptAttestationFields,
   routeFactVerdict,
   spawnNativeWorker
-} from "./chunk-TSHXZTOQ.js";
-import {
-  FLEET_COMMAND_BASE_ENV,
-  normalizeWriteBoundary
-} from "./chunk-KCMKRQX4.js";
+} from "./chunk-5HFBWUMU.js";
 import {
   AGENT_LEDGER_PROMPT_MAX_CHARS,
   RETRYABLE_OUTCOMES,
@@ -69,6 +80,8 @@ import {
   claudeSubprocessPermissionConfigForAutonomy,
   competeStanceLiner,
   createRunEffectsRecorder,
+  declaredScopeReplacementDiagnostic,
+  declaredScopeReplacementNotice,
   describeCallAction,
   isBoundedGateRolePrompt,
   isClaudeCanonicalTool,
@@ -77,6 +90,7 @@ import {
   networkToolsDisabled,
   projectExecutionHandoffs,
   renderAgentLedger,
+  resolveDispatchPathScope,
   resolveToolBudgetEnvelope,
   responseSchemaConflictsWithTools,
   runKindSupportsLiveSteering,
@@ -84,11 +98,7 @@ import {
   serializeWorkerRuntimeDescriptor,
   toolPromptHintsForNames,
   validateJobSpec
-} from "./chunk-CEYBNUGC.js";
-import {
-  WRITE_ROOT_REFUSED_TOOLS,
-  assessFinishContract
-} from "./chunk-OBMAI2DP.js";
+} from "./chunk-4H6ULJ3H.js";
 import {
   decideRoute,
   defaultRoutingIntent,
@@ -106,7 +116,7 @@ import {
   routingIntentRejection,
   sameRouteIdentity,
   toRouteCandidate
-} from "./chunk-5C77SEEY.js";
+} from "./chunk-VPTUJU4P.js";
 import {
   appliesRecipeResultContract,
   gateRouteCorrelation,
@@ -114,40 +124,38 @@ import {
   requestExecutionRole,
   routeCorrelationFactsForRun,
   withAttemptRole
-} from "./chunk-UND3GU2L.js";
+} from "./chunk-H7IXIC72.js";
 import {
-  canonicalJson,
-  endpointIdentityHash,
-  parseAgentLedgerBody
-} from "./chunk-CMZWFGD2.js";
-import {
-  compareCodepoints
-} from "./chunk-GH5622CP.js";
+  assessFinishContract
+} from "./chunk-7C6RYZGQ.js";
 import {
-  isSkillActivation
-} from "./chunk-GOXNB3AO.js";
+  WRITE_ROOT_REFUSED_TOOLS
+} from "./chunk-N3PBVRTZ.js";
 import {
-  DEFAULT_AUTONOMY_LEVEL,
-  autonomyDenyRejection,
-  mapAutonomy
-} from "./chunk-HWUFFB6L.js";
-import {
-  parseJsonObjectPayload,
-  parseVerifierResult,
-  resultContractAuthorship,
-  validateRecipeResult
-} from "./chunk-DJNLUABN.js";
+  compareCodepoints
+} from "./chunk-A2NJGIB3.js";
 import {
   agentSpecFingerprint,
   assertAgentSpecPolicy,
   classify,
   isUserVisibleAgent,
   normalizeAgentSpec,
-  resolveAgentToolCompatibility
-} from "./chunk-AOCYTWAV.js";
+  parseJsonObjectPayload,
+  parseVerifierResult,
+  pathBoundaryCovers,
+  resolveAgentToolCompatibility,
+  resultContractAuthorship,
+  validateRecipeResult
+} from "./chunk-S4COXYBG.js";
 import {
   detectValidationCommand
 } from "./chunk-MV3K5QF2.js";
+import {
+  DEFAULT_AUTONOMY_LEVEL,
+  autonomyDenyRejection,
+  isSkillActivation,
+  mapAutonomy
+} from "./chunk-RAPCMZL4.js";
 import {
   isProjectVerifierCheckId,
   isVerificationScriptName
@@ -160,6 +168,11 @@ import {
 import {
   canonicalizeExistingPath
 } from "./chunk-ECH6PKUQ.js";
+import {
+  canonicalJson,
+  endpointIdentityHash,
+  parseAgentLedgerBody
+} from "./chunk-CMZWFGD2.js";
 import {
   truncateUtf8
 } from "./chunk-6XLNIQDB.js";
@@ -169,46 +182,58 @@ import {
 } from "./chunk-CGKSTWHD.js";
 import {
   canonicalizeWireModelId,
+  endpointCapacitiesForStatuses,
+  endpointCapacityForStatus,
+  endpointLabel,
   firstRuntimeResolutionError,
+  foregroundStreamUsage,
   isDispatchEligibleRuntime,
-  resolveEffectivePricing,
   resolveModelCapabilities,
   resolveRuntimeTarget,
   runtimeResolutionWarnings,
   runtimeTargetSnapshot
-} from "./chunk-VQNODYQ4.js";
-import {
-  targetRequiresAuth
-} from "./chunk-JRIO5UD2.js";
+} from "./chunk-MIX5N5AC.js";
 import {
   ceilChars
-} from "./chunk-GEYXPTRF.js";
-import {
-  DEFAULT_DELEGATION_CONNECT_TIMEOUT_MS,
-  DEFAULT_DELEGATION_TURN_TIMEOUT_MS,
-  DEFAULT_SETTINGS,
-  THINKING_LEVELS
-} from "./chunk-4DGYLA73.js";
-import {
-  atomicWrite
-} from "./chunk-FO5ZOVUY.js";
-import {
-  assertSafeId
-} from "./chunk-R346GLFC.js";
+} from "./chunk-AEYBF3TB.js";
 import {
   attributeCommitMessage,
   gitCommitAttributionEnabled,
   reportCommitAttributionDiagnostic,
   withManagedGitCommitAttributionEnvironment
-} from "./chunk-D4MDIG46.js";
+} from "./chunk-B5CSFE7B.js";
 import {
   MAX_TIMER_DELAY_MS,
   rawDurationMs
 } from "./chunk-FQ4SKYE4.js";
+import {
+  BusChannels
+} from "./chunk-RKRLDWD3.js";
+import {
+  assertSafeId,
+  atomicWrite
+} from "./chunk-KV2AOLDF.js";
+import {
+  AI_AGENT_NAME
+} from "./chunk-6EJMN2Y3.js";
+import {
+  readClioVersion,
+  readPiMonoVersion,
+  resolvePackageRoot
+} from "./chunk-IWHMRKLL.js";
+import {
+  DEFAULT_DELEGATION_CONNECT_TIMEOUT_MS,
+  DEFAULT_DELEGATION_TURN_TIMEOUT_MS,
+  DEFAULT_SETTINGS,
+  THINKING_LEVELS
+} from "./chunk-XDOQXGFO.js";
 import {
   GUARDRAIL_DEFAULTS,
   resolveGuardrail
 } from "./chunk-4ZG3XFUR.js";
+import {
+  targetRequiresAuth
+} from "./chunk-EQ63NRB7.js";
 import {
   FILE_LOCK_ACQUIRE_TIMEOUT_MS,
   withStateFileLock,
@@ -225,16 +250,8 @@ import {
   stateRootRemoved
 } from "./chunk-BNAZZHFG.js";
 import {
-  AI_AGENT_NAME
-} from "./chunk-6EJMN2Y3.js";
-import {
-  BusChannels
-} from "./chunk-OB5HIGJY.js";
-import {
-  readClioVersion,
-  readPiMonoVersion,
-  resolvePackageRoot
-} from "./chunk-IWHMRKLL.js";
+  resolveEffectivePricing
+} from "./chunk-VO2LKSTM.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -1055,7 +1072,7 @@ function clone(lease) {
 function valid(value) {
   if (typeof value !== "object" || value === null) return false;
   const lease = value;
-  return typeof lease.leaseId === "string" && typeof lease.assignmentId === "string" && typeof lease.nodeId === "string" && (lease.host === void 0 || typeof lease.host === "string") && Number.isInteger(lease.ownerPid) && typeof lease.processBirthToken === "string" && typeof lease.acquiredAt === "string" && typeof lease.expiresAt === "string" && typeof lease.heartbeatAt === "string" && (lease.reservationOwnerId === null || typeof lease.reservationOwnerId === "string") && (lease.reservationMemberId === null || typeof lease.reservationMemberId === "string");
+  return typeof lease.leaseId === "string" && typeof lease.assignmentId === "string" && typeof lease.nodeId === "string" && (lease.endpointKey === void 0 || typeof lease.endpointKey === "string") && (lease.host === void 0 || typeof lease.host === "string") && Number.isInteger(lease.ownerPid) && typeof lease.processBirthToken === "string" && typeof lease.acquiredAt === "string" && typeof lease.expiresAt === "string" && typeof lease.heartbeatAt === "string" && (lease.reservationOwnerId === null || typeof lease.reservationOwnerId === "string") && (lease.reservationMemberId === null || typeof lease.reservationMemberId === "string");
 }
 function validTimestamp(value) {
   if (typeof value !== "string") return false;
@@ -1119,6 +1136,7 @@ var MEMBER_STATUSES = /* @__PURE__ */ new Set(["held", "consumed", "released"]);
 function heldReservationUsage(values) {
   let global = 0;
   const nodes = {};
+  const endpoints = {};
   for (const value of values) {
     if (typeof value !== "object" || value === null)
       throw new Error("dispatch capacity store has invalid reservation records");
@@ -1128,6 +1146,7 @@ function heldReservationUsage(values) {
     if (record.status !== "active") continue;
     const byWave = /* @__PURE__ */ new Map();
     const byNodeWave = /* @__PURE__ */ new Map();
+    const byEndpointWave = /* @__PURE__ */ new Map();
     for (const raw of record.members) {
       if (typeof raw !== "object" || raw === null)
         throw new Error("dispatch capacity store has invalid reservation records");
@@ -1140,13 +1159,34 @@ function heldReservationUsage(values) {
       const nodeWaves = byNodeWave.get(member.nodeId) ?? /* @__PURE__ */ new Map();
       nodeWaves.set(wave, (nodeWaves.get(wave) ?? 0) + 1);
       byNodeWave.set(member.nodeId, nodeWaves);
+      if (member.endpointKey !== void 0 && typeof member.endpointKey !== "string")
+        throw new Error("dispatch capacity store has invalid reservation records");
+      if (typeof member.endpointKey === "string") {
+        const endpointWaves = byEndpointWave.get(member.endpointKey) ?? /* @__PURE__ */ new Map();
+        endpointWaves.set(wave, (endpointWaves.get(wave) ?? 0) + 1);
+        byEndpointWave.set(member.endpointKey, endpointWaves);
+      }
     }
     global += Math.max(0, ...byWave.values());
     for (const [id, waves] of byNodeWave) nodes[id] = (nodes[id] ?? 0) + Math.max(0, ...waves.values());
+    for (const [key, waves] of byEndpointWave) endpoints[key] = (endpoints[key] ?? 0) + Math.max(0, ...waves.values());
   }
-  return { global, nodes };
+  return { global, nodes, endpoints };
 }
-function assertCapacity(file, nodeId, limits) {
+function describeEndpointCapacityHolders(holders) {
+  const parts = [];
+  const add = (count, singular, plural) => {
+    if (count > 0) parts.push(`${count} ${count === 1 ? singular : plural}`);
+  };
+  add(holders.leases, "active lease", "active leases");
+  add(holders.reservations, "held reservation", "held reservations");
+  add(holders.foregroundStreams, "foreground stream", "foreground streams");
+  if (parts.length === 0) return "no active lease, held reservation, or foreground stream currently holds a slot";
+  const named = parts.length === 1 ? parts[0] : parts.length === 2 ? `${parts[0]} and ${parts[1]}` : `${parts.slice(0, -1).join(", ")}, and ${parts.at(-1)}`;
+  const total = holders.leases + holders.reservations + holders.foregroundStreams;
+  return `${named} ${total === 1 ? "holds" : "hold"} ${total === 1 ? "the slot" : "the slots"}`;
+}
+function assertCapacity(file, nodeId, endpointKey, limits) {
   const held2 = heldReservationUsage(file.reservations);
   const globalUsed = file.leases.length + held2.global;
   if (globalUsed >= limits.global) {
@@ -1161,6 +1201,23 @@ function assertCapacity(file, nodeId, limits) {
     if (used >= nodeLimit)
       throw new Error(`dispatch: admission denied: node '${nodeId}' capacity reached (${used}/${nodeLimit})`);
   }
+  if (endpointKey !== void 0) {
+    const endpointLimit = limits.endpoints[endpointKey];
+    if (endpointLimit !== void 0) {
+      if (endpointLimit < 1)
+        throw new Error(`dispatch: admission denied: endpoint '${endpointLabel(endpointKey)}' capacity unavailable`);
+      const holders = {
+        leases: file.leases.filter((lease) => lease.endpointKey === endpointKey).length,
+        reservations: held2.endpoints[endpointKey] ?? 0,
+        foregroundStreams: foregroundStreamUsage()[endpointKey] ?? 0
+      };
+      const used = holders.leases + holders.reservations + holders.foregroundStreams;
+      if (used >= endpointLimit)
+        throw new Error(
+          `dispatch: admission denied: endpoint '${endpointLabel(endpointKey)}' capacity reached (${used}/${endpointLimit} slots): ${describeEndpointCapacityHolders(holders)}; collect in-flight runs or point workers at a second server`
+        );
+    }
+  }
 }
 function acquireCapacityLease(input) {
   return withStateFileLockSync(capacityStateLockPath(), () => {
@@ -1174,10 +1231,12 @@ function acquireCapacityLease(input) {
       );
     const existing = file.leases.find((lease2) => lease2.assignmentId === input.assignmentId);
     if (existing) {
-      if (existing.nodeId !== input.nodeId) {
+      if (existing.nodeId !== input.nodeId || existing.endpointKey !== input.endpointKey) {
         const without = { ...file, leases: file.leases.filter((lease2) => lease2 !== existing) };
-        assertCapacity(without, input.nodeId, input.limits);
+        assertCapacity(without, input.nodeId, input.endpointKey, input.limits);
         existing.nodeId = input.nodeId;
+        if (input.endpointKey === void 0) delete existing.endpointKey;
+        else existing.endpointKey = input.endpointKey;
       }
       existing.heartbeatAt = new Date(nowMs).toISOString();
       existing.expiresAt = new Date(nowMs + (input.ttlMs ?? DEFAULT_CAPACITY_LEASE_TTL_MS)).toISOString();
@@ -1185,7 +1244,7 @@ function acquireCapacityLease(input) {
       return clone(existing);
     }
     input.onAcquiredUnderLock?.(file);
-    assertCapacity(file, input.nodeId, input.limits);
+    assertCapacity(file, input.nodeId, input.endpointKey, input.limits);
     const token = input.processBirthToken ?? processBirthToken(input.ownerPid ?? process.pid);
     if (!token) throw new Error("dispatch: cannot establish process birth token");
     const at = new Date(nowMs).toISOString();
@@ -1193,6 +1252,7 @@ function acquireCapacityLease(input) {
       leaseId: `lease-${nowMs.toString(36)}-${randomBytes(6).toString("hex")}`,
       assignmentId: input.assignmentId,
       nodeId: input.nodeId,
+      ...input.endpointKey !== void 0 ? { endpointKey: input.endpointKey } : {},
       host: hostname(),
       ownerPid: input.ownerPid ?? process.pid,
       processBirthToken: token,
@@ -1264,8 +1324,23 @@ function capacityDrain(nowMs = Date.now()) {
 function capacityLeaseUsage(options) {
   const leases = listCapacityLeases(options);
   const nodes = {};
-  for (const lease of leases) nodes[lease.nodeId] = (nodes[lease.nodeId] ?? 0) + 1;
-  return { global: leases.length, nodes };
+  const foreground = foregroundStreamUsage();
+  const endpoints = { ...foreground };
+  const endpointHolders = Object.fromEntries(
+    Object.entries(foreground).map(([endpointKey, foregroundStreams]) => [
+      endpointKey,
+      { leases: 0, reservations: 0, foregroundStreams }
+    ])
+  );
+  for (const lease of leases) {
+    nodes[lease.nodeId] = (nodes[lease.nodeId] ?? 0) + 1;
+    if (lease.endpointKey !== void 0) {
+      endpoints[lease.endpointKey] = (endpoints[lease.endpointKey] ?? 0) + 1;
+      const holders = endpointHolders[lease.endpointKey] ?? { leases: 0, reservations: 0, foregroundStreams: 0 };
+      endpointHolders[lease.endpointKey] = { ...holders, leases: holders.leases + 1 };
+    }
+  }
+  return { global: leases.length, nodes, endpoints, endpointHolders };
 }
 function createNodeLeaseUsageReader(options) {
   const cacheMs = options.cacheMs ?? 200;
@@ -1438,9 +1513,42 @@ function agentLedgerContribution(id, runId) {
   return { posted: contribution.posted, refused: contribution.refused, digest };
 }
 
+// src/domains/dispatch/intent-requirements.ts
+init_esm_shims();
+function renderDispatchIntentRequirements(intent) {
+  if (intent === void 0 || intent.expectedOutputs.length === 0 && intent.verification.length === 0) return null;
+  const lines = [
+    "# 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.expectedOutputs.length > 0) {
+    lines.push("", "Expected outputs:", ...intent.expectedOutputs.map((output) => `- ${output}`));
+  }
+  if (intent.verification.length > 0) {
+    lines.push(
+      "",
+      "Verification requirements:",
+      ...intent.verification.map(
+        (entry) => `- ${entry.check} must pass within its declared timeout of ${entry.timeoutMs}ms`
+      )
+    );
+  }
+  return lines.join("\n");
+}
+function renderDispatchReviewerTask(originalTask, builderRunId, cycle, intent) {
+  const requirements = renderDispatchIntentRequirements(intent);
+  return [
+    `Review the work of builder run ${builderRunId} (review cycle ${cycle}).`,
+    "The builder's final answer is provided as input data; verify it against the workspace, do not trust it blindly.",
+    "Original task the builder was given:",
+    originalTask,
+    ...requirements === null ? [] : [requirements]
+  ].join("\n\n");
+}
+
 // src/domains/dispatch/receipt-findings.ts
 init_esm_shims();
-import { createHash as createHash12 } from "node:crypto";
+import { createHash as createHash11 } from "node:crypto";
 
 // src/domains/evidence/index.ts
 init_esm_shims();
@@ -1455,12 +1563,14 @@ init_esm_shims();
 
 // src/domains/dispatch/extension.ts
 init_esm_shims();
-import { createHash as createHash9, randomBytes as randomBytes6 } from "node:crypto";
+import { createHash as createHash8, randomBytes as randomBytes6 } from "node:crypto";
 import { existsSync as existsSync12, readdirSync as readdirSync4, readFileSync as readFileSync12 } from "node:fs";
 import { isAbsolute as isAbsolute2, relative, resolve as resolvePath, sep } from "node:path";
+import { performance as performance5 } from "node:perf_hooks";
 
 // src/engine/acp/adapter.ts
 init_esm_shims();
+import { performance as performance4 } from "node:perf_hooks";
 
 // src/engine/acp/event-mapper.ts
 init_esm_shims();
@@ -2229,7 +2339,14 @@ function errorEvents(messageText2) {
 function startAcpDelegationRun(input) {
   const connectTimeoutMs = input.agent.connectTimeoutMs ?? DEFAULT_DELEGATION_CONNECT_TIMEOUT_MS;
   const turnTimeoutMs = input.agent.turnTimeoutMs ?? DEFAULT_DELEGATION_TURN_TIMEOUT_MS;
-  const heartbeatAt = { current: Date.now() };
+  const now = input.now ?? Date.now;
+  const monotonicNow = input.monotonicNow ?? (() => performance4.now());
+  const heartbeatWallAnchor = now();
+  const heartbeatMonotonicAnchor = monotonicNow();
+  const heartbeatAt = {
+    current: heartbeatWallAnchor,
+    monotonic: heartbeatMonotonicAnchor
+  };
   const queue = new AsyncEventQueue();
   const usage = emptyUsage();
   const mapper = new AcpEventMapper();
@@ -2256,7 +2373,9 @@ function startAcpDelegationRun(input) {
     cancelTimer = null;
   };
   const emit = (event) => {
-    heartbeatAt.current = Date.now();
+    const stamp = monotonicNow();
+    heartbeatAt.monotonic = stamp;
+    heartbeatAt.current = heartbeatWallAnchor + (stamp - heartbeatMonotonicAnchor);
     queue.push(event);
   };
   const mediator = new AcpToolMediator({
@@ -2431,62 +2550,6 @@ function startAcpDelegationRun(input) {
 // src/domains/prompts/compiler.ts
 init_esm_shims();
 import { join as join3 } from "node:path";
-
-// src/domains/prompts/hash.ts
-init_esm_shims();
-import { createHash as createHash2 } from "node:crypto";
-function sha256(input) {
-  return createHash2("sha256").update(input, "utf8").digest("hex");
-}
-function canonicalJson2(value) {
-  return serialize(value);
-}
-function serialize(value) {
-  if (value === null) return "null";
-  if (typeof value === "number") {
-    if (!Number.isFinite(value)) {
-      throw new Error(`canonicalJson: non-finite number ${String(value)} is not representable`);
-    }
-    return JSON.stringify(value);
-  }
-  if (typeof value === "string" || typeof value === "boolean") {
-    return JSON.stringify(value);
-  }
-  if (typeof value === "bigint") {
-    throw new Error("canonicalJson: bigint is not representable");
-  }
-  if (typeof value === "symbol" || typeof value === "function") {
-    throw new Error(`canonicalJson: ${typeof value} is not representable`);
-  }
-  if (value === void 0) {
-    throw new Error("canonicalJson: undefined is not representable at root");
-  }
-  if (Array.isArray(value)) {
-    const parts = [];
-    for (let i = 0; i < value.length; i++) {
-      if (!(i in value) || value[i] === void 0) {
-        parts.push("null");
-        continue;
-      }
-      parts.push(serialize(value[i]));
-    }
-    return `[${parts.join(",")}]`;
-  }
-  if (typeof value === "object") {
-    const obj = value;
-    const keys = Object.keys(obj).sort();
-    const parts = [];
-    for (const key of keys) {
-      const child = obj[key];
-      if (child === void 0) continue;
-      parts.push(`${JSON.stringify(key)}:${serialize(child)}`);
-    }
-    return `{${parts.join(",")}}`;
-  }
-  throw new Error(`canonicalJson: unsupported value of type ${typeof value}`);
-}
-
-// src/domains/prompts/compiler.ts
 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) {
@@ -2698,15 +2761,45 @@ function renderProjectBlock(contextFiles) {
 
 ${trimmedFiles}`;
 }
-function renderMemoryBlock(memorySection) {
+function renderMemoryBlock(memorySection, legacyDuplicateHeader = false) {
   const trimmed = memorySection?.trim() ?? "";
-  return trimmed.length === 0 ? "" : `# Memory
+  if (trimmed.length === 0) return "";
+  if (legacyDuplicateHeader) return `# Memory
+
+${trimmed}`;
+  return /^#\s+Memory\s*$/.test(trimmed.split("\n", 1)[0] ?? "") ? trimmed : `# Memory
 
 ${trimmed}`;
 }
 function estimatePromptTokens(text) {
   return ceilChars(text.trim().length);
 }
+var SESSION_PROMPT_SECTION_ORDER = [
+  "identity",
+  "operating-contract",
+  "delegation",
+  "skills",
+  "safety",
+  "tool-contract",
+  "fleet",
+  "retrieval-hints",
+  "project-context",
+  "memory",
+  "runtime"
+];
+var LEGACY_SESSION_PROMPT_SECTION_ORDER = [
+  "identity",
+  "operating-contract",
+  "delegation",
+  "skills",
+  "safety",
+  "runtime",
+  "tool-contract",
+  "fleet",
+  "retrieval-hints",
+  "memory",
+  "project-context"
+];
 function compile(table, inputs) {
   const identity = lookupFragment(table, inputs.identity, "identity");
   const operatingContract = lookupFragment(table, inputs.operatingContract, "operating contract");
@@ -2726,24 +2819,29 @@ function compile(table, inputs) {
   const docsRouting = selfAwareness && sessionHasContext(session) ? table.byId.get("identity.docs-routing") : void 0;
   if (selfAwareness) {
     const packageRoot = resolvePackageRoot();
-    const rendered = 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"));
-    identityBody = [identity.body.trim(), rendered.trim(), ...docsRouting ? [docsRouting.body.trim()] : []].join(
+    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"));
+    identityBody = [identity.body.trim(), rendered2.trim(), ...docsRouting ? [docsRouting.body.trim()] : []].join(
       "\n\n"
     );
   }
   const delegation = sessionCanDispatch(session) ? table.byId.get("operating.delegation") : void 0;
   const skills = sessionHasContext(session) ? table.byId.get("operating.skills") : void 0;
-  push("identity", identityBody);
-  push("operating-contract", operatingContract.body);
-  if (delegation) push("delegation", delegation.body);
-  if (skills) push("skills", skills.body);
-  push("safety", renderSafetySection(safety, autonomyLevel));
-  push("runtime", renderRuntimeBlock(session));
-  push("tool-contract", renderToolContractBlock(session));
-  push("fleet", renderFleetBlock(session));
-  push("retrieval-hints", renderRetrievalHintsBlock(session));
-  push("memory", renderMemoryBlock(session.memorySection));
-  push("project-context", renderProjectBlock(session.contextFiles));
+  const legacy = inputs.sectionOrder === "legacy-0.3.8";
+  const rendered = /* @__PURE__ */ new Map([
+    ["identity", identityBody],
+    ["operating-contract", operatingContract.body],
+    ["delegation", delegation?.body ?? ""],
+    ["skills", skills?.body ?? ""],
+    ["safety", renderSafetySection(safety, autonomyLevel)],
+    ["runtime", renderRuntimeBlock(session)],
+    ["tool-contract", renderToolContractBlock(session)],
+    ["fleet", renderFleetBlock(session)],
+    ["retrieval-hints", renderRetrievalHintsBlock(session)],
+    ["memory", renderMemoryBlock(session.memorySection, legacy)],
+    ["project-context", renderProjectBlock(session.contextFiles)]
+  ]);
+  const order = legacy ? LEGACY_SESSION_PROMPT_SECTION_ORDER : SESSION_PROMPT_SECTION_ORDER;
+  for (const id of order) push(id, rendered.get(id) ?? "");
   for (const fragment of inputs.additionalFragments ?? []) {
     push(fragment.id, fragment.body);
   }
@@ -3308,6 +3406,9 @@ init_esm_shims();
 import { randomBytes as randomBytes2 } from "node:crypto";
 var MAX_RESERVATION_RECORDS = 500;
 var DEFAULT_RESERVATION_TTL_MS = 15 * 6e4;
+function endpointCapacityDenial(input) {
+  return `dispatch: admission denied: endpoint '${endpointLabel(input.endpointKey)}' capacity exceeded (${input.used + input.requested}/${input.limit} slots): ${describeEndpointCapacityHolders(input)}; reduce the same-wave worker count, collect in-flight runs, or point workers at a second server`;
+}
 function copyRecord(record) {
   return { ...record, members: record.members.map((member) => ({ ...member })) };
 }
@@ -3315,7 +3416,7 @@ function validRecord(value) {
   if (typeof value !== "object" || value === null) return false;
   const record = value;
   return typeof record.ownerId === "string" && typeof record.ownerPid === "number" && Number.isInteger(record.ownerPid) && record.ownerPid > 0 && (record.topology === "parallel" || record.topology === "detached" || record.topology === "sequential" || record.topology === "pipeline" || record.topology === "review" || record.topology === "compete") && (record.status === "active" || record.status === "released" || record.status === "rolled_back" || record.status === "expired") && typeof record.createdAt === "string" && typeof record.expiresAt === "string" && (record.settledAt === null || typeof record.settledAt === "string") && Array.isArray(record.members) && record.members.every(
-    (member) => typeof member.memberId === "string" && Number.isInteger(member.wave) && typeof member.nodeId === "string" && typeof member.costUpperBoundUsd === "number" && Number.isFinite(member.costUpperBoundUsd) && member.costUpperBoundUsd >= 0 && (member.status === "held" || member.status === "consumed" || member.status === "released") && (member.consumedAt === null || typeof member.consumedAt === "string") && (member.releasedAt === null || typeof member.releasedAt === "string")
+    (member) => typeof member.memberId === "string" && Number.isInteger(member.wave) && typeof member.nodeId === "string" && (member.endpointKey === void 0 || typeof member.endpointKey === "string") && typeof member.costUpperBoundUsd === "number" && Number.isFinite(member.costUpperBoundUsd) && member.costUpperBoundUsd >= 0 && (member.status === "held" || member.status === "consumed" || member.status === "released") && (member.consumedAt === null || typeof member.consumedAt === "string") && (member.releasedAt === null || typeof member.releasedAt === "string")
   );
 }
 function parseReservations(values) {
@@ -3352,9 +3453,13 @@ function reservationAllocation(tasks) {
     )
   );
   const nodeSlots = peakBy(tasks.map((task) => ({ wave: task.wave, key: task.nodeId })));
+  const endpointSlots = peakBy(
+    tasks.flatMap((task) => task.endpointKey === void 0 ? [] : [{ wave: task.wave, key: task.endpointKey }])
+  );
   return {
     globalSlots,
     nodeSlots,
+    endpointSlots,
     budgetUsd: tasks.reduce((sum, task) => sum + task.costUpperBoundUsd, 0)
   };
 }
@@ -3387,6 +3492,26 @@ function allocateReservation(tasks, existing, capacity) {
       return { ok: false, reason: `node '${nodeId}' capacity exceeded (${used + slots}/${node.limit})` };
     }
   }
+  for (const [endpointKey, slots] of Object.entries(requested.endpointSlots)) {
+    const endpoint = capacity.endpoints[endpointKey];
+    if (!endpoint || !Number.isFinite(endpoint.limit)) continue;
+    const heldSlots = held2.reduce((sum, allocation) => sum + (allocation.endpointSlots[endpointKey] ?? 0), 0);
+    const used = endpoint.active + heldSlots;
+    if (used + slots > endpoint.limit) {
+      return {
+        ok: false,
+        reason: endpointCapacityDenial({
+          endpointKey,
+          limit: endpoint.limit,
+          used,
+          requested: slots,
+          leases: endpoint.leases ?? endpoint.active - (endpoint.foregroundStreams ?? 0),
+          reservations: heldSlots,
+          foregroundStreams: endpoint.foregroundStreams ?? 0
+        })
+      };
+    }
+  }
   const existingBudget = activeRecords.reduce((sum, record) => sum + outstandingBudget(record), 0);
   const projected = capacity.budget.currentUsd + existingBudget + requested.budgetUsd;
   if (projected >= capacity.budget.ceilingUsd) {
@@ -3414,7 +3539,9 @@ function createDispatchReservation(input) {
     if (!planned.ok) {
       replaceReservations(state, records);
       writeCapacityStateUnsafe(state);
-      throw new Error(`dispatch: reservation denied: ${planned.reason}`);
+      throw new Error(
+        planned.reason.startsWith("dispatch:") ? planned.reason : `dispatch: reservation denied: ${planned.reason}`
+      );
     }
     const createdAt = new Date(nowMs).toISOString();
     const record = {
@@ -3437,6 +3564,7 @@ function transferDispatchReservationToLease(input) {
   return acquireCapacityLease({
     assignmentId: input.assignmentId,
     nodeId: input.nodeId,
+    ...input.endpointKey !== void 0 ? { endpointKey: input.endpointKey } : {},
     limits: input.limits,
     nowMs,
     ...input.ttlMs !== void 0 ? { ttlMs: input.ttlMs } : {},
@@ -3464,10 +3592,37 @@ function rebindDispatchReservationMember(input) {
     if (member.status === "released") {
       throw new Error(`dispatch: reservation member '${input.memberId}' was already released`);
     }
-    if (member.nodeId === input.nodeId && member.costUpperBoundUsd === input.costUpperBoundUsd) {
+    if (member.nodeId === input.nodeId && member.endpointKey === input.endpointKey && member.costUpperBoundUsd === input.costUpperBoundUsd) {
       return copyRecord(record);
     }
     const others = records.filter((entry) => entry.status === "active" && entry.ownerId !== input.ownerId);
+    if (member.endpointKey !== input.endpointKey && input.endpointKey !== void 0) {
+      const endpointKey = input.endpointKey;
+      const endpoint = input.capacity.endpoints[endpointKey];
+      if (endpoint !== void 0 && Number.isFinite(endpoint.limit)) {
+        const siblingSlots = record.members.filter(
+          (entry) => entry !== member && entry.status !== "released" && entry.endpointKey === endpointKey
+        ).length;
+        const otherHeld = others.reduce(
+          (sum, entry) => sum + (reservationAllocation(outstandingTasks(entry)).endpointSlots[endpointKey] ?? 0),
+          0
+        );
+        const used = endpoint.active + otherHeld + siblingSlots;
+        if (used + 1 > endpoint.limit) {
+          throw new Error(
+            endpointCapacityDenial({
+              endpointKey,
+              limit: endpoint.limit,
+              used,
+              requested: 1,
+              leases: endpoint.leases ?? endpoint.active - (endpoint.foregroundStreams ?? 0),
+              reservations: otherHeld + siblingSlots,
+              foregroundStreams: endpoint.foregroundStreams ?? 0
+            })
+          );
+        }
+      }
+    }
     if (member.nodeId !== input.nodeId) {
       const node = input.capacity.nodes[input.nodeId];
       if (node !== void 0 && Number.isFinite(node.limit)) {
@@ -3495,6 +3650,8 @@ function rebindDispatchReservationMember(input) {
       );
     }
     member.nodeId = input.nodeId;
+    if (input.endpointKey === void 0) delete member.endpointKey;
+    else member.endpointKey = input.endpointKey;
     member.costUpperBoundUsd = Math.max(0, input.costUpperBoundUsd);
     writeStore2(records);
     return copyRecord(record);
@@ -3517,6 +3674,24 @@ function releaseDispatchReservationMember(ownerId, memberId, nowMs = Date.now())
     return copyRecord(record);
   });
 }
+function releaseDispatchReservation(ownerId, nowMs = Date.now()) {
+  return withStateFileLockSync(capacityStateLockPath(), () => {
+    const records = readStore2();
+    const record = records.find((entry) => entry.ownerId === ownerId);
+    if (!record) return null;
+    if (record.status !== "active") return copyRecord(record);
+    const settledAt = new Date(nowMs).toISOString();
+    for (const member of record.members) {
+      if (member.status === "released") continue;
+      member.status = "released";
+      member.releasedAt = settledAt;
+    }
+    record.status = "released";
+    record.settledAt = settledAt;
+    writeStore2(records);
+    return copyRecord(record);
+  });
+}
 function rollbackDispatchReservation(ownerId, nowMs = Date.now()) {
   return withStateFileLockSync(capacityStateLockPath(), () => {
     const records = readStore2();
@@ -3621,6 +3796,15 @@ var PUMP_MIN_MS = 10;
 var PUMP_MAX_MS = 500;
 function describeAdmissionFailure(input) {
   if (input.state === "canceled") return "dispatch: admission canceled before a capacity slot opened";
+  if (input.endpointKey !== void 0) {
+    const endpointLimit = input.limits.endpoints[input.endpointKey];
+    const endpointActive = input.usage.endpoints[input.endpointKey] ?? 0;
+    if (endpointLimit !== void 0 && endpointActive >= endpointLimit) {
+      const holders = input.usage.endpointHolders?.[input.endpointKey];
+      const occupancy = holders === void 0 ? "the supplied capacity snapshot does not attribute the occupied slots" : describeEndpointCapacityHolders(holders);
+      return `dispatch: admission denied: endpoint '${endpointLabel(input.endpointKey)}' capacity reached (${endpointActive}/${endpointLimit} slots): ${occupancy}; collect in-flight runs or point workers at a second server`;
+    }
+  }
   const nodeLimit = input.limits.nodes[input.nodeId];
   const nodeActive = input.usage.nodes[input.nodeId] ?? 0;
   const where = nodeLimit === void 0 ? `${input.usage.global}/${input.limits.global} worker slots in use` : `${nodeActive}/${nodeLimit} worker slots in use on '${input.nodeId}', ${input.usage.global}/${input.limits.global} globally`;
@@ -3662,6 +3846,10 @@ function createCapacityAdmissionController(options) {
           admittedLease = request.value();
           return true;
         } catch (error) {
+          if (error instanceof Error && /endpoint '.*' capacity reached/u.test(error.message)) {
+            queue.fail(request.requestId, error);
+            return false;
+          }
           if (error instanceof Error && /capacity reached/.test(error.message)) return false;
           queue.fail(request.requestId, error instanceof Error ? error : new Error(String(error)));
           return false;
@@ -3712,11 +3900,13 @@ function createCapacityAdmissionController(options) {
             memberId: input.reservation.memberId,
             assignmentId: input.assignmentId,
             nodeId: input.nodeId,
+            ...input.endpointKey !== void 0 ? { endpointKey: input.endpointKey } : {},
             limits: options.limits(),
             nowMs: now()
           }) : acquireCapacityLease({
             assignmentId: input.assignmentId,
             nodeId: input.nodeId,
+            ...input.endpointKey !== void 0 ? { endpointKey: input.endpointKey } : {},
             limits: options.limits(),
             nowMs: now()
           })
@@ -3728,6 +3918,7 @@ function createCapacityAdmissionController(options) {
             describeAdmissionFailure({
               state: outcome.state,
               nodeId: input.nodeId,
+              ...input.endpointKey !== void 0 ? { endpointKey: input.endpointKey } : {},
               waitedMs: now() - queuedAt,
               overdueAtQueueMs: queuedAt - input.deadlineAt,
               queueDepth: queue.size(),
@@ -3906,6 +4097,12 @@ async function reconcileOrphanAssignments(deps) {
   const summary = { recovered: 0, abandoned: 0 };
   for (const record of deps.listRunning()) {
     if (record.status !== "running") continue;
+    if (deps.ownerAlive(record)) continue;
+    if (record.verdictOwner !== void 0) {
+      await deps.settle(record.assignmentId, record.assignmentId, "failed", record.verdictOwner);
+      summary.abandoned += 1;
+      continue;
+    }
     const views = record.attempts.map((runId) => deps.lookupAttempt(runId)).filter((view) => view !== null);
     const succeeded = views.find((view) => view.succeeded);
     if (succeeded) {
@@ -3934,10 +4131,15 @@ var MAX_ASSIGNMENT_RECORDS = 1e3;
 function storePath2() {
   return join4(clioStateDir(), "assignments.json");
 }
+function validProcessOwner(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const owner = value;
+  return Number.isSafeInteger(owner.pid) && (owner.pid ?? 0) > 0 && typeof owner.processBirthToken === "string" && typeof owner.acquiredAt === "string" && Number.isFinite(Date.parse(owner.acquiredAt));
+}
 function validRecord2(value) {
   if (typeof value !== "object" || value === null) return false;
   const record = value;
-  return typeof record.assignmentId === "string" && Array.isArray(record.attempts) && record.attempts.every((runId) => typeof runId === "string") && (record.terminalRunId === null || typeof record.terminalRunId === "string") && (record.status === "running" || record.status === "succeeded" || record.status === "failed" || record.status === "canceled" || record.status === "timed_out");
+  return typeof record.assignmentId === "string" && Array.isArray(record.attempts) && record.attempts.every((runId) => typeof runId === "string") && (record.terminalRunId === null || typeof record.terminalRunId === "string") && (record.verdictOwner === void 0 || record.verdictOwner === "fleet") && (record.processOwner === void 0 || validProcessOwner(record.processOwner)) && (record.status === "running" || record.status === "succeeded" || record.status === "failed" || record.status === "canceled" || record.status === "timed_out");
 }
 function readStore3() {
   const path2 = storePath2();
@@ -3951,7 +4153,24 @@ function readStore3() {
   }
 }
 function copyRecord2(record) {
-  return { ...record, attempts: [...record.attempts] };
+  return {
+    ...record,
+    attempts: [...record.attempts],
+    ...record.processOwner === void 0 ? {} : { processOwner: { ...record.processOwner } }
+  };
+}
+var defaultProcessOwnerProbe = {
+  birthToken: processBirthToken,
+  tokenProvesDeath: BIRTH_TOKEN_SOURCE_AVAILABLE,
+  alive: processAlive
+};
+function assignmentProcessOwnerAlive(record, probe = defaultProcessOwnerProbe) {
+  const owner = record.processOwner;
+  if (owner === void 0) return false;
+  const current = probe.birthToken(owner.pid);
+  if (current === null || current !== owner.processBirthToken) return false;
+  if (probe.tokenProvesDeath === false) return probe.alive?.(owner.pid) ?? false;
+  return true;
 }
 function writeStore3(assignments) {
   const file = {
@@ -3996,41 +4215,75 @@ async function renameStoredAssignment(fromAssignmentId, toAssignmentId) {
   });
   return copyRecord2(result);
 }
-function registerAssignment(assignmentId) {
-  return updateRecord(
+function currentProcessOwner() {
+  const token = processBirthToken();
+  if (token === null) throw new Error("dispatch: cannot establish assignment owner process birth token");
+  return {
+    pid: process.pid,
+    processBirthToken: token,
+    acquiredAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function openRecord(assignmentId) {
+  return {
     assignmentId,
-    (current) => current ?? { assignmentId, attempts: [], terminalRunId: null, status: "running" }
-  );
+    attempts: [],
+    terminalRunId: null,
+    status: "running",
+    processOwner: currentProcessOwner()
+  };
+}
+function ensureRunningProcessOwner(record) {
+  if (record.status !== "running" || record.processOwner !== void 0) return record;
+  return { ...record, processOwner: currentProcessOwner() };
+}
+function clearProcessOwner(record) {
+  const result = { ...record };
+  delete result.processOwner;
+  return result;
+}
+function registerAssignment(assignmentId) {
+  return updateRecord(assignmentId, (current) => ensureRunningProcessOwner(current ?? openRecord(assignmentId)));
+}
+function claimAssignmentVerdict(assignmentId, owner) {
+  return updateRecord(assignmentId, (current) => ({
+    ...ensureRunningProcessOwner(current ?? openRecord(assignmentId)),
+    verdictOwner: owner
+  }));
 }
 function recordAssignmentAttempt(assignmentId, runId) {
   return updateRecord(assignmentId, (current) => {
-    const base = current ?? { assignmentId, attempts: [], terminalRunId: null, status: "running" };
+    const base = ensureRunningProcessOwner(current ?? openRecord(assignmentId));
     return base.attempts.includes(runId) ? base : { ...base, attempts: [...base.attempts, runId] };
   });
 }
 function failQueuedAssignment(assignmentId) {
   return updateRecord(assignmentId, (current) => {
-    const base = current ?? { assignmentId, attempts: [], terminalRunId: null, status: "running" };
-    return base.status === "running" ? { ...base, status: "failed" } : base;
+    const base = current ?? openRecord(assignmentId);
+    if (base.verdictOwner !== void 0) return base;
+    return base.status === "running" ? clearProcessOwner({ ...base, status: "failed" }) : base;
   });
 }
 function timeoutStoredAssignment(assignmentId) {
   return updateRecord(assignmentId, (current) => {
-    const base = current ?? { assignmentId, attempts: [], terminalRunId: null, status: "running" };
-    return base.status === "running" ? { ...base, status: "timed_out" } : base;
+    const base = current ?? openRecord(assignmentId);
+    if (base.verdictOwner !== void 0) return base;
+    return base.status === "running" ? clearProcessOwner({ ...base, status: "timed_out" }) : base;
   });
 }
 function cancelStoredAssignment(assignmentId) {
   return updateRecord(assignmentId, (current) => {
-    const base = current ?? { assignmentId, attempts: [], terminalRunId: null, status: "running" };
-    return base.status === "running" ? { ...base, status: "canceled" } : base;
+    const base = current ?? openRecord(assignmentId);
+    if (base.verdictOwner !== void 0) return base;
+    return base.status === "running" ? clearProcessOwner({ ...base, status: "canceled" }) : base;
   });
 }
-function settleStoredAssignment(assignmentId, terminalRunId, status) {
+function settleStoredAssignment(assignmentId, terminalRunId, status, owner) {
   return updateRecord(assignmentId, (current) => {
-    const base = current ?? { assignmentId, attempts: [], terminalRunId: null, status: "running" };
+    const base = current ?? openRecord(assignmentId);
     const attempts = base.attempts.includes(terminalRunId) ? base.attempts : [...base.attempts, terminalRunId];
-    return { ...base, attempts, terminalRunId, status };
+    if (base.verdictOwner !== owner) return { ...base, attempts };
+    return clearProcessOwner({ ...base, attempts, terminalRunId, status });
   });
 }
 
@@ -4235,7 +4488,7 @@ function assessCapabilityMismatch(input) {
 
 // src/domains/dispatch/checkout-writer-lease.ts
 init_esm_shims();
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 import { existsSync as existsSync5, mkdirSync, readFileSync as readFileSync5, realpathSync, unlinkSync } from "node:fs";
 import { dirname, join as join6 } from "node:path";
 var held = /* @__PURE__ */ new Map();
@@ -4245,7 +4498,7 @@ function canonicalCheckout(checkout) {
 }
 function checkoutWriterLeasePath(checkout) {
   const canonical = canonicalCheckout(checkout);
-  const key = createHash3("sha256").update(canonical, "utf8").digest("hex");
+  const key = createHash2("sha256").update(canonical, "utf8").digest("hex");
   return join6(clioStateDir(), "checkout-writer-leases", `${key}.json`);
 }
 function validRecord3(value) {
@@ -4445,8 +4698,11 @@ function isInfrastructureFailure(failureClass) {
 // src/domains/dispatch/heartbeat.ts
 init_esm_shims();
 var DEFAULT_HEARTBEAT_SPEC = { windowMs: 5e3, graceMs: 1e4 };
-function classifyHeartbeat(heartbeatAt, now, spec) {
-  const age = now - heartbeatAt;
+function heartbeatMonotonicAt(heartbeat) {
+  return heartbeat.monotonic ?? heartbeat.current;
+}
+function classifyHeartbeat(heartbeatMonotonicAt2, monotonicNow, spec) {
+  const age = monotonicNow - heartbeatMonotonicAt2;
   if (age <= spec.windowMs) return "alive";
   if (age <= spec.windowMs + spec.graceMs) return "stale";
   return "dead";
@@ -4455,14 +4711,14 @@ function classifyHeartbeat(heartbeatAt, now, spec) {
 // src/domains/dispatch/host-verification.ts
 init_esm_shims();
 import { execFileSync as execFileSync2 } from "node:child_process";
-import { createHash as createHash5, randomUUID } from "node:crypto";
+import { createHash as createHash4, randomUUID } from "node:crypto";
 import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync6, renameSync, writeFileSync as writeFileSync2 } from "node:fs";
 import { dirname as dirname2, join as join8, resolve as resolve3 } from "node:path";
 
 // src/domains/dispatch/code-step.ts
 init_esm_shims();
 import { execFileSync, spawn as spawn2 } from "node:child_process";
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 import { mkdirSync as mkdirSync2, writeFileSync } from "node:fs";
 import { isAbsolute, join as join7, resolve as resolve2 } from "node:path";
 var CODE_STEP_CAPTURE_MAX_BYTES = 1048576;
@@ -4482,10 +4738,10 @@ function canonicalCodeReport(report) {
   });
 }
 function codeReportDigest(report) {
-  return createHash4("sha256").update(canonicalCodeReport(report), "utf8").digest("hex");
+  return createHash3("sha256").update(canonicalCodeReport(report), "utf8").digest("hex");
 }
 function sha2562(value) {
-  return createHash4("sha256").update(value, "utf8").digest("hex");
+  return createHash3("sha256").update(value, "utf8").digest("hex");
 }
 function tailUtf8(value, limit, marker) {
   if (value.length <= limit) return { text: value.toString("utf8"), truncated: false };
@@ -4535,7 +4791,7 @@ function workspaceHasChanges(root) {
   return status.trim().length > 0;
 }
 function newCodeRunId() {
-  return `code-${createHash4("sha256").update(`${process.pid}:${Date.now()}:${Math.random()}`).digest("hex").slice(0, 12)}`;
+  return `code-${createHash3("sha256").update(`${process.pid}:${Date.now()}:${Math.random()}`).digest("hex").slice(0, 12)}`;
 }
 async function spawnCommand(input, cwd, argv) {
   const command = input.command;
@@ -4699,7 +4955,7 @@ ${spawned.spawnError}
 var OUTPUT_TAIL_BYTES = 2048;
 var MEMO_VERSION = 1;
 function sha2563(value) {
-  return createHash5("sha256").update(value, "utf8").digest("hex");
+  return createHash4("sha256").update(value, "utf8").digest("hex");
 }
 function outputTail(value) {
   const bytes = Buffer.from(value, "utf8");
@@ -5468,7 +5724,7 @@ function selectApprovedRecoveryCandidates(input) {
 // src/domains/dispatch/reproducibility.ts
 init_esm_shims();
 import { spawnSync } from "node:child_process";
-import { createHash as createHash6 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 function collectReproducibilityMetadata(cwd, safety) {
   const branch = git(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]);
   const commit = git(cwd, ["rev-parse", "HEAD"]);
@@ -5505,7 +5761,7 @@ function git(cwd, args) {
   return trimmed.length > 0 ? trimmed : null;
 }
 function sha2564(input) {
-  return createHash6("sha256").update(input, "utf8").digest("hex");
+  return createHash5("sha256").update(input, "utf8").digest("hex");
 }
 
 // src/domains/dispatch/route-observer.ts
@@ -5515,7 +5771,7 @@ import { join as join12 } from "node:path";
 
 // src/domains/dispatch/gate-decisions.ts
 init_esm_shims();
-import { createHash as createHash7, randomBytes as randomBytes4 } from "node:crypto";
+import { createHash as createHash6, randomBytes as randomBytes4 } from "node:crypto";
 import { closeSync, existsSync as existsSync8, fsyncSync, mkdirSync as mkdirSync4, openSync, readdirSync as readdirSync2, readFileSync as readFileSync8, rmSync } from "node:fs";
 import { dirname as dirname3, join as join10, resolve as resolve4 } from "node:path";
 function parseReviewGateResult(output) {
@@ -5705,7 +5961,7 @@ function decisionPayload(decision) {
   };
 }
 function decisionDigest(decision) {
-  return createHash7("sha256").update(JSON.stringify(decisionPayload(decision)), "utf8").digest("hex");
+  return createHash6("sha256").update(JSON.stringify(decisionPayload(decision)), "utf8").digest("hex");
 }
 function artifactWithoutIntegrity(artifact) {
   const result = {
@@ -5841,7 +6097,7 @@ function pendingRecordPayload(record) {
   };
 }
 function pendingRecordDigest(record) {
-  return createHash7("sha256").update(JSON.stringify(pendingRecordPayload(record)), "utf8").digest("hex");
+  return createHash6("sha256").update(JSON.stringify(pendingRecordPayload(record)), "utf8").digest("hex");
 }
 function pendingRecordWithoutIntegrity(record) {
   if (record.kind === "output") {
@@ -6332,7 +6588,7 @@ function isPhaseTiming(value) {
 
 // src/domains/dispatch/route-quality.ts
 init_esm_shims();
-import { createHash as createHash8 } from "node:crypto";
+import { createHash as createHash7 } from "node:crypto";
 function compareStrings(left, right) {
   return left < right ? -1 : left > right ? 1 : 0;
 }
@@ -6447,19 +6703,19 @@ function reduceRouteQuality(input) {
   return { label, checks, correlatedGates, sourceDigests: [...sourceDigests].sort(compareStrings) };
 }
 function routeQualityEvalDigest(artifact) {
-  return createHash8("sha256").update(canonicalJson3(artifact), "utf8").digest("hex");
+  return createHash7("sha256").update(canonicalJson2(artifact), "utf8").digest("hex");
 }
-function canonicalJson3(value) {
+function canonicalJson2(value) {
   if (value === null) return "null";
   if (typeof value === "string" || typeof value === "boolean") return JSON.stringify(value);
   if (typeof value === "number") {
     if (!Number.isFinite(value)) throw new Error("route quality eval digest requires finite numbers");
     return JSON.stringify(value);
   }
-  if (Array.isArray(value)) return `[${value.map(canonicalJson3).join(",")}]`;
+  if (Array.isArray(value)) return `[${value.map(canonicalJson2).join(",")}]`;
   if (typeof value === "object") {
     const record = value;
-    return `{${Object.keys(record).sort(compareStrings).map((key) => `${JSON.stringify(key)}:${canonicalJson3(record[key])}`).join(",")}}`;
+    return `{${Object.keys(record).sort(compareStrings).map((key) => `${JSON.stringify(key)}:${canonicalJson2(record[key])}`).join(",")}}`;
   }
   throw new Error(`route quality eval digest cannot represent ${typeof value}`);
 }
@@ -7165,7 +7421,7 @@ function requestOriginFor(req) {
   return req.requestOrigin ?? "agent";
 }
 function sha2565(input) {
-  return createHash9("sha256").update(input, "utf8").digest("hex");
+  return createHash8("sha256").update(input, "utf8").digest("hex");
 }
 function promptHash(systemPrompt) {
   return systemPrompt.length > 0 ? sha2565(systemPrompt) : null;
@@ -7304,6 +7560,7 @@ function recordWorkerRunEffect(recorder, event) {
   if (event.type === "tool_execution_end") recorder.finish(toolCallId, event.isError === true);
 }
 var DISPATCH_DRAIN_GRACE_MS = 2e3;
+var RUN_WRITE_TARGET_HISTORY = 512;
 async function awaitEventDrain(drained, graceMs = DISPATCH_DRAIN_GRACE_MS) {
   let timer;
   const grace = new Promise((resolve5) => {
@@ -7391,9 +7648,10 @@ function mergeRouteWarningDetail(routeWarning, base) {
 function pickOrchestratorScope(safety) {
   return safety.scopes.workspace;
 }
-function pickWorkerScope(safety, requestedActions) {
+function pickWorkerScope(safety, requestedActions, pathScope) {
   if (requestedActions.every((action) => action === "read")) return safety.scopes.readonly;
-  return safety.scopes.workspace;
+  if (pathScope.writeBoundaries.length === 0) return safety.scopes.workspace;
+  return { ...safety.scopes.workspace, allowedWriteRoots: pathScope.writeBoundaries };
 }
 function deriveRequestedActions(tools, safety) {
   const actions = /* @__PURE__ */ new Set();
@@ -7520,6 +7778,10 @@ function projectContextProvenanceFor(tier, messages) {
 function hasPersonaOverride(req) {
   return typeof req.systemPrompt === "string" && req.systemPrompt.trim().length > 0;
 }
+function hasCallerPersonaOverride(req) {
+  if (!hasPersonaOverride(req)) return false;
+  return !isBoundedGateRolePrompt({ role: req.gate?.role, autonomy: req.autonomy, systemPrompt: req.systemPrompt });
+}
 function personaOverrideFor(req, staticCompositionHash) {
   if (!hasPersonaOverride(req) || staticCompositionHash === null) return null;
   return { promptHash: staticCompositionHash };
@@ -7556,19 +7818,6 @@ function renderWorkerProjectContext(project, options = {}) {
 function workerProjectContextIncludesVerification(body) {
   return body.includes("\nVerification expectations:\n");
 }
-var PATH_TOKEN_RE = /(?:[\w.-]+\/)+[\w.-]+|\b[\w-]+\.[A-Za-z0-9]{1,8}\b/g;
-function workerWorkingContextPaths(req) {
-  const out = /* @__PURE__ */ new Set();
-  for (const root of req.writeRoots ?? []) out.add(root);
-  const text = `${req.task}
-${req.briefing ?? ""}`;
-  for (const match of text.matchAll(PATH_TOKEN_RE)) {
-    const token = match[0];
-    if (token.startsWith("http://") || token.startsWith("https://")) continue;
-    out.add(token);
-  }
-  return [...out];
-}
 function buildDynamicPromptMessages(req, dynamicContext = {}) {
   const messages = [];
   if (dynamicContext.workspace) {
@@ -7589,6 +7838,10 @@ function buildDynamicPromptMessages(req, dynamicContext = {}) {
     const body = `Safety posture: autonomy ${autonomy}. ${workerSafetyOneLiner(autonomy, permission)} Worker permission routing: ${permission}.`;
     messages.push({ id: "dispatch-safety-posture", body, contentHash: sha2565(body) });
   }
+  const requirements = renderDispatchIntentRequirements(req.intent);
+  if (requirements !== null) {
+    messages.push({ id: "dispatch-intent-requirements", body: requirements, contentHash: sha2565(requirements) });
+  }
   if (req.competeStance !== void 0) {
     const body = competeStanceLiner(req.competeStance);
     messages.push({ id: "dispatch-compete-stance", body, contentHash: sha2565(body) });
@@ -7719,9 +7972,6 @@ function explicitToolCapability(providers, target, wireModelId) {
   const fromKnowledgeBase = hit?.entry.capabilities?.tools;
   return typeof fromKnowledgeBase === "boolean" ? fromKnowledgeBase : null;
 }
-function writeConfinedRequest(req) {
-  return req.writeRoots !== void 0 && req.writeRoots.length > 0;
-}
 function effectiveToolNames(allowedTools, target, writeConfined = false, denied = /* @__PURE__ */ new Set()) {
   if (!targetToolCapability(target)) return [];
   const networkStripped = networkToolsDisabled();
@@ -7866,7 +8116,7 @@ function readWorkerTargets(settings) {
   const targetOrder = settings?.targets?.map((target) => target.id) ?? [];
   return { workerDefault, workerProfiles, agentBindings, targetOrder };
 }
-function resolveDispatchAdmissionStage(req, recipe, safety) {
+function resolveDispatchAdmissionStage(req, recipe, safety, pathScope) {
   const recipeTools = recipe.tools;
   const candidateTools = recipeTools && recipeTools.length > 0 ? Array.from(recipeTools) : [];
   const allowedTools = applyToolProfile(candidateTools, req.toolProfile, { agentId: req.agentId, task: req.task });
@@ -7879,7 +8129,7 @@ function resolveDispatchAdmissionStage(req, recipe, safety) {
   }
   const requestedActions = deriveRequestedActions(allowedTools, safety);
   const orchScope = pickOrchestratorScope(safety);
-  const workerScope = pickWorkerScope(safety, requestedActions);
+  const workerScope = pickWorkerScope(safety, requestedActions, pathScope);
   const verdict = admit(
     {
       requestedScope: workerScope,
@@ -7903,7 +8153,7 @@ function resolveDelegationAdmissionStage(req, safety) {
   const allowedTools = applyToolProfile([], req.toolProfile);
   const requestedActions = deriveRequestedActions(allowedTools, safety);
   const orchScope = pickOrchestratorScope(safety);
-  const workerScope = pickWorkerScope(safety, requestedActions);
+  const workerScope = pickWorkerScope(safety, requestedActions, resolveDispatchPathScope(req));
   const verdict = admit(
     {
       requestedScope: workerScope,
@@ -7970,9 +8220,8 @@ function buildDispatchWorkerSpec(input, config) {
     };
   }
   if (input.req.responseSchema !== void 0) spec.responseSchema = input.req.responseSchema;
-  if (appliesRecipeResultContract(input.req.gate?.role) && input.recipe?.resultContract) {
-    spec.resultContract = input.req.resultContractOverride ?? input.recipe.resultContract;
-  }
+  const workerResultContract = appliesRecipeResultContract(input.req.gate?.role) ? input.req.resultContractOverride ?? input.recipe?.resultContract : void 0;
+  if (workerResultContract) spec.resultContract = workerResultContract;
   const product = input.req.product ?? input.recipe?.product;
   if (product) spec.product = product;
   const resolutionSnapshot = runtimeTargetSnapshot(input.target.runtimeResolution);
@@ -8005,10 +8254,7 @@ function buildDispatchWorkerSpec(input, config) {
     if (escalation) spec.escalation = { timeoutMs: escalation.timeoutMs, fallback: escalation.fallback };
   }
   assertRuntimeCanHonorWorkerPermissionMode(input.target.runtime, spec.onPermission);
-  if (input.req.writeRoots !== void 0 && input.req.writeRoots.length > 0) {
-    const jobCwd = input.req.cwd !== void 0 && input.req.cwd.length > 0 ? input.req.cwd : process.cwd();
-    spec.writeRoots = input.req.writeRoots.map((root) => resolvePath(jobCwd, root));
-  }
+  if (input.pathScope.writeBoundaries.length > 0) spec.writeRoots = [...input.pathScope.writeBoundaries];
   assertWriteRootsEnforceable(input.target.runtime, spec.writeRoots);
   if (input.admission.toolProfile !== void 0) spec.toolProfile = input.admission.toolProfile;
   spec.autonomy = input.effectiveAutonomy;
@@ -8397,18 +8643,28 @@ function createDispatchBundle(context, options) {
     return DEFAULT_RESILIENCE_COOLDOWN_MS;
   };
   const now = options?.now ?? (() => Date.now());
+  const monotonicNow = options?.monotonicNow ?? (() => performance5.now());
   const routeObserver = options?.routeObserver ?? createRouteObserver({});
   let ledger = null;
   let heartbeatTimer = null;
   const active = /* @__PURE__ */ new Map();
   const targetCooldowns = /* @__PURE__ */ new Map();
   const ownedReservations = /* @__PURE__ */ new Set();
+  const runWriteAttributions = /* @__PURE__ */ new Map();
+  const recordRunWriteAttribution = (runId, attribution) => {
+    runWriteAttributions.set(runId, attribution);
+    while (runWriteAttributions.size > RUN_WRITE_TARGET_HISTORY) {
+      const oldest = runWriteAttributions.keys().next();
+      if (oldest.done === true) break;
+      runWriteAttributions.delete(oldest.value);
+    }
+  };
   const capacityAdmission = createCapacityAdmissionController({
     limits: () => {
       const settings = getEffectiveSettings();
       const nodes = { local: configuredGlobalCapacity(settings) };
       for (const node of settings?.fleet?.nodes ?? []) nodes[node.id] = node.maxWorkers;
-      return { global: configuredGlobalCapacity(settings), nodes };
+      return { global: configuredGlobalCapacity(settings), nodes, endpoints: configuredEndpointLimits() };
     },
     now,
     reservedPlanPeak: (planId) => reservedPlanPeakSlots(planId, (error) => reportDispatchDiagnostic("read reserved plan peak", error))
@@ -8419,6 +8675,19 @@ function createDispatchBundle(context, options) {
       onError: (error) => reportDispatchDiagnostic("read capacity lease usage", error)
     })
   );
+  function configuredEndpointLimits() {
+    return Object.fromEntries(
+      Object.entries(endpointCapacitiesForStatuses(providers.list())).map(([key, value]) => [key, value.limit])
+    );
+  }
+  function endpointCapacityForTarget(targetId) {
+    const status = providers.list().find((entry) => entry.target.id === targetId);
+    if (status === void 0) return null;
+    const endpoint = endpointCapacityForStatus(status);
+    if (endpoint === null) return null;
+    const configured = endpointCapacitiesForStatuses(providers.list())[endpoint.key];
+    return configured ?? endpoint;
+  }
   function reservationCapacitySnapshot(settings) {
     const preflight = scheduling.preflight();
     const usage = capacityLeaseUsage();
@@ -8427,9 +8696,21 @@ function createDispatchBundle(context, options) {
     };
     for (const node of settings?.fleet?.nodes ?? [])
       nodes[node.id] = { active: usage.nodes[node.id] ?? 0, limit: node.maxWorkers };
+    const endpoints = Object.fromEntries(
+      Object.entries(configuredEndpointLimits()).map(([key, limit]) => [
+        key,
+        {
+          active: usage.endpoints[key] ?? 0,
+          limit,
+          leases: usage.endpointHolders[key]?.leases ?? 0,
+          foregroundStreams: usage.endpointHolders[key]?.foregroundStreams ?? 0
+        }
+      ])
+    );
     return {
       global: { active: usage.global, limit: configuredGlobalCapacity(settings) },
       nodes,
+      endpoints,
       budget: { currentUsd: preflight.currentUsd, ceilingUsd: preflight.ceilingUsd }
     };
   }
@@ -8440,6 +8721,7 @@ function createDispatchBundle(context, options) {
         memberId: task.memberId,
         wave: task.wave,
         nodeId: task.resolution.node.id,
+        ...task.resolution.endpoint !== void 0 ? { endpointKey: task.resolution.endpoint.key } : {},
         costUpperBoundUsd: task.resolution.routeApproval?.totalCostUpperBoundUsd ?? task.resolution.costUpperBoundUsd
       })),
       capacity: reservationCapacitySnapshot(getEffectiveSettings()),
@@ -8481,7 +8763,7 @@ function createDispatchBundle(context, options) {
     const configured = settings?.budget.concurrency;
     return scheduling.maxWorkers?.() ?? (configured === "auto" || configured === void 0 ? 4 : Math.max(1, configured));
   }
-  async function admitAssignmentCapacity(req, nodeId, timing) {
+  async function admitAssignmentCapacity(req, nodeId, timing, endpoint) {
     const queuedAt = now();
     timing.queuedAt = new Date(queuedAt).toISOString();
     const assignmentId = req.lineage?.rootRunId ?? `pending-${queuedAt.toString(36)}-${randomBytes6(6).toString("hex")}`;
@@ -8497,9 +8779,14 @@ function createDispatchBundle(context, options) {
       const admitted = await capacityAdmission.admit({
         assignmentId,
         nodeId,
+        ...endpoint !== null && endpoint !== void 0 ? { endpointKey: endpoint.key } : {},
         deadlineAt,
         ...plan,
-        ...req.reservation !== void 0 && req.lineage === void 0 ? { reservation: req.reservation } : {}
+        // A fleet's first attempt carries lineage and still owns the held
+        // reservation member that admission must transfer into its lease.
+        // Retries carry the same reservation identity after that member was
+        // consumed, so they reacquire/rebind the assignment lease normally.
+        ...req.reservation !== void 0 && (req.lineage === void 0 || req.lineage.attempt === 0) ? { reservation: req.reservation } : {}
       });
       timing.admittedAt = new Date(admitted.admittedAt).toISOString();
       return admitted.lease;
@@ -8511,12 +8798,13 @@ function createDispatchBundle(context, options) {
       throw error;
     }
   }
-  function rebindReservationSlot(req, nodeId, costUsd, settings) {
+  function rebindReservationSlot(req, nodeId, endpoint, costUsd, settings) {
     if (req.reservation === void 0 || req.lineage === void 0) return;
     const capacity = reservationCapacitySnapshot(settings);
     const rebind = {
       ...req.reservation,
       nodeId,
+      ...endpoint !== null ? { endpointKey: endpoint.key } : {},
       costUpperBoundUsd: req.routeApproval?.totalCostUpperBoundUsd ?? costUsd,
       capacity,
       nowMs: now()
@@ -8583,10 +8871,23 @@ function createDispatchBundle(context, options) {
     persistAssignment(settleStoredAssignment(rootRunId, attemptRunId, "failed"), `${rootRunId}:finalize-error`);
     capacityAdmission.releaseAssignment(rootRunId);
   }
+  function retryChainIsLive(run) {
+    if (run.aborted) return false;
+    const reservation = run.req.reservation;
+    if (reservation === void 0) return assignments.get(run.lineage.rootRunId)?.status === "running";
+    try {
+      const record = getDispatchReservation(reservation.ownerId);
+      const member = record?.members.find((entry) => entry.memberId === reservation.memberId);
+      return record?.status === "active" && member !== void 0 && member.status !== "released";
+    } catch (error) {
+      reportDispatchDiagnostic(`read retry liveness for reservation member ${reservation.memberId}`, error);
+      return false;
+    }
+  }
   function maybeScheduleRetry(run, outcome, detail, receipt, failureClass) {
     if (draining) return { scheduled: false };
     const rootRunId = run.lineage.rootRunId;
-    if (assignments.get(rootRunId)?.status !== "running") return { scheduled: false };
+    if (!retryChainIsLive(run)) return { scheduled: false };
     if (!RETRYABLE_OUTCOMES.has(outcome)) {
       retryBackoff.delete(rootRunId);
       return { scheduled: false };
@@ -8695,7 +8996,7 @@ function createDispatchBundle(context, options) {
     });
   }
   async function executeRetry(run, attempt, reason = "retry", decision = decideRetry("internal", run.lineage.attempt, assignmentPolicyFor(run.req).maxRetries)) {
-    if (draining || assignments.get(run.lineage.rootRunId)?.status !== "running") return;
+    if (draining || !retryChainIsLive(run)) return;
     const excludesNode = decision.excludedRouteParts.includes("node");
     const rerouteHops = excludesNode && run.node !== null ? [...run.req.reroutes ?? [], { attempt, fromNode: run.node.id, toNode: "", reason }] : run.req.reroutes;
     const retryReq = {
@@ -8851,8 +9152,8 @@ function createDispatchBundle(context, options) {
       fleetRegistry.recordChannelSuccess(run.node.id);
     }
   }
-  function heartbeatIso(heartbeatMs) {
-    return new Date(heartbeatMs).toISOString();
+  function heartbeatIso(heartbeat) {
+    return new Date(heartbeat.current).toISOString();
   }
   function heartbeatRunStatus(status) {
     return status === "alive" ? "running" : status;
@@ -8871,22 +9172,22 @@ function createDispatchBundle(context, options) {
       event: {
         type: "heartbeat_status",
         status,
-        heartbeatAt: run.heartbeatAt ? heartbeatIso(run.heartbeatAt.current) : null
+        heartbeatAt: run.heartbeatAt ? heartbeatIso(run.heartbeatAt) : null
       }
     });
   }
   function checkActiveHeartbeats() {
     if (!ledger) return;
-    const tickNow = now();
+    const tickMonotonic = monotonicNow();
     for (const run of active.values()) {
       if (run.aborted || run.stallKilled || !run.heartbeatAt) continue;
-      const heartbeatMs = run.heartbeatAt.current;
-      if (!Number.isFinite(heartbeatMs)) continue;
+      const heartbeatMonotonic = heartbeatMonotonicAt(run.heartbeatAt);
+      if (!Number.isFinite(heartbeatMonotonic) || !Number.isFinite(run.heartbeatAt.current)) continue;
       if (run.runtimeKind === "acp-delegation") {
-        ledger.update(run.runId, { heartbeatAt: heartbeatIso(heartbeatMs) });
+        ledger.update(run.runId, { heartbeatAt: heartbeatIso(run.heartbeatAt) });
         const stallMs = run.stallTimeoutMs;
         if (stallMs === null || stallMs <= 0) continue;
-        if (tickNow - heartbeatMs <= stallMs) continue;
+        if (tickMonotonic - heartbeatMonotonic <= stallMs) continue;
         run.stallKilled = true;
         run.heartbeatStatus = "dead";
         emitHeartbeatStatus(run, "dead");
@@ -8896,10 +9197,10 @@ function createDispatchBundle(context, options) {
         }
         continue;
       }
-      const status = classifyHeartbeat(heartbeatMs, tickNow, heartbeatSpec);
+      const status = classifyHeartbeat(heartbeatMonotonic, tickMonotonic, heartbeatSpec);
       const patch = {
         status: heartbeatRunStatus(status),
-        heartbeatAt: heartbeatIso(heartbeatMs)
+        heartbeatAt: heartbeatIso(run.heartbeatAt)
       };
       ledger.update(run.runId, patch);
       if (status === "alive" && run.node !== null && run.node.kind === "ssh") {
@@ -9005,6 +9306,19 @@ function createDispatchBundle(context, options) {
     if (cooldownMs <= 0) return;
     targetCooldowns.set(key, { until: now() + cooldownMs, reason: failureClass });
   }
+  function publishDispatchPathScope(req, pathScope) {
+    const replacementDiagnostic = declaredScopeReplacementDiagnostic(pathScope);
+    if (replacementDiagnostic !== null) {
+      reportDispatchDiagnostic("typed scope replacement", new Error(replacementDiagnostic));
+    }
+    const notice = declaredScopeReplacementNotice(pathScope);
+    if (notice !== null) {
+      context.bus.emit(BusChannels.DispatchScopeNotice, {
+        ...notice,
+        agentId: req.agentId
+      });
+    }
+  }
   async function resolveLifecycle(req, settings) {
     const recipe = agents.get(req.agentId);
     if (!recipe) {
@@ -9016,7 +9330,7 @@ function createDispatchBundle(context, options) {
         `dispatch: agent '${req.agentId}' is a ${spec.audience} agent reserved for Clio internal orchestration`
       );
     }
-    if (hasPersonaOverride(req) && (spec.audience === "shadow" || spec.audience === "internal")) {
+    if (hasCallerPersonaOverride(req) && (spec.audience === "shadow" || spec.audience === "internal")) {
       throw new Error(`dispatch: persona overrides are not allowed for ${spec.audience} agent '${req.agentId}'`);
     }
     const capabilityMismatch = req.gate !== void 0 ? null : assessCapabilityMismatch({
@@ -9028,7 +9342,9 @@ function createDispatchBundle(context, options) {
       specs: agents.listSpecs()
     });
     if (capabilityMismatch?.verdict === "refuse") throw new Error(capabilityMismatch.detail);
-    const admission = resolveDispatchAdmissionStage(req, recipe, safety);
+    const pathScope = resolveDispatchPathScope(req);
+    publishDispatchPathScope(req, pathScope);
+    const admission = resolveDispatchAdmissionStage(req, recipe, safety, pathScope);
     const targets = readWorkerTargets(settings);
     const target = resolveDispatchTarget(
       req,
@@ -9046,7 +9362,7 @@ function createDispatchBundle(context, options) {
     const sessionAutonomy = settings?.autonomy ?? "auto-edit";
     const effectiveAutonomy = clampWorkerAutonomy(sessionAutonomy, req.autonomy);
     const effectiveTools = withLedgerToolNarrowing(
-      effectiveToolNames(admission.allowedTools, target, writeConfinedRequest(req), deniedToolNames(req)),
+      effectiveToolNames(admission.allowedTools, target, pathScope.writeBoundaries.length > 0, deniedToolNames(req)),
       req
     );
     assertPostRuntimeToolCompatibility(req.agentId, spec, effectiveTools, target);
@@ -9071,7 +9387,7 @@ function createDispatchBundle(context, options) {
         dynamic: false
       },
       cwd,
-      workingContextPaths: workerWorkingContextPaths(req)
+      workingContextPaths: pathScope.workingContextPaths
     });
     const systemPrompt = compiledWorkerPrompt.systemPrompt;
     const budgetEnvelope = resolveEffectiveWorkerBudget({
@@ -9105,6 +9421,7 @@ function createDispatchBundle(context, options) {
     const limitations = runtimeLimitations(runtimeKind, target.runtime.id);
     return {
       recipe,
+      pathScope,
       admission: effectiveAdmission,
       target,
       cwd,
@@ -9138,12 +9455,7 @@ function createDispatchBundle(context, options) {
   function resolveAcpDelegationLifecycle(req, settings) {
     const agentId = req.delegationAgentId;
     if (!agentId) throw new Error("dispatch: missing delegationAgentId");
-    const boundedGateRolePrompt = isBoundedGateRolePrompt({
-      role: req.gate?.role,
-      autonomy: req.autonomy,
-      systemPrompt: req.systemPrompt
-    });
-    if (hasPersonaOverride(req) && !boundedGateRolePrompt) {
+    if (hasCallerPersonaOverride(req)) {
       throw new Error(`dispatch: persona overrides are not allowed for ACP delegation agent '${agentId}'`);
     }
     if (req.agentId && maybeAgents) {
@@ -9172,6 +9484,7 @@ function createDispatchBundle(context, options) {
       );
     }
     const cwd = req.cwd ?? process.cwd();
+    const pathScope = resolveDispatchPathScope(req);
     const personaBody = workerPersonaBody(req, null, []);
     const systemPrompt = personaBody;
     const tier = configured.projectContext ?? "none";
@@ -9191,6 +9504,7 @@ function createDispatchBundle(context, options) {
     const personaOverride = personaOverrideFor(req, staticCompositionHash);
     return {
       admission,
+      pathScope,
       agentConfig: configured,
       cwd,
       systemPrompt,
@@ -9215,13 +9529,14 @@ function createDispatchBundle(context, options) {
   }
   async function dispatchAcpDelegation(req, settings, timing, routeDecision, observer) {
     const lifecycle = resolveAcpDelegationLifecycle(req, settings);
+    publishDispatchPathScope(req, lifecycle.pathScope);
     timing.decisionCompletedAt = new Date(now()).toISOString();
     const targetId = `delegation:${lifecycle.agentConfig.id}`;
     const runtimeId = "acp";
     const wireModelId = lifecycle.agentConfig.id;
     assertTargetNotCoolingDown(req, targetId, runtimeId, wireModelId);
     assertBudgetAdmitsRoute(req, { rates: null, provenance: "unknown" }, settings);
-    const capacityLease = await admitAssignmentCapacity(req, "local", timing);
+    const capacityLease = await admitAssignmentCapacity(req, "local", timing, null);
     const leaseSlot = createLeaseSlotGuard(capacityAdmission, capacityLease.leaseId, req.lineage !== void 0);
     const ledgerRef = (() => {
       try {
@@ -9243,7 +9558,9 @@ function createDispatchBundle(context, options) {
         cwd: lifecycle.cwd,
         safety,
         autonomy: lifecycle.autonomy,
-        clientVersion: readClioVersion()
+        clientVersion: readClioVersion(),
+        now,
+        monotonicNow
       });
     } catch (error) {
       leaseSlot.release();
@@ -9396,7 +9713,7 @@ function createDispatchBundle(context, options) {
       ledgerRef.update(envelope.id, {
         status: "running",
         pid: acp.pid,
-        heartbeatAt: heartbeatIso(acp.heartbeatAt.current),
+        heartbeatAt: heartbeatIso(acp.heartbeatAt),
         lineage,
         identity,
         node: LOCAL_RUN_NODE,
@@ -9526,6 +9843,7 @@ function createDispatchBundle(context, options) {
         requestOrigin: lifecycle.requestOrigin,
         task: req.task,
         ...req.intent !== void 0 ? { intent: structuredClone(req.intent) } : {},
+        pathScope: structuredClone(lifecycle.pathScope.provenance),
         targetId,
         wireModelId,
         runtimeId,
@@ -9755,7 +10073,7 @@ function createDispatchBundle(context, options) {
           cacheReadTokenCount: receiptDraft.cacheReadTokenCount ?? 0,
           cacheWriteTokenCount: receiptDraft.cacheWriteTokenCount ?? 0,
           reasoningTokenCount: receiptDraft.reasoningTokenCount ?? 0,
-          heartbeatAt: heartbeatIso(acp.heartbeatAt.current)
+          heartbeatAt: heartbeatIso(acp.heartbeatAt)
         };
         ledgerRef.update(envelope.id, ledgerPatch);
         const receipt = ledgerRef.recordReceipt(envelope.id, sealRouteDecision(receiptDraft, routeDecision));
@@ -9892,7 +10210,7 @@ function createDispatchBundle(context, options) {
           "dispatch: writeRoots cannot be enforced on an ACP delegation target; the external agent runs its own tool surface. Dispatch to a native or claude-sdk worker."
         );
       }
-      rebindReservationSlot(req, "local", UNKNOWN_PRICING_ADMISSION_ESTIMATE_USD, settings);
+      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),
@@ -9923,10 +10241,12 @@ function createDispatchBundle(context, options) {
       model: lifecycle.target.wireModelId,
       node: placement?.node?.id ?? "local"
     };
+    const endpoint = endpointCapacityForTarget(lifecycle.target.target.id);
     assertRouteWithinApprovedEnvelope(req, effectiveRoute);
     rebindReservationSlot(
       req,
       effectiveRoute.node,
+      endpoint,
       conservativeRouteAdmissionEstimateUsd(lifecycle.target.effectivePricing, admissionMaxOutputTokens(settings)),
       settings
     );
@@ -9944,7 +10264,7 @@ function createDispatchBundle(context, options) {
       },
       shadow: () => observeShadowRoute(req, placed, settings)
     });
-    const capacityLease = await admitAssignmentCapacity(req, placement?.node.id ?? "local", timing);
+    const capacityLease = await admitAssignmentCapacity(req, placement?.node.id ?? "local", timing, endpoint);
     const leaseSlot = createLeaseSlotGuard(capacityAdmission, capacityLease.leaseId, req.lineage !== void 0);
     const ledgerRef = (() => {
       try {
@@ -9961,6 +10281,7 @@ function createDispatchBundle(context, options) {
     const spec = buildDispatchWorkerSpec(
       {
         req,
+        pathScope: lifecycle.pathScope,
         target: lifecycle.target,
         admission: lifecycle.admission,
         recipe: lifecycle.recipe,
@@ -10001,6 +10322,8 @@ function createDispatchBundle(context, options) {
     try {
       worker = (placement?.spawn ?? spawnWorker)(spec, {
         cwd: lifecycle.cwd,
+        now,
+        monotonicNow,
         ...agentLedgerId !== null ? { onLedgerPost } : {}
       });
     } catch (error) {
@@ -10050,7 +10373,18 @@ function createDispatchBundle(context, options) {
     const upstreamResponses = [];
     const skillActivations = [];
     const finishContractEntries = [];
-    const runEffects = createRunEffectsRecorder(lifecycle.cwd);
+    let runIdForPermissionAudit = null;
+    const runEffects = createRunEffectsRecorder(lifecycle.cwd, {
+      onWriteRecordDowngraded(downgrade) {
+        const runId = runIdForPermissionAudit;
+        if (runId === null) return;
+        context.bus.emit(BusChannels.DispatchProgress, {
+          runId,
+          agentId: req.agentId,
+          event: { type: "clio_write_record_downgraded", payload: downgrade }
+        });
+      }
+    });
     let finishContractAssistantText = "";
     let finishContractAssistantTurnId = null;
     let failureMessage;
@@ -10058,7 +10392,6 @@ function createDispatchBundle(context, options) {
     const trustedOutcomeCodes = /* @__PURE__ */ new Set();
     let reportedUntrustedOutcome = false;
     const acceptsOutcomeCodeEvents = lifecycle.runtimeKind === "http" || lifecycle.runtimeKind === "sdk" && lifecycle.target.runtime.id === "claude-sdk";
-    let runIdForPermissionAudit = null;
     let workerPolicyPermissionCounter = 0;
     const outputCapture = createWorkerOutputCapture();
     const markObservedPhase = (field) => {
@@ -10271,7 +10604,7 @@ function createDispatchBundle(context, options) {
         ...req.council !== void 0 ? { council: req.council } : {},
         ...req.plan !== void 0 ? { plan: req.plan } : {},
         ...lifecycle.personaOverride ? { personaOverride: lifecycle.personaOverride } : {},
-        ...heartbeatAt ? { heartbeatAt: heartbeatIso(heartbeatAt.current) } : {}
+        ...heartbeatAt ? { heartbeatAt: heartbeatIso(heartbeatAt) } : {}
       });
       observer?.onAdmitted({
         runId: envelope.id,
@@ -10281,6 +10614,7 @@ function createDispatchBundle(context, options) {
       await ledgerRef.persist();
       const fleetIdentity = {
         budget: lifecycle.budgetEnvelope,
+        ...endpoint !== null ? { endpoint: { key: endpoint.key, label: endpoint.label, limit: endpoint.limit } } : {},
         ...placement !== void 0 && placement !== null ? { node: placement.node.id } : {},
         ...req.gate !== void 0 ? { gate: { role: req.gate.role, cycle: req.gate.cycle } } : {},
         ...req.council !== void 0 ? { council: req.council } : {},
@@ -10404,9 +10738,9 @@ function createDispatchBundle(context, options) {
         if (req.fleetGateReceipt === void 0) return null;
         try {
           const content = readFileSync12(resolvePath(lifecycle.cwd, req.fleetGateReceipt.path));
-          return { path: req.fleetGateReceipt.path, pathHash: createHash9("sha256").update(content).digest("hex") };
+          return { path: req.fleetGateReceipt.path, pathHash: createHash8("sha256").update(content).digest("hex") };
         } catch {
-          return { path: req.fleetGateReceipt.path, pathHash: createHash9("sha256").update("").digest("hex") };
+          return { path: req.fleetGateReceipt.path, pathHash: createHash8("sha256").update("").digest("hex") };
         }
       })();
       const ledgerContribution = (() => {
@@ -10435,6 +10769,7 @@ function createDispatchBundle(context, options) {
         outcomeCode,
         lineage,
         ...req.intent !== void 0 ? { intent: structuredClone(req.intent) } : {},
+        pathScope: structuredClone(lifecycle.pathScope.provenance),
         identity,
         node: placement?.node ?? LOCAL_RUN_NODE,
         ...receiptAttestationFields(worker.attestation?.() ?? null),
@@ -10762,13 +11097,35 @@ function createDispatchBundle(context, options) {
           dynamicHash: receiptDraft.dynamicHash ?? null,
           ...receiptDraft.cacheReadTokenCount !== void 0 ? { cacheReadTokenCount: receiptDraft.cacheReadTokenCount } : {},
           ...receiptDraft.cacheWriteTokenCount !== void 0 ? { cacheWriteTokenCount: receiptDraft.cacheWriteTokenCount } : {},
-          ...activeRun.heartbeatAt ? { heartbeatAt: heartbeatIso(activeRun.heartbeatAt.current) } : {}
+          ...activeRun.heartbeatAt ? { heartbeatAt: heartbeatIso(activeRun.heartbeatAt) } : {}
         };
         if (receiptDraft.reasoningTokenCount !== void 0) {
           ledgerPatch.reasoningTokenCount = receiptDraft.reasoningTokenCount;
         }
         ledgerRef.update(envelope.id, ledgerPatch);
         const receipt = ledgerRef.recordReceipt(envelope.id, sealRouteDecision(receiptDraft, routeObservation.decision));
+        const toolTelemetryComplete = receipt.safety?.toolTelemetry?.coverage === "complete";
+        const downgrades = observedRunEffects.writeRecordDowngrades.map((entry) => ({
+          reason: entry.reason,
+          tool: entry.tool,
+          toolCallId: entry.toolCallId,
+          runId: envelope.id,
+          stepId: null
+        }));
+        if (!toolTelemetryComplete) {
+          downgrades.push({
+            reason: "incomplete_tool_telemetry",
+            tool: null,
+            toolCallId: null,
+            runId: envelope.id,
+            stepId: null
+          });
+        }
+        recordRunWriteAttribution(envelope.id, {
+          recorded: [...observedRunEffects.mutatedPaths],
+          complete: toolTelemetryComplete && observedRunEffects.writeRecordComplete,
+          downgrades
+        });
         await ledgerRef.persist();
         if (worktreeReceipt?.applied === true && req.taskWorktree !== void 0) {
           try {
@@ -10972,10 +11329,11 @@ function createDispatchBundle(context, options) {
         `dispatch: agent '${req.agentId}' is a ${agentSpec.audience} agent reserved for Clio internal orchestration`
       );
     }
-    if (hasPersonaOverride(req) && (agentSpec.audience === "shadow" || agentSpec.audience === "internal")) {
+    if (hasCallerPersonaOverride(req) && (agentSpec.audience === "shadow" || agentSpec.audience === "internal")) {
       throw new Error(`dispatch: persona overrides are not allowed for ${agentSpec.audience} agent '${req.agentId}'`);
     }
-    const admission = resolveDispatchAdmissionStage(req, recipe, safety);
+    const pathScope = resolveDispatchPathScope(req);
+    const admission = resolveDispatchAdmissionStage(req, recipe, safety, pathScope);
     const targets = readWorkerTargets(settings);
     const target = resolveDispatchTarget(
       req,
@@ -10988,14 +11346,14 @@ function createDispatchBundle(context, options) {
     );
     enforceCapabilityGate(target.target.id, target.modelCapabilities, req.requiredCapabilities);
     const effectiveTools = withLedgerToolNarrowing(
-      effectiveToolNames(admission.allowedTools, target, writeConfinedRequest(req), deniedToolNames(req)),
+      effectiveToolNames(admission.allowedTools, target, pathScope.writeBoundaries.length > 0, deniedToolNames(req)),
       req
     );
     assertPostRuntimeToolCompatibility(req.agentId, agentSpec, effectiveTools, target);
     assertRuntimeCanHonorWorkerPermissionMode(target.runtime, settings?.workers.onPermission ?? "deny");
     assertWorkerBudgetEnforceable(target.runtime, agentSpec.budget !== null || req.budget !== void 0);
     assertResponseSchemaEnforceable(target.runtime, target.modelCapabilities, req.responseSchema, effectiveTools.length);
-    assertWriteRootsEnforceable(target.runtime, req.writeRoots);
+    assertWriteRootsEnforceable(target.runtime, pathScope.writeBoundaries);
     assertProtectedArtifactsEnforceable(
       target.runtime.id,
       target.runtime.kind !== "subprocess",
@@ -11008,12 +11366,14 @@ function createDispatchBundle(context, options) {
       allowedTools: effectiveTools,
       settings
     });
+    const endpoint = endpointCapacityForTarget(target.target.id);
     return {
       agentId: req.agentId,
       specFingerprint: agentSpecFingerprint(agentSpec),
       targetId: target.target.id,
       wireModelId: target.wireModelId,
       runtimeId: target.runtime.id,
+      ...endpoint !== null ? { endpoint: { key: endpoint.key, label: endpoint.label, limit: endpoint.limit } } : {},
       node: previewNode(req).node,
       thinkingLevel: target.thinkingLevel,
       toolSignature: toolSignature(effectiveTools),
@@ -11376,6 +11736,7 @@ function createDispatchBundle(context, options) {
         const reconciledLedger = ledger;
         const reconciled = await reconcileOrphanAssignments({
           listRunning: () => listStoredAssignments().filter((record) => record.status === "running"),
+          ownerAlive: assignmentProcessOwnerAlive,
           lookupAttempt: (runId) => {
             const envelope = reconciledLedger?.get(runId) ?? null;
             if (!envelope) return null;
@@ -11385,7 +11746,7 @@ function createDispatchBundle(context, options) {
               succeeded: envelope.outcome === "succeeded"
             };
           },
-          settle: (assignmentId, terminalRunId, status) => settleStoredAssignment(assignmentId, terminalRunId, status)
+          settle: (assignmentId, terminalRunId, status, owner) => settleStoredAssignment(assignmentId, terminalRunId, status, owner)
         });
         if ((reconciled.recovered > 0 || reconciled.abandoned > 0) && process.env.CLIO_CODER_INTERACTIVE !== "1") {
           process.stderr.write(
@@ -11423,19 +11784,21 @@ function createDispatchBundle(context, options) {
   }
   function snapshot() {
     const tickNow = now();
+    const tickMonotonic = monotonicNow();
     const running = [];
     const totals = { ...finalizedTotals };
     const costAmounts = [...finalizedCosts];
     for (const run of active.values()) {
       let heartbeat = "n/a";
-      if (run.heartbeatAt && Number.isFinite(run.heartbeatAt.current)) {
+      if (run.heartbeatAt && Number.isFinite(heartbeatMonotonicAt(run.heartbeatAt))) {
+        const heartbeatMonotonic = heartbeatMonotonicAt(run.heartbeatAt);
         if (run.runtimeKind === "acp-delegation") {
           const stallMs = run.stallTimeoutMs;
           if (stallMs !== null && stallMs > 0) {
-            heartbeat = tickNow - run.heartbeatAt.current > stallMs ? "dead" : "alive";
+            heartbeat = tickMonotonic - heartbeatMonotonic > stallMs ? "dead" : "alive";
           }
         } else {
-          heartbeat = classifyHeartbeat(run.heartbeatAt.current, tickNow, heartbeatSpec);
+          heartbeat = classifyHeartbeat(heartbeatMonotonic, tickMonotonic, heartbeatSpec);
         }
       }
       const meter = run.meter;
@@ -11549,6 +11912,7 @@ function createDispatchBundle(context, options) {
     routeCandidates,
     reservations: {
       prepare: prepareReservation,
+      release: (ownerId) => releaseDispatchReservation(ownerId, now()),
       rollback: (ownerId) => rollbackDispatchReservation(ownerId, now()),
       rollbackUnconsumed: (ownerId) => rollbackUnconsumedDispatchReservation(ownerId, now()),
       get: getDispatchReservation
@@ -11566,6 +11930,19 @@ function createDispatchBundle(context, options) {
       if (!ledger) return null;
       return ledger.get(runId);
     },
+    observedRunWrites(runId) {
+      const attribution = runWriteAttributions.get(runId);
+      return attribution?.complete === true ? [...attribution.recorded] : null;
+    },
+    observedRunWriteAttribution(runId) {
+      const attribution = runWriteAttributions.get(runId);
+      if (attribution === void 0) return null;
+      return {
+        recorded: [...attribution.recorded],
+        complete: attribution.complete,
+        downgrades: attribution.downgrades?.map((entry) => ({ ...entry })) ?? []
+      };
+    },
     assignments: {
       get: (id) => assignments.get(id),
       getStored: (id) => getStoredAssignment(id),
@@ -11691,7 +12068,7 @@ async function writeCodeStepRecord(rootId, record) {
 
 // src/domains/dispatch/delegation-plan.ts
 init_esm_shims();
-import { createHash as createHash10 } from "node:crypto";
+import { createHash as createHash9 } from "node:crypto";
 var DELEGATION_PROPOSAL_BRIEFING_MAX_BYTES = 12e3;
 function buildDelegationProposalBriefing(proposals) {
   const value = proposals.map((proposal) => `PROPOSAL ${proposal.agent}
@@ -11708,9 +12085,6 @@ ${proposal.output}`).join("\n\n");
   return `${source.subarray(0, end).toString("utf8")}${suffix}`;
 }
 var ID_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/u;
-function insideBoundary(path2, boundary) {
-  return boundary.some((root) => root.endsWith("/") ? path2.startsWith(root) : path2 === root);
-}
 function malformed(detail) {
   return { ok: false, reason: "delegation_plan_malformed", detail };
 }
@@ -11755,7 +12129,7 @@ function validateDelegationPlan(input) {
     } catch (error) {
       return malformed(`task '${task.id}' has invalid writes: ${error instanceof Error ? error.message : String(error)}`);
     }
-    const outside = writes.find((path2) => !insideBoundary(path2, input.writes));
+    const outside = writes.find((path2) => !pathBoundaryCovers(input.writes, path2));
     if (outside !== void 0) {
       return {
         ok: false,
@@ -11802,7 +12176,7 @@ function validateDelegationPlan(input) {
     }
   }
   const plan = { tasks };
-  return { ok: true, plan, hash: createHash10("sha256").update(JSON.stringify(plan)).digest("hex") };
+  return { ok: true, plan, hash: createHash9("sha256").update(JSON.stringify(plan)).digest("hex") };
 }
 
 // src/domains/dispatch/execution-scheduler.ts
@@ -12230,7 +12604,7 @@ function gateFailureLines(output) {
 
 // src/domains/dispatch/fleet-run.ts
 init_esm_shims();
-import { createHash as createHash11 } from "node:crypto";
+import { createHash as createHash10 } from "node:crypto";
 import { readFileSync as readFileSync13 } from "node:fs";
 import { join as join15 } from "node:path";
 
@@ -12347,13 +12721,47 @@ async function executeFleetRun(input) {
     dynamicPlans: []
   };
   await writeFleetRun(fleetRunRecord);
+  await claimAssignmentVerdict(fleetRootId, "fleet");
+  const fileStepAttempt = (terminalRunId) => recordAssignmentAttempt(fleetRootId, terminalRunId);
+  const settleFleetAssignment = (cleanRun2) => settleStoredAssignment(
+    fleetRootId,
+    fleetRunRecord.steps.at(-1)?.result.terminalRunId ?? fleetRootId,
+    cleanRun2 ? "succeeded" : "failed",
+    "fleet"
+  ).catch(() => void 0);
   const boundaryEnforcer = createWriteBoundaryEnforcer({
     root: workspaceRoot,
     rootId: fleetRootId,
     boundaryFor: (stepId) => livePlan.steps.find((step) => step.id === stepId)?.writes,
+    recordedWritesFor: (stepId) => {
+      const step = livePlan.steps.find((entry) => entry.id === stepId);
+      if (step === void 0) return null;
+      if (step.kind !== "agent") {
+        return {
+          recorded: [],
+          complete: false,
+          downgrades: [
+            {
+              reason: "code_step_untracked",
+              tool: null,
+              toolCallId: null,
+              runId: null,
+              stepId
+            }
+          ]
+        };
+      }
+      const receipt = receiptsByStep.get(stepId);
+      if (receipt === void 0) return null;
+      if (dispatch.observedRunWriteAttribution !== void 0) {
+        return dispatch.observedRunWriteAttribution(receipt.runId);
+      }
+      const recorded = dispatch.observedRunWrites?.(receipt.runId) ?? null;
+      return recorded === null ? null : { recorded, complete: true, downgrades: [] };
+    },
     onVerdict(verdict, path2) {
-      if (verdict.reason === null) return;
-      notice(`write boundary ${verdict.window}: ${verdict.detail ?? verdict.reason} record=${path2}`, "write-boundary");
+      if (verdict.detail === null) return;
+      notice(`write boundary ${verdict.window}: ${verdict.detail} record=${path2}`, "write-boundary");
     }
   });
   const receipts = [];
@@ -12384,6 +12792,7 @@ async function executeFleetRun(input) {
       costUsd: receiptsByStep.get(stepId)?.costUsd ?? 0,
       result: replayedResult
     });
+    await fileStepAttempt(replayedResult.terminalRunId);
   }
   const planStep = (stepId) => livePlan.steps.find((entry) => entry.id === stepId);
   let validationFresh = false;
@@ -12546,7 +12955,7 @@ async function executeFleetRun(input) {
               } catch {
                 gateBytes = "";
               }
-              gatePathHash = createHash11("sha256").update(gateBytes).digest("hex");
+              gatePathHash = createHash10("sha256").update(gateBytes).digest("hex");
               const command = input.commands?.commands.get(step.gate.commandId);
               if (gateBytes.length === 0 || command === void 0) {
                 stepSucceeded = false;
@@ -12719,7 +13128,7 @@ async function executeFleetRun(input) {
       cancel: (assignmentId) => dispatch.abort(assignmentId),
       release: (ownerId) => {
         if (ownerId === NO_WORKER_RESERVATION) return;
-        dispatch.reservations?.rollbackUnconsumed(ownerId);
+        dispatch.reservations?.release(ownerId);
       },
       releaseUnconsumed: (ownerId) => {
         if (ownerId === NO_WORKER_RESERVATION) return;
@@ -12728,6 +13137,7 @@ async function executeFleetRun(input) {
       onStepSettled: async (step, stepResult) => {
         fleetRunRecord.steps.push({ stepId: step.id, result: stepResult });
         await writeFleetRun(fleetRunRecord);
+        await fileStepAttempt(stepResult.terminalRunId);
       },
       spliceAfter(currentPlan, step, stepResult) {
         if (stepResult.delegationPlan === void 0) return null;
@@ -12767,6 +13177,7 @@ async function executeFleetRun(input) {
   } catch (error) {
     fleetRunRecord.endedAt = (/* @__PURE__ */ new Date()).toISOString();
     await writeFleetRun(fleetRunRecord);
+    await settleFleetAssignment(false);
     throw error;
   }
   fleetRunRecord.endedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -12774,6 +13185,8 @@ async function executeFleetRun(input) {
   const required = livePlan.steps.filter((step) => step.loop === void 0 && !result.unneeded.includes(step.id));
   const failedLoops = result.loops.filter((loop) => !loop.resolved);
   const succeededStepCount = required.filter((step) => result.results.get(step.id)?.succeeded === true).length;
+  const cleanRun = failedLoops.length === 0 && result.skipped.length === 0 && succeededStepCount === required.length;
+  await settleFleetAssignment(cleanRun);
   return {
     rootId: fleetRootId,
     planHash: input.plan.hash,
@@ -12783,7 +13196,7 @@ async function executeFleetRun(input) {
     requiredStepCount: required.length,
     succeededStepCount,
     resolvedLoopCount: result.loops.length - failedLoops.length,
-    cleanRun: failedLoops.length === 0 && result.skipped.length === 0 && succeededStepCount === required.length
+    cleanRun
   };
 }
 
@@ -12828,6 +13241,36 @@ function attributeEvidenceFailure(facts) {
   return "unknown";
 }
 
+// src/domains/evidence/findings-markdown.ts
+init_esm_shims();
+function renderEvidenceFindingsMarkdown(findings, trustStatus) {
+  const lines = ["# Findings", "", "## Canonical trust", ""];
+  if (trustStatus.runs.length === 0) {
+    lines.push("No linked run trust status.");
+  } else {
+    for (const run of trustStatus.runs) {
+      lines.push(
+        `- run=${run.runId}`,
+        `  tier: ${trustVerdict(run.status)}`,
+        `  summary: ${formatTrustSummary(run.status)}`,
+        `  axes: ${formatTrustAxes(run.status)}`
+      );
+    }
+  }
+  lines.push("", "## Finding records", "");
+  if (findings.length === 0) {
+    lines.push("No findings.");
+  } else {
+    for (const item of findings) {
+      const run = item.runId === null ? "" : ` run=${item.runId}`;
+      lines.push(`- ${item.id} [${item.severity}] ${item.tag}${run}: ${item.message}`);
+    }
+  }
+  lines.push("");
+  return `${lines.join("\n")}
+`;
+}
+
 // src/domains/evidence/provenance.ts
 init_esm_shims();
 var PERSONA_HASH_PREFIX_CHARS = 12;
@@ -12840,6 +13283,19 @@ function extractRunProvenance(receipt) {
   if (receipt.autonomyEnforcement !== void 0) view.autonomyEnforcement = receipt.autonomyEnforcement;
   return view;
 }
+function admitRunProvenance(view, status) {
+  const admitted = {};
+  if (status === void 0 || status.artifactIntegrity.state === "verified") {
+    if (view.pipeline !== void 0) admitted.pipeline = view.pipeline;
+    if (view.personaOverride !== void 0) admitted.personaOverride = view.personaOverride;
+    if (view.escalation !== void 0) admitted.escalation = view.escalation;
+  }
+  const autonomy = status?.autonomyEnforcement.state;
+  if (view.autonomyEnforcement !== void 0 && (autonomy === "enforced" || autonomy === "approximated" || autonomy === "bypassed")) {
+    admitted.autonomyEnforcement = view.autonomyEnforcement;
+  }
+  return admitted;
+}
 function hasRunProvenance(view) {
   return view.pipeline !== void 0 || view.personaOverride !== void 0 || view.escalation !== void 0 || view.autonomyEnforcement !== void 0;
 }
@@ -12910,13 +13366,14 @@ function formatPersonaHashPrefix(promptHash2) {
   if (promptHash2.length <= PERSONA_HASH_PREFIX_CHARS) return promptHash2;
   return `${promptHash2.slice(0, PERSONA_HASH_PREFIX_CHARS)}...`;
 }
-function provenanceTranscriptLines(view) {
+function provenanceTranscriptLines(source, status) {
+  const view = admitRunProvenance(source, status);
   const lines = [];
   if (view.pipeline !== void 0) {
     const { fromRunId, position, inputBytes, inputTruncated } = view.pipeline;
-    const source = fromRunId ?? "unknown";
+    const source2 = fromRunId ?? "unknown";
     const truncation = inputTruncated ? "input truncated" : "not truncated";
-    lines.push(`pipeline: step ${position}, input ${inputBytes} bytes from ${source} (${truncation})`);
+    lines.push(`pipeline: step ${position}, input ${inputBytes} bytes from ${source2} (${truncation})`);
   }
   if (view.personaOverride !== void 0) {
     lines.push(`persona override: prompt hash ${formatPersonaHashPrefix(view.personaOverride.promptHash)}`);
@@ -12926,14 +13383,15 @@ function provenanceTranscriptLines(view) {
     lines.push(`escalations: ${requested} requested, ${approved} approved, ${denied} denied, ${timedOut} timed out`);
   }
   if (view.autonomyEnforcement !== void 0) {
-    const { grade, autonomy, externalMode, dangerousBypass } = view.autonomyEnforcement;
+    const { autonomy, externalMode, dangerousBypass } = view.autonomyEnforcement;
     const mode = externalMode !== void 0 ? ` mode=${externalMode}` : "";
     const bypass = dangerousBypass === true ? " dangerousBypass=true" : "";
-    lines.push(`autonomy enforcement: ${grade} autonomy=${autonomy}${mode}${bypass}`);
+    lines.push(`autonomy: ${autonomy}${mode}${bypass}`);
   }
   return lines;
 }
-function provenanceCompactSuffix(view) {
+function provenanceCompactSuffix(source, status) {
+  const view = admitRunProvenance(source, status);
   const parts = [];
   if (view.pipeline !== void 0) {
     const { fromRunId, position, inputBytes, inputTruncated } = view.pipeline;
@@ -12948,10 +13406,10 @@ function provenanceCompactSuffix(view) {
     parts.push(`escalations=${requested}req/${approved}appr/${denied}deny/${timedOut}timeout`);
   }
   if (view.autonomyEnforcement !== void 0) {
-    const { grade, autonomy, externalMode, dangerousBypass } = view.autonomyEnforcement;
+    const { autonomy, externalMode, dangerousBypass } = view.autonomyEnforcement;
     const mode = externalMode !== void 0 ? `/${externalMode}` : "";
     const bypass = dangerousBypass === true ? "/bypass" : "";
-    parts.push(`enforcement=${grade}:${autonomy}${mode}${bypass}`);
+    parts.push(`autonomy=${autonomy}${mode}${bypass}`);
   }
   return parts.length === 0 ? "" : ` ${parts.join(" ")}`;
 }
@@ -12959,521 +13417,6 @@ function provenanceCompactSuffix(view) {
 // src/domains/evidence/run-trust.ts
 init_esm_shims();
 
-// src/domains/evidence/trust-status.ts
-init_esm_shims();
-var TRUST_STATUS_VERSION = 1;
-var TRUST_STATUS_MAX_ARTIFACT_REFERENCES = 16;
-var TRUST_STATUS_MAX_IDENTIFIER_LENGTH = 512;
-var TRUST_STATUS_AXES = [
-  "artifactIntegrity",
-  "validationGrounding",
-  "independentReview",
-  "contextProvenance",
-  "autonomyEnforcement",
-  "completionEvidence"
-];
-var TRUST_STATUS_STATES = {
-  artifactIntegrity: ["verified", "failed", "absent", "unknown", "not_applicable"],
-  validationGrounding: ["validated", "failed", "ungrounded", "absent", "unknown", "not_applicable"],
-  independentReview: ["passed", "failed", "inconclusive", "not_independent", "absent", "unknown", "not_applicable"],
-  contextProvenance: ["recorded", "invalid", "absent", "unknown", "not_applicable"],
-  autonomyEnforcement: ["enforced", "approximated", "bypassed", "absent", "unknown", "not_applicable"],
-  completionEvidence: ["evidenced", "incomplete", "limited", "absent", "unknown", "not_applicable"]
-};
-var SELF_REPORTED_ARTIFACT_KINDS = /* @__PURE__ */ new Set([
-  "finish_contract_evidence",
-  "run_receipt"
-]);
-var AXIS_STATES = {
-  artifactIntegrity: new Set(TRUST_STATUS_STATES.artifactIntegrity),
-  validationGrounding: new Set(TRUST_STATUS_STATES.validationGrounding),
-  independentReview: new Set(TRUST_STATUS_STATES.independentReview),
-  contextProvenance: new Set(TRUST_STATUS_STATES.contextProvenance),
-  autonomyEnforcement: new Set(TRUST_STATUS_STATES.autonomyEnforcement),
-  completionEvidence: new Set(TRUST_STATUS_STATES.completionEvidence)
-};
-var AXIS_SOURCES = {
-  artifactIntegrity: /* @__PURE__ */ new Set(["receipt_integrity_verification", "compatibility"]),
-  validationGrounding: /* @__PURE__ */ new Set(["run_receipt", "evidence_bundle", "compatibility"]),
-  independentReview: /* @__PURE__ */ new Set(["gate_decision", "compatibility"]),
-  contextProvenance: /* @__PURE__ */ new Set(["run_receipt", "evidence_bundle", "compatibility"]),
-  autonomyEnforcement: /* @__PURE__ */ new Set(["run_receipt", "compatibility"]),
-  completionEvidence: /* @__PURE__ */ new Set(["finish_contract", "compatibility"])
-};
-var SOURCE_AUTHORITIES = {
-  receipt_integrity_verification: /* @__PURE__ */ new Set(["clio"]),
-  run_receipt: /* @__PURE__ */ new Set(["clio", "validator", "runtime", "external_system", "unknown"]),
-  gate_decision: /* @__PURE__ */ new Set(["clio", "reviewer", "operator", "unknown"]),
-  evidence_bundle: /* @__PURE__ */ new Set(["clio"]),
-  finish_contract: /* @__PURE__ */ new Set(["clio"]),
-  compatibility: /* @__PURE__ */ new Set(["clio", "unknown"])
-};
-var ABSENCE_REASONS = /* @__PURE__ */ new Set([
-  "not_recorded",
-  "not_observed",
-  "artifact_missing",
-  "historical_format"
-]);
-var SOURCE_KINDS = /* @__PURE__ */ new Set([
-  "receipt_integrity_verification",
-  "run_receipt",
-  "gate_decision",
-  "evidence_bundle",
-  "finish_contract",
-  "compatibility"
-]);
-var AUTHORITY_KINDS = /* @__PURE__ */ new Set([
-  "clio",
-  "validator",
-  "reviewer",
-  "operator",
-  "runtime",
-  "external_system",
-  "unknown"
-]);
-var ARTIFACT_KINDS = /* @__PURE__ */ new Set([
-  "run_receipt",
-  "validation_result",
-  "gate_decision",
-  "briefing",
-  "project_context",
-  "autonomy_policy",
-  "finish_contract_evidence",
-  "evidence_bundle",
-  "session_entry"
-]);
-function isRecord10(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function hasExactKeys(value, keys) {
-  const expected = new Set(keys);
-  return Object.keys(value).length === expected.size && Object.keys(value).every((key) => expected.has(key));
-}
-function isTrustStatusIdentifier(value) {
-  if (typeof value !== "string" || value.trim().length === 0 || value.length > TRUST_STATUS_MAX_IDENTIFIER_LENGTH) {
-    return false;
-  }
-  for (const character of value) {
-    const codePoint = character.codePointAt(0);
-    if (codePoint !== void 0 && (codePoint < 32 || codePoint === 127)) return false;
-  }
-  return true;
-}
-function compareArtifactReferences(left, right) {
-  const leftKey = `${left.kind}\0${left.id}\0${left.digest?.value ?? ""}`;
-  const rightKey = `${right.kind}\0${right.id}\0${right.digest?.value ?? ""}`;
-  return leftKey < rightKey ? -1 : leftKey > rightKey ? 1 : 0;
-}
-function normalizeArtifactReference(value, path2) {
-  if (!isRecord10(value)) throw new Error(`${path2} must be an object`);
-  if (!hasExactKeys(value, value.digest === void 0 ? ["kind", "id"] : ["kind", "id", "digest"])) {
-    throw new Error(`${path2} has unknown or missing fields`);
-  }
-  if (typeof value.kind !== "string" || !ARTIFACT_KINDS.has(value.kind)) {
-    throw new Error(`${path2}.kind is invalid`);
-  }
-  if (!isTrustStatusIdentifier(value.id)) throw new Error(`${path2}.id is invalid`);
-  const reference = { kind: value.kind, id: value.id };
-  if (value.digest !== void 0) {
-    if (!isRecord10(value.digest) || !hasExactKeys(value.digest, ["algorithm", "value"]) || value.digest.algorithm !== "sha256" || typeof value.digest.value !== "string" || !/^[a-f0-9]{64}$/u.test(value.digest.value)) {
-      throw new Error(`${path2}.digest is invalid`);
-    }
-    reference.digest = { algorithm: "sha256", value: value.digest.value };
-  }
-  return reference;
-}
-function normalizeAttributedStatus(axis, value) {
-  if (!hasExactKeys(value, ["state", "source", "authority", "artifacts"])) {
-    throw new Error(`${axis} has unknown or missing fields`);
-  }
-  if (!isRecord10(value.source) || !hasExactKeys(value.source, ["kind", "id"])) {
-    throw new Error(`${axis}.source is invalid`);
-  }
-  if (typeof value.source.kind !== "string" || !SOURCE_KINDS.has(value.source.kind) || !AXIS_SOURCES[axis].has(value.source.kind) || !isTrustStatusIdentifier(value.source.id)) {
-    throw new Error(`${axis}.source is invalid`);
-  }
-  if (!isRecord10(value.authority) || !hasExactKeys(value.authority, ["kind", "id"])) {
-    throw new Error(`${axis}.authority is invalid`);
-  }
-  if (typeof value.authority.kind !== "string" || !AUTHORITY_KINDS.has(value.authority.kind) || !SOURCE_AUTHORITIES[value.source.kind].has(
-    value.authority.kind
-  ) || !isTrustStatusIdentifier(value.authority.id)) {
-    throw new Error(`${axis}.authority is invalid`);
-  }
-  if (value.source.kind === "compatibility" && value.state !== "unknown" && value.state !== "not_applicable") {
-    throw new Error(`${axis} compatibility source cannot establish ${value.state}`);
-  }
-  if (!Array.isArray(value.artifacts) || value.artifacts.length > TRUST_STATUS_MAX_ARTIFACT_REFERENCES) {
-    throw new Error(`${axis}.artifacts exceeds the bounded reference list`);
-  }
-  const artifacts = value.artifacts.map(
-    (entry, index) => normalizeArtifactReference(entry, `${axis}.artifacts[${index}]`)
-  );
-  artifacts.sort(compareArtifactReferences);
-  for (let index = 1; index < artifacts.length; index += 1) {
-    if (compareArtifactReferences(
-      artifacts[index - 1],
-      artifacts[index]
-    ) === 0) {
-      throw new Error(`${axis}.artifacts contains a duplicate reference`);
-    }
-  }
-  return {
-    state: value.state,
-    source: { kind: value.source.kind, id: value.source.id },
-    authority: { kind: value.authority.kind, id: value.authority.id },
-    artifacts
-  };
-}
-function normalizeAxis(axis, value) {
-  if (!isRecord10(value) || typeof value.state !== "string" || !AXIS_STATES[axis].has(value.state)) {
-    throw new Error(`${axis}.state is invalid`);
-  }
-  if (value.state === "absent") {
-    if (!hasExactKeys(value, ["state", "reason"]) || typeof value.reason !== "string" || !ABSENCE_REASONS.has(value.reason)) {
-      throw new Error(`${axis} absent state is invalid`);
-    }
-    return { state: "absent", reason: value.reason };
-  }
-  return normalizeAttributedStatus(axis, value);
-}
-function normalizeTrustStatus(value) {
-  if (!isRecord10(value) || !hasExactKeys(value, ["version", ...TRUST_STATUS_AXES])) {
-    throw new Error("trust status has unknown or missing fields");
-  }
-  if (value.version !== TRUST_STATUS_VERSION) throw new Error("trust status version is invalid");
-  return {
-    version: TRUST_STATUS_VERSION,
-    artifactIntegrity: normalizeAxis("artifactIntegrity", value.artifactIntegrity),
-    validationGrounding: normalizeAxis("validationGrounding", value.validationGrounding),
-    independentReview: normalizeAxis("independentReview", value.independentReview),
-    contextProvenance: normalizeAxis("contextProvenance", value.contextProvenance),
-    autonomyEnforcement: normalizeAxis("autonomyEnforcement", value.autonomyEnforcement),
-    completionEvidence: normalizeAxis("completionEvidence", value.completionEvidence)
-  };
-}
-function absentTrustStatus(reason) {
-  return { state: "absent", reason };
-}
-function composeTrustStatus(...projections) {
-  const axes = {
-    artifactIntegrity: absentTrustStatus("not_recorded"),
-    validationGrounding: absentTrustStatus("not_recorded"),
-    independentReview: absentTrustStatus("not_recorded"),
-    contextProvenance: absentTrustStatus("not_recorded"),
-    autonomyEnforcement: absentTrustStatus("not_recorded"),
-    completionEvidence: absentTrustStatus("not_recorded")
-  };
-  for (const projection of projections) {
-    if (projection.artifactIntegrity !== void 0) axes.artifactIntegrity = projection.artifactIntegrity;
-    if (projection.validationGrounding !== void 0) axes.validationGrounding = projection.validationGrounding;
-    if (projection.independentReview !== void 0) axes.independentReview = projection.independentReview;
-    if (projection.contextProvenance !== void 0) axes.contextProvenance = projection.contextProvenance;
-    if (projection.autonomyEnforcement !== void 0) axes.autonomyEnforcement = projection.autonomyEnforcement;
-    if (projection.completionEvidence !== void 0) axes.completionEvidence = projection.completionEvidence;
-  }
-  return normalizeTrustStatus({ version: TRUST_STATUS_VERSION, ...axes });
-}
-function sha256Reference(kind, id, digest) {
-  const reference = { kind, id };
-  if (digest !== void 0 && /^[a-f0-9]{64}$/u.test(digest)) {
-    reference.digest = { algorithm: "sha256", value: digest };
-  }
-  return reference;
-}
-function receiptReference(receipt) {
-  return sha256Reference("run_receipt", receipt.runId, receipt.integrity?.digest);
-}
-function attributed(state, source, authority, artifacts) {
-  return { state, source, authority, artifacts: [...artifacts].sort(compareArtifactReferences) };
-}
-function receiptSource(receipt) {
-  return { kind: "run_receipt", id: receipt.runId };
-}
-function compatibilitySource(receipt, field) {
-  return { kind: "compatibility", id: `run_receipt:${receipt.runId}:${field}` };
-}
-var DISPATCH_AUTHORITY = { kind: "clio", id: "dispatch" };
-var COMPATIBILITY_AUTHORITY = { kind: "unknown", id: "historical-persisted-format" };
-function adaptReceiptIntegrityStatus(receipt, verification) {
-  if (receipt === null || receipt === void 0) return absentTrustStatus("artifact_missing");
-  const artifacts = [receiptReference(receipt)];
-  if (verification === void 0 || verification.ok && receipt.integrity === void 0) {
-    return attributed(
-      "unknown",
-      {
-        kind: "compatibility",
-        id: `run_receipt:${receipt.runId}:${receipt.integrity === void 0 ? "integrity-missing" : "integrity-unchecked"}`
-      },
-      COMPATIBILITY_AUTHORITY,
-      artifacts
-    );
-  }
-  return attributed(
-    verification.ok ? "verified" : "failed",
-    { kind: "receipt_integrity_verification", id: receipt.runId },
-    { kind: "clio", id: "receipt-integrity" },
-    artifacts
-  );
-}
-function validationArtifacts(receipt) {
-  const artifacts = [receiptReference(receipt)];
-  for (const fact of receipt.quality?.typedValidations ?? []) {
-    artifacts.push(sha256Reference("validation_result", fact.sourceId, fact.validatorDigest));
-  }
-  const resultContract = receipt.quality?.resultContract;
-  if (resultContract !== null && resultContract !== void 0) {
-    artifacts.push(sha256Reference("validation_result", resultContract.sourceId, resultContract.validatorDigest));
-  }
-  return uniqueBoundedReferences(artifacts);
-}
-function qualityHasFailure(quality) {
-  if (quality === void 0) return false;
-  if (quality.typedValidations.some((fact) => !fact.passed)) return true;
-  return quality.resultContract?.conformance === "fail" || quality.resultContract?.quality === "fail";
-}
-function qualityHasValidation(quality) {
-  if (quality === void 0) return false;
-  if (quality.typedValidations.some((fact) => fact.passed)) return true;
-  return quality.resultContract?.quality === "pass";
-}
-function verificationStatus(verification, receipt, artifacts) {
-  if (verification.state === "verified") {
-    return attributed("validated", receiptSource(receipt), { kind: "validator", id: verification.basis }, artifacts);
-  }
-  if (verification.state === "unverified") return absentTrustStatus("not_observed");
-  if (verification.state === "not_applicable") {
-    return attributed("not_applicable", receiptSource(receipt), DISPATCH_AUTHORITY, artifacts);
-  }
-  return attributed(
-    "unknown",
-    receiptSource(receipt),
-    verification.basis === "acp-external-unobserved" ? { kind: "external_system", id: "acp-delegation" } : COMPATIBILITY_AUTHORITY,
-    artifacts
-  );
-}
-function adaptRunReceiptValidationStatus(receipt) {
-  if (receipt === null || receipt === void 0) return absentTrustStatus("artifact_missing");
-  const artifacts = validationArtifacts(receipt);
-  if (receipt.hostVerification?.status === "rejected") {
-    return attributed("failed", receiptSource(receipt), { kind: "validator", id: "host-verification" }, artifacts);
-  }
-  if (receipt.hostVerification?.status === "verified") {
-    return attributed("validated", receiptSource(receipt), { kind: "validator", id: "host-verification" }, artifacts);
-  }
-  if (qualityHasFailure(receipt.quality)) {
-    return attributed("failed", receiptSource(receipt), { kind: "validator", id: "receipt-quality" }, artifacts);
-  }
-  if ((receipt.validationGrounding?.ungrounded.length ?? 0) > 0 || receipt.validationGrounding !== void 0 && receipt.validationGrounding.claimed > receipt.validationGrounding.grounded) {
-    return attributed("ungrounded", receiptSource(receipt), { kind: "validator", id: "command-grounding" }, artifacts);
-  }
-  if (qualityHasValidation(receipt.quality)) {
-    return attributed("validated", receiptSource(receipt), { kind: "validator", id: "receipt-quality" }, artifacts);
-  }
-  if (receipt.verification !== void 0) {
-    return verificationStatus(receipt.verification, receipt, artifacts);
-  }
-  return attributed("unknown", compatibilitySource(receipt, "verification"), COMPATIBILITY_AUTHORITY, artifacts);
-}
-function validBriefing(briefing) {
-  return Number.isSafeInteger(briefing.bytes) && briefing.bytes >= 0 && /^[a-f0-9]{64}$/u.test(briefing.contentHash);
-}
-function validBoundedProjectContext(context) {
-  return context.tier === "bounded" && Number.isSafeInteger(context.chars) && (context.chars ?? -1) >= 0 && typeof context.contentHash === "string" && /^[a-f0-9]{64}$/u.test(context.contentHash);
-}
-function contextArtifacts(receipt) {
-  const artifacts = [receiptReference(receipt)];
-  if (receipt.briefing !== void 0 && validBriefing(receipt.briefing)) {
-    artifacts.push(sha256Reference("briefing", `${receipt.runId}:briefing`, receipt.briefing.contentHash));
-  }
-  if (receipt.projectContext?.tier === "bounded" && validBoundedProjectContext(receipt.projectContext)) {
-    artifacts.push(
-      sha256Reference("project_context", `${receipt.runId}:project-context`, receipt.projectContext.contentHash)
-    );
-  }
-  return uniqueBoundedReferences(artifacts);
-}
-function adaptRunReceiptContextStatus(receipt) {
-  if (receipt === null || receipt === void 0) return absentTrustStatus("artifact_missing");
-  const artifacts = contextArtifacts(receipt);
-  const source = receiptSource(receipt);
-  const briefingInvalid = receipt.briefing !== void 0 && !validBriefing(receipt.briefing);
-  if (briefingInvalid) return attributed("invalid", source, DISPATCH_AUTHORITY, artifacts);
-  const context = receipt.projectContext;
-  if (context === void 0) {
-    if (receipt.briefing !== void 0) return attributed("recorded", source, DISPATCH_AUTHORITY, artifacts);
-    return attributed("unknown", compatibilitySource(receipt, "projectContext"), COMPATIBILITY_AUTHORITY, artifacts);
-  }
-  if (context.tier === "none") {
-    if (context.chars !== void 0 || context.contentHash !== void 0 || context.sections !== void 0) {
-      return attributed("invalid", source, DISPATCH_AUTHORITY, artifacts);
-    }
-    return receipt.briefing === void 0 ? attributed("not_applicable", source, DISPATCH_AUTHORITY, artifacts) : attributed("recorded", source, DISPATCH_AUTHORITY, artifacts);
-  }
-  return attributed(validBoundedProjectContext(context) ? "recorded" : "invalid", source, DISPATCH_AUTHORITY, artifacts);
-}
-function adaptRunReceiptAutonomyStatus(receipt) {
-  if (receipt === null || receipt === void 0) return absentTrustStatus("artifact_missing");
-  const enforcement = receipt.autonomyEnforcement;
-  const artifacts = [receiptReference(receipt)];
-  if (enforcement === void 0) {
-    return attributed("unknown", compatibilitySource(receipt, "autonomyEnforcement"), COMPATIBILITY_AUTHORITY, artifacts);
-  }
-  artifacts.push({ kind: "autonomy_policy", id: `${receipt.runId}:${enforcement.autonomy}` });
-  const authority = enforcement.grade === "mediated" ? { kind: "clio", id: "safety-autonomy" } : { kind: "runtime", id: enforcement.externalMode ?? "external-runtime" };
-  const state = enforcement.dangerousBypass === true || enforcement.grade === "bypassed" ? "bypassed" : enforcement.grade === "approximated" ? "approximated" : "enforced";
-  return attributed(state, receiptSource(receipt), authority, artifacts);
-}
-function receiptClaimsAreAuthenticated(receipt, integrity) {
-  return receipt?.integrity !== void 0 && integrity?.ok === true;
-}
-function unauthenticatedReceiptProjection(receipt) {
-  if (receipt === null || receipt === void 0) {
-    return {
-      validationGrounding: absentTrustStatus("artifact_missing"),
-      contextProvenance: absentTrustStatus("artifact_missing"),
-      autonomyEnforcement: absentTrustStatus("artifact_missing")
-    };
-  }
-  if (receipt.integrity === void 0) {
-    const artifacts = [receiptReference(receipt)];
-    return {
-      validationGrounding: attributed(
-        "unknown",
-        compatibilitySource(receipt, "canonical-projection"),
-        COMPATIBILITY_AUTHORITY,
-        artifacts
-      ),
-      contextProvenance: attributed(
-        "unknown",
-        compatibilitySource(receipt, "canonical-projection"),
-        COMPATIBILITY_AUTHORITY,
-        artifacts
-      ),
-      autonomyEnforcement: attributed(
-        "unknown",
-        compatibilitySource(receipt, "canonical-projection"),
-        COMPATIBILITY_AUTHORITY,
-        artifacts
-      )
-    };
-  }
-  return {
-    validationGrounding: absentTrustStatus("not_observed"),
-    contextProvenance: absentTrustStatus("not_observed"),
-    autonomyEnforcement: absentTrustStatus("not_observed")
-  };
-}
-function adaptRunReceiptTrustStatus(receipt, options = {}) {
-  const authenticated2 = receiptClaimsAreAuthenticated(receipt, options.integrity);
-  const receiptProjection = authenticated2 ? {
-    validationGrounding: adaptRunReceiptValidationStatus(receipt),
-    contextProvenance: adaptRunReceiptContextStatus(receipt),
-    autonomyEnforcement: adaptRunReceiptAutonomyStatus(receipt)
-  } : unauthenticatedReceiptProjection(receipt);
-  return composeTrustStatus({
-    artifactIntegrity: adaptReceiptIntegrityStatus(receipt, options.integrity),
-    ...receiptProjection,
-    independentReview: absentTrustStatus(receipt === null || receipt === void 0 ? "artifact_missing" : "not_recorded"),
-    completionEvidence: absentTrustStatus(
-      receipt === null || receipt === void 0 ? "artifact_missing" : "not_recorded"
-    )
-  });
-}
-function inspectRunReceiptTrustStatus(receipt, envelope) {
-  let integrity;
-  if (receipt === null || receipt === void 0) {
-    integrity = { ok: false, reason: "receipt unavailable" };
-  } else if (envelope === null || envelope === void 0) {
-    integrity = { ok: false, reason: "run ledger envelope unavailable" };
-  } else {
-    try {
-      integrity = verifyReceiptIntegrity(receipt, envelope);
-    } catch (error) {
-      integrity = {
-        ok: false,
-        reason: `receipt invalid: ${error instanceof Error ? error.message : String(error)}`
-      };
-    }
-  }
-  return {
-    integrity,
-    status: adaptRunReceiptTrustStatus(receipt, { integrity })
-  };
-}
-function gateReference(artifact) {
-  return sha256Reference("gate_decision", artifact.id, artifact.integrity.digest);
-}
-function gateAuthority(artifact) {
-  if (artifact.outcome === "operator-confirmed") return { kind: "operator", id: "gate-confirmation" };
-  if (artifact.outcome === "full-auto-applied") return { kind: "clio", id: "full-auto-gate-policy" };
-  return { kind: "reviewer", id: artifact.decider?.runId ?? "unavailable-decider" };
-}
-function adaptGateDecisionReviewStatus(artifact, subjectRunId, verification) {
-  if (artifact === null || artifact === void 0) return absentTrustStatus("artifact_missing");
-  const source = { kind: "gate_decision", id: artifact.id };
-  const artifacts = [gateReference(artifact)];
-  const authority = gateAuthority(artifact);
-  if (!artifact.subjects.some((subject) => subject.runId === subjectRunId)) return absentTrustStatus("not_recorded");
-  if (verification === void 0 || !verification.ok) {
-    return attributed(
-      "unknown",
-      source,
-      verification === void 0 ? COMPATIBILITY_AUTHORITY : { kind: "unknown", id: "unauthenticated-gate-artifact" },
-      artifacts
-    );
-  }
-  if (artifact.decider === void 0 || artifact.correlation === void 0) {
-    if (artifact.outcome === "operator-confirmed" || artifact.outcome === "full-auto-applied") {
-      return attributed("not_applicable", source, authority, artifacts);
-    }
-    return attributed("inconclusive", source, authority, artifacts);
-  }
-  if (!artifact.correlation.independent) return attributed("not_independent", source, authority, artifacts);
-  if (artifact.outcome === "pass") return attributed("passed", source, authority, artifacts);
-  if (artifact.outcome === "fail") return attributed("failed", source, authority, artifacts);
-  if (artifact.outcome === "winner") {
-    return attributed(
-      artifact.winner?.subject.runId === subjectRunId ? "passed" : "failed",
-      source,
-      authority,
-      artifacts
-    );
-  }
-  return attributed("inconclusive", source, authority, artifacts);
-}
-function adaptGroundedEvidenceValidationStatus(input) {
-  const observed = (input.artifacts ?? []).filter((artifact) => !SELF_REPORTED_ARTIFACT_KINDS.has(artifact.kind));
-  if (observed.length === 0) return absentTrustStatus("not_observed");
-  return attributed(
-    "validated",
-    { kind: "evidence_bundle", id: `${input.evidenceId}:${input.runId}` },
-    { kind: "clio", id: "evidence-grounding" },
-    uniqueBoundedReferences([{ kind: "evidence_bundle", id: input.evidenceId }, ...observed])
-  );
-}
-function adaptFinishContractCompletionStatus(assessment, options = {}) {
-  const artifacts = uniqueBoundedReferences(
-    options.artifacts ?? assessment.evidence.map((evidence, index) => ({
-      kind: evidence.turnId === void 0 ? "finish_contract_evidence" : "session_entry",
-      id: evidence.turnId ?? `${evidence.kind}:${index + 1}`
-    }))
-  );
-  const source = { kind: "finish_contract", id: options.sourceId ?? assessment.reason };
-  const authority = { kind: "clio", id: "finish-contract" };
-  if (assessment.reason === "no_mutation") return attributed("not_applicable", source, authority, artifacts);
-  if (assessment.reason === "validation_evidence") return attributed("evidenced", source, authority, artifacts);
-  if (assessment.reason === "explicit_limitation") return attributed("limited", source, authority, artifacts);
-  return attributed("incomplete", source, authority, artifacts);
-}
-function uniqueBoundedReferences(references) {
-  const sorted = [...references].sort(compareArtifactReferences);
-  const unique = sorted.filter(
-    (reference, index) => index === 0 || compareArtifactReferences(sorted[index - 1], reference) !== 0
-  );
-  return unique.slice(0, TRUST_STATUS_MAX_ARTIFACT_REFERENCES);
-}
-
 // src/domains/evidence/types.ts
 init_esm_shims();
 var EVIDENCE_VERSION = 1;
@@ -13499,7 +13442,6 @@ function buildEvidenceTrustStatusFile(input) {
         evidenceId: input.evidenceId,
         source,
         gateDecisions: input.gateDecisions,
-        auditRows: input.auditRows,
         validationEvidence: input.validationEvidence?.get(source.envelope.id) ?? []
       })
     }))
@@ -13507,7 +13449,6 @@ function buildEvidenceTrustStatusFile(input) {
 }
 function composeEvidenceRunTrustStatus(input) {
   const inspection = inspectRunReceiptTrustStatus(input.source.receipt, input.source.envelope);
-  const receiptRejected = inspection.status.artifactIntegrity.state === "failed";
   let status = inspection.status;
   const grounded = input.validationEvidence.filter((artifact) => isTrustStatusIdentifier(artifact.id));
   if (grounded.length > 0 && (status.validationGrounding.state === "absent" || status.validationGrounding.state === "unknown")) {
@@ -13532,21 +13473,6 @@ function composeEvidenceRunTrustStatus(input) {
       independentReview: adaptGateDecisionReviewStatus(gate, input.source.envelope.id, verification)
     });
   }
-  const finish = latestFinishContractForRun(input.auditRows, input.source.envelope.id);
-  if (finish !== null) {
-    const completion = adaptFinishContractCompletionStatus(finish.assessment, {
-      sourceId: finish.sourceId,
-      artifacts: finish.artifacts
-    });
-    status = composeTrustStatus(status, {
-      completionEvidence: receiptRejected && completion.state === "evidenced" ? {
-        state: "unknown",
-        source: { kind: "finish_contract", id: finish.sourceId },
-        authority: { kind: "clio", id: "finish-contract" },
-        artifacts: finish.artifacts
-      } : completion
-    });
-  }
   return status;
 }
 function latestGateDecisionForRun(decisions, runId) {
@@ -13554,55 +13480,6 @@ function latestGateDecisionForRun(decisions, runId) {
     (left, right) => compareCodepoints(left.createdAt, right.createdAt) || left.cycle - right.cycle || compareCodepoints(left.id, right.id)
   ).at(-1) ?? null;
 }
-function latestFinishContractForRun(rows, runId) {
-  const candidates = rows.filter((row) => row.auditKind === "completion_contract" && row.runId === runId && row.confidence === "exact").flatMap((row) => {
-    const assessment = finishContractAssessmentFromAudit(row.row);
-    if (assessment === null) return [];
-    const correlationId = readOptionalString(row.row.correlationId) ?? `${runId}:completion-contract`;
-    if (!isTrustStatusIdentifier(correlationId)) return [];
-    const turnId = readOptionalString(row.row.turnId);
-    const artifacts = [
-      { kind: "finish_contract_evidence", id: correlationId },
-      ...turnId === null || !isTrustStatusIdentifier(turnId) ? [] : [{ kind: "session_entry", id: turnId }]
-    ];
-    return [{ sourceId: correlationId, assessment, artifacts, timestamp: row.ts ?? "" }];
-  }).sort(
-    (left, right) => compareCodepoints(left.timestamp, right.timestamp) || compareCodepoints(left.sourceId, right.sourceId)
-  );
-  const latest2 = candidates.at(-1);
-  return latest2 === void 0 ? null : { sourceId: latest2.sourceId, assessment: latest2.assessment, artifacts: latest2.artifacts };
-}
-function finishContractAssessmentFromAudit(row) {
-  const reason = readOptionalString(row.reason);
-  const decision = readOptionalString(row.decision);
-  const mutatedPaths = Array.isArray(row.mutatedPaths) ? row.mutatedPaths.filter((entry) => typeof entry === "string") : [];
-  const turnId = readOptionalString(row.turnId);
-  const evidenceKinds = Array.isArray(row.evidenceKinds) ? row.evidenceKinds.filter(isFinishContractEvidenceKind) : [];
-  const evidence = evidenceKinds.map((kind) => ({
-    kind,
-    summary: "recorded by the finish contract",
-    ...turnId === null ? {} : { turnId }
-  }));
-  if (decision === "ok" && reason === "no_mutation") {
-    return { kind: "ok", reason, evidence: [], mutatedPaths };
-  }
-  if (decision === "ok" && reason === "validation_evidence") {
-    return { kind: "ok", reason, evidence, mutatedPaths };
-  }
-  if (decision === "ok" && reason === "explicit_limitation") {
-    return { kind: "ok", reason, evidence: [], mutatedPaths };
-  }
-  if (decision === "engage" && reason === "unvalidated_mutation") {
-    return { kind: "engage", reason, message: "finish contract engaged", evidence: [], mutatedPaths };
-  }
-  return null;
-}
-function isFinishContractEvidenceKind(value) {
-  return value === "validation_command" || value === "protected_artifact" || value === "dispatch_receipt";
-}
-function readOptionalString(value) {
-  return typeof value === "string" && value.trim().length > 0 ? value : null;
-}
 
 // src/domains/evidence/store.ts
 init_esm_shims();
@@ -13676,7 +13553,7 @@ async function loadEvidenceTrustStatus(dataDir, evidenceId) {
   }
   const source = `${evidenceId}/trust-status.json`;
   const parsed = parseJson(raw, source);
-  if (!isRecord11(parsed)) throw new Error(`${source}: expected object`);
+  if (!isRecord10(parsed)) throw new Error(`${source}: expected object`);
   if (parsed.version !== 1) throw new Error(`${source}: expected version 1`);
   if (readString(parsed, source, "evidenceId") !== evidenceId) {
     throw new Error(`${source}.evidenceId: expected ${evidenceId}`);
@@ -13689,7 +13566,7 @@ async function loadEvidenceTrustStatus(dataDir, evidenceId) {
     projection: "canonical",
     runs: parsed.runs.map((entry, index) => {
       const entrySource = `${source}.runs[${index}]`;
-      if (!isRecord11(entry)) throw new Error(`${entrySource}: expected object`);
+      if (!isRecord10(entry)) throw new Error(`${entrySource}: expected object`);
       return {
         runId: readString(entry, entrySource, "runId"),
         status: normalizeTrustStatus(entry.status)
@@ -13707,10 +13584,10 @@ async function loadEvidenceRunProvenance(dataDir, evidenceId) {
     throw error;
   }
   const parsed = parseJson(raw, `${evidenceId}/receipt.json`);
-  if (!isRecord11(parsed) || !Array.isArray(parsed.receipts)) return [];
+  if (!isRecord10(parsed) || !Array.isArray(parsed.receipts)) return [];
   const out = [];
   for (const entry of parsed.receipts) {
-    if (!isRecord11(entry) || typeof entry.runId !== "string") continue;
+    if (!isRecord10(entry) || typeof entry.runId !== "string") continue;
     const view = runProvenanceFromUnknown(entry);
     if (hasRunProvenance(view)) out.push({ runId: entry.runId, view });
   }
@@ -13735,7 +13612,7 @@ async function listEvidenceOverviews(dataDir) {
   return overviews;
 }
 function parseOverview(value, source) {
-  if (!isRecord11(value)) throw new Error(`${source}: expected object`);
+  if (!isRecord10(value)) throw new Error(`${source}: expected object`);
   if (value.version !== 1) throw new Error(`${source}: expected version 1`);
   const evidenceId = readString(value, source, "evidenceId");
   const sourceValue = readSource(value.source, `${source}.source`);
@@ -13776,13 +13653,13 @@ function parseOverview(value, source) {
   };
 }
 function parseFindingsFile(value, source) {
-  if (!isRecord11(value)) throw new Error(`${source}: expected object`);
+  if (!isRecord10(value)) throw new Error(`${source}: expected object`);
   if (value.version !== 1) throw new Error(`${source}: expected version 1`);
   if (!Array.isArray(value.findings)) throw new Error(`${source}.findings: expected array`);
   return value.findings.map((entry, index) => parseFinding(entry, `${source}.findings[${index}]`));
 }
 function parseFinding(value, source) {
-  if (!isRecord11(value)) throw new Error(`${source}: expected object`);
+  if (!isRecord10(value)) throw new Error(`${source}: expected object`);
   const severity = readString(value, source, "severity");
   if (severity !== "info" && severity !== "warn") throw new Error(`${source}.severity: expected info or warn`);
   const tag = readString(value, source, "tag");
@@ -13795,14 +13672,14 @@ function parseFinding(value, source) {
   };
 }
 function readSource(value, source) {
-  if (!isRecord11(value)) throw new Error(`${source}: expected object`);
+  if (!isRecord10(value)) throw new Error(`${source}: expected object`);
   if (value.kind === "run") return { kind: "run", runId: readString(value, source, "runId") };
   if (value.kind === "session") return { kind: "session", sessionId: readString(value, source, "sessionId") };
   if (value.kind === "eval") return { kind: "eval", evalId: readString(value, source, "evalId") };
   throw new Error(`${source}.kind: expected run, session, or eval`);
 }
 function readTotals(value, source) {
-  if (!isRecord11(value)) throw new Error(`${source}: expected object`);
+  if (!isRecord10(value)) throw new Error(`${source}: expected object`);
   return {
     runs: readNumber(value, source, "runs"),
     receipts: readNumber(value, source, "receipts"),
@@ -13860,7 +13737,7 @@ function parseJson(raw, source) {
     throw new Error(`${source}: invalid JSON: ${message}`);
   }
 }
-function isRecord11(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function findingsFile(evidenceId, findings) {
@@ -13915,7 +13792,6 @@ async function buildEvidence(options) {
     evidenceId,
     runSources,
     gateDecisions: gateDecisions.decisions,
-    auditRows: auditLinks.rows,
     validationEvidence
   });
   const findings = buildFindings(runSources, trustStatusRaw, sessionLinks, auditLinks, protectedArtifactsRaw);
@@ -13946,7 +13822,10 @@ async function buildEvidence(options) {
     redactedToolEvents,
     protectedArtifacts
   );
-  const transcript = redactSecretsText(renderTranscript(overview, redactedRunSources, sessionLinks), tally);
+  const transcript = redactSecretsText(
+    renderTranscript(overview, redactedRunSources, sessionLinks, trustStatusRaw),
+    tally
+  );
   const finalOverview = { ...overview, redactionCount: tally.count };
   await writeEvidenceFiles(
     directory,
@@ -14019,8 +13898,9 @@ function buildFindings(runSources, trustStatus, sessionLinks, auditLinks, protec
     const status = trustByRun.get(source.envelope.id);
     if (status === void 0) throw new Error(`canonical trust status missing for run ${source.envelope.id}`);
     if (source.receiptError !== null) {
-      const tag = source.receiptIntegrityFailed ? "receipt-integrity" : "unknown";
-      findings.push(finding(findings.length, "warn", tag, source.envelope.id, source.receiptError));
+      const retired = retiredIntegrityVersionOf(status.artifactIntegrity) !== null;
+      const tag = retired ? "receipt-retired" : source.receiptIntegrityFailed ? "receipt-integrity" : "unknown";
+      findings.push(finding(findings.length, retired ? "info" : "warn", tag, source.envelope.id, source.receiptError));
     }
     if (isSuccessfulRun(source) && (status.validationGrounding.state === "absent" || status.validationGrounding.state === "unknown")) {
       findings.push(
@@ -14081,6 +13961,7 @@ function buildFindings(runSources, trustStatus, sessionLinks, auditLinks, protec
         )
       );
     }
+    findings.push(...axisFindings(findings.length, source, status));
     if (source.envelope.status === "stale" || source.envelope.status === "dead") {
       findings.push(
         finding(findings.length, "warn", "timeout", source.envelope.id, `run status ${source.envelope.status}`)
@@ -14231,17 +14112,17 @@ function validationToolCallCandidate(entry, linked, runSources) {
 }
 function validationToolCallSummary(toolName, args) {
   const parsed = parseMaybeJson(args);
-  const argRecord = isRecord12(parsed) ? parsed : null;
+  const argRecord = isRecord11(parsed) ? parsed : null;
   if (toolName === "bash") {
-    const command = readOptionalString2(argRecord?.command);
+    const command = readOptionalString(argRecord?.command);
     if (command === null) return null;
     const detected = detectValidationCommand(command);
     return detected.kind === "validation" ? detected.matched : null;
   }
   if (toolName === "verify") {
-    const check = readOptionalString2(argRecord?.check);
+    const check = readOptionalString(argRecord?.check);
     if (check === "frontend") {
-      const target = readOptionalString2(argRecord?.path) ?? "artifact";
+      const target = readOptionalString(argRecord?.path) ?? "artifact";
       return `verify frontend ${target}`;
     }
     if (check === null) return null;
@@ -14253,8 +14134,8 @@ function validationToolCallSummary(toolName, args) {
 }
 function isSuccessfulSessionToolResult(result) {
   if (result.isError) return false;
-  const obj = isRecord12(result.result) ? result.result : null;
-  const details = isRecord12(obj?.details) ? obj.details : null;
+  const obj = isRecord11(result.result) ? result.result : null;
+  const details = isRecord11(obj?.details) ? obj.details : null;
   return details?.kind !== "error";
 }
 function finding(index, severity, tag, runId, message) {
@@ -14271,7 +14152,7 @@ async function writeEvidenceFiles(directory, overview, runSources, findings, ses
   await writeJson(join17(directory, "overview.json"), overview);
   await writeFile(
     join17(directory, "transcript.md"),
-    transcript ?? renderTranscript(overview, runSources, sessionLinks),
+    transcript ?? renderTranscript(overview, runSources, sessionLinks, trustStatus),
     "utf8"
   );
   await writeJsonl(join17(directory, "trace.raw.jsonl"), rawTraceRows(runSources));
@@ -14283,7 +14164,7 @@ async function writeEvidenceFiles(directory, overview, runSources, findings, ses
   await writeJson(join17(directory, "trust-status.json"), trustStatus);
   await writeJson(join17(directory, "protected-artifacts.json"), protectedArtifacts);
   await writeJson(join17(directory, "findings.json"), findingsFile(overview.evidenceId, [...findings]));
-  await writeFile(join17(directory, "findings.md"), renderFindings(findings), "utf8");
+  await writeFile(join17(directory, "findings.md"), renderEvidenceFindingsMarkdown(findings, trustStatus), "utf8");
 }
 function rawTraceRows(runSources) {
   const rows = [];
@@ -14300,7 +14181,8 @@ function cleanedTraceRows(runSources, findings, toolEventRows) {
   const rows = [];
   for (const source of runSources) {
     const envelope = source.envelope;
-    const provenance = source.receipt === null ? {} : extractRunProvenance(source.receipt);
+    const receipt = authenticatedReceipt(source);
+    const provenance = receipt === null ? {} : extractRunProvenance(receipt);
     rows.push({
       kind: "run",
       runId: envelope.id,
@@ -14426,13 +14308,13 @@ function attributionWindows(ledger, runSources, sessionIds) {
   }
   const linkedSessions = new Set(sessionIds);
   for (const row of ledger.rows) {
-    if (!isRecord12(row)) continue;
-    const id = readOptionalString2(row.id);
-    const startedAt = readOptionalString2(row.startedAt);
-    const sessionId = readOptionalString2(row.sessionId);
+    if (!isRecord11(row)) continue;
+    const id = readOptionalString(row.id);
+    const startedAt = readOptionalString(row.startedAt);
+    const sessionId = readOptionalString(row.sessionId);
     if (id === null || startedAt === null || sessionId === null) continue;
     if (windows.has(id) || !linkedSessions.has(sessionId)) continue;
-    windows.set(id, { runId: id, startedAt, endedAt: readOptionalString2(row.endedAt) });
+    windows.set(id, { runId: id, startedAt, endedAt: readOptionalString(row.endedAt) });
   }
   return [...windows.values()].sort((left, right) => compareCodepoints(left.runId, right.runId));
 }
@@ -14547,16 +14429,16 @@ function extractSessionToolCall(entry, linked) {
   const payload = payloadObject(entry.payload);
   const block = firstContentBlock(entry.payload, "toolCall");
   const fn = payloadObject(payload?.function);
-  const id = readOptionalString2(payload?.id) ?? readOptionalString2(payload?.toolCallId) ?? readOptionalString2(payload?.tool_call_id) ?? readOptionalString2(block?.id) ?? entry.turnId;
-  const tool = readOptionalString2(payload?.name) ?? readOptionalString2(payload?.toolName) ?? readOptionalString2(payload?.tool) ?? readOptionalString2(fn?.name) ?? readOptionalString2(block?.name) ?? "tool";
+  const id = readOptionalString(payload?.id) ?? readOptionalString(payload?.toolCallId) ?? readOptionalString(payload?.tool_call_id) ?? readOptionalString(block?.id) ?? entry.turnId;
+  const tool = readOptionalString(payload?.name) ?? readOptionalString(payload?.toolName) ?? readOptionalString(payload?.tool) ?? readOptionalString(fn?.name) ?? readOptionalString(block?.name) ?? "tool";
   const args = payload?.arguments ?? payload?.args ?? payload?.input ?? parseMaybeJson(fn?.arguments) ?? block?.arguments ?? block?.args ?? void 0;
   return { id, tool, args, timestamp: entry.timestamp, link: linked.link, sessionId: linked.sessionId };
 }
 function extractSessionToolResult(entry, linked) {
   const payload = payloadObject(entry.payload);
   const contentText = extractTextFromPayload(entry.payload);
-  const id = readOptionalString2(payload?.toolCallId) ?? readOptionalString2(payload?.tool_call_id) ?? readOptionalString2(payload?.id) ?? null;
-  const tool = readOptionalString2(payload?.toolName) ?? readOptionalString2(payload?.name) ?? readOptionalString2(payload?.tool) ?? "tool";
+  const id = readOptionalString(payload?.toolCallId) ?? readOptionalString(payload?.tool_call_id) ?? readOptionalString(payload?.id) ?? null;
+  const tool = readOptionalString(payload?.toolName) ?? readOptionalString(payload?.name) ?? readOptionalString(payload?.tool) ?? "tool";
   const result = payload?.result ?? payload?.output ?? payload?.out ?? payload?.content ?? (contentText.length > 0 ? contentText : entry.payload);
   return {
     id,
@@ -14583,12 +14465,12 @@ async function linkAuditRows(stateDir, source, runSources, sessionLinks) {
     runSources.map((item) => [item.envelope.id, item.envelope.sessionId ?? item.receipt?.sessionId ?? null])
   );
   for (const audit of auditRows.rows) {
-    const directRunId = readOptionalString2(audit.row.runId);
+    const directRunId = readOptionalString(audit.row.runId);
     if (directRunId !== null && runIds.has(directRunId)) {
       rows.push(
         auditLinkedRow(audit, {
           runId: directRunId,
-          sessionId: readOptionalString2(audit.row.sessionId) ?? runSessionIds.get(directRunId) ?? null,
+          sessionId: readOptionalString(audit.row.sessionId) ?? runSessionIds.get(directRunId) ?? null,
           linkKind: "run-id",
           confidence: "exact",
           reasons: ["audit runId matched run ledger"]
@@ -14596,7 +14478,7 @@ async function linkAuditRows(stateDir, source, runSources, sessionLinks) {
       );
       continue;
     }
-    const directSessionId = readOptionalString2(audit.row.sessionId);
+    const directSessionId = readOptionalString(audit.row.sessionId);
     if (directSessionId !== null && sessionIds.has(directSessionId)) {
       rows.push(
         auditLinkedRow(audit, {
@@ -14631,7 +14513,7 @@ function auditLinkedRow(audit, fields) {
 }
 function bestEffortAuditLink(audit, source, runSources, sessionIds) {
   if (audit.auditKind !== "tool_call") return null;
-  const tool = readOptionalString2(audit.row.tool);
+  const tool = readOptionalString(audit.row.tool);
   if (tool === null || audit.ts === null) return null;
   const candidates = runSources.filter((item) => {
     if (!timestampInRunWindow(audit.ts ?? "", item.envelope)) return false;
@@ -14695,9 +14577,9 @@ function auditToolEvents(rows) {
   const events = [];
   for (const row of rows) {
     if (row.auditKind !== "tool_call") continue;
-    const tool = readOptionalString2(row.row.tool);
+    const tool = readOptionalString(row.row.tool);
     if (tool === null) continue;
-    const decision = readOptionalString2(row.row.decision);
+    const decision = readOptionalString(row.row.decision);
     if (decision === "classified") continue;
     const event = {
       source: "audit-row",
@@ -14714,7 +14596,7 @@ function auditToolEvents(rows) {
     };
     if (row.ts !== null) event.timestamp = row.ts;
     if (decision !== null) event.decision = decision;
-    const actionClass = readOptionalString2(row.row.actionClass);
+    const actionClass = readOptionalString(row.row.actionClass);
     if (actionClass !== null) event.actionClass = actionClass;
     events.push(event);
   }
@@ -14725,8 +14607,8 @@ function compareAuditLinkedRows(a, b) {
   if (byTs !== 0) return byTs;
   const byKind = compareCodepoints(a.auditKind, b.auditKind);
   if (byKind !== 0) return byKind;
-  const aCorrelation = readOptionalString2(a.row.correlationId) ?? "";
-  const bCorrelation = readOptionalString2(b.row.correlationId) ?? "";
+  const aCorrelation = readOptionalString(a.row.correlationId) ?? "";
+  const bCorrelation = readOptionalString(b.row.correlationId) ?? "";
   if (aCorrelation !== bCorrelation) return compareCodepoints(aCorrelation, bCorrelation);
   return compareCodepoints(JSON.stringify(a.row), JSON.stringify(b.row));
 }
@@ -14767,7 +14649,8 @@ function protectedArtifactsFile(sessionLinks) {
 function compareProtectedArtifactEvents(left, right) {
   return compareCodepoints(left.timestamp, right.timestamp) || compareCodepoints(left.sessionId, right.sessionId) || compareCodepoints(left.turnId, right.turnId) || compareCodepoints(left.artifact.path, right.artifact.path);
 }
-function renderTranscript(overview, runSources, sessionLinks) {
+function renderTranscript(overview, runSources, sessionLinks, trustStatus) {
+  const trustByRun = new Map(trustStatus.runs.map((entry) => [entry.runId, entry.status]));
   const lines = [
     `# Evidence ${overview.evidenceId}`,
     "",
@@ -14784,7 +14667,8 @@ function renderTranscript(overview, runSources, sessionLinks) {
     );
     lines.push(`  task: ${truncateText(envelope.task, MAX_TASK_CHARS)}`);
     if (source.receipt !== null) {
-      for (const line of provenanceTranscriptLines(extractRunProvenance(source.receipt))) {
+      const status = trustByRun.get(envelope.id);
+      for (const line of provenanceTranscriptLines(extractRunProvenance(source.receipt), status)) {
         lines.push(`  ${line}`);
       }
     }
@@ -14926,16 +14810,36 @@ function renderSessionTranscriptEntry(linked) {
   const _exhaustive = entry;
   return [`${prefix} ${String(_exhaustive)}`];
 }
-function renderFindings(findings) {
-  if (findings.length === 0) return "# Findings\n\nNo findings.\n";
-  const lines = ["# Findings", ""];
-  for (const item of findings) {
-    const run = item.runId === null ? "" : ` run=${item.runId}`;
-    lines.push(`- ${item.id} [${item.severity}] ${item.tag}${run}: ${item.message}`);
+function axisFindings(offset, source, status) {
+  const out = [];
+  const runId = source.envelope.id;
+  const next = (severity, tag, message) => {
+    out.push(finding(offset + out.length, severity, tag, runId, message));
+  };
+  const review = status.independentReview.state;
+  if (review === "failed") {
+    next("warn", "independent-review", "independent review failed for this run");
+  } else if (review === "not_independent") {
+    next("warn", "independent-review", "review was not independent of the run it judged");
+  } else if (review === "inconclusive") {
+    next("info", "independent-review", "independent review was inconclusive");
+  } else if (isSuccessfulRun(source) && (review === "absent" || review === "unknown")) {
+    next("info", "independent-review", "run was not independently reviewed; its result rests on its own receipt");
+  }
+  if (status.contextProvenance.state === "invalid") {
+    next("warn", "context-provenance", "context provenance record is contradictory; see trust-status.json");
+  }
+  const completion = status.completionEvidence.state;
+  if (completion === "incomplete") {
+    next(
+      "warn",
+      "completion-evidence",
+      "run mutated the workspace and finished without validation evidence at the completion boundary"
+    );
+  } else if (completion === "limited") {
+    next("info", "completion-evidence", "run finished with an explicit limitation instead of validation evidence");
   }
-  lines.push("");
-  return `${lines.join("\n")}
-`;
+  return out;
 }
 async function readRunLedger(stateDir) {
   const target = join17(stateDir, "runs.json");
@@ -14953,7 +14857,7 @@ async function readRunLedger(stateDir) {
 }
 function selectRunEnvelopes(ledger, source) {
   return ledger.rows.flatMap((entry, index) => {
-    if (!isRecord12(entry)) return [];
+    if (!isRecord11(entry)) return [];
     const selected = source.kind === "run" ? entry.id === source.runId : entry.sessionId === source.sessionId;
     return selected ? [parseRunEnvelope(entry, `${ledger.path}[${index}]`)] : [];
   });
@@ -14983,6 +14887,7 @@ async function readReceipt(stateDir, envelope) {
   }
   const integrity = inspectRunReceiptTrustStatus(receipt, envelope).integrity;
   if (!integrity.ok) {
+    if (integrity.retired !== void 0) return { receipt, error: integrity.reason, integrityFailed: false };
     return { receipt, error: `receipt integrity: ${integrity.reason}`, integrityFailed: true };
   }
   return { receipt, error: null, integrityFailed: false };
@@ -14993,7 +14898,7 @@ function readExecutionRole(value, source) {
   return role;
 }
 function parseRunEnvelope(value, source) {
-  if (!isRecord12(value)) throw new Error(`${source}: expected object`);
+  if (!isRecord11(value)) throw new Error(`${source}: expected object`);
   const reasoningTokenCount = readOptionalNumber2(value, source, "reasoningTokenCount");
   return {
     ...value,
@@ -15020,11 +14925,11 @@ function parseRunEnvelope(value, source) {
   };
 }
 function parseRunReceipt(value, source) {
-  if (!isRecord12(value)) throw new Error(`${source}: expected object`);
+  if (!isRecord11(value)) throw new Error(`${source}: expected object`);
   const integrity = value.integrity;
-  if (!isRecord12(integrity)) throw new Error(`${source}.integrity: expected object`);
+  if (!isRecord11(integrity)) throw new Error(`${source}.integrity: expected object`);
   const reasoningTokenCount = readOptionalNumber2(value, source, "reasoningTokenCount");
-  const failureMessage = readOptionalString2(value.failureMessage);
+  const failureMessage = readOptionalString(value.failureMessage);
   return {
     ...value,
     runId: readString2(value, source, "runId"),
@@ -15062,7 +14967,7 @@ function readToolStats(record, source, field) {
   if (!Array.isArray(value)) throw new Error(`${source}.${field}: expected array`);
   return value.map((entry, index) => {
     const itemSource = `${source}.${field}[${index}]`;
-    if (!isRecord12(entry)) throw new Error(`${itemSource}: expected object`);
+    if (!isRecord11(entry)) throw new Error(`${itemSource}: expected object`);
     return {
       tool: readString2(entry, itemSource, "tool"),
       count: readNumber2(entry, itemSource, "count"),
@@ -15116,7 +15021,7 @@ function readNullableNumber(record, source, field) {
     throw new Error(`${source}.${field}: expected number or null`);
   return value;
 }
-function readOptionalString2(value) {
+function readOptionalString(value) {
   return typeof value === "string" && value.length > 0 ? value : null;
 }
 function parseJson2(raw, source) {
@@ -15127,11 +15032,11 @@ function parseJson2(raw, source) {
     throw new Error(`${source}: invalid JSON: ${message}`);
   }
 }
-function isRecord12(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function payloadObject(payload) {
-  return isRecord12(payload) ? payload : null;
+  return isRecord11(payload) ? payload : null;
 }
 function parseMaybeJson(value) {
   if (typeof value !== "string") return value;
@@ -15148,7 +15053,7 @@ function firstContentBlock(payload, type) {
   const content = obj?.content;
   if (!Array.isArray(content)) return null;
   for (const block of content) {
-    if (!isRecord12(block)) continue;
+    if (!isRecord11(block)) continue;
     if (block.type === type) return block;
   }
   return null;
@@ -15161,7 +15066,7 @@ function extractTextFromPayload(payload) {
   if (Array.isArray(obj.content)) {
     const parts = [];
     for (const block of obj.content) {
-      if (!isRecord12(block)) continue;
+      if (!isRecord11(block)) continue;
       if (block.type === "text" && typeof block.text === "string") parts.push(block.text);
     }
     return parts.join("\n");
@@ -15258,9 +15163,6 @@ init_esm_shims();
 // src/domains/eval/report.ts
 init_esm_shims();
 
-// src/domains/eval/run-compare.ts
-init_esm_shims();
-
 // src/domains/eval/runner.ts
 init_esm_shims();
 function summarizeEvalResults(records) {
@@ -15329,8 +15231,7 @@ async function buildEvalEvidence(options) {
   const trustStatus = buildEvidenceTrustStatusFile({
     evidenceId,
     runSources: linkedRuns.runSources,
-    gateDecisions: gateDecisions.decisions,
-    auditRows: linkedRuns.auditRows
+    gateDecisions: gateDecisions.decisions
   });
   await writeEvalEvidenceFiles(
     directory,
@@ -15464,7 +15365,7 @@ async function writeEvalEvidenceFiles(directory, artifact, overview, findings, t
   await writeJson2(join18(directory, "protected-artifacts.json"), emptyProtected);
   await writeJson2(join18(directory, "eval-result.json"), redactedArtifact);
   await writeJson2(join18(directory, "findings.json"), findingsFile(overview.evidenceId, [...findings]));
-  await writeFile2(join18(directory, "findings.md"), renderFindings2(findings), "utf8");
+  await writeFile2(join18(directory, "findings.md"), renderEvidenceFindingsMarkdown(findings, trustStatus), "utf8");
 }
 function rawEvalTraceRows(artifact) {
   return artifact.results.map((result) => ({
@@ -15554,16 +15455,6 @@ function renderEvalTranscript(artifact, overview) {
   return `${lines.join("\n")}
 `;
 }
-function renderFindings2(findings) {
-  if (findings.length === 0) return "No findings.\n";
-  const lines = ["# Findings", ""];
-  for (const finding2 of findings) {
-    lines.push(`- ${finding2.id} [${finding2.severity}] ${finding2.tag}: ${finding2.message}`);
-  }
-  lines.push("");
-  return `${lines.join("\n")}
-`;
-}
 async function writeJson2(path2, value) {
   await writeFile2(path2, `${JSON.stringify(value, null, 2)}
 `, "utf8");
@@ -15617,7 +15508,7 @@ async function readRunLedger2(stateDir) {
   try {
     const raw = await readFile3(join18(stateDir, "runs.json"), "utf8");
     const parsed = JSON.parse(raw);
-    return Array.isArray(parsed) ? parsed.filter(isRecord13) : [];
+    return Array.isArray(parsed) ? parsed.filter(isRecord12) : [];
   } catch {
     return [];
   }
@@ -15629,7 +15520,7 @@ async function readReceiptForRun(stateDir, envelope) {
   const path2 = envelope.receiptPath ?? join18(stateDir, "receipts", `${envelope.id}.json`);
   try {
     const parsed = JSON.parse(await readFile3(path2, "utf8"));
-    return isRecord13(parsed) ? parsed : null;
+    return isRecord12(parsed) ? parsed : null;
   } catch {
     return null;
   }
@@ -15644,7 +15535,7 @@ async function countSessionEntries(stateDir, sessionIds) {
       count += raw.split("\n").filter((line) => line.trim().length > 0).filter((line) => {
         try {
           const parsed = JSON.parse(line);
-          return isRecord13(parsed) && parsed.type !== "session";
+          return isRecord12(parsed) && parsed.type !== "session";
         } catch {
           return false;
         }
@@ -15693,7 +15584,7 @@ async function linkedEvalAuditRows(stateDir, runIds, artifact) {
       } catch {
         continue;
       }
-      if (!isRecord13(parsed)) continue;
+      if (!isRecord12(parsed)) continue;
       const directRunId = typeof parsed.runId === "string" ? parsed.runId : null;
       if (directRunId !== null && runIds.has(directRunId)) {
         rows.push(evalAuditRow(parsed, directRunId, "run-id", "exact", ["audit runId matched nested eval run"]));
@@ -15764,7 +15655,7 @@ function sanitizeEvidenceId2(value) {
   const sanitized = value.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
   return sanitized.length === 0 ? "unknown" : sanitized;
 }
-function isRecord13(value) {
+function isRecord12(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -15775,30 +15666,30 @@ init_esm_shims();
 function lower(value) {
   return (value ?? "").toLowerCase();
 }
-function canonicalJson4(value) {
+function canonicalJson3(value) {
   if (value === null) return "null";
   if (typeof value === "string" || typeof value === "boolean") return JSON.stringify(value);
   if (typeof value === "number") {
     if (!Number.isFinite(value)) throw new Error("response schema digest requires finite numbers");
     return JSON.stringify(value);
   }
-  if (Array.isArray(value)) return `[${value.map(canonicalJson4).join(",")}]`;
+  if (Array.isArray(value)) return `[${value.map(canonicalJson3).join(",")}]`;
   if (typeof value === "object") {
     const record = value;
     return `{${Object.keys(record).sort().map((key) => {
       if (record[key] === void 0) throw new Error("response schema digest cannot contain undefined");
-      return `${JSON.stringify(key)}:${canonicalJson4(record[key])}`;
+      return `${JSON.stringify(key)}:${canonicalJson3(record[key])}`;
     }).join(",")}}`;
   }
   throw new Error(`response schema digest cannot represent ${typeof value}`);
 }
 function canonicalResponseSchemaDigest(schema) {
-  return createHash12("sha256").update(canonicalJson4(schema), "utf8").digest("hex");
+  return createHash11("sha256").update(canonicalJson3(schema), "utf8").digest("hex");
 }
 function typedValidationFactsFromToolStats(toolStats) {
   return toolStats.filter((stat) => stat.tool === "verify" && stat.count > 0).map((stat) => ({
     sourceId: "tool:verify",
-    validatorDigest: createHash12("sha256").update(canonicalJson4(stat), "utf8").digest("hex"),
+    validatorDigest: createHash11("sha256").update(canonicalJson3(stat), "utf8").digest("hex"),
     passed: stat.ok === stat.count && stat.errors === 0 && stat.blocked === 0
   }));
 }
@@ -15925,17 +15816,17 @@ export {
   ACP_MAX_RAW_RECORD_BYTES,
   ACP_MAX_CHUNK_BYTES,
   ACP_MAX_TOOL_CALL_ID_BYTES,
-  sha256,
-  canonicalJson2 as canonicalJson,
   compile,
   compileWorker,
   WORKER_OUTPUT_MAX_BYTES,
   durableAssistantTextFromEvent,
   setCapacityDraining,
   capacityDrain,
+  capacityLeaseUsage,
   openAgentLedger,
   renderAgentLedgerBoard,
   closeAgentLedger,
+  renderDispatchReviewerTask,
   createRunReceiptQuality,
   UNVERIFIABLE_RECEIPT_VERIFICATION,
   decideReviewGate,
@@ -15959,8 +15850,6 @@ export {
   extractRunProvenance,
   provenanceTranscriptLines,
   provenanceCompactSuffix,
-  adaptRunReceiptTrustStatus,
-  inspectRunReceiptTrustStatus,
   FAILURE_CAUSE_TAGS,
   evidenceDirectory,
   EvidenceNotFoundError,
@@ -15971,4 +15860,4 @@ export {
   summarizeEvalResults,
   buildEvalEvidence
 };
-//# sourceMappingURL=chunk-UUANF5CR.js.map
+//# sourceMappingURL=chunk-TEO2TLVN.js.map