orkestrator 2.23.0 → 2.24.0-alpha

package/resources/claude-bridge/dist/index.js

@@ -2534,6 +2534,9 @@ function claudeSessionPreferencesDir() {
 function claudeCommandChangesDir() {
   return join(claudeHome(), ".claude", "orkestrator", "command-changes");
 }
+function claudeChangeEvidenceDir() {
+  return join(claudeHome(), ".claude", "orkestrator", "change-evidence");
+}
 
 // ../../bridges/claude-bridge/src/services/session-preferences.ts
 function parseTurnInFlightMark(value) {
@@ -5702,6 +5705,11 @@ function parseMcpToolName(toolName, knownServerNames) {
   if (!toolName.startsWith("mcp_")) {
     return { isMcpTool: false };
   }
+  if (toolName.startsWith("mcp__")) {
+    const separator = toolName.indexOf("__", 5);
+    const server = separator > 5 ? toolName.slice(5, separator) : "";
+    return server ? { isMcpTool: true, mcpServerName: server } : { isMcpTool: true };
+  }
   const remainder = toolName.slice(4);
   if (knownServerNames && knownServerNames.size > 0) {
     let matchedServer;
@@ -7462,7 +7470,7 @@ function noMessages() {
 // ../../bridges/claude-bridge/src/services/session-manager-persistence.ts
 import { constants } from "node:fs";
 import { lstat as lstat2, open as open2, realpath } from "node:fs/promises";
-import { isAbsolute as isAbsolute3, join as join6, relative as relative2, resolve as resolve3, sep } from "node:path";
+import { isAbsolute as isAbsolute3, join as join8, relative as relative2, resolve as resolve3, sep } from "node:path";
 
 // ../protocol/src/node/command-change-journal.ts
 import { appendFile, mkdir as mkdir2, readFile as readFile4, rename as rename2, rm as rm2, stat as stat3, writeFile as writeFile2 } from "node:fs/promises";
@@ -7738,11 +7746,31 @@ class WorkspaceChangeProbe {
     await this.open(cwd, callId, "note");
   }
   async end(callId) {
+    const observation = await this.endObservation(callId);
+    const change = observation?.change;
+    if (!change)
+      return;
+    if (observation.overlap === "known-overlap" || observation.boundary.before === "late-start" || observation.omittedReasons.length > 0) {
+      change.approximate = true;
+    }
+    return change;
+  }
+  async endObservation(callId) {
     await this.opening.get(callId);
     const call = this.calls.get(callId);
     if (!call)
       return;
     this.calls.delete(callId);
+    const boundary = {
+      before: call.mode === "fresh" ? "fresh-before" : call.late ? "late-start" : "prior-observation",
+      after: "after-terminal"
+    };
+    const unavailable = (reason) => ({
+      boundary: { before: boundary.before, after: "unknown" },
+      overlap: call.overlapped ? "known-overlap" : "none-observed",
+      omittedReasons: [],
+      unavailableReason: reason
+    });
     try {
       if (!call.measure || !call.before) {
         if (call.repo.keepsBaseline && !call.repo.disabled) {
@@ -7751,20 +7779,26 @@ class WorkspaceChangeProbe {
         return;
       }
       const before = await call.before;
-      if (!before || call.repo.disabled)
-        return;
+      if (!before)
+        return unavailable("before-unavailable");
+      if (call.repo.disabled)
+        return unavailable("probe-disabled");
       const after = await this.snapshotShared(call.repo, "fresh");
-      if (!after || call.unavailable)
-        return;
+      if (!after)
+        return unavailable("after-unavailable");
+      if (call.unavailable)
+        return unavailable("baseline-priming");
       const change = await this.diff(call.repo, before, after).catch(() => {
         return;
       });
       if (!change)
-        return;
-      if (call.overlapped || call.late || skippedFilesChanged(before.skipped, after.skipped)) {
-        change.approximate = true;
-      }
-      return change;
+        return unavailable("diff-failed");
+      return {
+        change,
+        boundary,
+        overlap: call.overlapped ? "known-overlap" : "none-observed",
+        omittedReasons: skippedFilesChanged(before.skipped, after.skipped) ? ["untracked-file-too-large"] : []
+      };
     } finally {
       call.repo.open.delete(call);
       await this.releaseUnusedObjects(call.repo);
@@ -7808,6 +7842,7 @@ class WorkspaceChangeProbe {
     const call = {
       id: callId,
       repo,
+      mode,
       measure,
       openedAt: this.now(),
       overlapped: false,
@@ -8035,54 +8070,1470 @@ function parseNameStatusZ(output) {
         statuses.set(path, status);
     }
   }
-  return statuses;
+  return statuses;
+}
+function splitNul(value) {
+  return value.split("\x00").filter((entry) => entry.length > 0);
+}
+function skippedFilesChanged(before, after) {
+  if (before.size !== after.size)
+    return true;
+  for (const [path, stamp] of before) {
+    if (after.get(path) !== stamp)
+      return true;
+  }
+  return false;
+}
+function parseNumstatZ(output) {
+  const tokens = output.split("\x00");
+  const files = [];
+  for (let index = 0;index < tokens.length; index += 1) {
+    const header = tokens[index];
+    if (!header)
+      continue;
+    const match = /^(-|\d+)\t(-|\d+)\t(.*)$/s.exec(header);
+    if (!match)
+      continue;
+    const [, rawAdditions, rawDeletions, inlinePath] = match;
+    let path = inlinePath ?? "";
+    let previousPath;
+    if (path === "") {
+      previousPath = tokens[index + 1];
+      path = tokens[index + 2] ?? "";
+      index += 2;
+    }
+    if (!path)
+      continue;
+    const binary = rawAdditions === "-" || rawDeletions === "-";
+    files.push({
+      path,
+      additions: binary ? 0 : Number(rawAdditions),
+      deletions: binary ? 0 : Number(rawDeletions),
+      ...binary ? { binary: true } : {},
+      ...previousPath ? { previousPath } : {}
+    });
+  }
+  return files;
+}
+
+// ../../bridges/claude-bridge/src/services/command-changes.ts
+import { join as join7 } from "node:path";
+
+// ../../bridges/claude-bridge/src/services/change-evidence.ts
+import { createHash as createHash7 } from "node:crypto";
+import {
+  closeSync,
+  existsSync,
+  mkdirSync,
+  openSync,
+  readFileSync as readFileSync2,
+  rmSync as rmSync2,
+  writeSync
+} from "node:fs";
+import { join as join6 } from "node:path";
+
+// ../protocol/src/field-validation.ts
+function isPlainRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+
+// ../protocol/src/change-evidence.ts
+var PROVIDER_EVIDENCE_SCHEMA_VERSION = 1;
+var TOOL_KINDS2 = [
+  "shell",
+  "file-edit",
+  "file-write",
+  "file-delete",
+  "file-move",
+  "notebook-edit",
+  "read",
+  "other"
+];
+var TOOL_PHASES = [
+  "proposed",
+  "awaiting-approval",
+  "running",
+  "succeeded",
+  "failed",
+  "denied",
+  "cancelled",
+  "unknown"
+];
+var TERMINAL_TOOL_PHASES = new Set([
+  "succeeded",
+  "failed",
+  "denied",
+  "cancelled"
+]);
+var EXECUTION_OCCURRENCE_VALUES = [
+  "not-started",
+  "started",
+  "did-not-run",
+  "unknown"
+];
+var CANONICAL_FRAME_METADATA_MAX_BYTES = 256 * 1024;
+var MAX_EVIDENCE_UPDATES_PER_FRAME = 256;
+var MAX_EVIDENCE_ID_LENGTH = 512;
+var MAX_EVIDENCE_PATH_LENGTH = 4096;
+var MAX_GAP_FRAME_IDS = 1024;
+function oneOf(values, value) {
+  return typeof value === "string" && values.includes(value);
+}
+function isId(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= MAX_EVIDENCE_ID_LENGTH;
+}
+function isPathValue(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= MAX_EVIDENCE_PATH_LENGTH && !value.includes("\x00");
+}
+function isCount2(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function isUnsignedDecimal(value) {
+  return typeof value === "string" && /^(0|[1-9][0-9]{0,39})$/.test(value);
+}
+function compareUnsignedDecimal(left, right) {
+  if (left.length !== right.length)
+    return left.length < right.length ? -1 : 1;
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function bodyRefIssues(value, path) {
+  if (!isPlainRecord(value))
+    return [{ path, message: "expected a body reference" }];
+  const issues = [];
+  if (!isId(value.id))
+    issues.push({ path: `${path}.id`, message: "expected an opaque id" });
+  if (!oneOf(["pending", "available", "unavailable"], value.state)) {
+    issues.push({ path: `${path}.state`, message: "unknown body state" });
+  }
+  if (!isCount2(value.retainedBytes)) {
+    issues.push({ path: `${path}.retainedBytes`, message: "expected a byte count" });
+  }
+  if (value.originalBytes !== undefined && !isCount2(value.originalBytes)) {
+    issues.push({ path: `${path}.originalBytes`, message: "expected a byte count" });
+  }
+  if (typeof value.complete !== "boolean") {
+    issues.push({ path: `${path}.complete`, message: "expected a boolean" });
+  }
+  if (value.state === "unavailable" && typeof value.unavailableReason !== "string") {
+    issues.push({ path: `${path}.unavailableReason`, message: "unavailable needs a reason" });
+  }
+  return issues;
+}
+function sideIssues(value, path) {
+  if (!isPlainRecord(value))
+    return [{ path, message: "expected a file side" }];
+  if (value.state === "absent")
+    return [];
+  if (value.state === "unknown") {
+    return typeof value.reason === "string" && value.reason.length > 0 ? [] : [{ path: `${path}.reason`, message: "unknown sides need a reason" }];
+  }
+  if (value.state === "present")
+    return bodyRefIssues(value.body, `${path}.body`);
+  return [{ path: `${path}.state`, message: "unknown side state" }];
+}
+var CLAIMS = ["proposal", "provider-reported", "unknown"];
+function evidenceIssues(value, path) {
+  if (!isPlainRecord(value))
+    return [{ path, message: "expected evidence" }];
+  const issues = [];
+  if (!oneOf(CLAIMS, value.effectClaim)) {
+    issues.push({ path: `${path}.effectClaim`, message: "unknown effect claim" });
+  }
+  const optionalPath = (key) => {
+    if (value[key] !== undefined && !isPathValue(value[key])) {
+      issues.push({ path: `${path}.${key}`, message: "invalid path" });
+    }
+  };
+  switch (value.kind) {
+    case "patch":
+      optionalPath("path");
+      optionalPath("previousPath");
+      issues.push(...bodyRefIssues(value.body, `${path}.body`));
+      if (!oneOf(["git_unified", "opaque"], value.format)) {
+        issues.push({ path: `${path}.format`, message: "unknown patch format" });
+      }
+      break;
+    case "replacement":
+      if (!isPathValue(value.path))
+        issues.push({ path: `${path}.path`, message: "invalid path" });
+      issues.push(...sideIssues(value.before, `${path}.before`));
+      issues.push(...sideIssues(value.after, `${path}.after`));
+      if (!oneOf(["fragment", "whole-file", "notebook-cell", "unknown"], value.extent)) {
+        issues.push({ path: `${path}.extent`, message: "unknown extent" });
+      }
+      if (!oneOf(["input", "result"], value.origin)) {
+        issues.push({ path: `${path}.origin`, message: "unknown origin" });
+      }
+      break;
+    case "reported-counts":
+      optionalPath("path");
+      for (const key of ["additions", "deletions"]) {
+        if (value[key] !== null && !isCount2(value[key])) {
+          issues.push({ path: `${path}.${key}`, message: "expected a count or null" });
+        }
+      }
+      if (value.contentLines !== undefined && value.contentLines !== null && !isCount2(value.contentLines)) {
+        issues.push({ path: `${path}.contentLines`, message: "expected a count or null" });
+      }
+      if (!oneOf(["file", "tool", "turn"], value.scope)) {
+        issues.push({ path: `${path}.scope`, message: "unknown count scope" });
+      }
+      break;
+    case "path-operation":
+      if (!isPathValue(value.path))
+        issues.push({ path: `${path}.path`, message: "invalid path" });
+      optionalPath("previousPath");
+      if (!oneOf(["add", "modify", "delete", "rename", "unknown"], value.operation)) {
+        issues.push({ path: `${path}.operation`, message: "unknown operation" });
+      }
+      break;
+    default:
+      issues.push({ path: `${path}.kind`, message: "unknown evidence kind" });
+  }
+  return issues;
+}
+function updateIssues(value, path) {
+  if (!isPlainRecord(value))
+    return [{ path, message: "expected an evidence update" }];
+  const issues = [];
+  if (!isId(value.evidenceKey))
+    issues.push({ path: `${path}.evidenceKey`, message: "required" });
+  if (!isId(value.revisionKey))
+    issues.push({ path: `${path}.revisionKey`, message: "required" });
+  if (value.kind === "replace") {
+    if (value.replacesRevisionKey !== undefined && !isId(value.replacesRevisionKey)) {
+      issues.push({ path: `${path}.replacesRevisionKey`, message: "invalid" });
+    }
+    issues.push(...evidenceIssues(value.evidence, `${path}.evidence`));
+  } else if (value.kind === "append") {
+    if (!isId(value.targetBodyId))
+      issues.push({ path: `${path}.targetBodyId`, message: "id" });
+    if (!isId(value.chunkId))
+      issues.push({ path: `${path}.chunkId`, message: "id" });
+    if (!isCount2(value.chunkIndex))
+      issues.push({ path: `${path}.chunkIndex`, message: "count" });
+    if (!isCount2(value.offsetBytes))
+      issues.push({ path: `${path}.offsetBytes`, message: "count" });
+    if (typeof value.final !== "boolean")
+      issues.push({ path: `${path}.final`, message: "bool" });
+    issues.push(...bodyRefIssues(value.chunk, `${path}.chunk`));
+  } else {
+    issues.push({ path: `${path}.kind`, message: "expected replace or append" });
+  }
+  return issues;
+}
+function updatesIssues(value, path) {
+  if (!Array.isArray(value))
+    return [{ path, message: "expected an array" }];
+  if (value.length > MAX_EVIDENCE_UPDATES_PER_FRAME) {
+    return [{ path, message: `at most ${MAX_EVIDENCE_UPDATES_PER_FRAME} updates per frame` }];
+  }
+  return value.flatMap((update, index) => updateIssues(update, `${path}[${index}]`));
+}
+function gapCoverageIssues(value, path) {
+  if (!isPlainRecord(value))
+    return [{ path, message: "expected gap coverage" }];
+  switch (value.kind) {
+    case "frames":
+      return Array.isArray(value.frameIds) && value.frameIds.length <= MAX_GAP_FRAME_IDS && value.frameIds.every(isId) ? [] : [{ path: `${path}.frameIds`, message: "expected bounded frame ids" }];
+    case "source-sequence":
+      return isId(value.scopeId) && isId(value.epoch) && isUnsignedDecimal(value.fromInclusive) && isUnsignedDecimal(value.toInclusive) && compareUnsignedDecimal(value.fromInclusive, value.toInclusive) <= 0 ? [] : [{ path, message: "invalid sequence range" }];
+    case "unknown-range":
+      return isId(value.bindingId) && isId(value.runtimeEpoch) ? [] : [{ path, message: "invalid unknown range" }];
+    default:
+      return [{ path: `${path}.kind`, message: "unknown coverage kind" }];
+  }
+}
+function eventIssues(value, path) {
+  if (!isPlainRecord(value))
+    return [{ path, message: "expected an event" }];
+  const issues = [];
+  switch (value.kind) {
+    case "tool":
+      if (!oneOf(TOOL_KINDS2, value.toolKind))
+        issues.push({ path, message: "unknown tool kind" });
+      if (!oneOf(TOOL_PHASES, value.phase))
+        issues.push({ path, message: "unknown phase" });
+      if (!oneOf(EXECUTION_OCCURRENCE_VALUES, value.executionOccurrence)) {
+        issues.push({ path, message: "unknown execution occurrence" });
+      }
+      if (value.backgroundTaskId !== undefined && !isId(value.backgroundTaskId)) {
+        issues.push({ path: `${path}.backgroundTaskId`, message: "invalid id" });
+      }
+      issues.push(...updatesIssues(value.evidence, `${path}.evidence`));
+      break;
+    case "turn":
+      if (!oneOf(["proposed", "running", "succeeded", "failed", "cancelled", "unknown"], value.phase)) {
+        issues.push({ path, message: "unknown turn phase" });
+      }
+      if (!oneOf(["may-write", "quiescent", "unknown"], value.writerLiveness)) {
+        issues.push({ path, message: "unknown writer liveness" });
+      }
+      break;
+    case "background-task":
+      if (!isId(value.taskId))
+        issues.push({ path: `${path}.taskId`, message: "required" });
+      if (!oneOf(["running", "succeeded", "failed", "cancelled", "unknown"], value.phase)) {
+        issues.push({ path, message: "unknown task phase" });
+      }
+      if (!oneOf(EXECUTION_OCCURRENCE_VALUES, value.executionOccurrence)) {
+        issues.push({ path, message: "unknown execution occurrence" });
+      }
+      if (!oneOf(["may-write", "quiescent", "unknown"], value.writerLiveness)) {
+        issues.push({ path, message: "unknown writer liveness" });
+      }
+      issues.push(...updatesIssues(value.evidence, `${path}.evidence`));
+      break;
+    case "turn-diff":
+      if (!oneOf(["provider-reported", "unknown"], value.endpointMeaning)) {
+        issues.push({ path, message: "unknown endpoint meaning" });
+      }
+      issues.push(...updatesIssues(value.evidence, `${path}.evidence`));
+      break;
+    case "stream-gap":
+      if (!isId(value.gapId))
+        issues.push({ path: `${path}.gapId`, message: "required" });
+      if (typeof value.reason !== "string" || value.reason.length === 0) {
+        issues.push({ path: `${path}.reason`, message: "required" });
+      }
+      issues.push(...gapCoverageIssues(value.coverage, `${path}.coverage`));
+      break;
+    default:
+      issues.push({ path: `${path}.kind`, message: "unknown event kind" });
+  }
+  return issues;
+}
+function providerEvidenceFrameIssues(value) {
+  if (!isPlainRecord(value))
+    return [{ path: "$", message: "expected an object" }];
+  const issues = [];
+  if (value.schemaVersion !== PROVIDER_EVIDENCE_SCHEMA_VERSION) {
+    issues.push({ path: "schemaVersion", message: "unsupported" });
+  }
+  for (const key of ["bindingId", "runtimeEpoch", "capabilityRevision", "frameId"]) {
+    if (!isId(value[key]))
+      issues.push({ path: key, message: "required id" });
+  }
+  if (value.sourceSequence !== undefined) {
+    const seq = value.sourceSequence;
+    if (!isPlainRecord(seq) || !isId(seq.scopeId) || !isId(seq.epoch) || !isUnsignedDecimal(seq.value)) {
+      issues.push({ path: "sourceSequence", message: "invalid source sequence" });
+    }
+  }
+  if (value.sourceCursor !== undefined) {
+    const cursor = value.sourceCursor;
+    if (!isPlainRecord(cursor) || !isId(cursor.scopeId) || !isId(cursor.value)) {
+      issues.push({ path: "sourceCursor", message: "invalid source cursor" });
+    }
+  }
+  const source = value.source;
+  if (!isPlainRecord(source))
+    issues.push({ path: "source", message: "required" });
+  else {
+    if (!isId(source.conversationId)) {
+      issues.push({ path: "source.conversationId", message: "required" });
+    }
+    for (const key of [
+      "turnId",
+      "callId",
+      "parentCallId",
+      "parentConversationId",
+      "subagentId",
+      "itemId",
+      "attemptId",
+      "nativeRevision"
+    ]) {
+      if (source[key] !== undefined && !isId(source[key])) {
+        issues.push({ path: `source.${key}`, message: "invalid id" });
+      }
+    }
+    if (!oneOf(["live", "history", "reconciliation"], source.mode)) {
+      issues.push({ path: "source.mode", message: "unknown mode" });
+    }
+  }
+  issues.push(...eventIssues(value.event, "event"));
+  if (value.raw !== undefined)
+    issues.push(...bodyRefIssues(value.raw, "raw"));
+  if (issues.length > 0)
+    return issues;
+  const event = value.event;
+  const src = source;
+  if (event.kind === "tool" && !src.callId && !src.itemId) {
+    issues.push({ path: "source.callId", message: "tool frames need a native call identity" });
+  }
+  if ((event.kind === "turn" || event.kind === "turn-diff") && !src.turnId) {
+    issues.push({ path: "source.turnId", message: "turn frames need a turn identity" });
+  }
+  if (JSON.stringify(value).length > CANONICAL_FRAME_METADATA_MAX_BYTES) {
+    issues.push({ path: "$", message: "frame metadata exceeds its byte budget" });
+  }
+  return issues;
+}
+function isProviderEvidenceFrame(value) {
+  return providerEvidenceFrameIssues(value).length === 0;
+}
+var MAX_OBSERVATION_FILES = 200;
+function workspaceObservationReportIssues(value) {
+  if (!isPlainRecord(value))
+    return [{ path: "$", message: "expected an object" }];
+  const issues = [];
+  if (value.schemaVersion !== PROVIDER_EVIDENCE_SCHEMA_VERSION) {
+    issues.push({ path: "schemaVersion", message: "unsupported" });
+  }
+  for (const key of ["reportId", "bindingId", "runtimeEpoch", "capabilityRevision"]) {
+    if (!isId(value[key]))
+      issues.push({ path: key, message: "required id" });
+  }
+  const source = value.source;
+  if (!isPlainRecord(source) || !isId(source.conversationId)) {
+    issues.push({ path: "source", message: "conversation identity required" });
+  }
+  if (!oneOf(["host-worker", "container-worker"], value.executor)) {
+    issues.push({ path: "executor", message: "unknown executor" });
+  }
+  const boundary = value.boundary;
+  if (!isPlainRecord(boundary) || !oneOf(["fresh-before", "prior-observation", "late-start", "unknown"], boundary.before) || !oneOf(["after-terminal", "running-observation", "later-recovery", "unknown"], boundary.after)) {
+    issues.push({ path: "boundary", message: "invalid boundary" });
+  }
+  if (!oneOf(["known-overlap", "none-observed", "unknown"], value.overlap)) {
+    issues.push({ path: "overlap", message: "unknown overlap" });
+  }
+  if (!oneOf(["stable-observation", "changed-during-capture", "unknown"], value.consistency)) {
+    issues.push({ path: "consistency", message: "unknown consistency" });
+  }
+  const outcome = value.outcome;
+  if (!isPlainRecord(outcome))
+    issues.push({ path: "outcome", message: "required" });
+  else if (outcome.kind === "unavailable") {
+    if (typeof outcome.reason !== "string" || !outcome.reason) {
+      issues.push({ path: "outcome.reason", message: "required" });
+    }
+  } else if (outcome.kind === "measured") {
+    if (!isCount2(outcome.additions) || !isCount2(outcome.deletions) || !isCount2(outcome.changedFiles)) {
+      issues.push({ path: "outcome", message: "invalid totals" });
+    }
+    if (!Array.isArray(outcome.files) || outcome.files.length > MAX_OBSERVATION_FILES || !outcome.files.every((file) => isPlainRecord(file) && isPathValue(file.path) && (file.previousPath === undefined || isPathValue(file.previousPath)) && oneOf(["A", "D", "M", "R", "T", "unknown"], file.status) && (file.additions === null || isCount2(file.additions)) && (file.deletions === null || isCount2(file.deletions)) && typeof file.binary === "boolean")) {
+      issues.push({ path: "outcome.files", message: "invalid files" });
+    }
+    if (typeof outcome.filesTruncated !== "boolean") {
+      issues.push({ path: "outcome.filesTruncated", message: "required" });
+    }
+    if (!Array.isArray(outcome.omittedReasons) || !outcome.omittedReasons.every((reason) => typeof reason === "string")) {
+      issues.push({ path: "outcome.omittedReasons", message: "required" });
+    }
+  } else {
+    issues.push({ path: "outcome.kind", message: "unknown outcome" });
+  }
+  if (typeof value.observedAt !== "string")
+    issues.push({ path: "observedAt", message: "required" });
+  return issues;
+}
+
+// ../protocol/src/node/change-tracking/evidence-spool.ts
+import { createHash as createHash6, randomUUID as randomUUID3 } from "node:crypto";
+import { readdirSync, readFileSync } from "node:fs";
+import { appendFile as appendFile2, mkdir as mkdir3, rename as rename3, rm as rm4, writeFile as writeFile3 } from "node:fs/promises";
+import { join as join5 } from "node:path";
+var DEFAULT_EVIDENCE_SPOOL_LIMITS = {
+  maxEntries: 2048,
+  maxEntryBytes: 256 * 1024,
+  maxQueuedBytes: 16 * 1024 * 1024,
+  maxBodyBytes: 64 * 1024 * 1024,
+  maxSingleBodyBytes: 8 * 1024 * 1024,
+  maxReadEntries: 256,
+  maxReadBytes: 4 * 1024 * 1024
+};
+var ENTRIES_FILE = "entries.jsonl";
+var BODY_DIRECTORY = "bodies";
+function evidenceBodyId(bytes) {
+  return `sha256:${createHash6("sha256").update(bytes).digest("hex")}`;
+}
+function stableEvidenceId(...parts) {
+  const hash = createHash6("sha256");
+  for (const part of parts)
+    hash.update(`${part ?? ""}\x00`);
+  return hash.digest("hex").slice(0, 40);
+}
+
+class ChangeEvidenceSpool {
+  runtimeEpoch;
+  limits;
+  directory;
+  entries = [];
+  bodies = new Map;
+  capabilities = new Map;
+  seenFrameIds = new Set;
+  nextSeq = 1;
+  queuedBytes = 0;
+  bodyBytes = 0;
+  pendingBodies = new Set;
+  droppedFrameIds = [];
+  droppedUnknown = false;
+  gapBindingId = "";
+  io = Promise.resolve();
+  pendingLines = [];
+  flushScheduled = false;
+  restoring = false;
+  constructor(options = {}) {
+    this.limits = { ...DEFAULT_EVIDENCE_SPOOL_LIMITS, ...options.limits };
+    this.runtimeEpoch = options.runtimeEpoch ?? randomUUID3();
+    this.directory = options.directory;
+    if (this.directory) {
+      this.restoring = true;
+      try {
+        this.restore(this.directory);
+      } finally {
+        this.restoring = false;
+      }
+      this.compactPersisted();
+    }
+  }
+  declareCapabilities(capabilities) {
+    this.capabilities.set(capabilities.capabilityRevision, capabilities);
+  }
+  retainBody(content) {
+    const original = typeof content === "string" ? new TextEncoder().encode(content) : content;
+    const complete = original.length <= this.limits.maxSingleBodyBytes;
+    const bytes = complete ? original : original.subarray(0, this.limits.maxSingleBodyBytes);
+    const id = evidenceBodyId(bytes);
+    if (!this.bodies.has(id) && this.bodyBytes + bytes.length > this.limits.maxBodyBytes) {
+      return {
+        id: `unretained:${stableEvidenceId(evidenceBodyId(original))}`,
+        state: "unavailable",
+        retainedBytes: 0,
+        originalBytes: original.length,
+        complete: false,
+        unavailableReason: "bridge-spool-body-capacity"
+      };
+    }
+    if (!this.bodies.has(id)) {
+      this.bodies.set(id, { bytes, refs: 0 });
+      this.pendingBodies.add(id);
+      this.bodyBytes += bytes.length;
+      this.persistBody(id, bytes);
+    }
+    return {
+      id,
+      state: "available",
+      retainedBytes: bytes.length,
+      ...complete ? {} : { originalBytes: original.length },
+      complete
+    };
+  }
+  appendFrame(frame) {
+    if (this.seenFrameIds.has(frame.frameId)) {
+      this.releasePendingBodies();
+      return true;
+    }
+    this.gapBindingId ||= frame.bindingId;
+    const frameId = frame.frameId;
+    if (!isProviderEvidenceFrame(frame)) {
+      this.recordDrop(frameId);
+      this.releasePendingBodies();
+      return false;
+    }
+    this.seenFrameIds.add(frame.frameId);
+    if (this.seenFrameIds.size > this.limits.maxEntries * 4) {
+      const oldest = this.seenFrameIds.values().next().value;
+      if (oldest !== undefined)
+        this.seenFrameIds.delete(oldest);
+    }
+    this.gapBindingId ||= frame.bindingId;
+    const accepted = this.push({ seq: 0, type: "frame", frame }, collectBodyIds(frame), frame.frameId);
+    this.releasePendingBodies();
+    return accepted;
+  }
+  appendObservation(report) {
+    if (workspaceObservationReportIssues(report).length > 0)
+      return false;
+    this.gapBindingId ||= report.bindingId;
+    return this.push({ seq: 0, type: "observation", report }, [], report.reportId);
+  }
+  push(entry, bodyIds, identity) {
+    this.flushGap();
+    const serialized = JSON.stringify(entry);
+    const bytes = serialized.length;
+    if (bytes > this.limits.maxEntryBytes || this.entries.length >= this.limits.maxEntries - 1 || this.queuedBytes + bytes > this.limits.maxQueuedBytes) {
+      this.recordDrop(identity);
+      return false;
+    }
+    entry.seq = this.nextSeq++;
+    for (const id of bodyIds) {
+      const body = this.bodies.get(id);
+      if (body)
+        body.refs++;
+    }
+    this.entries.push({ entry, bytes, bodyIds });
+    this.queuedBytes += bytes;
+    this.persistEntry(entry);
+    return true;
+  }
+  recordDrop(identity) {
+    if (this.droppedFrameIds.length < 1000)
+      this.droppedFrameIds.push(identity);
+    else
+      this.droppedUnknown = true;
+  }
+  flushGap() {
+    if (this.droppedFrameIds.length === 0 && !this.droppedUnknown)
+      return;
+    if (this.entries.length >= this.limits.maxEntries - 1)
+      return;
+    const gapId = randomUUID3();
+    const coverage = this.droppedUnknown ? {
+      kind: "unknown-range",
+      bindingId: this.gapBindingId || "unknown",
+      runtimeEpoch: this.runtimeEpoch
+    } : { kind: "frames", frameIds: this.droppedFrameIds };
+    const gap = {
+      schemaVersion: PROVIDER_EVIDENCE_SCHEMA_VERSION,
+      bindingId: this.gapBindingId || "unknown",
+      runtimeEpoch: this.runtimeEpoch,
+      capabilityRevision: "spool",
+      frameId: `gap:${gapId}`,
+      source: { conversationId: "spool", mode: "live" },
+      event: { kind: "stream-gap", gapId, coverage, reason: "bridge-spool-capacity" }
+    };
+    this.droppedFrameIds = [];
+    this.droppedUnknown = false;
+    const entry = { seq: this.nextSeq++, type: "frame", frame: gap };
+    const bytes = JSON.stringify(entry).length;
+    this.entries.push({ entry, bytes, bodyIds: [] });
+    this.queuedBytes += bytes;
+    this.persistEntry(entry);
+  }
+  read(cursor, maxEntries = this.limits.maxReadEntries) {
+    this.flushGap();
+    const limit = Math.max(1, Math.min(maxEntries, this.limits.maxReadEntries));
+    const entries = [];
+    let bytes = 0;
+    let nextCursor = cursor;
+    for (const stored of this.entries) {
+      if (stored.entry.seq <= cursor)
+        continue;
+      if (entries.length >= limit)
+        break;
+      if (entries.length > 0 && bytes + stored.bytes > this.limits.maxReadBytes)
+        break;
+      entries.push(stored.entry);
+      bytes += stored.bytes;
+      nextCursor = stored.entry.seq;
+    }
+    return {
+      schemaVersion: PROVIDER_EVIDENCE_SCHEMA_VERSION,
+      runtimeEpoch: this.runtimeEpoch,
+      entries,
+      nextCursor,
+      pendingGap: this.droppedFrameIds.length > 0 || this.droppedUnknown,
+      capabilities: [...this.capabilities.values()]
+    };
+  }
+  readBody(id) {
+    return this.bodies.get(id)?.bytes ?? null;
+  }
+  acknowledge(request) {
+    if (request.runtimeEpoch !== this.runtimeEpoch)
+      return { released: 0 };
+    let released = 0;
+    while (this.entries.length > 0 && this.entries[0].entry.seq <= request.upTo) {
+      const stored = this.entries.shift();
+      this.queuedBytes -= stored.bytes;
+      released++;
+      for (const id of stored.bodyIds) {
+        const body = this.bodies.get(id);
+        if (body)
+          body.refs--;
+      }
+    }
+    this.releaseUnreferencedBodies([...request.retainedBodyIds, ...request.unavailableBodyIds]);
+    if (released > 0)
+      this.compactPersisted();
+    return { released };
+  }
+  releasePendingBodies() {
+    this.releaseUnreferencedBodies(this.pendingBodies);
+    this.pendingBodies.clear();
+  }
+  releaseUnreferencedBodies(ids) {
+    for (const id of Array.from(ids)) {
+      const body = this.bodies.get(id);
+      if (!body || body.refs > 0)
+        continue;
+      this.bodies.delete(id);
+      this.bodyBytes -= body.bytes.length;
+      this.removeBody(id);
+    }
+  }
+  stats() {
+    return {
+      entries: this.entries.length,
+      queuedBytes: this.queuedBytes,
+      bodies: this.bodies.size,
+      bodyBytes: this.bodyBytes
+    };
+  }
+  enqueueIo(operation) {
+    this.io = this.io.then(operation).catch(() => {});
+  }
+  persistEntry(entry) {
+    if (!this.directory || this.restoring)
+      return;
+    this.pendingLines.push(`${JSON.stringify({ epoch: this.runtimeEpoch, entry })}
+`);
+    if (this.flushScheduled)
+      return;
+    this.flushScheduled = true;
+    const timer = setTimeout(() => {
+      this.flushScheduled = false;
+      this.flushLines();
+    }, 0);
+    timer.unref?.();
+  }
+  flushLines() {
+    const directory = this.directory;
+    if (!directory || this.pendingLines.length === 0)
+      return;
+    const lines = this.pendingLines.splice(0).join("");
+    this.enqueueIo(async () => {
+      await mkdir3(directory, { recursive: true, mode: 448 });
+      await appendFile2(join5(directory, ENTRIES_FILE), lines, { mode: 384 });
+    });
+  }
+  persistBody(id, bytes) {
+    const directory = this.directory;
+    if (!directory || this.restoring)
+      return;
+    this.enqueueIo(async () => {
+      const bodies = join5(directory, BODY_DIRECTORY);
+      await mkdir3(bodies, { recursive: true, mode: 448 });
+      await writeFile3(join5(bodies, bodyFileName(id)), bytes, { mode: 384, flag: "wx" }).catch((error) => {
+        if (error.code !== "EEXIST")
+          throw error;
+      });
+    });
+  }
+  removeBody(id) {
+    const directory = this.directory;
+    if (!directory)
+      return;
+    this.enqueueIo(() => rm4(join5(directory, BODY_DIRECTORY, bodyFileName(id)), { force: true }));
+  }
+  compactPersisted() {
+    const directory = this.directory;
+    if (!directory)
+      return;
+    this.pendingLines.length = 0;
+    const body = this.entries.map((stored) => JSON.stringify({ epoch: this.runtimeEpoch, entry: stored.entry })).join(`
+`);
+    this.enqueueIo(async () => {
+      await mkdir3(directory, { recursive: true, mode: 448 });
+      const file = join5(directory, ENTRIES_FILE);
+      const temp = `${file}.${process.pid}.tmp`;
+      await writeFile3(temp, body ? `${body}
+` : "", { mode: 384 });
+      await rename3(temp, file);
+    });
+  }
+  async flush() {
+    this.flushLines();
+    await this.io;
+  }
+  restore(directory) {
+    const bodyDirectory = join5(directory, BODY_DIRECTORY);
+    try {
+      for (const name of readdirSync(bodyDirectory)) {
+        const bytes = new Uint8Array(readFileSync(join5(bodyDirectory, name)));
+        const id = evidenceBodyId(bytes);
+        if (bodyFileName(id) !== name)
+          continue;
+        if (this.bodyBytes + bytes.length > this.limits.maxBodyBytes)
+          break;
+        this.bodies.set(id, { bytes, refs: 0 });
+        this.bodyBytes += bytes.length;
+      }
+    } catch {}
+    let text = "";
+    try {
+      text = readFileSync(join5(directory, ENTRIES_FILE), "utf8");
+    } catch {
+      return;
+    }
+    for (const line of text.split(`
+`)) {
+      if (!line)
+        continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      const entry = parsed.entry;
+      if (!entry)
+        continue;
+      if (entry.type === "frame" && isProviderEvidenceFrame(entry.frame)) {
+        if (this.seenFrameIds.has(entry.frame.frameId))
+          continue;
+        this.seenFrameIds.add(entry.frame.frameId);
+        this.push({ ...entry, seq: 0 }, collectBodyIds(entry.frame), entry.frame.frameId);
+      } else if (entry.type === "observation" && workspaceObservationReportIssues(entry.report).length === 0) {
+        this.push({ ...entry, seq: 0 }, [], entry.report.reportId);
+      }
+    }
+    for (const [id, body] of Array.from(this.bodies)) {
+      if (body.refs > 0)
+        continue;
+      this.bodies.delete(id);
+      this.bodyBytes -= body.bytes.length;
+      this.removeBody(id);
+    }
+  }
+}
+function bodyFileName(id) {
+  return id.replace(/[^A-Za-z0-9]/g, "_");
+}
+function collectBodyIds(frame) {
+  const ids = new Set;
+  const add = (ref) => {
+    if (ref && ref.state === "available")
+      ids.add(ref.id);
+  };
+  add(frame.raw);
+  const event = frame.event;
+  const updates = event.kind === "tool" || event.kind === "background-task" || event.kind === "turn-diff" ? event.evidence : [];
+  for (const update of updates) {
+    if (update.kind === "append") {
+      add(update.chunk);
+      continue;
+    }
+    const evidence = update.evidence;
+    if (evidence.kind === "patch")
+      add(evidence.body);
+    if (evidence.kind === "replacement") {
+      if (evidence.before.state === "present")
+        add(evidence.before.body);
+      if (evidence.after.state === "present")
+        add(evidence.after.body);
+    }
+  }
+  return [...ids];
+}
+
+// ../protocol/src/node/change-tracking/evidence-builders.ts
+var MAX_KEY = 200;
+function clampId(value) {
+  return value.length <= MAX_KEY ? value : `${value.slice(0, 120)}~${stableEvidenceId(value)}`;
+}
+var MAX_TRACKED_REVISIONS = 4096;
+
+class ChangeEvidenceRecorder {
+  capabilityRevision;
+  lastRevisions = new Map;
+  capabilities;
+  spool;
+  provider;
+  executor;
+  constructor(options) {
+    this.spool = options.spool;
+    this.provider = options.provider;
+    this.executor = options.executor ?? "host-worker";
+    this.capabilityRevision = `cap:${stableEvidenceId(options.provider, JSON.stringify(options.capabilities))}`;
+    this.capabilities = { ...options.capabilities, capabilityRevision: this.capabilityRevision };
+    this.spool.declareCapabilities(this.capabilities);
+  }
+  bindingFor(conversationId) {
+    return clampId(`${this.provider}:${conversationId}`);
+  }
+  source(input) {
+    const source = {
+      conversationId: clampId(input.conversationId),
+      mode: input.mode ?? "live"
+    };
+    for (const key of [
+      "turnId",
+      "callId",
+      "parentCallId",
+      "parentConversationId",
+      "subagentId",
+      "itemId",
+      "attemptId",
+      "nativeRevision"
+    ]) {
+      const value = input[key];
+      if (value)
+        source[key] = clampId(value);
+    }
+    return source;
+  }
+  side(value, reason) {
+    if (value === null)
+      return { state: "absent" };
+    if (value === undefined)
+      return { state: "unknown", reason };
+    return { state: "present", body: this.spool.retainBody(value) };
+  }
+  updates(inputs) {
+    const counters = new Map;
+    return inputs.map((input) => {
+      const ordinal = counters.get(input.kind) ?? 0;
+      counters.set(input.kind, ordinal + 1);
+      const evidenceKey = clampId(input.key ?? `${input.kind}:${ordinal}`);
+      const evidence = this.evidence(input);
+      return {
+        kind: "replace",
+        evidenceKey,
+        revisionKey: `rev:${stableEvidenceId(evidenceKey, canonicalEvidence(evidence))}`,
+        evidence
+      };
+    });
+  }
+  evidence(input) {
+    switch (input.kind) {
+      case "patch":
+        return {
+          kind: "patch",
+          ...input.path ? { path: input.path } : {},
+          ...input.previousPath ? { previousPath: input.previousPath } : {},
+          body: this.spool.retainBody(input.text),
+          format: input.format ?? "git_unified",
+          effectClaim: input.claim
+        };
+      case "replacement":
+        return {
+          kind: "replacement",
+          path: input.path,
+          before: this.side(input.before, input.unknownReason ?? "before-not-supplied"),
+          after: this.side(input.after, input.unknownReason ?? "after-not-supplied"),
+          extent: input.extent,
+          origin: input.origin,
+          effectClaim: input.claim
+        };
+      case "reported-counts":
+        return {
+          kind: "reported-counts",
+          ...input.path ? { path: input.path } : {},
+          additions: input.additions,
+          deletions: input.deletions,
+          ...input.contentLines !== undefined ? { contentLines: input.contentLines } : {},
+          scope: input.scope,
+          effectClaim: input.claim
+        };
+      case "path-operation":
+        return {
+          kind: "path-operation",
+          path: input.path,
+          ...input.previousPath ? { previousPath: input.previousPath } : {},
+          operation: input.operation,
+          effectClaim: input.claim
+        };
+    }
+  }
+  frame(source, event, identity) {
+    const bindingId = this.bindingFor(source.conversationId);
+    return {
+      schemaVersion: PROVIDER_EVIDENCE_SCHEMA_VERSION,
+      bindingId,
+      runtimeEpoch: this.spool.runtimeEpoch,
+      capabilityRevision: this.capabilityRevision,
+      frameId: `frame:${stableEvidenceId(bindingId, identity)}`,
+      source: this.source(source),
+      event
+    };
+  }
+  tool(source, event) {
+    const updates = this.supersede(`${this.bindingFor(source.conversationId)}\x00${source.callId}\x00${source.attemptId ?? ""}`, this.updates(event.evidence ?? []));
+    const identity = [
+      "tool",
+      source.callId,
+      source.attemptId,
+      event.toolKind,
+      event.phase,
+      event.executionOccurrence,
+      event.backgroundTaskId,
+      ...updates.map((u) => u.revisionKey)
+    ].join("\x00");
+    return this.spool.appendFrame(this.frame(source, {
+      kind: "tool",
+      toolKind: event.toolKind,
+      phase: event.phase,
+      executionOccurrence: event.executionOccurrence,
+      evidence: updates,
+      ...event.backgroundTaskId ? { backgroundTaskId: clampId(event.backgroundTaskId) } : {}
+    }, identity));
+  }
+  supersede(scope, updates) {
+    return updates.map((update) => {
+      if (update.kind !== "replace")
+        return update;
+      const key = `${scope}\x00${update.evidenceKey}`;
+      const previous = this.lastRevisions.get(key);
+      const content = update.revisionKey;
+      const revisionKey = previous?.content === content ? previous.revision : previous ? `rev:${stableEvidenceId(scope, content, previous.revision)}` : content;
+      this.lastRevisions.delete(key);
+      this.lastRevisions.set(key, { content, revision: revisionKey });
+      if (this.lastRevisions.size > MAX_TRACKED_REVISIONS) {
+        const oldest = this.lastRevisions.keys().next().value;
+        if (oldest !== undefined)
+          this.lastRevisions.delete(oldest);
+      }
+      return {
+        ...update,
+        revisionKey,
+        ...previous && previous.revision !== revisionKey ? { replacesRevisionKey: previous.revision } : {}
+      };
+    });
+  }
+  turn(source, phase, writerLiveness = "unknown") {
+    return this.spool.appendFrame(this.frame(source, { kind: "turn", phase, writerLiveness }, ["turn", source.turnId, phase, writerLiveness].join("\x00")));
+  }
+  turnDiff(source, patch) {
+    const updates = this.supersede(`${this.bindingFor(source.conversationId)}\x00turn\x00${source.turnId}`, this.updates([{ kind: "patch", key: "turn-diff", text: patch, claim: "provider-reported" }]));
+    return this.spool.appendFrame(this.frame(source, { kind: "turn-diff", evidence: updates, endpointMeaning: "provider-reported" }, ["turn-diff", source.turnId, updates[0].revisionKey].join("\x00")));
+  }
+  backgroundTask(source, task) {
+    return this.spool.appendFrame(this.frame(source, {
+      kind: "background-task",
+      taskId: clampId(task.taskId),
+      ...task.parentCallId ? { parentCallId: clampId(task.parentCallId) } : {},
+      phase: task.phase,
+      executionOccurrence: task.executionOccurrence,
+      writerLiveness: task.writerLiveness,
+      evidence: []
+    }, ["task", task.taskId, task.phase, task.writerLiveness].join("\x00")));
+  }
+  observation(source, observation) {
+    const bindingId = this.bindingFor(source.conversationId);
+    const report = {
+      schemaVersion: PROVIDER_EVIDENCE_SCHEMA_VERSION,
+      reportId: `obs:${stableEvidenceId(bindingId, source.callId, source.attemptId, observation.windowId)}`,
+      bindingId,
+      runtimeEpoch: this.spool.runtimeEpoch,
+      capabilityRevision: this.capabilityRevision,
+      source: {
+        conversationId: clampId(source.conversationId),
+        ...source.turnId ? { turnId: clampId(source.turnId) } : {},
+        callId: clampId(source.callId),
+        ...source.attemptId ? { attemptId: clampId(source.attemptId) } : {}
+      },
+      executor: this.executor,
+      boundary: observation.boundary,
+      overlap: observation.overlap,
+      consistency: observation.consistency ?? "unknown",
+      outcome: observation.change ? measuredOutcome(observation.change, observation.omittedReasons ?? []) : { kind: "unavailable", reason: observation.unavailableReason ?? "capture-unavailable" },
+      observedAt: new Date().toISOString()
+    };
+    return this.spool.appendObservation(report);
+  }
+}
+function measuredOutcome(change, omittedReasons) {
+  const files = change.files.slice(0, 200).map((file) => ({
+    path: file.path,
+    ...file.previousPath ? { previousPath: file.previousPath } : {},
+    status: file.status ?? "unknown",
+    additions: file.binary ? null : file.additions,
+    deletions: file.binary ? null : file.deletions,
+    binary: file.binary === true
+  }));
+  return {
+    kind: "measured",
+    files,
+    additions: change.additions,
+    deletions: change.deletions,
+    changedFiles: change.filesTruncated ? Math.max(files.length, change.files.length) : files.length,
+    filesTruncated: change.filesTruncated === true,
+    omittedReasons
+  };
+}
+function bodyKey(ref) {
+  return `${ref.id}:${ref.state}:${ref.complete}`;
+}
+function canonicalEvidence(evidence) {
+  switch (evidence.kind) {
+    case "patch":
+      return [
+        "patch",
+        evidence.path,
+        evidence.previousPath,
+        evidence.format,
+        evidence.effectClaim,
+        bodyKey(evidence.body)
+      ].join("\x00");
+    case "replacement": {
+      const side = (value) => value.state === "present" ? `p:${bodyKey(value.body)}` : value.state === "absent" ? "a" : `u:${value.reason}`;
+      return [
+        "replacement",
+        evidence.path,
+        side(evidence.before),
+        side(evidence.after),
+        evidence.extent,
+        evidence.origin,
+        evidence.effectClaim
+      ].join("\x00");
+    }
+    case "reported-counts":
+      return [
+        "counts",
+        evidence.path,
+        evidence.additions,
+        evidence.deletions,
+        evidence.contentLines,
+        evidence.scope,
+        evidence.effectClaim
+      ].join("\x00");
+    case "path-operation":
+      return [
+        "path",
+        evidence.path,
+        evidence.previousPath,
+        evidence.operation,
+        evidence.effectClaim
+      ].join("\x00");
+  }
+}
+
+// ../../bridges/claude-bridge/src/services/change-evidence.ts
+function detectCaptureExecutor(exists = existsSync) {
+  return exists("/.dockerenv") || exists("/run/.containerenv") ? "container-worker" : "host-worker";
+}
+function claudeChangeCapabilities(executor) {
+  return {
+    resolution: "resolved",
+    beforeTurn: "controlled-dispatch",
+    afterTurn: "terminal-observed",
+    beforeTool: "awaited",
+    afterTool: "awaited",
+    historicalCallIdentity: "stable",
+    fileEvidence: { resolution: "confirmed", kinds: ["replacement"] },
+    turnDiff: "absent",
+    captureExecutor: executor,
+    captureAvailability: "ready",
+    backgroundCompletion: "launch-only"
+  };
+}
+function claudeToolKind(toolName) {
+  switch (toolName) {
+    case "Bash":
+      return "shell";
+    case "Edit":
+    case "MultiEdit":
+      return "file-edit";
+    case "Write":
+      return "file-write";
+    case "NotebookEdit":
+      return "notebook-edit";
+    case "Read":
+    case "Grep":
+    case "Glob":
+      return "read";
+    default:
+      return "other";
+  }
+}
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function text(value) {
+  return typeof value === "string" ? value : undefined;
+}
+function path(value) {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function claudeProposalEvidence(toolName, input) {
+  const fields = record(input);
+  switch (toolName) {
+    case "Edit": {
+      const filePath = path(fields.file_path);
+      if (!filePath)
+        return [];
+      return [
+        {
+          kind: "replacement",
+          key: "edit:0",
+          path: filePath,
+          before: text(fields.old_string),
+          after: text(fields.new_string),
+          unknownReason: "not-in-input",
+          extent: "fragment",
+          origin: "input",
+          claim: "proposal"
+        }
+      ];
+    }
+    case "MultiEdit": {
+      const filePath = path(fields.file_path);
+      if (!filePath || !Array.isArray(fields.edits))
+        return [];
+      return fields.edits.map((edit, index) => {
+        const entry = record(edit);
+        return {
+          kind: "replacement",
+          key: `edit:${index}`,
+          path: filePath,
+          before: text(entry.old_string),
+          after: text(entry.new_string),
+          unknownReason: "not-in-input",
+          extent: "fragment",
+          origin: "input",
+          claim: "proposal"
+        };
+      });
+    }
+    case "Write": {
+      const filePath = path(fields.file_path);
+      if (!filePath)
+        return [];
+      return [
+        {
+          kind: "replacement",
+          key: "write",
+          path: filePath,
+          before: undefined,
+          after: text(fields.content),
+          unknownReason: "before-not-captured",
+          extent: "whole-file",
+          origin: "input",
+          claim: "proposal"
+        }
+      ];
+    }
+    case "NotebookEdit": {
+      const filePath = path(fields.notebook_path);
+      if (!filePath)
+        return [];
+      const deleting = fields.edit_mode === "delete";
+      return [
+        {
+          kind: "replacement",
+          key: "cell",
+          path: filePath,
+          before: undefined,
+          after: deleting ? null : text(fields.new_source),
+          unknownReason: "before-not-captured",
+          extent: "notebook-cell",
+          origin: "input",
+          claim: "proposal"
+        }
+      ];
+    }
+    default:
+      return [];
+  }
 }
-function splitNul(value) {
-  return value.split("\x00").filter((entry) => entry.length > 0);
+function claudeToolResultOutcomes(message) {
+  const content = record(record(message).message).content;
+  if (!Array.isArray(content))
+    return [];
+  return content.flatMap((block) => {
+    const entry = record(block);
+    return entry.type === "tool_result" && typeof entry.tool_use_id === "string" && entry.tool_use_id ? [{ callId: entry.tool_use_id, isError: entry.is_error === true }] : [];
+  });
 }
-function skippedFilesChanged(before, after) {
-  if (before.size !== after.size)
+function claudeToolUses(message) {
+  const content = record(record(message).message).content;
+  if (!Array.isArray(content))
+    return [];
+  return content.flatMap((block) => {
+    const entry = record(block);
+    return entry.type === "tool_use" && typeof entry.id === "string" && entry.id && typeof entry.name === "string" ? [{ callId: entry.id, toolName: entry.name, input: entry.input }] : [];
+  });
+}
+function legacyCommandChange(observation) {
+  const change = observation?.change;
+  if (!change)
+    return;
+  if (observation.overlap === "known-overlap" || observation.boundary.before === "late-start" || observation.omittedReasons.length > 0) {
+    change.approximate = true;
+  }
+  return change;
+}
+var MAX_TRACKED_CALLS = 4096;
+function createChangeEvidence(options) {
+  const executor = options.executor ?? detectCaptureExecutor();
+  const spool = new ChangeEvidenceSpool(options.directory ? { directory: options.directory } : {});
+  const recorder = new ChangeEvidenceRecorder({
+    spool,
+    provider: "claude",
+    capabilities: claudeChangeCapabilities(executor),
+    executor
+  });
+  return {
+    spool,
+    recorder,
+    executor,
+    calls: new Map,
+    executed: new Map,
+    activeTurns: new Map
+  };
+}
+function claimSpoolDirectory() {
+  const scope = process.env.CWD || process.cwd();
+  const directory = join6(claudeChangeEvidenceDir(), createHash7("sha256").update(scope).digest("hex").slice(0, 32));
+  const owner = join6(directory, "owner.pid");
+  try {
+    mkdirSync(directory, { recursive: true, mode: 448 });
+    for (let attempt = 0;attempt < 2; attempt++) {
+      try {
+        const fd = openSync(owner, "wx", 384);
+        writeSync(fd, String(process.pid));
+        closeSync(fd);
+        return directory;
+      } catch (error) {
+        if (error.code !== "EEXIST")
+          return;
+        const holder = Number.parseInt(readFileSync2(owner, "utf8"), 10);
+        if (holder === process.pid)
+          return directory;
+        if (Number.isSafeInteger(holder) && holder > 0 && processIsAlive2(holder))
+          return;
+        rmSync2(owner, { force: true });
+      }
+    }
+  } catch {}
+  return;
+}
+function processIsAlive2(pid) {
+  try {
+    process.kill(pid, 0);
     return true;
-  for (const [path, stamp] of before) {
-    if (after.get(path) !== stamp)
-      return true;
+  } catch (error) {
+    return error.code === "EPERM";
   }
-  return false;
 }
-function parseNumstatZ(output) {
-  const tokens = output.split("\x00");
-  const files = [];
-  for (let index = 0;index < tokens.length; index += 1) {
-    const header = tokens[index];
-    if (!header)
-      continue;
-    const match = /^(-|\d+)\t(-|\d+)\t(.*)$/s.exec(header);
-    if (!match)
-      continue;
-    const [, rawAdditions, rawDeletions, inlinePath] = match;
-    let path = inlinePath ?? "";
-    let previousPath;
-    if (path === "") {
-      previousPath = tokens[index + 1];
-      path = tokens[index + 2] ?? "";
-      index += 2;
+var current;
+function claudeChangeEvidence() {
+  current ??= createChangeEvidence({
+    directory: claimSpoolDirectory()
+  });
+  return current;
+}
+function remember(map, key, value) {
+  map.delete(key);
+  map.set(key, value);
+  while (map.size > MAX_TRACKED_CALLS) {
+    const oldest = map.keys().next().value;
+    if (oldest === undefined)
+      break;
+    map.delete(oldest);
+  }
+}
+function emit(state, callId, call, phase, executionOccurrence) {
+  call.phase = phase;
+  const backgroundTaskId = state.executed.get(callId)?.backgroundTaskId;
+  state.recorder.tool({
+    conversationId: call.conversationId,
+    callId,
+    ...call.turnId ? { turnId: call.turnId } : {},
+    ...call.parentCallId ? { parentCallId: call.parentCallId } : {}
+  }, {
+    toolKind: call.toolKind,
+    phase,
+    executionOccurrence,
+    evidence: call.evidence,
+    ...backgroundTaskId && phase !== "running" ? { backgroundTaskId } : {}
+  });
+}
+function ensureCall(state, conversationId, callId, native) {
+  const existing = state.calls.get(callId);
+  if (existing) {
+    if (existing.evidence.length === 0 && native.toolName && native.input !== undefined) {
+      existing.evidence = claudeProposalEvidence(native.toolName, native.input);
     }
-    if (!path)
-      continue;
-    const binary = rawAdditions === "-" || rawDeletions === "-";
-    files.push({
-      path,
-      additions: binary ? 0 : Number(rawAdditions),
-      deletions: binary ? 0 : Number(rawDeletions),
-      ...binary ? { binary: true } : {},
-      ...previousPath ? { previousPath } : {}
-    });
+    if (existing.toolKind === "other" && native.toolName) {
+      existing.toolKind = claudeToolKind(native.toolName);
+    }
+    existing.turnId ??= native.turnId;
+    existing.parentCallId ??= native.parentCallId;
+    return existing;
   }
-  return files;
+  const turnId = native.turnId ?? state.activeTurns.get(conversationId);
+  const call = {
+    conversationId,
+    toolKind: claudeToolKind(native.toolName),
+    evidence: native.toolName && native.input !== undefined ? claudeProposalEvidence(native.toolName, native.input) : [],
+    phase: "unknown",
+    ...turnId ? { turnId } : {},
+    ...native.parentCallId ? { parentCallId: native.parentCallId } : {}
+  };
+  remember(state.calls, callId, call);
+  return call;
+}
+function recordClaudeTurn(conversationId, turnId, phase, writerLiveness = "unknown") {
+  const state = claudeChangeEvidence();
+  if (phase === "running")
+    remember(state.activeTurns, conversationId, turnId);
+  state.recorder.turn({ conversationId, turnId }, phase, writerLiveness);
+}
+function recordClaudeToolUse(conversationId, use) {
+  const state = claudeChangeEvidence();
+  const call = ensureCall(state, conversationId, use.callId, use);
+  if (call.phase === "denied")
+    emit(state, use.callId, call, "denied", "did-not-run");
+  else if (call.phase === "unknown")
+    emit(state, use.callId, call, "running", "unknown");
+}
+function recordClaudeToolAwaitingApproval(conversationId, callId, toolName, input) {
+  if (!callId)
+    return;
+  const state = claudeChangeEvidence();
+  const call = ensureCall(state, conversationId, callId, { toolName, input });
+  if (TERMINAL_TOOL_PHASES.has(call.phase))
+    return;
+  emit(state, callId, call, "awaiting-approval", "not-started");
+}
+function recordClaudePermissionDecision(conversationId, callId, toolName, input, behavior) {
+  if (!callId)
+    return;
+  const state = claudeChangeEvidence();
+  if (behavior === "deny") {
+    recordClaudeToolDenied(conversationId, callId, { toolName, input });
+    return;
+  }
+  const call = state.calls.get(callId);
+  if (call?.phase === "awaiting-approval")
+    emit(state, callId, call, "running", "unknown");
+}
+function recordClaudeToolDenied(conversationId, callId, native = {}) {
+  const state = claudeChangeEvidence();
+  const call = ensureCall(state, conversationId, callId, native);
+  if (TERMINAL_TOOL_PHASES.has(call.phase) && call.phase !== "denied")
+    return;
+  emit(state, callId, call, "denied", "did-not-run");
+}
+function recordClaudeToolExecuted(callId, backgroundTaskId) {
+  remember(claudeChangeEvidence().executed, callId, backgroundTaskId ? { backgroundTaskId } : {});
+}
+function recordClaudeToolResult(callId, isError) {
+  const state = claudeChangeEvidence();
+  const call = state.calls.get(callId);
+  if (!call || call.phase === "denied")
+    return;
+  const ran = state.executed.has(callId);
+  emit(state, callId, call, isError ? "failed" : "succeeded", !isError || ran ? "started" : "unknown");
+}
+function recordClaudeObservation(conversationId, callId, observation) {
+  const state = claudeChangeEvidence();
+  const call = state.calls.get(callId);
+  const turnId = call?.turnId ?? state.activeTurns.get(conversationId);
+  state.recorder.observation({
+    conversationId: call?.conversationId ?? conversationId,
+    callId,
+    ...turnId ? { turnId } : {}
+  }, {
+    boundary: observation.boundary,
+    overlap: observation.overlap,
+    ...observation.change ? { change: observation.change } : {},
+    omittedReasons: observation.omittedReasons,
+    ...observation.unavailableReason ? { unavailableReason: observation.unavailableReason } : {}
+  });
+}
+function claudeEvidenceTurnId(turn) {
+  return turn.dispatchRequestId || turn.promptUuid;
 }
 
 // ../../bridges/claude-bridge/src/services/command-changes.ts
-import { join as join5 } from "node:path";
 var commandChangeProbe = new WorkspaceChangeProbe;
 var COMMAND_CHANGE_HOOK_MATCHER = "^(Bash|Edit|Write|MultiEdit|NotebookEdit)$";
 var COMMAND_CHANGE_HOOK_TIMEOUT_SECONDS = 60;
@@ -8096,7 +9547,7 @@ function commandChangeJournal(sdkSessionId) {
   if (journal) {
     journals.delete(sdkSessionId);
   } else {
-    journal = new CommandChangeJournal(join5(claudeCommandChangesDir(), `${sdkSessionId}.jsonl`));
+    journal = new CommandChangeJournal(join7(claudeCommandChangesDir(), `${sdkSessionId}.jsonl`));
   }
   journals.set(sdkSessionId, journal);
   while (journals.size > MAX_CACHED_JOURNALS) {
@@ -8118,7 +9569,11 @@ function isMeasuredCommand(toolName, toolInput) {
   const input = toolInput && typeof toolInput === "object" ? toolInput : {};
   return input.run_in_background !== true;
 }
-function commandChangeHooks(onMeasured) {
+function backgroundTaskIdOf(response) {
+  const id = response?.backgroundTaskId;
+  return typeof id === "string" && id.length > 0 ? id : undefined;
+}
+function commandChangeHooks(onMeasured, conversationId) {
   const before = async (input) => {
     if (input.hook_event_name !== "PreToolUse" || !input.tool_use_id)
       return {};
@@ -8135,11 +9590,16 @@ function commandChangeHooks(onMeasured) {
     }
     if (!input.tool_use_id)
       return {};
-    const change = await commandChangeProbe.end(input.tool_use_id);
+    recordClaudeToolExecuted(input.tool_use_id, input.hook_event_name === "PostToolUse" ? backgroundTaskIdOf(input.tool_response) : undefined);
+    const observation = await commandChangeProbe.endObservation(input.tool_use_id);
+    const change = legacyCommandChange(observation);
     if (change && hasMeasuredChanges(change)) {
       commandChangeJournal(input.session_id)?.append(input.tool_use_id, change);
       onMeasured(input.tool_use_id, change);
     }
+    if (observation && conversationId) {
+      recordClaudeObservation(conversationId, input.tool_use_id, observation);
+    }
     return {};
   };
   const matcher = (hook) => ({
@@ -8837,7 +10297,7 @@ async function assertNoSymlinkComponents(lexicalRoot, targetPath) {
   const childPath = relative2(lexicalRoot, targetPath);
   let currentPath = lexicalRoot;
   for (const segment of childPath.split(sep).filter(Boolean)) {
-    currentPath = join6(currentPath, segment);
+    currentPath = join8(currentPath, segment);
     const stats = await lstat2(currentPath).catch((error) => {
       throw attachmentErrorForFsFailure(error);
     });
@@ -10366,11 +11826,84 @@ function createClaudeTurn(admission, input) {
 import { query as query2 } from "@anthropic-ai/claude-agent-sdk";
 
 // ../../bridges/claude-bridge/src/services/mcp-config.ts
-import { createHash as createHash6 } from "node:crypto";
-import { join as join7 } from "node:path";
+import { createHash as createHash8 } from "node:crypto";
+import { join as join9 } from "node:path";
+
+// ../protocol/src/agent-mail.ts
+var AGENT_MAIL_MAX_BODY_BYTES = 32 * 1024;
+var AGENT_MAIL_MAX_STORE_BYTES = 32 * 1024 * 1024;
+var AGENT_MAIL_DEFAULT_RETENTION_DAYS = 14;
+var AGENT_MAIL_DEFAULT_AUTONOMOUS_WAKE_BUDGET = 16;
+var AGENT_MAIL_DEFAULT_HOURLY_WAKE_LIMIT = 40;
+var AGENT_MAIL_TOOL_NAMES = Object.freeze([
+  "list_mailboxes",
+  "send_message",
+  "check_inbox",
+  "read_message",
+  "ack_message",
+  "reply_message",
+  "get_message_status"
+]);
+var DEFAULT_AGENT_MESSAGING_SETTINGS = Object.freeze({
+  enabled: true,
+  allowCrossProject: false,
+  defaultInjectPolicy: "off",
+  wakePeers: false,
+  autonomousWakeBudget: AGENT_MAIL_DEFAULT_AUTONOMOUS_WAKE_BUDGET,
+  hourlyWakeLimit: AGENT_MAIL_DEFAULT_HOURLY_WAKE_LIMIT,
+  coordinatorStatusWakes: "settled",
+  retentionDays: AGENT_MAIL_DEFAULT_RETENTION_DAYS,
+  paused: false
+});
+function agentMailCapabilities(tabType, agent, locked = true) {
+  if (tabType === "agent-native") {
+    if (!locked || !agent)
+      return { canPull: false, canSend: false, canInject: false };
+    if (agent === "claude" || agent === "codex" || agent === "opencode" || agent === "pi" || agent === "cursor" || agent === "grok") {
+      return { canPull: true, canSend: true, canInject: true };
+    }
+    return { canPull: false, canSend: false, canInject: false };
+  }
+  if (tabType === "claude-tmux")
+    return { canPull: true, canSend: true, canInject: true };
+  if (["claude", "codex", "opencode"].includes(tabType)) {
+    return { canPull: true, canSend: true, canInject: false };
+  }
+  if (["cursor", "grok", "pi"].includes(tabType)) {
+    return { canPull: false, canSend: false, canInject: false };
+  }
+  return { canPull: false, canSend: false, canInject: false };
+}
+var NATIVE_AGENT_MAIL_CAPABILITIES = Object.freeze(Object.fromEntries(AGENT_PLATFORMS.map((agent) => [agent, agentMailCapabilities("agent-native", agent)])));
+
+// ../protocol/src/transcript-artifacts.ts
+var ARTIFACT_TOOL_NAMES = Object.freeze([
+  "create_artifact",
+  "update_artifact",
+  "preview_artifact",
+  "publish_artifact",
+  "get_artifact",
+  "get_artifact_operation",
+  "cancel_artifact_operation"
+]);
+var ORKESTRATOR_ARTIFACT_MCP_SERVER_NAME = "orkestrator-artifacts";
+var ORKESTRATOR_ARTIFACT_MCP_PATH = "/artifact-mcp";
+
+// ../../bridges/claude-bridge/src/services/mcp-config.ts
 var AGENT_MCP_SERVER_NAME = "orkestrator";
 var AGENT_MCP_URL_ENV = "ORKESTRATOR_AGENT_MCP_URL";
 var AGENT_MCP_TOKEN_ENV = "ORKESTRATOR_AGENT_MCP_TOKEN";
+function getOrkestratorArtifactMcpServer(connection) {
+  const token = connection?.artifacts?.token?.trim();
+  const agentServer = getOrkestratorAgentMcpServerFromConnection(connection);
+  if (!token || Buffer.byteLength(token, "utf8") > 1024 || !agentServer)
+    return null;
+  return {
+    ...agentServer,
+    url: new URL(ORKESTRATOR_ARTIFACT_MCP_PATH, agentServer.url).toString(),
+    headers: { Authorization: `Bearer ${token}` }
+  };
+}
 function getOrkestratorAgentMcpServerFromConnection(connection) {
   if (!connection?.url?.trim() || !connection.token?.trim())
     return null;
@@ -10403,7 +11936,7 @@ async function loadGlobalMcpServers() {
   return servers ?? {};
 }
 async function loadProjectMcpServers(cwd) {
-  const servers = await readJsonSliceCached(join7(cwd, ".mcp.json"), "mcpServers", (config) => config?.mcpServers);
+  const servers = await readJsonSliceCached(join9(cwd, ".mcp.json"), "mcpServers", (config) => config?.mcpServers);
   return servers ?? {};
 }
 async function loadProjectOverridesFromGlobal2(cwd) {
@@ -10507,7 +12040,7 @@ async function loadScopedMcpServers(cwd, scope) {
   const [global2, projectGlobal, projectLocal] = await Promise.all([
     readJsonSliceCachedWithDigest(path, "mcpServers", (config) => config?.mcpServers),
     scope === "all" ? readJsonSliceCachedWithDigest(path, `projects:${cwd}:mcpServers`, (config) => config?.projects?.[cwd]?.mcpServers) : null,
-    scope === "all" ? readJsonSliceCachedWithDigest(join7(cwd, ".mcp.json"), "mcpServers", (config) => config?.mcpServers) : null
+    scope === "all" ? readJsonSliceCachedWithDigest(join9(cwd, ".mcp.json"), "mcpServers", (config) => config?.mcpServers) : null
   ]);
   const configs = {
     ...global2.value,
@@ -10521,7 +12054,7 @@ async function loadScopedMcpServers(cwd, scope) {
   return { configs, revision: { fingerprint: revisionFingerprint(sources), sources, scope } };
 }
 function revisionFingerprint(sources) {
-  return createHash6("sha256").update(`user=${sources.user}\x00project=${sources.project}`).digest("base64url");
+  return createHash8("sha256").update(`user=${sources.user}\x00project=${sources.project}`).digest("base64url");
 }
 async function getMcpRuntimeConfig(cwd, env = process.env, connection, sources = "all") {
   const { configs, revision } = await loadScopedMcpServers(cwd, normalizeScope(sources));
@@ -10535,14 +12068,20 @@ async function getMcpRuntimeConfig(cwd, env = process.env, connection, sources =
         url: new URL("/design-mcp", agentServer.url).toString()
       };
   }
+  const artifactServer = getOrkestratorArtifactMcpServer(connection);
+  if (artifactServer)
+    servers[ORKESTRATOR_ARTIFACT_MCP_SERVER_NAME] = artifactServer;
+  else
+    delete servers[ORKESTRATOR_ARTIFACT_MCP_SERVER_NAME];
   const research = normalizeScope(sources) === "none" ? coordinatorResearchMcpServersFromEnv(env) : [];
   for (const server of research)
     servers[server.name] = { type: "http", url: server.url };
   return {
     servers,
     names: new Set([
-      ...Object.keys(configs),
+      ...Object.keys(configs).filter((name) => name !== ORKESTRATOR_ARTIFACT_MCP_SERVER_NAME),
       ...agentServer ? [AGENT_MCP_SERVER_NAME, ...connection?.design ? ["orkestrator-design"] : []] : [],
+      ...artifactServer ? [ORKESTRATOR_ARTIFACT_MCP_SERVER_NAME] : [],
       ...research.map((server) => server.name)
     ]),
     revision
@@ -10550,7 +12089,7 @@ async function getMcpRuntimeConfig(cwd, env = process.env, connection, sources =
 }
 
 // ../../bridges/claude-bridge/src/services/session-manager-commands.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 
 // ../protocol/src/agent-command-catalogue.ts
 var NATIVE_AGENT_COMMAND_CATALOGUE_VERSION = 1;
@@ -10854,8 +12393,8 @@ function idleSteerPromptReply(prompt, agentLabel) {
 }
 
 // ../../bridges/claude-bridge/src/services/claude-terminal-commands.ts
-import { mkdir as mkdir3, readFile as readFile5, rename as rename3, writeFile as writeFile3 } from "node:fs/promises";
-import { join as join8 } from "node:path";
+import { mkdir as mkdir4, readFile as readFile5, rename as rename4, writeFile as writeFile4 } from "node:fs/promises";
+import { join as join10 } from "node:path";
 var FILE_NAME = "terminal-slash-commands.json";
 var MAX_VERSIONS = 4;
 var MAX_NAMES = 512;
@@ -10866,7 +12405,7 @@ var dirty = false;
 var entries = [];
 var writes = Promise.resolve();
 function filePath() {
-  return join8(claudeOrkestratorDir(), FILE_NAME);
+  return join10(claudeOrkestratorDir(), FILE_NAME);
 }
 function validVersion(value) {
   return typeof value === "string" && value.length > 0 && value.length <= MAX_VERSION_LENGTH;
@@ -10921,22 +12460,22 @@ function recordTerminalSlashCommands(version, commands) {
   writes = writes.then(async () => {
     await load();
     const directory = claudeOrkestratorDir();
-    await mkdir3(directory, { recursive: true });
+    await mkdir4(directory, { recursive: true });
     const target = filePath();
     const temporary = `${target}.${process.pid}.${Date.now()}.tmp`;
     const snapshot = entries;
-    await writeFile3(temporary, `${JSON.stringify({ versions: snapshot })}
+    await writeFile4(temporary, `${JSON.stringify({ versions: snapshot })}
 `, {
       mode: 384
     });
-    await rename3(temporary, target);
+    await rename4(temporary, target);
     if (entries === snapshot)
       dirty = false;
   }).catch(() => {});
 }
 
 // ../../bridges/claude-bridge/src/services/session-manager-catalog.ts
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash9 } from "node:crypto";
 
 // ../../bridges/claude-bridge/src/services/claude-sign-in.ts
 var AUTH_CACHE_TTL_MS = 30000;
@@ -11303,7 +12842,7 @@ async function steerClaudeSession(sessionId, text, requestId, expectedRunId) {
     requestId
   };
   const session = sessions.get(sessionId);
-  const inputDigest = createHash7("sha256").update(text).digest("hex");
+  const inputDigest = createHash9("sha256").update(text).digest("hex");
   const previous = session?.steerJournal?.get(requestId);
   if (previous) {
     if (previous.inputDigest !== inputDigest || previous.expectedRunId !== expectedRunId) {
@@ -11452,7 +12991,7 @@ async function gracefulInterruptClaudeSession(sessionId) {
 }
 
 // ../../bridges/claude-bridge/src/services/session-manager-commands.ts
-var CATALOGUE_GENERATION = randomUUID3();
+var CATALOGUE_GENERATION = randomUUID4();
 var COMMAND_PROBE_TIMEOUT_MS = 30000;
 var MAX_LOCAL_COMMAND_OUTPUT_BYTES = 64 * 1024;
 var MAX_MESSAGE_BYTES = 512;
@@ -12070,55 +13609,8 @@ function createStaleMcpServerHook(mcp) {
   };
 }
 
-// ../protocol/src/agent-mail.ts
-var AGENT_MAIL_MAX_BODY_BYTES = 32 * 1024;
-var AGENT_MAIL_MAX_STORE_BYTES = 32 * 1024 * 1024;
-var AGENT_MAIL_DEFAULT_RETENTION_DAYS = 14;
-var AGENT_MAIL_DEFAULT_AUTONOMOUS_WAKE_BUDGET = 16;
-var AGENT_MAIL_DEFAULT_HOURLY_WAKE_LIMIT = 40;
-var AGENT_MAIL_TOOL_NAMES = Object.freeze([
-  "list_mailboxes",
-  "send_message",
-  "check_inbox",
-  "read_message",
-  "ack_message",
-  "reply_message",
-  "get_message_status"
-]);
-var DEFAULT_AGENT_MESSAGING_SETTINGS = Object.freeze({
-  enabled: true,
-  allowCrossProject: false,
-  defaultInjectPolicy: "off",
-  wakePeers: false,
-  autonomousWakeBudget: AGENT_MAIL_DEFAULT_AUTONOMOUS_WAKE_BUDGET,
-  hourlyWakeLimit: AGENT_MAIL_DEFAULT_HOURLY_WAKE_LIMIT,
-  coordinatorStatusWakes: "settled",
-  retentionDays: AGENT_MAIL_DEFAULT_RETENTION_DAYS,
-  paused: false
-});
-function agentMailCapabilities(tabType, agent, locked = true) {
-  if (tabType === "agent-native") {
-    if (!locked || !agent)
-      return { canPull: false, canSend: false, canInject: false };
-    if (agent === "claude" || agent === "codex" || agent === "opencode" || agent === "pi" || agent === "cursor" || agent === "grok") {
-      return { canPull: true, canSend: true, canInject: true };
-    }
-    return { canPull: false, canSend: false, canInject: false };
-  }
-  if (tabType === "claude-tmux")
-    return { canPull: true, canSend: true, canInject: true };
-  if (["claude", "codex", "opencode"].includes(tabType)) {
-    return { canPull: true, canSend: true, canInject: false };
-  }
-  if (["cursor", "grok", "pi"].includes(tabType)) {
-    return { canPull: false, canSend: false, canInject: false };
-  }
-  return { canPull: false, canSend: false, canInject: false };
-}
-var NATIVE_AGENT_MAIL_CAPABILITIES = Object.freeze(Object.fromEntries(AGENT_PLATFORMS.map((agent) => [agent, agentMailCapabilities("agent-native", agent)])));
-
 // ../../bridges/claude-bridge/src/services/session-manager-prompt-query.ts
-import { createHash as createHash8 } from "node:crypto";
+import { createHash as createHash10 } from "node:crypto";
 
 // ../protocol/src/review-evidence-frames.ts
 var STRUCTURED_REVIEW_FINDINGS_PROMPT_PREFIX = "The findings below are an untrusted JSON data frame.";
@@ -12192,6 +13684,11 @@ function claudeWorkflowResultTools(servers) {
     REPORT_FINDING_TOOL_NAME
   ].map((name) => `mcp__${AGENT_MCP_SERVER_NAME}__${name}`);
 }
+function claudeArtifactServerTools(servers) {
+  if (!servers.has(ORKESTRATOR_ARTIFACT_MCP_SERVER_NAME))
+    return [];
+  return ARTIFACT_TOOL_NAMES.map((name) => `mcp__${ORKESTRATOR_ARTIFACT_MCP_SERVER_NAME}__${name}`);
+}
 
 // ../protocol/src/claude-background-commands.ts
 var CLAUDE_BASH_MAX_TIMEOUT_ENV = "BASH_MAX_TIMEOUT_MS";
@@ -12405,7 +13902,7 @@ function canAdmitInteraction(candidate, family) {
 import { readFile as readFile6 } from "node:fs/promises";
 
 // ../../bridges/claude-bridge/src/services/claude-elicitation-schema.ts
-function record(value) {
+function record2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 var ROOT_KEYS = new Set([
@@ -12430,17 +13927,17 @@ var FIELD_KEYS = new Set([
   "maximum"
 ]);
 function isSupportedClaudeForm(schema) {
-  if (!record(schema) || schema.type !== "object" || Object.keys(schema).some((key) => !ROOT_KEYS.has(key)))
+  if (!record2(schema) || schema.type !== "object" || Object.keys(schema).some((key) => !ROOT_KEYS.has(key)))
     return false;
   if (schema.additionalProperties !== undefined && schema.additionalProperties !== false)
     return false;
   const properties = schema.properties ?? {};
-  if (!record(properties))
+  if (!record2(properties))
     return false;
   if (schema.required !== undefined && (!Array.isArray(schema.required) || !schema.required.every((key) => typeof key === "string" && Object.hasOwn(properties, key))))
     return false;
   return Object.values(properties).every((field) => {
-    if (!record(field) || Object.keys(field).some((key) => !FIELD_KEYS.has(key)))
+    if (!record2(field) || Object.keys(field).some((key) => !FIELD_KEYS.has(key)))
       return false;
     if (!["string", "number", "integer", "boolean"].includes(String(field.type)))
       return false;
@@ -12460,7 +13957,7 @@ function isSupportedClaudeForm(schema) {
   });
 }
 function isValidClaudeFormContent(schema, content) {
-  if (!isSupportedClaudeForm(schema) || !record(content))
+  if (!isSupportedClaudeForm(schema) || !record2(content))
     return false;
   const properties = schema.properties ?? {};
   if (schema.required?.some((key) => !Object.hasOwn(content, key)))
@@ -12987,8 +14484,21 @@ function shellTaskHooks(session) {
   const matcher = { matcher: "^Bash$", hooks: [hook] };
   return { PreToolUse: matcher, PostToolUse: matcher, PostToolUseFailure: matcher };
 }
-function commandChangeHookFor(route) {
-  return commandChangeHooks((toolUseId, change) => route(toolUseId).applyCommandChanges(toolUseId, change));
+function commandChangeHookFor(route, conversationId) {
+  return commandChangeHooks((toolUseId, change) => route(toolUseId).applyCommandChanges(toolUseId, change), conversationId);
+}
+function recordingHookDenials(hook, conversationId) {
+  return async (input, toolUseId, options) => {
+    const output = await hook(input, toolUseId, options);
+    const decision = output.hookSpecificOutput?.permissionDecision;
+    if (input.hook_event_name === "PreToolUse" && input.tool_use_id && decision === "deny") {
+      recordClaudeToolDenied(conversationId, input.tool_use_id, {
+        toolName: input.tool_name,
+        input: input.tool_input
+      });
+    }
+    return output;
+  };
 }
 function turnHook(turn, hook) {
   return (hookInput) => hook(turn, hookInput);
@@ -13035,7 +14545,7 @@ async function resolveQueryPlan(turn, sdkTextPrompt, testHooks) {
     "Agent"
   ];
   const coordinatorReadOnly = isCoordinatorReadOnlyPolicy(policy);
-  const agentMailTools = mcpServerNames.has(AGENT_MCP_SERVER_NAME) ? AGENT_MAIL_TOOL_NAMES.map((name) => `mcp__${AGENT_MCP_SERVER_NAME}__${name}`) : [];
+  const agentMailTools = mcpServerNames.has(AGENT_MCP_SERVER_NAME) ? [...AGENT_MAIL_TOOL_NAMES, ...ARTIFACT_TOOL_NAMES].map((name) => `mcp__${AGENT_MCP_SERVER_NAME}__${name}`) : [];
   const allowedTools = coordinatorReadOnly ? claudeReadOnlyAllowedTools({
     agentMcpServerNames: mcpServerNames.has(AGENT_MCP_SERVER_NAME) ? [AGENT_MCP_SERVER_NAME] : [],
     policy,
@@ -13043,7 +14553,8 @@ async function resolveQueryPlan(turn, sdkTextPrompt, testHooks) {
   }) : [
     ...policy?.toolPolicy?.allow ?? defaultAllowedTools,
     ...agentMailTools,
-    ...claudeWorkflowResultTools(mcpServerNames)
+    ...claudeWorkflowResultTools(mcpServerNames),
+    ...claudeArtifactServerTools(mcpServerNames)
   ];
   const disallowedTools = coordinatorReadOnly ? claudeDeniedTools(policy) : claudeDisallowedTools(policy);
   const fastMode = options?.fastMode === true;
@@ -13075,7 +14586,7 @@ async function resolveQueryPlan(turn, sdkTextPrompt, testHooks) {
     parameterValues: options?.parameterValues,
     fastMode
   });
-  const mcpServersKey = createHash8("sha256").update(JSON.stringify(mcpServers)).digest("hex");
+  const mcpServersKey = createHash10("sha256").update(JSON.stringify(mcpServers)).digest("hex");
   return {
     cwd,
     policy,
@@ -13132,7 +14643,7 @@ function claudeQueryOptions(turn, plan, turnFor, mcp) {
   } = plan;
   const latestTurnHook = (pick) => (...args) => pick(turnFor())(...args);
   const backgroundTaskHook = latestTurnHook((target) => target.recordBackgroundTaskHook);
-  const commandChangeHook = commandChangeHookFor(turnFor);
+  const commandChangeHook = commandChangeHookFor(turnFor, session.id);
   const shellTaskHook = shellTaskHooks(session);
   return {
     cwd,
@@ -13196,8 +14707,8 @@ function claudeQueryOptions(turn, plan, turnFor, mcp) {
     plugins: pluginCount > 0 ? plugins : undefined,
     hooks: {
       PreToolUse: [
-        ...coordinatorReadOnly && policy ? [{ hooks: [createCoordinatorReadOnlyHook(policy)] }] : [],
-        { hooks: [createStaleMcpServerHook(mcp)] },
+        ...coordinatorReadOnly && policy ? [{ hooks: [recordingHookDenials(createCoordinatorReadOnlyHook(policy), session.id)] }] : [],
+        { hooks: [recordingHookDenials(createStaleMcpServerHook(mcp), session.id)] },
         commandChangeHook.PreToolUse,
         shellTaskHook.PreToolUse
       ],
@@ -13218,19 +14729,19 @@ function claudeQueryOptions(turn, plan, turnFor, mcp) {
 }
 
 // ../../bridges/claude-bridge/src/services/diagnostics.ts
-function record2(value) {
+function record3(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function observeClaudeMessage(diagnostics, message) {
   diagnostics.activity("message");
   diagnostics.streamEvent();
-  if (!record2(message))
+  if (!record3(message))
     return;
-  const body = record2(message.message) ? message.message : undefined;
+  const body = record3(message.message) ? message.message : undefined;
   if (!Array.isArray(body?.content))
     return;
   for (const block of body.content.slice(0, 512)) {
-    if (!record2(block))
+    if (!record3(block))
       continue;
     if (block.type === "tool_use") {
       const name = typeof block.name === "string" && block.name.length <= 64 ? block.name.toLowerCase() : "other";
@@ -13327,6 +14838,14 @@ function handleAssistantMessage(turn, message) {
     stream.pendingPlanRejectionFeedback = null;
   }
   const { orderedParts, newTaskIds, contentBlockCount } = parseMessageContent(message, toolTracker, turn.mcpServerNames, activeTaskIds, taskRegistry, receivedAt, recordUnknownContentBlock);
+  const evidenceParent = message.parent_tool_use_id;
+  for (const use of claudeToolUses(message)) {
+    recordClaudeToolUse(sessionId, {
+      ...use,
+      turnId: claudeEvidenceTurnId(turn),
+      ...typeof evidenceParent === "string" && evidenceParent ? { parentCallId: evidenceParent } : {}
+    });
+  }
   if (turn.runtime && turn.thisTurn) {
     for (const toolUseId of toolUseIdsFromAssistantMessage(message)) {
       recordClaudeToolOwner(turn.runtime, toolUseId, turn.thisTurn);
@@ -13363,10 +14882,10 @@ function handleAssistantMessage(turn, message) {
 var MAX_INIT_PLUGINS = 128;
 var MAX_INIT_PLUGIN_ERRORS = 64;
 var MAX_PLUGIN_ERROR_LENGTH = 1000;
-function text(value, limit) {
+function text2(value, limit) {
   return typeof value === "string" && value.length > 0 ? value.slice(0, limit) : undefined;
 }
-function record3(value) {
+function record4(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
 }
 function errorNamesRow(pluginId, errorPath, row) {
@@ -13389,11 +14908,11 @@ function pluginStatusesFromInit(init) {
   const statuses = [];
   const mcpServers = Array.isArray(init.mcp_servers) ? init.mcp_servers : [];
   for (const candidate of mcpServers) {
-    const server = record3(candidate);
-    const name = text(server?.name, 256);
+    const server = record4(candidate);
+    const name = text2(server?.name, 256);
     if (!name?.startsWith("plugin:"))
       continue;
-    const error = text(server?.error, MAX_PLUGIN_ERROR_LENGTH);
+    const error = text2(server?.error, MAX_PLUGIN_ERROR_LENGTH);
     statuses.push({
       name,
       status: server?.status === "connected" ? "loaded" : "failed",
@@ -13403,24 +14922,24 @@ function pluginStatusesFromInit(init) {
   const plugins = Array.isArray(init.plugins) ? init.plugins : [];
   const loadedRows = [];
   for (const candidate of plugins) {
-    const plugin = record3(candidate);
-    const name = text(plugin?.name, 256);
+    const plugin = record4(candidate);
+    const name = text2(plugin?.name, 256);
     if (!name)
       continue;
-    const path = text(plugin?.path, 4096);
+    const path = text2(plugin?.path, 4096);
     loadedRows.push({ name, ...path ? { path } : {}, status: "loaded" });
   }
   statuses.push(...loadedRows);
   const errors = [];
   const rawErrors = Array.isArray(init.plugin_errors) ? init.plugin_errors : [];
   for (const candidate of rawErrors.slice(0, MAX_INIT_PLUGIN_ERRORS)) {
-    const entry = record3(candidate);
-    const pluginId = text(entry?.plugin, 256);
+    const entry = record4(candidate);
+    const pluginId = text2(entry?.plugin, 256);
     if (!pluginId)
       continue;
-    const message = text(entry?.message, MAX_PLUGIN_ERROR_LENGTH) ?? "Plugin failed to load";
-    const type = text(entry?.type, 128) ?? "generic-error";
-    const path = text(entry?.path, 4096);
+    const message = text2(entry?.message, MAX_PLUGIN_ERROR_LENGTH) ?? "Plugin failed to load";
+    const type = text2(entry?.type, 128) ?? "generic-error";
+    const path = text2(entry?.path, 4096);
     const row = loadedRows.find((candidateRow) => errorNamesRow(pluginId, path, candidateRow));
     if (row) {
       row.error ??= message;
@@ -14154,6 +15673,7 @@ function handlePermissionDenied(turn, message) {
   const reason = boundedNoticeText(denial.decision_reason ?? denial.message);
   if (typeof denial.tool_use_id === "string") {
     commandChangeProbe.discard(denial.tool_use_id);
+    recordClaudeToolDenied(sessionId, denial.tool_use_id, typeof denial.tool_name === "string" ? { toolName: denial.tool_name } : {});
   }
   const marked = typeof denial.tool_use_id === "string" && toolTracker.recordDenial(denial.tool_use_id, {
     reason,
@@ -14253,6 +15773,9 @@ function handleUserMessage(turn, message) {
       toolTracker.setCommandChanges(toolUseId, pending);
     }
   }
+  for (const outcome of claudeToolResultOutcomes(sdkUserMessage)) {
+    recordClaudeToolResult(outcome.callId, outcome.isError);
+  }
   let settledProvisionalTask = false;
   for (const outcome of bashToolResultOutcomes(sdkUserMessage, toolTracker)) {
     if (outcome.launch) {
@@ -14569,12 +16092,13 @@ Please revise the plan based on this feedback.` : `I've reviewed the plan and I
       planApprovalResolvers.delete(approvalId);
     }
   }
-  if (claudeWorkflowResultTools(turn.mcpServerNames).includes(toolName) && !session.executionPolicy?.toolPolicy?.deny?.includes(toolName)) {
+  if ((claudeWorkflowResultTools(turn.mcpServerNames).includes(toolName) || claudeArtifactServerTools(turn.mcpServerNames).includes(toolName)) && !session.executionPolicy?.toolPolicy?.deny?.includes(toolName)) {
     return { behavior: "allow", updatedInput: input };
   }
   const turnPolicy = claudeTurnPolicy(session.executionPolicy, turn.options?.readOnly);
   const approvals = turnPolicy?.approvals;
   if (claudeAsksForApproval(turnPolicy, turn.options)) {
+    recordClaudeToolAwaitingApproval(sessionId, permissionContext?.toolUseID, toolName, input);
     return requestClaudeToolApproval(sessionId, toolName, input, permissionContext);
   }
   if (approvals === "deny") {
@@ -14594,7 +16118,13 @@ function createClaudeRuntimeTurn(turn) {
   return {
     handleMessage: (message) => handleTurnMessage(turn, message),
     pushSteerInput: (message) => pushSteerInput(turn, message),
-    canUseTool: (toolName, input, permissionContext) => turnCanUseTool(turn, toolName, input, permissionContext),
+    canUseTool: async (toolName, input, permissionContext) => {
+      const decision = await turnCanUseTool(turn, toolName, input, permissionContext);
+      if (decision) {
+        recordClaudePermissionDecision(turn.sessionId, permissionContext?.toolUseID, toolName, input, decision.behavior);
+      }
+      return decision;
+    },
     recordBackgroundTaskHook: turnHook(turn, recordBackgroundTaskHook),
     recordPreCompact: turnHook(turn, recordPreCompact),
     recordPostCompact: turnHook(turn, recordPostCompact),
@@ -15077,6 +16607,16 @@ function finalizeTurn(turn) {
 }
 
 // ../../bridges/claude-bridge/src/services/session-manager-prompt.ts
+function turnWriterLiveness(turn) {
+  const tasks = Object.values(turn.session.backgroundTasks ?? {});
+  if (tasks.some((task) => LIVE_BACKGROUND_TASK_STATUSES.has(task.status)))
+    return "may-write";
+  return turn.runtime?.state === "ended" ? "quiescent" : "unknown";
+}
+function recordTurnOutcome(turn, failed) {
+  const phase = turn.abortController.signal.aborted ? "cancelled" : failed ? "failed" : turn.receivedPromptResult ? "succeeded" : "unknown";
+  recordClaudeTurn(turn.sessionId, claudeEvidenceTurnId(turn), phase, turnWriterLiveness(turn));
+}
 async function sendPrompt(sessionId, prompt, options, testHooks) {
   const admission = admitPrompt(sessionId, options);
   if (!admission)
@@ -15093,11 +16633,16 @@ async function sendPrompt(sessionId, prompt, options, testHooks) {
     userMessage,
     transcriptHydrationFailed
   });
+  let turnRunning = false;
   try {
     const plan = await resolveQueryPlan(turn, sdkTextPrompt, testHooks);
     if (!await runTurnOnRuntime(turn, plan, testHooks))
       return;
+    turnRunning = true;
+    recordClaudeTurn(sessionId, claudeEvidenceTurnId(turn), "running", "may-write");
     await turn.turnEnded;
+    turnRunning = false;
+    recordTurnOutcome(turn, false);
     const followUp = settleTurnEnd(turn);
     if (!followUp)
       return;
@@ -15108,6 +16653,8 @@ async function sendPrompt(sessionId, prompt, options, testHooks) {
       return Promise.reject(repromptError);
     }
   } catch (error) {
+    if (turnRunning)
+      recordTurnOutcome(turn, true);
     settleFailedTurn(turn, error);
   } finally {
     finalizeTurn(turn);
@@ -15217,7 +16764,7 @@ config.get("/models", async (c) => {
 var config_default = config;
 
 // ../../bridges/claude-bridge/src/routes/session.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 
 // ../../node_modules/.bun/hono@4.13.13/node_modules/hono/dist/middleware/body-limit/index.js
 var ERROR_MESSAGE = "Payload Too Large";
@@ -15604,7 +17151,7 @@ sessionActivityBatch.post(SESSION_ACTIVITY_BATCH_PATH, async (c) => {
 
 // ../protocol/src/node/bridge-transcript-summary.ts
 import { Buffer as Buffer3 } from "node:buffer";
-import { createHash as createHash9 } from "node:crypto";
+import { createHash as createHash11 } from "node:crypto";
 
 // ../protocol/src/node/progressive-transcript.ts
 var BRIDGE_TRANSCRIPT_MAX_MESSAGES = 100;
@@ -15770,7 +17317,7 @@ function digestPayload(payload) {
   const serialized = JSON.stringify(payload);
   return {
     bytes: Buffer3.byteLength(serialized),
-    digest: createHash9("sha256").update(serialized).digest("base64url").slice(0, 32)
+    digest: createHash11("sha256").update(serialized).digest("base64url").slice(0, 32)
   };
 }
 function topLevelKey(part, index) {
@@ -16163,7 +17710,7 @@ function registerSessionTranscriptRoutes(app, generation) {
 
 // ../../bridges/claude-bridge/src/routes/session.ts
 var session = new Hono2;
-var TRANSCRIPT_GENERATION = randomUUID4();
+var TRANSCRIPT_GENERATION = randomUUID5();
 var MAX_IMAGE_ATTACHMENT_BYTES2 = 8 * 1024 * 1024;
 var MAX_QUESTION_ANSWER_REQUEST_BYTES = AGENT_INTERACTION_LIMITS.maxSerializedPayloadBytes + 1024;
 var MAX_CLAUDE_TRANSCRIPT_RESPONSE_BYTES = 16 * 1024 * 1024;
@@ -16206,6 +17753,13 @@ var STALE_PROMPT_STATUS = 409;
 function stalePrompt(message) {
   return { error: message, status: "stale" };
 }
+function agentMcpArtifactsToken(record) {
+  const artifacts = record.artifacts;
+  if (!artifacts || typeof artifacts !== "object" || Array.isArray(artifacts))
+    return;
+  const token = artifacts.token;
+  return typeof token === "string" && token.length > 0 && token.length <= 1024 ? token : undefined;
+}
 function errorMessage(error, fallback) {
   return error instanceof Error && error.message ? error.message : fallback;
 }
@@ -16536,10 +18090,12 @@ session.post("/:id/prompt", async (c) => {
     const effort = resolvedEffort;
     const outputSchema = body.outputSchema;
     const agentMcpRecord = body.agentMcp && typeof body.agentMcp === "object" && !Array.isArray(body.agentMcp) ? body.agentMcp : undefined;
+    const artifactsToken = agentMcpRecord ? agentMcpArtifactsToken(agentMcpRecord) : undefined;
     const agentMcp = typeof agentMcpRecord?.url === "string" && typeof agentMcpRecord.token === "string" ? {
       url: agentMcpRecord.url,
       token: agentMcpRecord.token,
-      ...agentMcpRecord.design === true ? { design: true } : {}
+      ...agentMcpRecord.design === true ? { design: true } : {},
+      ...artifactsToken ? { artifacts: { token: artifactsToken } } : {}
     } : undefined;
     const requestId = typeof body.requestId === "string" && body.requestId.trim().length > 0 ? body.requestId.trim() : outputSchema === undefined ? undefined : crypto.randomUUID();
     if (outputSchema !== undefined && !isJsonSchema(outputSchema)) {
@@ -17051,6 +18607,68 @@ registerHoldRoute("plan-approvals", "approvalId");
 registerHoldRoute("interactions", "interactionId");
 var session_default = session;
 
+// ../protocol/src/node/change-tracking/evidence-routes.ts
+var CHANGE_EVIDENCE_ROUTE = "/change-evidence";
+var CHANGE_EVIDENCE_BODY_ROUTE = "/change-evidence/body";
+var CHANGE_EVIDENCE_ACK_ROUTE = "/change-evidence/ack";
+function boundedInteger3(value, fallback, max) {
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed) || parsed < 0)
+    return fallback;
+  return Math.min(parsed, max);
+}
+function changeEvidenceReadBody(spool, query) {
+  const cursor = boundedInteger3(query("cursor"), 0, Number.MAX_SAFE_INTEGER);
+  const limit = boundedInteger3(query("limit"), 256, 1024);
+  const epoch = query("epoch");
+  return spool.read(epoch && epoch !== spool.runtimeEpoch ? 0 : cursor, limit || 256);
+}
+function changeEvidenceBodyRouteBody(spool, query) {
+  const id = query("id") ?? "";
+  const bytes = id ? spool.readBody(id) : null;
+  if (!bytes)
+    return { id, state: "missing" };
+  return {
+    id,
+    state: "available",
+    base64: Buffer.from(bytes).toString("base64"),
+    bytes: bytes.length
+  };
+}
+function parseChangeEvidenceAck(value) {
+  if (!isPlainRecord(value))
+    return null;
+  const ids = (input) => Array.isArray(input) && input.length <= 1e4 && input.every((id) => typeof id === "string") ? input : null;
+  const retained = ids(value.retainedBodyIds ?? []);
+  const unavailable = ids(value.unavailableBodyIds ?? []);
+  if (typeof value.runtimeEpoch !== "string" || !Number.isSafeInteger(value.upTo) || value.upTo < 0 || !retained || !unavailable) {
+    return null;
+  }
+  return {
+    runtimeEpoch: value.runtimeEpoch,
+    upTo: value.upTo,
+    retainedBodyIds: retained,
+    unavailableBodyIds: unavailable
+  };
+}
+function changeEvidenceAckRouteBody(spool, body) {
+  const request = parseChangeEvidenceAck(body);
+  if (!request)
+    return { ok: false, error: "invalid-ack" };
+  return { ok: true, ...spool.acknowledge(request) };
+}
+
+// ../../bridges/claude-bridge/src/routes/change-evidence.ts
+var changeEvidence = new Hono2;
+changeEvidence.get(CHANGE_EVIDENCE_ROUTE, (c) => c.json(changeEvidenceReadBody(claudeChangeEvidence().spool, (name) => c.req.query(name))));
+changeEvidence.get(CHANGE_EVIDENCE_BODY_ROUTE, (c) => c.json(changeEvidenceBodyRouteBody(claudeChangeEvidence().spool, (name) => c.req.query(name))));
+changeEvidence.post(CHANGE_EVIDENCE_ACK_ROUTE, async (c) => {
+  const body = await c.req.json().catch(() => null);
+  const result = changeEvidenceAckRouteBody(claudeChangeEvidence().spool, body);
+  return result.ok ? c.json(result) : c.json(result, 400);
+});
+var change_evidence_default = changeEvidence;
+
 // ../../node_modules/.bun/hono@4.13.13/node_modules/hono/dist/utils/stream.js
 var StreamingApi = class {
   writer;
@@ -17535,7 +19153,7 @@ var mcp_default = mcp;
 // ../../bridges/claude-bridge/src/services/slash-commands.ts
 import { open as open3, readdir as readdir2, stat as stat4 } from "node:fs/promises";
 import { StringDecoder } from "node:string_decoder";
-import { join as join9, basename, dirname as dirname2 } from "node:path";
+import { join as join11, basename, dirname as dirname2 } from "node:path";
 var commandDescriptions = new Map;
 var MAX_COMMAND_DESCRIPTION_CACHE_ENTRIES = 512;
 function rememberCommandDescription(filePath, entry) {
@@ -17640,7 +19258,7 @@ async function scanCommandsDir(commandsDir, prefix) {
       continue;
     const name = basename(entry, ".md");
     const fullName = prefix ? `/${prefix}${name}` : `/${name}`;
-    const commandPath = join9(commandsDir, entry);
+    const commandPath = join11(commandsDir, entry);
     livePaths.add(commandPath);
     let description;
     try {
@@ -17661,7 +19279,7 @@ async function discoverSlashCommands(cwd) {
       result.push(cmd);
     }
   };
-  const repoCommands = await scanCommandsDir(join9(cwd, ".claude", "commands"), "");
+  const repoCommands = await scanCommandsDir(join11(cwd, ".claude", "commands"), "");
   for (const cmd of repoCommands)
     addCommand(cmd);
   try {
@@ -17669,7 +19287,7 @@ async function discoverSlashCommands(cwd) {
     for (const plugin of plugins) {
       const manifest = await readPluginManifest(plugin.path);
       const pluginName = manifest?.name || plugin.path.split("/").pop() || "unknown";
-      const commandsDir = join9(plugin.path, "commands");
+      const commandsDir = join11(plugin.path, "commands");
       const pluginCommands = await scanCommandsDir(commandsDir, `${pluginName}:`);
       for (const cmd of pluginCommands)
         addCommand(cmd);
@@ -19372,6 +20990,7 @@ app.route("/global", health_default);
 app.route("/config", config_default);
 app.route("/session", session_default);
 app.route("/", sessionActivityBatch);
+app.route("/", change_evidence_default);
 app.route("/event", events_default);
 app.route("/mcp", mcp_default);
 app.route("/plugins", plugins_default);