@iowarp/clio-coder 0.5.0 → 0.5.2

package/dist/chunk-GPTR6OTU.js

@@ -0,0 +1,2551 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  probeWorkspace
+} from "./chunk-DNHVRBH4.js";
+import {
+  entryBelongsToPath
+} from "./chunk-O5F25NIE.js";
+import {
+  collectSessionEntries,
+  enrichForkMeta,
+  listSessionsForCwd,
+  operatorTextOfUserPayload
+} from "./chunk-CNXU7TR2.js";
+import {
+  stripTokenizerSentinels
+} from "./chunk-MCJKEGHO.js";
+import {
+  estimateAgentMessageTokens
+} from "./chunk-53P775GE.js";
+import {
+  HANDOFF_MAX_WINDOW_MS,
+  HANDOFF_NOTE_MAX_BYTES,
+  HANDOFF_RECOVERY_REQUEST_CUSTOM_TYPE,
+  HANDOFF_SCHEMA_VERSION,
+  canonicalJson,
+  isContinuityCarryingSummary,
+  isContinuityCheckpointPayload,
+  isContinuityCommitEntry,
+  isHandoffRecoveryRequestEntry,
+  isHandoffTransactionEntry,
+  isSessionEntry,
+  isSessionHeader
+} from "./chunk-F6KCJO3U.js";
+import {
+  CURRENT_SESSION_FORMAT_VERSION,
+  appendSessionFileEntry,
+  atomicWrite,
+  createSession,
+  openSession,
+  readSessionFileEntries,
+  readSessionMeta,
+  resumeSession,
+  sessionPaths
+} from "./chunk-PZBQUJ2F.js";
+import {
+  protectArtifact
+} from "./chunk-OYUS3UZP.js";
+import {
+  clioStatePath,
+  stateRootRemoved
+} from "./chunk-CTTI7G3T.js";
+import {
+  BusChannels
+} from "./chunk-PS6JAWJZ.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/core/response-model-id.ts
+init_esm_shims();
+function emptyResponseModelIdObservationCounts() {
+  return { reportedCalls: 0, notReportedCalls: 0, notObservedCalls: 0, legacyDifferenceOnlyCalls: 0 };
+}
+function addResponseModelIdObservationCount(counts, observation, calls = 1) {
+  switch (observation.state) {
+    case "reported":
+      counts.reportedCalls += calls;
+      break;
+    case "not-reported":
+      counts.notReportedCalls += calls;
+      break;
+    case "not-observed":
+      counts.notObservedCalls += calls;
+      break;
+    case "legacy-difference-only":
+      counts.legacyDifferenceOnlyCalls += calls;
+      break;
+  }
+}
+function addResponseModelIdObservationCounts(counts, additional) {
+  counts.reportedCalls += additional.reportedCalls;
+  counts.notReportedCalls += additional.notReportedCalls;
+  counts.notObservedCalls += additional.notObservedCalls;
+  counts.legacyDifferenceOnlyCalls += additional.legacyDifferenceOnlyCalls;
+}
+function responseModelIdObservationCountsLabel(counts) {
+  const parts = [];
+  if (counts.reportedCalls > 0) parts.push(`reported ${counts.reportedCalls}`);
+  if (counts.notReportedCalls > 0) parts.push(`not reported ${counts.notReportedCalls}`);
+  if (counts.notObservedCalls > 0) parts.push(`not observed ${counts.notObservedCalls}`);
+  if (counts.legacyDifferenceOnlyCalls > 0) parts.push(`legacy difference-only ${counts.legacyDifferenceOnlyCalls}`);
+  return parts.join(", ");
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function parsedObservation(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return null;
+  const record = value;
+  switch (record.state) {
+    case "reported": {
+      const reportedModelId = nonEmptyString(record.reportedModelId);
+      return reportedModelId === null ? null : { state: "reported", reportedModelId };
+    }
+    case "not-reported":
+      return { state: "not-reported" };
+    case "not-observed":
+      return { state: "not-observed" };
+    case "legacy-difference-only":
+      return { state: "legacy-difference-only", differingModelId: nonEmptyString(record.differingModelId) };
+    default:
+      return null;
+  }
+}
+function responseModelIdObservationFromRecord(record, missing) {
+  const current = parsedObservation(record.responseModelIdObservation);
+  if (current !== null) return current;
+  if (Object.hasOwn(record, "servedModel")) {
+    const reportedModelId = nonEmptyString(record.servedModel);
+    return reportedModelId === null ? { state: "not-reported" } : { state: "reported", reportedModelId };
+  }
+  if (missing === "not-observed") return { state: "not-observed" };
+  return { state: "legacy-difference-only", differingModelId: nonEmptyString(record.responseModel) };
+}
+function attributedModelId(observation, requestedModelId, differingResponseModelId) {
+  switch (observation.state) {
+    case "reported":
+      return observation.reportedModelId;
+    case "not-reported":
+      return "unknown";
+    case "not-observed":
+      return differingResponseModelId ?? requestedModelId;
+    case "legacy-difference-only":
+      return observation.differingModelId ?? requestedModelId;
+  }
+}
+
+// src/domains/session/archive-readers.ts
+init_esm_shims();
+import { readdir, readFile } from "node:fs/promises";
+import { join as join3 } from "node:path";
+
+// src/domains/session/index.ts
+init_esm_shims();
+
+// src/domains/session/extension.ts
+init_esm_shims();
+
+// src/domains/session/checkpoint.ts
+init_esm_shims();
+async function performCheckpoint(state, reason) {
+  await state.writer.persistTree();
+  if (stateRootRemoved()) return;
+  const paths = sessionPaths(state.meta);
+  const at = (/* @__PURE__ */ new Date()).toISOString();
+  const enriched = {
+    ...state.meta,
+    lastCheckpointAt: at,
+    lastCheckpointReason: reason ?? null
+  };
+  atomicWrite(paths.meta, JSON.stringify(enriched, null, 2));
+  Object.assign(state.meta, enriched);
+}
+
+// src/domains/session/manager.ts
+init_esm_shims();
+
+// node_modules/.pnpm/uuid@14.0.1/node_modules/uuid/dist-node/index.js
+init_esm_shims();
+
+// node_modules/.pnpm/uuid@14.0.1/node_modules/uuid/dist-node/stringify.js
+init_esm_shims();
+var byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 256).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset = 0) {
+  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+}
+
+// node_modules/.pnpm/uuid@14.0.1/node_modules/uuid/dist-node/rng.js
+init_esm_shims();
+var rnds8 = new Uint8Array(16);
+function rng() {
+  return crypto.getRandomValues(rnds8);
+}
+
+// node_modules/.pnpm/uuid@14.0.1/node_modules/uuid/dist-node/v7.js
+init_esm_shims();
+var _state = {};
+function v7(options, buf, offset) {
+  let bytes;
+  if (options) {
+    bytes = v7Bytes(options.random ?? options.rng?.() ?? rng(), options.msecs, options.seq, buf, offset);
+  } else {
+    const now = Date.now();
+    const rnds = rng();
+    updateV7State(_state, now, rnds);
+    bytes = v7Bytes(rnds, _state.msecs, _state.seq, buf, offset);
+  }
+  return buf ?? unsafeStringify(bytes);
+}
+function updateV7State(state, now, rnds) {
+  state.msecs ??= -Infinity;
+  state.seq ??= 0;
+  if (now > state.msecs) {
+    state.seq = rnds[6] << 23 | rnds[7] << 16 | rnds[8] << 8 | rnds[9];
+    state.msecs = now;
+  } else {
+    state.seq = state.seq + 1 | 0;
+    if (state.seq === 0) {
+      state.msecs++;
+    }
+  }
+  return state;
+}
+function v7Bytes(rnds, msecs, seq, buf, offset = 0) {
+  if (rnds.length < 16) {
+    throw new Error("Random bytes length must be >= 16");
+  }
+  if (!buf) {
+    buf = new Uint8Array(16);
+    offset = 0;
+  } else {
+    if (offset < 0 || offset + 16 > buf.length) {
+      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+    }
+  }
+  msecs ??= Date.now();
+  seq ??= rnds[6] * 127 << 24 | rnds[7] << 16 | rnds[8] << 8 | rnds[9];
+  buf[offset++] = msecs / 1099511627776 & 255;
+  buf[offset++] = msecs / 4294967296 & 255;
+  buf[offset++] = msecs / 16777216 & 255;
+  buf[offset++] = msecs / 65536 & 255;
+  buf[offset++] = msecs / 256 & 255;
+  buf[offset++] = msecs & 255;
+  buf[offset++] = 112 | seq >>> 28 & 15;
+  buf[offset++] = seq >>> 20 & 255;
+  buf[offset++] = 128 | seq >>> 14 & 63;
+  buf[offset++] = seq >>> 6 & 255;
+  buf[offset++] = seq << 2 & 255 | rnds[10] & 3;
+  buf[offset++] = rnds[11];
+  buf[offset++] = rnds[12];
+  buf[offset++] = rnds[13];
+  buf[offset++] = rnds[14];
+  buf[offset++] = rnds[15];
+  return buf;
+}
+var v7_default = v7;
+
+// src/domains/session/migrations/index.ts
+init_esm_shims();
+var OLDEST_READABLE_SESSION_FORMAT_VERSION = 3;
+function runMigrations(meta, sessionPath) {
+  const from = meta.sessionFormatVersion ?? 1;
+  if (from < OLDEST_READABLE_SESSION_FORMAT_VERSION) {
+    throw new Error(
+      `session metadata has an unsupported format version (expected version ${CURRENT_SESSION_FORMAT_VERSION}, got ${from}): ${sessionPath}. Remove the session directory to start a new session.`
+    );
+  }
+  if (from > CURRENT_SESSION_FORMAT_VERSION) {
+    throw new Error(
+      `session was written by a newer Clio (format version ${from}, this build reads version ${CURRENT_SESSION_FORMAT_VERSION}): ${sessionPath}. Upgrade clio-coder to resume this session.`
+    );
+  }
+  if (from < CURRENT_SESSION_FORMAT_VERSION) {
+    return { migrated: true, from, to: CURRENT_SESSION_FORMAT_VERSION };
+  }
+  return { migrated: false, from, to: from };
+}
+
+// src/domains/session/manager.ts
+function newTurnId() {
+  return v7_default();
+}
+function startSession(input) {
+  const { meta, writer } = createSession({
+    cwd: input.cwd,
+    model: input.model ?? null,
+    target: input.target ?? null,
+    ...input.initialEntries !== void 0 ? { initialEntries: input.initialEntries } : {},
+    ...input.initialTree !== void 0 ? { initialTree: input.initialTree } : {},
+    ...input.parentSession !== void 0 ? { parentSession: input.parentSession } : {},
+    ...input.parentTurnId !== void 0 ? { parentTurnId: input.parentTurnId } : {}
+  });
+  return { meta, writer };
+}
+function persistSessionMeta(state) {
+  if (stateRootRemoved()) return;
+  atomicWrite(sessionPaths(state.meta).meta, JSON.stringify(state.meta, null, 2));
+}
+function resumeSessionState(sessionId) {
+  const persistedMeta = readSessionMeta(sessionId);
+  const paths = sessionPaths(persistedMeta);
+  const migration = runMigrations(persistedMeta, paths.meta);
+  const candidate = openSession(sessionId);
+  collectSessionEntries(candidate.turns(), paths.current);
+  const { meta, writer, tree } = resumeSession(
+    sessionId,
+    migration.migrated ? { sessionFormatVersion: migration.to } : {}
+  );
+  const state = { meta, writer };
+  return { state, nodes: tree };
+}
+function appendTurn(state, input) {
+  const record = {
+    id: input.id ?? newTurnId(),
+    parentId: input.parentId,
+    at: input.at ?? (/* @__PURE__ */ new Date()).toISOString(),
+    kind: input.kind,
+    payload: input.payload
+  };
+  const entry = {
+    kind: "message",
+    turnId: record.id,
+    parentTurnId: record.parentId,
+    timestamp: record.at,
+    role: record.kind,
+    payload: record.payload
+  };
+  state.writer.appendEntry(entry, {
+    treeNode: {
+      id: record.id,
+      parentId: record.parentId,
+      at: record.at,
+      kind: record.kind
+    }
+  });
+  return record;
+}
+function appendEntry(state, input) {
+  const turnId = input.turnId ?? newTurnId();
+  const timestamp = input.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
+  const entry = { ...input, turnId, timestamp };
+  if (!isSessionEntry(entry)) throw new Error(`session.appendEntry: invalid ${String(input.kind)} entry`);
+  state.writer.appendEntry(entry);
+  return entry;
+}
+function replaceEntries(state, entries) {
+  for (const entry of entries) {
+    if (!isSessionEntry(entry)) throw new Error("session.replaceEntries: invalid entry");
+  }
+  state.writer.replaceEntries(entries);
+}
+
+// src/domains/session/tree/fork.ts
+init_esm_shims();
+function linkedRecordFromEntry(entry) {
+  return {
+    id: entry.turnId,
+    parentId: entry.parentTurnId,
+    timestamp: entry.timestamp,
+    treeKind: entry.kind === "message" ? entry.role : null,
+    raw: entry
+  };
+}
+function traceAncestry(records, leafTurnId) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const record of records) byId.set(record.id, record);
+  const path = [];
+  let current = byId.get(leafTurnId);
+  if (!current) throw new Error(`session.fork: parent turn not found: ${leafTurnId}`);
+  const seen = /* @__PURE__ */ new Set();
+  while (current) {
+    if (seen.has(current.id)) throw new Error(`session.fork: cycle in parent chain at ${current.id}`);
+    seen.add(current.id);
+    path.unshift(current);
+    if (current.parentId === null) break;
+    const next = byId.get(current.parentId);
+    if (!next) throw new Error(`session.fork: broken parent chain at ${current.id}`);
+    current = next;
+  }
+  return path;
+}
+function treeFromLinearPath(path) {
+  return path.filter((record) => record.treeKind !== null).map((record) => ({
+    id: record.id,
+    parentId: record.parentId,
+    at: record.timestamp,
+    kind: record.treeKind
+  }));
+}
+function sessionEntryBelongsToPath(entry, pathIds, atOrBeforeForkPoint) {
+  if (atOrBeforeForkPoint) return entryBelongsToPath(entry, pathIds, atOrBeforeForkPoint);
+  if (entry.kind === "compactionSummary") return false;
+  if (entry.kind === "handoffTransaction" || entry.kind === "continuityCommit") return false;
+  if (entry.kind === "custom" && entry.customType === HANDOFF_RECOVERY_REQUEST_CUSTOM_TYPE) return false;
+  return entryBelongsToPath(entry, pathIds, atOrBeforeForkPoint);
+}
+function branchEntriesFromParent(parentMeta, leafTurnId) {
+  const parentCurrentPath = sessionPaths(parentMeta).current;
+  const records = readSessionFileEntries(parentCurrentPath).filter((entry) => !isSessionHeader(entry));
+  const parsed = collectSessionEntries(records, parentCurrentPath);
+  const linked = parsed.map(linkedRecordFromEntry);
+  const path = traceAncestry(linked, leafTurnId);
+  const pathIds = new Set(path.map((record) => record.id));
+  const forkPointIndex = parsed.findIndex((entry) => linkedRecordFromEntry(entry).id === leafTurnId);
+  const entries = parsed.filter(
+    (entry, index) => sessionEntryBelongsToPath(entry, pathIds, forkPointIndex >= 0 && index <= forkPointIndex)
+  );
+  return {
+    parentCurrentPath,
+    entries,
+    tree: treeFromLinearPath(path)
+  };
+}
+function forkFromState(input) {
+  const parentMeta = input.from.meta;
+  input.from.writer.flushAppends();
+  const branch = branchEntriesFromParent(parentMeta, input.parentTurnId);
+  const cwd = input.cwd ?? parentMeta.cwd;
+  const next = startSession({
+    cwd,
+    model: parentMeta.model,
+    target: parentMeta.target,
+    initialEntries: branch.entries,
+    initialTree: branch.tree,
+    parentSession: branch.parentCurrentPath,
+    parentTurnId: input.parentTurnId
+  });
+  enrichForkMeta(next.meta, parentMeta.id, input.parentTurnId);
+  void input.from.writer.close();
+  return { next, parentMeta, nodes: branch.tree };
+}
+
+// src/domains/session/tree/manager.ts
+init_esm_shims();
+import { existsSync, renameSync, rmSync } from "node:fs";
+import { dirname, join } from "node:path";
+function readTreeBundle(sessionId) {
+  const reader = openSession(sessionId);
+  const meta = reader.meta();
+  const paths = sessionPaths(meta);
+  const nodes = [...reader.tree()];
+  const entries = collectSessionEntries(reader.turns(), paths.current);
+  const labels = resolveLabelMap(entries);
+  return { sessionId, meta, nodes, entries, labels };
+}
+function resolveLabelMap(entries) {
+  const out = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const info = labelFields(entry);
+    if (!info) continue;
+    const existing = out.get(info.targetTurnId);
+    if (existing && existing.timestamp > info.timestamp) continue;
+    if (info.label === void 0 || info.label === "") {
+      out.set(info.targetTurnId, { label: "", timestamp: info.timestamp });
+      continue;
+    }
+    out.set(info.targetTurnId, { label: info.label, timestamp: info.timestamp });
+  }
+  return out;
+}
+function labelFields(entry) {
+  if (entry.kind === "label") return entry;
+  if (entry.kind !== "sessionInfo") return null;
+  const info = entry;
+  if (!info.targetTurnId) return null;
+  const out = {
+    targetTurnId: info.targetTurnId,
+    timestamp: info.timestamp
+  };
+  if (info.label !== void 0) out.label = info.label;
+  return out;
+}
+function appendEntryToSessionFile(sessionId, entry) {
+  const meta = readSessionMeta(sessionId);
+  const paths = sessionPaths(meta);
+  appendSessionFileEntry(paths.current, entry);
+}
+function removeSessionDirectory(sessionId) {
+  const meta = readSessionMeta(sessionId);
+  const paths = sessionPaths(meta);
+  const dir = dirname(paths.meta);
+  rmSync(dir, { recursive: true, force: true });
+}
+function tombstoneSession(sessionId) {
+  const meta = readSessionMeta(sessionId);
+  const paths = sessionPaths(meta);
+  if (!existsSync(paths.meta)) return;
+  const tombstone = join(dirname(paths.meta), "meta.deleted.json");
+  renameSync(paths.meta, tombstone);
+}
+
+// src/domains/session/tree/navigator.ts
+init_esm_shims();
+function pickMeta(meta) {
+  const out = {
+    id: meta.id,
+    cwd: meta.cwd,
+    createdAt: meta.createdAt,
+    endedAt: meta.endedAt,
+    model: meta.model,
+    target: meta.target
+  };
+  if (meta.parentSessionId !== void 0) out.parentSessionId = meta.parentSessionId;
+  if (meta.parentTurnId !== void 0) out.parentTurnId = meta.parentTurnId;
+  return out;
+}
+function computeLeafId(nodes) {
+  if (nodes.length === 0) return null;
+  const hasChild = /* @__PURE__ */ new Set();
+  for (const node of nodes) {
+    if (node.parentId) hasChild.add(node.parentId);
+  }
+  let leaf = null;
+  for (const node of nodes) {
+    if (hasChild.has(node.id)) continue;
+    if (!leaf || node.at >= leaf.at) leaf = node;
+  }
+  return leaf?.id ?? null;
+}
+function buildTreeSnapshot(input) {
+  const nodesById = {};
+  for (const node of input.nodes) {
+    const entry = {
+      id: node.id,
+      parentId: node.parentId,
+      at: node.at,
+      kind: node.kind,
+      children: []
+    };
+    const resolved = input.labels.get(node.id);
+    if (resolved && resolved.label !== "") entry.label = resolved.label;
+    const preview = input.previews?.get(node.id);
+    if (preview !== void 0 && preview.length > 0) entry.preview = preview;
+    nodesById[node.id] = entry;
+  }
+  const rootIds = [];
+  for (const node of input.nodes) {
+    const parent = node.parentId ? nodesById[node.parentId] : void 0;
+    if (!parent) {
+      rootIds.push(node.id);
+    } else {
+      parent.children.push(node.id);
+    }
+  }
+  const byTime = (a, b) => {
+    const na = nodesById[a];
+    const nb = nodesById[b];
+    if (!na || !nb) return a < b ? -1 : a > b ? 1 : 0;
+    if (na.at === nb.at) return na.id < nb.id ? -1 : na.id > nb.id ? 1 : 0;
+    return na.at < nb.at ? -1 : 1;
+  };
+  rootIds.sort(byTime);
+  for (const key of Object.keys(nodesById)) {
+    const entry = nodesById[key];
+    if (entry) entry.children.sort(byTime);
+  }
+  const leafId = input.leafId !== void 0 ? input.leafId : computeLeafId(input.nodes);
+  return {
+    sessionId: input.meta.id,
+    meta: pickMeta(input.meta),
+    leafId,
+    nodesById,
+    rootIds
+  };
+}
+
+// src/domains/session/tree/preview.ts
+init_esm_shims();
+var TURN_PREVIEW_MAX_CHARS = 60;
+var ESC = String.fromCharCode(27);
+var ANSI_CSI_RE = new RegExp(`${ESC}\\[[0-9;?]*[ -/]*[@-~]`, "g");
+var ANSI_FALLBACK_RE = new RegExp(`${ESC}[@-_]`, "g");
+function stripAnsi(text) {
+  return text.replace(ANSI_CSI_RE, "").replace(ANSI_FALLBACK_RE, "");
+}
+function collapseSingleLine(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function sanitize(text) {
+  return collapseSingleLine(stripTokenizerSentinels(stripAnsi(text)));
+}
+function clamp(text, max) {
+  if (text.length <= max) return text;
+  if (max <= 1) return text.slice(0, max);
+  return `${text.slice(0, max - 1)}\u2026`;
+}
+function extractPlainText(payload) {
+  if (typeof payload === "string") {
+    const sanitized = sanitize(payload);
+    return sanitized.length > 0 ? sanitized : null;
+  }
+  if (!payload || typeof payload !== "object") return null;
+  const obj = payload;
+  if (typeof obj.text === "string") {
+    const sanitized = sanitize(obj.text);
+    if (sanitized.length > 0) return sanitized;
+  }
+  if (Array.isArray(obj.content)) {
+    const parts = [];
+    for (const block of obj.content) {
+      if (!block || typeof block !== "object") continue;
+      const b = block;
+      if (b.type === "text" && typeof b.text === "string") parts.push(b.text);
+    }
+    if (parts.length > 0) {
+      const sanitized = sanitize(parts.join(" "));
+      if (sanitized.length > 0) return sanitized;
+    }
+  }
+  return null;
+}
+function pickToolArg(toolName, args) {
+  if (!args || typeof args !== "object") return "";
+  const a = args;
+  const preferred = {
+    read: ["path"],
+    write: ["path"],
+    edit: ["path"],
+    bash: ["command"],
+    code_nav: ["query", "mode"],
+    git: ["op"],
+    verify: ["check"],
+    grep: ["pattern", "query"],
+    search: ["query", "pattern"],
+    web_fetch: ["url"],
+    web_search: ["query"]
+  };
+  const order = preferred[toolName] ?? [];
+  for (const key of order) {
+    const value = a[key];
+    if (typeof value === "string" && value.length > 0) return sanitize(value);
+    if (typeof value === "number") return String(value);
+  }
+  for (const [, value] of Object.entries(a)) {
+    if (typeof value === "string" && value.length > 0) return sanitize(value);
+    if (typeof value === "number" || typeof value === "boolean") return String(value);
+  }
+  return "";
+}
+function extractToolCall(payload) {
+  if (!payload || typeof payload !== "object") return null;
+  const p = payload;
+  const toolName = typeof p.name === "string" ? p.name : typeof p.toolName === "string" ? p.toolName : null;
+  if (!toolName) return null;
+  const args = p.args !== void 0 ? p.args : p.arguments ?? p.input;
+  return { toolName, args };
+}
+function extractToolResult(payload) {
+  if (!payload || typeof payload !== "object") return null;
+  const p = payload;
+  if (!("toolCallId" in p) && !("result" in p) && !("isError" in p)) return null;
+  const isError = p.isError === true;
+  let text = "";
+  const result = p.result;
+  if (typeof result === "string") text = result;
+  else if (result && typeof result === "object") {
+    const r = result;
+    if (Array.isArray(r.content)) {
+      const parts = [];
+      for (const block of r.content) {
+        if (!block || typeof block !== "object") continue;
+        const b = block;
+        if (b.type === "text" && typeof b.text === "string") parts.push(b.text);
+      }
+      text = parts.join(" ");
+    } else if (typeof r.text === "string") {
+      text = r.text;
+    }
+  }
+  if (text.length === 0 && typeof p.errorMessage === "string") text = p.errorMessage;
+  return { isError, text: sanitize(text) };
+}
+function assistantStopMarker(payload) {
+  if (!payload || typeof payload !== "object") return null;
+  const sr = payload.stopReason;
+  if (sr === "aborted") return "(aborted)";
+  if (sr === "error") return "(error)";
+  return null;
+}
+function buildTurnPreview(turn, max = TURN_PREVIEW_MAX_CHARS) {
+  const budget = Math.max(1, max);
+  switch (turn.kind) {
+    case "user": {
+      const text = operatorTextOfUserPayload(turn.payload);
+      return text === null ? "(empty)" : clamp(sanitize(text), budget);
+    }
+    case "assistant": {
+      const stop = assistantStopMarker(turn.payload);
+      const text = extractPlainText(turn.payload);
+      if (text !== null) return clamp(text, budget);
+      if (stop !== null) return stop;
+      if (turn.payload && typeof turn.payload === "object" && Array.isArray(turn.payload.content)) {
+        const content = turn.payload.content;
+        const toolCalls = content.filter(
+          (b) => b && typeof b === "object" && b.type === "toolCall"
+        );
+        if (toolCalls.length > 0) {
+          const names = toolCalls.map((b) => b.name).filter((n) => typeof n === "string");
+          if (names.length > 0) return clamp(`(tool calls) ${names.join(", ")}`, budget);
+        }
+      }
+      return "(empty)";
+    }
+    case "tool_call": {
+      const call = extractToolCall(turn.payload);
+      if (!call) return "(empty)";
+      const arg = pickToolArg(call.toolName, call.args);
+      const inner = arg.length > 0 ? `"${clamp(arg, Math.max(8, budget - call.toolName.length - 4))}"` : "";
+      const composed = `${call.toolName}(${inner})`;
+      return clamp(composed, budget);
+    }
+    case "tool_result": {
+      const result = extractToolResult(turn.payload);
+      if (!result) return "(empty)";
+      const status = result.isError ? "err" : "ok";
+      const head = `[${status}]`;
+      if (result.text.length === 0) return head;
+      const remaining = Math.max(4, budget - head.length - 1);
+      return `${head} ${clamp(result.text, remaining)}`;
+    }
+    case "system": {
+      const text = extractPlainText(turn.payload);
+      return text === null ? "(system)" : clamp(text, budget);
+    }
+    case "checkpoint":
+      return "(checkpoint)";
+    default:
+      return `(${String(turn.kind)})`;
+  }
+}
+
+// src/domains/session/extension.ts
+function createSessionBundle(context) {
+  let state = null;
+  let currentTurnId = null;
+  function emitPark(sessionId, reason) {
+    context.bus.emit(BusChannels.SessionParked, { sessionId, reason, at: Date.now() });
+  }
+  function emitResume(sessionId, via) {
+    context.bus.emit(BusChannels.SessionResumed, { sessionId, via, at: Date.now() });
+  }
+  function emitTurnSwitched(sessionId, turnId) {
+    context.bus.emit(BusChannels.SessionTurnSwitched, { sessionId, turnId, at: Date.now() });
+  }
+  function resolveLeafOnOpen(resumed) {
+    const pinned = resumed.state.meta.pinnedLeafTurnId;
+    if (pinned && resumed.nodes.some((node) => node.id === pinned)) return pinned;
+    return computeLeafId(resumed.nodes);
+  }
+  async function closeCurrent(reason = "close") {
+    if (!state) return;
+    const s = state;
+    emitPark(s.meta.id, reason);
+    state = null;
+    currentTurnId = null;
+    await s.writer.close();
+  }
+  async function flushIfCurrent(sessionId) {
+    if (state?.meta.id === sessionId) {
+      await state.writer.persistTree();
+    }
+  }
+  function structuralTreeNodes(entries, previews) {
+    const nodes = [];
+    for (const entry of entries) {
+      if (entry.kind === "compactionSummary") {
+        nodes.push({ id: entry.turnId, parentId: entry.parentTurnId, at: entry.timestamp, kind: "compaction" });
+        const summarized = entry.messagesSummarized === void 0 ? "history" : `${entry.messagesSummarized} entries`;
+        const after = entry.tokensAfter === void 0 ? "" : ` -> ~${entry.tokensAfter}`;
+        previews.set(entry.turnId, `${summarized} summarized, ~${entry.tokensBefore}${after} tokens`);
+        continue;
+      }
+      if (entry.kind === "branchSummary") {
+        nodes.push({ id: entry.turnId, parentId: entry.parentTurnId, at: entry.timestamp, kind: "branch" });
+        const text = entry.summary.split("\n", 1)[0] ?? "";
+        previews.set(
+          entry.turnId,
+          text.length > 0 ? `returned from ${entry.fromTurnId}: ${text}` : `returned from ${entry.fromTurnId}`
+        );
+      }
+    }
+    return nodes;
+  }
+  function snapshotFor(sessionId) {
+    const bundle = readTreeBundle(sessionId);
+    const meta = state?.meta.id === sessionId ? state.meta : bundle.meta;
+    const previews = /* @__PURE__ */ new Map();
+    let structural = [];
+    try {
+      for (const entry of bundle.entries) {
+        if (entry.kind !== "message") continue;
+        const text = buildTurnPreview({ kind: entry.role, payload: entry.payload });
+        if (text.length > 0) previews.set(entry.turnId, text);
+      }
+      structural = structuralTreeNodes(bundle.entries, previews);
+    } catch {
+    }
+    const persistedLeaf = bundle.meta.pinnedLeafTurnId && bundle.nodes.some((node) => node.id === bundle.meta.pinnedLeafTurnId) ? bundle.meta.pinnedLeafTurnId : computeLeafId(bundle.nodes);
+    return buildTreeSnapshot({
+      meta,
+      nodes: [...bundle.nodes, ...structural],
+      labels: bundle.labels,
+      previews,
+      // The leaf is the next append point, so it is computed over turn nodes
+      // only: a structural node marks a moment in the timeline, never a place
+      // the session continues from.
+      leafId: state?.meta.id === sessionId ? currentTurnId : persistedLeaf
+    });
+  }
+  const contract = {
+    current: () => state?.meta ?? null,
+    create(input) {
+      const cwd = input?.cwd ?? process.cwd();
+      const startInput = { cwd };
+      if (input?.model !== void 0) startInput.model = input.model;
+      if (input?.target !== void 0) startInput.target = input.target;
+      if (state) {
+        const prior = state;
+        emitPark(prior.meta.id, "create_new");
+        state = null;
+        void prior.writer.close();
+      }
+      const next = startSession(startInput);
+      next.meta.workspace = probeWorkspace(cwd);
+      persistSessionMeta(next);
+      state = next;
+      currentTurnId = null;
+      return next.meta;
+    },
+    append(turn) {
+      if (!state) throw new Error("session.append: no current session");
+      if (turn.parentId !== currentTurnId) {
+        throw new Error(
+          `session.append: turn parentId ${turn.parentId ?? "null"} is not this session's current leaf (expected ${currentTurnId ?? "null"}); refusing to parent a turn onto another session's turn`
+        );
+      }
+      const record = appendTurn(state, turn);
+      currentTurnId = record.id;
+      if (state.meta.pinnedLeafTurnId !== void 0 && state.meta.pinnedLeafTurnId !== null) {
+        state.meta.pinnedLeafTurnId = null;
+        persistSessionMeta(state);
+      }
+      return record;
+    },
+    appendEntry(entry) {
+      if (!state) throw new Error("session.appendEntry: no current session");
+      return appendEntry(state, entry);
+    },
+    replaceEntries(entries) {
+      if (!state) throw new Error("session.replaceEntries: no current session");
+      replaceEntries(state, entries);
+    },
+    recordSkillActivation(activation) {
+      if (!state) throw new Error("session.recordSkillActivation: no current session");
+      appendEntry(state, {
+        kind: "skillActivation",
+        parentTurnId: activation.turnId ?? null,
+        activation
+      });
+      const existing = state.meta.skillActivations ?? [];
+      state.meta.skillActivations = [...existing, activation];
+      persistSessionMeta(state);
+      return activation;
+    },
+    async checkpoint(reason) {
+      if (!state) throw new Error("session.checkpoint: no current session");
+      await performCheckpoint(state, reason);
+    },
+    flushAppends() {
+      if (!state) throw new Error("session.flushAppends: no current session");
+      state.writer.flushAppends();
+    },
+    resume(sessionId) {
+      if (state && state.meta.id === sessionId) return state.meta;
+      const resumed = resumeSessionState(sessionId);
+      if (state) {
+        const prior = state;
+        emitPark(prior.meta.id, "resume_other");
+        void prior.writer.close();
+      }
+      state = resumed.state;
+      currentTurnId = resolveLeafOnOpen(resumed);
+      emitResume(resumed.state.meta.id, "resume");
+      return resumed.state.meta;
+    },
+    fork(parentTurnId, input) {
+      if (!state) throw new Error("session.fork: no current session to fork from");
+      const prior = state;
+      const { next, nodes } = forkFromState({
+        from: prior,
+        parentTurnId,
+        ...input?.cwd !== void 0 ? { cwd: input.cwd } : {}
+      });
+      emitPark(prior.meta.id, "fork");
+      state = next;
+      currentTurnId = computeLeafId(nodes);
+      return next.meta;
+    },
+    tree(sessionId) {
+      const id = sessionId ?? state?.meta.id;
+      if (!id) throw new Error("session.tree: no sessionId provided and no current session");
+      if (state?.meta.id === id) void flushIfCurrent(id);
+      return snapshotFor(id);
+    },
+    switchBranch(sessionId) {
+      if (state?.meta.id === sessionId) return state.meta;
+      const resumed = resumeSessionState(sessionId);
+      if (state) {
+        const prior = state;
+        emitPark(prior.meta.id, "switch_branch");
+        void prior.writer.close();
+      }
+      state = resumed.state;
+      currentTurnId = resolveLeafOnOpen(resumed);
+      emitResume(resumed.state.meta.id, "switch_branch");
+      return resumed.state.meta;
+    },
+    switchTurn(turnId) {
+      if (!state) throw new Error("session.switchTurn: no current session");
+      void flushIfCurrent(state.meta.id);
+      const nodes = readTreeBundle(state.meta.id).nodes;
+      if (!nodes.some((node) => node.id === turnId)) {
+        throw new Error(`session.switchTurn: turn not found: ${turnId}`);
+      }
+      currentTurnId = turnId;
+      state.meta.pinnedLeafTurnId = turnId;
+      persistSessionMeta(state);
+      emitTurnSwitched(state.meta.id, turnId);
+      return state.meta;
+    },
+    editLabel(turnId, label, sessionId) {
+      const targetId = sessionId ?? state?.meta.id;
+      if (!targetId) throw new Error("session.editLabel: no sessionId provided and no current session");
+      if (state && state.meta.id === targetId) {
+        appendEntry(state, {
+          kind: "label",
+          parentTurnId: null,
+          targetTurnId: turnId,
+          label
+        });
+        return;
+      }
+      const entry = {
+        kind: "label",
+        turnId: newTurnId(),
+        parentTurnId: null,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        targetTurnId: turnId,
+        label
+      };
+      appendEntryToSessionFile(targetId, entry);
+    },
+    setName(name, sessionId) {
+      const targetId = sessionId ?? state?.meta.id;
+      if (!targetId) throw new Error("session.setName: no sessionId provided and no current session");
+      if (state && state.meta.id === targetId) {
+        appendEntry(state, {
+          kind: "sessionInfo",
+          parentTurnId: null,
+          name
+        });
+        return;
+      }
+      const entry = {
+        kind: "sessionInfo",
+        turnId: newTurnId(),
+        parentTurnId: null,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        name
+      };
+      appendEntryToSessionFile(targetId, entry);
+    },
+    deleteSession(id, opts) {
+      if (state?.meta.id === id) {
+        throw new Error("session.deleteSession: refusing to delete the currently open session; close() first");
+      }
+      const options = opts ?? {};
+      if (options.keepFiles) {
+        tombstoneSession(id);
+      } else {
+        removeSessionDirectory(id);
+      }
+    },
+    history() {
+      const cwd = state?.meta.cwd ?? process.cwd();
+      return listSessionsForCwd(cwd);
+    },
+    async close() {
+      await closeCurrent();
+    }
+  };
+  const extension = {
+    async start() {
+    },
+    async stop() {
+      if (!state) return;
+      try {
+        await performCheckpoint(state, "shutdown");
+      } catch (err) {
+        process.stderr.write(
+          `[clio-coder:session] shutdown checkpoint failed: ${err instanceof Error ? err.message : String(err)}
+`
+        );
+      }
+      await closeCurrent("shutdown");
+    }
+  };
+  return { extension, contract };
+}
+
+// src/domains/session/manifest.ts
+init_esm_shims();
+var SessionManifest = {
+  name: "session",
+  dependsOn: ["config"]
+};
+
+// src/domains/session/continuity/ports.ts
+init_esm_shims();
+import { existsSync as existsSync2, readFileSync } from "node:fs";
+import { join as join2 } from "node:path";
+function pinnedLedgerPath(origin) {
+  return join2(clioStatePath(), "sessions", origin.cwdHash, origin.sessionId, "current.jsonl");
+}
+function readContinuityRecordExact(origin, expected) {
+  const path = pinnedLedgerPath(origin);
+  if (!existsSync2(path)) {
+    const temp = `${path}.tmp`;
+    if (existsSync2(temp)) {
+      return { status: "unresolved", detail: "session ledger is missing and a temporary candidate exists beside it" };
+    }
+    return { status: "unresolved", detail: "session ledger does not exist" };
+  }
+  let raw;
+  try {
+    raw = readFileSync(path, "utf8");
+  } catch (error) {
+    return {
+      status: "unresolved",
+      detail: `session ledger could not be read: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+  const wanted = canonicalJson(expected);
+  let found = 0;
+  let conflicting = null;
+  let headers = 0;
+  for (const line of raw.split("\n")) {
+    if (line.trim().length === 0) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      return { status: "unresolved", detail: "session ledger contains a line that could not be parsed" };
+    }
+    if (isSessionHeader(parsed)) {
+      headers += 1;
+      if (headers > 1) return { status: "unresolved", detail: "session ledger carries more than one session header" };
+      if (parsed.id !== origin.sessionId) {
+        return {
+          status: "unresolved",
+          detail: `session ledger carries session header ${parsed.id}, not ${origin.sessionId}`
+        };
+      }
+      if (parsed.version < OLDEST_READABLE_SESSION_FORMAT_VERSION || parsed.version > CURRENT_SESSION_FORMAT_VERSION) {
+        return { status: "unresolved", detail: `session ledger header declares format version ${parsed.version}` };
+      }
+      continue;
+    }
+    if (!isSessionEntry(parsed)) {
+      return { status: "unresolved", detail: "session ledger contains a structured record this build cannot validate" };
+    }
+    const record = parsed;
+    if (record.turnId !== expected.turnId) continue;
+    if (canonicalJson(record) === wanted) {
+      found += 1;
+      continue;
+    }
+    conflicting = `stored record ${String(expected.turnId)} has this id and different payload`;
+  }
+  if (conflicting !== null) return { status: "conflicting", detail: conflicting };
+  if (headers === 0) {
+    return { status: "unresolved", detail: "session ledger carries no session header to attribute it to this session" };
+  }
+  return found > 0 ? { status: "matching" } : { status: "absent" };
+}
+function createContinuityPersistencePorts(input) {
+  const session = input.session;
+  const origin = {
+    sessionId: input.origin.sessionId,
+    cwdHash: input.origin.cwdHash,
+    ...input.origin.stillCurrent === void 0 ? {} : { stillCurrent: input.origin.stillCurrent }
+  };
+  const isOriginCurrent = () => {
+    if (session.current()?.id !== origin.sessionId) return false;
+    return origin.stillCurrent?.() ?? true;
+  };
+  const ports = {
+    append(entry) {
+      if (!isOriginCurrent()) {
+        throw new Error(`continuity append refused: session ${origin.sessionId} is no longer current`);
+      }
+      if (typeof entry.turnId !== "string" || entry.turnId.length === 0) {
+        throw new Error("continuity append refused: the record carries no reserved turnId");
+      }
+      if (typeof entry.timestamp !== "string" || entry.timestamp.length === 0) {
+        throw new Error("continuity append refused: the record carries no explicit timestamp");
+      }
+      session.appendEntry(entry);
+    },
+    readExact: (expected) => readContinuityRecordExact(origin, expected),
+    isStateRemoved: () => stateRootRemoved(),
+    isOriginCurrent
+  };
+  if (session.flushAppends) {
+    ports.flushAppends = () => {
+      if (!isOriginCurrent()) {
+        throw new Error(`continuity flush refused: session ${origin.sessionId} is no longer current`);
+      }
+      session.flushAppends?.();
+    };
+  }
+  ports.checkpoint = async (reason) => {
+    if (!isOriginCurrent()) {
+      throw new Error(`continuity checkpoint refused: session ${origin.sessionId} is no longer current`);
+    }
+    await session.checkpoint(reason);
+  };
+  return ports;
+}
+
+// src/domains/session/continuity/projection.ts
+init_esm_shims();
+
+// src/domains/session/continuity/evidence.ts
+init_esm_shims();
+function terminalStatus(entry) {
+  const payload = entry.payload;
+  if (!payload || typeof payload !== "object") return "empty";
+  const record = payload;
+  const stop = record.stopReason;
+  if (stop === "error") return "error";
+  if (stop === "aborted") return "aborted";
+  if (stop === "interrupted") return "interrupted";
+  if (typeof record.errorMessage === "string" && record.errorMessage.length > 0) return "error";
+  if (stop !== void 0 && stop !== "stop") return "empty";
+  if (record.continuityDeliveryId !== void 0 && stop !== "stop") return "empty";
+  const content = Array.isArray(record.content) ? record.content : [];
+  for (const block of content) {
+    if (!block || typeof block !== "object") continue;
+    if (block.type === "toolCall") return "empty";
+  }
+  if (typeof record.text === "string" && record.text.trim().length > 0) return "success";
+  for (const block of content) {
+    if (!block || typeof block !== "object") continue;
+    const typed = block;
+    if (typed.type === "text" && typeof typed.text === "string" && typed.text.trim().length > 0) return "success";
+  }
+  return "empty";
+}
+function terminalResponses(entries) {
+  const rows = [];
+  const messages = new Map(
+    entries.filter((entry) => entry.kind === "message").map((entry) => [entry.turnId, entry])
+  );
+  for (let position = 0; position < entries.length; position += 1) {
+    const entry = entries[position];
+    if (entry?.kind !== "message" || entry.role !== "assistant" || entry.parentTurnId === null) continue;
+    let continuationTurnId = entry.parentTurnId;
+    const payload = entry.payload;
+    if (typeof payload?.continuityDeliveryId === "string") {
+      const delivery = entries.slice(0, position).filter(
+        (candidate) => candidate.kind === "handoffTransaction" && candidate.event.phase === "delivered" && candidate.event.deliveryId === payload.continuityDeliveryId
+      );
+      if (delivery.length !== 1) continue;
+      const intent = delivery[0];
+      if (intent?.kind !== "handoffTransaction" || intent.event.phase !== "delivered") continue;
+      const visited = /* @__PURE__ */ new Set();
+      let ancestor = entry.parentTurnId;
+      while (ancestor && ancestor !== intent.event.continuationTurnId && !visited.has(ancestor)) {
+        visited.add(ancestor);
+        const parent = messages.get(ancestor);
+        if (parent?.role === "user") break;
+        ancestor = parent?.parentTurnId ?? null;
+      }
+      if (ancestor !== intent.event.continuationTurnId) continue;
+      continuationTurnId = ancestor;
+    }
+    rows.push({ entryId: entry.turnId, continuationTurnId, status: terminalStatus(entry), position });
+  }
+  return rows;
+}
+function resumeAuthorities(entries, pathTurnIds) {
+  const rows = [];
+  const anchorByHandoff = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const identity = entry.kind === "handoffTransaction" ? entry.identity : entry.kind === "continuityCommit" ? entry.continuity.identity : entry.kind === "compactionSummary" ? entry.continuity?.identity : void 0;
+    if (identity === void 0) continue;
+    if (!anchorByHandoff.has(identity.handoffId)) anchorByHandoff.set(identity.handoffId, identity.branchAnchorTurnId);
+  }
+  for (let position = 0; position < entries.length; position += 1) {
+    const entry = entries[position];
+    if (!isHandoffRecoveryRequestEntry(entry)) continue;
+    const acceptedAtMs = Date.parse(entry.timestamp);
+    if (!Number.isFinite(acceptedAtMs)) continue;
+    const data = entry.data;
+    if (data === void 0) continue;
+    if (!anchorByHandoff.has(data.handoffId)) continue;
+    if (anchorByHandoff.get(data.handoffId) !== data.branchAnchorTurnId) continue;
+    if (entry.parentTurnId !== data.selectedLeafTurnId) continue;
+    if (data.selectedLeafTurnId !== null && !pathTurnIds.has(data.selectedLeafTurnId)) continue;
+    rows.push({
+      operatorRequestEntryId: entry.turnId,
+      handoffId: data.handoffId,
+      action: data.action,
+      pausedOrFailedEntryId: data.pausedOrFailedEntryId,
+      originSessionId: data.sessionId,
+      position,
+      acceptedAtMs
+    });
+  }
+  return rows;
+}
+function outcomeRefs(entries) {
+  const rows = [];
+  const positions = /* @__PURE__ */ new Map();
+  for (let position = 0; position < entries.length; position += 1) {
+    const entry = entries[position];
+    if (entry === void 0) continue;
+    if (!positions.has(entry.turnId)) positions.set(entry.turnId, position);
+    if (entry.kind === "compactionSummary" && entry.continuity !== void 0) {
+      rows.push({
+        entryId: entry.turnId,
+        outcome: "summarized",
+        handoffId: entry.continuity.identity.handoffId,
+        commitId: entry.continuity.identity.commitId,
+        position
+      });
+    }
+  }
+  const claims = /* @__PURE__ */ new Map();
+  for (let position = 0; position < entries.length; position += 1) {
+    const entry = entries[position];
+    const payload = entry?.kind === "continuityCommit" ? entry.continuity : entry?.kind === "compactionSummary" ? entry.continuity : void 0;
+    if (payload === void 0) continue;
+    const ref = payload.commit.evictionRef;
+    if (ref === void 0 || payload.commit.outcome !== "evicted") continue;
+    const identity = payload.identity;
+    const claimedAt = positions.get(payload.commit.entry.turnId) ?? position;
+    const existing = claims.get(ref);
+    if (existing === void 0) {
+      claims.set(ref, { handoffId: identity.handoffId, commitId: identity.commitId, claimedAt });
+      continue;
+    }
+    if (existing !== null && (existing.handoffId !== identity.handoffId || existing.commitId !== identity.commitId)) {
+      claims.set(ref, null);
+    }
+  }
+  for (const [ref, claim] of claims) {
+    if (claim === null) continue;
+    const position = positions.get(ref);
+    if (position === void 0 || position >= claim.claimedAt) continue;
+    if (entries[position]?.kind !== "contextEviction") continue;
+    rows.push({ entryId: ref, outcome: "evicted", handoffId: claim.handoffId, commitId: claim.commitId, position });
+  }
+  return rows;
+}
+function resolveContinuityEvidence(input) {
+  const pathTurnIds = new Set(
+    input.pathTurnIds ?? input.entries.filter((entry) => entry.kind === "message").map((entry) => entry.turnId)
+  );
+  return {
+    resumeAuthorities: resumeAuthorities(input.entries, pathTurnIds),
+    terminalResponses: terminalResponses(input.entries),
+    outcomeRefs: outcomeRefs(input.entries),
+    unreadableRecords: input.unreadableRecords
+  };
+}
+
+// src/domains/session/continuity/fold.ts
+init_esm_shims();
+
+// src/domains/session/continuity/note.ts
+init_esm_shims();
+import { createHash } from "node:crypto";
+function sha256Utf8(value) {
+  return createHash("sha256").update(Buffer.from(value, "utf8")).digest("hex");
+}
+function validateContinuityNote(note) {
+  if (typeof note !== "string") return { ok: false, reason: "not_a_string", noteBytes: null };
+  if (note.trim().length === 0) return { ok: false, reason: "blank", noteBytes: null };
+  if (note.includes("\0")) return { ok: false, reason: "contains_nul", noteBytes: null };
+  const encoded = Buffer.from(note, "utf8");
+  if (encoded.toString("utf8") !== note) {
+    return { ok: false, reason: "not_utf8_round_trip", noteBytes: encoded.byteLength };
+  }
+  if (encoded.byteLength > HANDOFF_NOTE_MAX_BYTES) {
+    return { ok: false, reason: "exceeds_max_bytes", noteBytes: encoded.byteLength };
+  }
+  return {
+    ok: true,
+    accepted: { note, noteBytes: encoded.byteLength, noteSha256: sha256Utf8(note) }
+  };
+}
+function verifyAcceptedNote(accepted, expected) {
+  const revalidated = validateContinuityNote(accepted.note);
+  if (!revalidated.ok) return { ok: false, reason: revalidated.reason };
+  if (revalidated.accepted.noteBytes !== accepted.noteBytes) return { ok: false, reason: "byte_count_mismatch" };
+  if (revalidated.accepted.noteSha256 !== accepted.noteSha256) return { ok: false, reason: "hash_mismatch" };
+  if (!expected) return { ok: true };
+  if (expected.note !== accepted.note) return { ok: false, reason: "decoded_text_mismatch" };
+  if (expected.noteBytes !== accepted.noteBytes) return { ok: false, reason: "byte_count_mismatch" };
+  if (expected.noteSha256 !== accepted.noteSha256) return { ok: false, reason: "hash_mismatch" };
+  return { ok: true };
+}
+
+// src/domains/session/continuity/fold.ts
+var LEGAL_PREDECESSORS = Object.freeze({
+  prepared: /* @__PURE__ */ new Set(["absent"]),
+  reducing: /* @__PURE__ */ new Set(["prepared", "failed", "resumed"]),
+  ready: /* @__PURE__ */ new Set(["reducing"]),
+  delivered: /* @__PURE__ */ new Set(["ready", "resumed"]),
+  acknowledged: /* @__PURE__ */ new Set(["delivered"]),
+  paused: /* @__PURE__ */ new Set(["prepared", "reducing", "ready", "delivered", "resumed"]),
+  failed: /* @__PURE__ */ new Set(["prepared", "reducing", "resumed"]),
+  resumed: /* @__PURE__ */ new Set(["paused", "failed"])
+});
+var LIFECYCLE_RANK = Object.freeze({
+  absent: 0,
+  prepared: 1,
+  reducing: 2,
+  ready: 3,
+  delivered: 4,
+  acknowledged: 5,
+  paused: -1,
+  failed: -1,
+  resumed: -1
+});
+function isUsableTimestamp(value) {
+  return Number.isSafeInteger(value) && value >= 0;
+}
+function newChain(handoffId, position) {
+  return {
+    handoffId,
+    rootPosition: position,
+    identity: null,
+    accepted: null,
+    policy: null,
+    commit: null,
+    head: null,
+    activeResume: null,
+    resumeEvidence: null,
+    delivery: null,
+    deliveryPosition: null,
+    carry: null,
+    commitPresent: false,
+    rootSeen: false,
+    seen: /* @__PURE__ */ new Map(),
+    anomalies: [],
+    poisoned: false
+  };
+}
+function fail(chain, kind, entryId, detail) {
+  chain.anomalies.push({ kind, entryId, detail });
+  chain.poisoned = true;
+}
+function headPhase(chain) {
+  return chain.head ? chain.head.event.phase : "absent";
+}
+function duplicateVerdict(chain, entryId, payload) {
+  const previous = chain.seen.get(entryId);
+  if (previous === void 0) {
+    chain.seen.set(entryId, payload);
+    return "new";
+  }
+  return previous === payload ? "identical" : "conflict";
+}
+function adoptImmutable(chain, entryId, identity, accepted, policy) {
+  if (chain.identity === null) {
+    chain.identity = identity;
+  } else if (canonicalJson(chain.identity) !== canonicalJson(identity)) {
+    fail(chain, "duplicate_conflict", entryId, "identity differs across copies of one handoff");
+    return false;
+  }
+  const verified = verifyAcceptedNote(accepted, chain.accepted ?? void 0);
+  if (!verified.ok) {
+    fail(chain, chain.accepted ? "conflicting_carry" : "unverified_note", entryId, `note rejected: ${verified.reason}`);
+    return false;
+  }
+  chain.accepted ??= accepted;
+  if (chain.policy === null) {
+    chain.policy = policy;
+  } else if (canonicalJson(chain.policy) !== canonicalJson(policy)) {
+    fail(chain, "policy_conflict", entryId, "policy differs across copies of one handoff");
+    return false;
+  }
+  return true;
+}
+function adoptCommit(chain, entryId, commit) {
+  if (chain.commit === null) {
+    chain.commit = commit;
+    return true;
+  }
+  if (canonicalJson(chain.commit) !== canonicalJson(commit)) {
+    fail(chain, "conflicting_carry", entryId, "commit data differs across copies of one handoff");
+    return false;
+  }
+  return true;
+}
+function validSuccessor(chain, entryId, phase, transition) {
+  const from = headPhase(chain);
+  if (!LEGAL_PREDECESSORS[phase].has(from)) {
+    fail(chain, "illegal_transition", entryId, `${from} -> ${phase} is not a legal transition`);
+    return false;
+  }
+  if (phase === "prepared") return true;
+  const head = chain.head;
+  if (!head) {
+    fail(chain, "broken_chain", entryId, `${phase} has no predecessor in this projection`);
+    return false;
+  }
+  if (transition.prevEntryId !== head.transition.entryId) {
+    fail(chain, "broken_chain", entryId, `predecessor ${transition.prevEntryId} is not the head`);
+    return false;
+  }
+  if (transition.sequence !== head.transition.sequence + 1) {
+    fail(chain, "broken_chain", entryId, `sequence ${transition.sequence} does not follow the head`);
+    return false;
+  }
+  const expectedAttempt = phase === "reducing" ? head.transition.attempt + 1 : head.transition.attempt;
+  if (transition.attempt !== expectedAttempt) {
+    fail(chain, "invalid_attempt", entryId, `attempt ${transition.attempt} should be ${expectedAttempt}`);
+    return false;
+  }
+  if (phase === "reducing" && chain.policy && transition.attempt > chain.policy.maxAttempts) {
+    fail(chain, "invalid_attempt", entryId, `attempt ${transition.attempt} exceeds the policy maximum`);
+    return false;
+  }
+  return true;
+}
+function resumeRefValid(chain, entryId, event) {
+  if (event.phase !== "reducing" && event.phase !== "delivered") return true;
+  const ref = event.resumeRef;
+  if (headPhase(chain) !== "resumed") {
+    if (ref === void 0) return true;
+    fail(chain, "missing_resume_ref", entryId, "resumeRef names a resume this event does not follow");
+    return false;
+  }
+  const resume = chain.activeResume;
+  if (!resume || ref !== resume.entryId) {
+    fail(chain, "missing_resume_ref", entryId, "event after a resume must name that resume");
+    return false;
+  }
+  const wanted = event.phase === "reducing" ? "reduce" : "deliver";
+  if (resume.authority.action !== wanted) {
+    fail(chain, "illegal_transition", entryId, `resume granted ${resume.authority.action}, not ${wanted}`);
+    return false;
+  }
+  return true;
+}
+function authorizeResume(chain, entry, authority, position, context) {
+  if (entry.transition.prevEntryId !== authority.pausedOrFailedEntryId) {
+    fail(chain, "unmatched_resume", entry.turnId, "resume authority does not name its own predecessor");
+    return null;
+  }
+  if (authority.action === "deliver" && chain.commit === null) {
+    fail(chain, "illegal_transition", entry.turnId, "resume to deliver requires a valid commit");
+    return null;
+  }
+  if (authority.action === "reduce" && chain.commit !== null) {
+    fail(chain, "illegal_transition", entry.turnId, "resume to reduce is not legal once a commit exists");
+    return null;
+  }
+  const answered = context.positions.get(authority.pausedOrFailedEntryId);
+  if (answered === void 0) {
+    fail(chain, "unmatched_resume", entry.turnId, "the paused or failed head this resume answers is not in the input");
+    return null;
+  }
+  const matched = context.authorities.find(
+    (candidate) => candidate.operatorRequestEntryId === authority.operatorRequestEntryId && candidate.handoffId === chain.handoffId && candidate.action === authority.action && candidate.pausedOrFailedEntryId === authority.pausedOrFailedEntryId && candidate.originSessionId === context.sessionId && candidate.position > answered && candidate.position < position
+  );
+  if (!matched) {
+    fail(
+      chain,
+      "unvalidated_resume_authority",
+      entry.turnId,
+      "no durable operator control request binds this handoff, action, head and position"
+    );
+    return null;
+  }
+  if (!isUsableTimestamp(matched.acceptedAtMs)) {
+    fail(chain, "unvalidated_resume_authority", entry.turnId, "the operator request has no usable accepted time");
+    return null;
+  }
+  return matched;
+}
+function carriedResumeAuthorized(chain, entryId, resume, context, carriedPrevEntryId) {
+  const refuse = (detail) => {
+    fail(chain, "unvalidated_resume_authority", entryId, detail);
+    return null;
+  };
+  if (carriedPrevEntryId !== null) {
+    if (carriedPrevEntryId !== resume.authority.pausedOrFailedEntryId) {
+      return refuse("the carried resume does not follow the head its authority answers");
+    }
+    if (resume.authority.action === "reduce" && chain.commit !== null) {
+      return refuse("a carried resume to reduce is not legal once a commit exists");
+    }
+    if (resume.authority.action === "deliver" && chain.commit === null) {
+      return refuse("a carried resume to deliver requires a valid commit");
+    }
+  }
+  const resumeRecord = context.records.get(resume.entryId);
+  if (!resumeRecord || resumeRecord.event.phase !== "resumed") {
+    return refuse("the carried resume names no actual resumed record in this input");
+  }
+  if (resumeRecord.identity.handoffId !== chain.handoffId) {
+    return refuse("the referenced resumed record belongs to another handoff");
+  }
+  if (canonicalJson(resumeRecord.event.authority) !== canonicalJson(resume.authority) || resumeRecord.transition.prevEntryId !== resume.authority.pausedOrFailedEntryId) {
+    return refuse("the carried resume disagrees with the actual resumed record it names");
+  }
+  const answeredRecord = context.records.get(resume.authority.pausedOrFailedEntryId);
+  if (!answeredRecord || answeredRecord.event.phase !== "paused" && answeredRecord.event.phase !== "failed") {
+    return refuse("the head this carried resume answers is not an actual paused or failed record");
+  }
+  if (answeredRecord.identity.handoffId !== chain.handoffId) {
+    return refuse("the answered paused or failed record belongs to another handoff");
+  }
+  const answered = context.positions.get(resume.authority.pausedOrFailedEntryId);
+  const upper = context.positions.get(resume.entryId);
+  if (answered === void 0 || upper === void 0 || upper <= answered) {
+    return refuse("the carried resume does not sit after the head it answers");
+  }
+  const matched = context.authorities.find(
+    (candidate) => candidate.operatorRequestEntryId === resume.authority.operatorRequestEntryId && candidate.handoffId === chain.handoffId && candidate.action === resume.authority.action && candidate.pausedOrFailedEntryId === resume.authority.pausedOrFailedEntryId && candidate.originSessionId === context.sessionId && isUsableTimestamp(candidate.acceptedAtMs) && candidate.position > answered && candidate.position < upper
+  );
+  if (!matched) {
+    return refuse("no durable operator control request binds this carried resume's handoff, action, head and order");
+  }
+  return matched;
+}
+function applyTransactionEvent(chain, entry, position, context) {
+  const verdict = duplicateVerdict(chain, entry.turnId, canonicalJson(entry));
+  if (verdict === "identical") return;
+  if (verdict === "conflict") {
+    fail(chain, "duplicate_conflict", entry.turnId, `two different payloads share entry id ${entry.turnId}`);
+    return;
+  }
+  if (entry.event.phase === "prepared") {
+    if (!validSuccessor(chain, entry.turnId, "prepared", entry.transition)) return;
+    if (!adoptImmutable(chain, entry.turnId, entry.identity, entry.event.accepted, entry.event.policy)) return;
+    chain.rootSeen = true;
+    chain.rootPosition = position;
+  } else {
+    if (chain.identity === null) {
+      chain.identity = entry.identity;
+    } else if (canonicalJson(chain.identity) !== canonicalJson(entry.identity)) {
+      fail(chain, "duplicate_conflict", entry.turnId, "identity differs across records of one handoff");
+      return;
+    }
+    if (!validSuccessor(chain, entry.turnId, entry.event.phase, entry.transition)) return;
+  }
+  if (entry.event.phase === "reducing" && headPhase(chain) === "failed") {
+    const failure = chain.head?.event;
+    if (failure.reason !== "provider_failed") {
+      fail(chain, "illegal_transition", entry.turnId, `failed(${failure.reason}) may not resume reduction`);
+      return;
+    }
+  }
+  if (!resumeRefValid(chain, entry.turnId, entry.event)) return;
+  if (entry.event.phase === "resumed") {
+    const evidence = authorizeResume(chain, entry, entry.event.authority, position, context);
+    if (!evidence) return;
+    chain.activeResume = { entryId: entry.turnId, authority: entry.event.authority };
+    chain.resumeEvidence = evidence;
+  }
+  chain.head = { transition: entry.transition, event: entry.event };
+  if (entry.event.phase === "delivered") {
+    chain.delivery = { deliveryId: entry.event.deliveryId, continuationTurnId: entry.event.continuationTurnId };
+    chain.deliveryPosition = position;
+  }
+}
+function applyCommit(chain, entry) {
+  const payload = entry.continuity;
+  const verdict = duplicateVerdict(chain, entry.turnId, canonicalJson(entry));
+  if (verdict === "identical") {
+    chain.commitPresent = true;
+    return;
+  }
+  if (verdict === "conflict") {
+    fail(chain, "duplicate_conflict", entry.turnId, `two different commit payloads share entry id ${entry.turnId}`);
+    return;
+  }
+  if (!adoptImmutable(chain, entry.turnId, payload.identity, payload.accepted, payload.policy)) return;
+  const known = chain.commit;
+  const restoresKnownCommit = known !== null && canonicalJson(known) === canonicalJson(payload.commit);
+  if (!adoptCommit(chain, entry.turnId, payload.commit)) return;
+  if (restoresKnownCommit) {
+    chain.commitPresent = true;
+    return;
+  }
+  if (!validSuccessor(chain, entry.turnId, "ready", payload.commit.transition)) return;
+  chain.commitPresent = true;
+  chain.head = { transition: payload.commit.transition, event: { phase: "ready" } };
+}
+function carryMayAdvance(chain, to) {
+  const from = headPhase(chain);
+  if (from === "absent") return true;
+  if (from === "acknowledged") return false;
+  if (from === "paused") return to === "resumed";
+  if (from === "failed") {
+    if (to === "resumed") return true;
+    if (to !== "reducing") return false;
+    const failure = chain.head?.event;
+    return failure.reason === "provider_failed";
+  }
+  if (to === "paused" || to === "failed" || to === "resumed") return true;
+  return LIFECYCLE_RANK[to] > LIFECYCLE_RANK[from];
+}
+function applyCarry(chain, payload, entryId, context) {
+  const verdict = duplicateVerdict(chain, entryId, canonicalJson(payload));
+  if (verdict === "identical") return;
+  if (verdict === "conflict") {
+    fail(chain, "conflicting_carry", entryId, `two different carried payloads share entry id ${entryId}`);
+    return;
+  }
+  if (!adoptImmutable(chain, entryId, payload.identity, payload.accepted, payload.policy)) return;
+  if (!adoptCommit(chain, entryId, payload.commit)) return;
+  if (chain.carry && payload.state.transition.sequence === chain.carry.state.transition.sequence) {
+    if (canonicalJson(chain.carry.state) !== canonicalJson(payload.state)) {
+      fail(chain, "conflicting_carry", entryId, "two carries disagree about the state at the same sequence");
+      return;
+    }
+  }
+  if (chain.carry === null || payload.state.transition.sequence > chain.carry.state.transition.sequence) {
+    chain.carry = payload;
+  }
+  const head = chain.head;
+  const carriedPhase = payload.state.event.phase;
+  let adjacent = false;
+  if (head) {
+    if (payload.state.transition.sequence === head.transition.sequence) {
+      const observed = {
+        transition: head.transition,
+        event: head.event,
+        delivery: chain.delivery,
+        activeResume: chain.activeResume
+      };
+      const carried = {
+        transition: payload.state.transition,
+        event: payload.state.event,
+        delivery: payload.state.delivery,
+        activeResume: payload.state.activeResume
+      };
+      if (canonicalJson(observed) !== canonicalJson(carried)) {
+        fail(chain, "conflicting_carry", entryId, "the carry contradicts the observed head at the same sequence");
+      }
+      return;
+    }
+    if (payload.state.transition.sequence < head.transition.sequence) return;
+    adjacent = payload.state.transition.sequence === head.transition.sequence + 1;
+    if (adjacent) {
+      if (!validSuccessor(chain, entryId, carriedPhase, payload.state.transition)) return;
+    } else {
+      if (!carryMayAdvance(chain, carriedPhase)) {
+        fail(chain, "fabricated_carry_extension", entryId, `a carry cannot move ${headPhase(chain)} to ${carriedPhase}`);
+        return;
+      }
+      if (payload.state.transition.attempt < head.transition.attempt) {
+        fail(chain, "invalid_attempt", entryId, "a carry cannot advance the head while refunding a spent attempt");
+        return;
+      }
+    }
+  }
+  const carriedResume = payload.state.activeResume;
+  if (carriedResume) {
+    const carriedPrev = carriedPhase === "resumed" ? payload.state.transition.prevEntryId : null;
+    const evidence = carriedResumeAuthorized(chain, entryId, carriedResume, context, carriedPrev);
+    if (!evidence) return;
+    chain.activeResume = carriedResume;
+    chain.resumeEvidence = evidence;
+  } else if (carriedPhase === "resumed") {
+    fail(chain, "unmatched_resume", entryId, "a carried resumed head retains no resume to validate");
+    return;
+  }
+  if (adjacent && !resumeRefValid(chain, entryId, payload.state.event)) return;
+  chain.head = { transition: payload.state.transition, event: payload.state.event };
+  if (payload.state.delivery) chain.delivery = payload.state.delivery;
+}
+function outcomeRefMatches(commit, identity, refs) {
+  if (commit.outcome === "continuity_only") return true;
+  const expectedId = commit.outcome === "summarized" ? commit.summaryRef : commit.evictionRef;
+  if (expectedId === void 0) return false;
+  return refs.some(
+    (ref) => ref.entryId === expectedId && ref.outcome === commit.outcome && ref.handoffId === identity.handoffId && ref.commitId === identity.commitId
+  );
+}
+function acknowledgementSupported(event, delivery, responses, bounds) {
+  if (!delivery || delivery.deliveryId !== event.deliveryId) return false;
+  const { deliveredAfter, acknowledgedBefore } = bounds;
+  if (deliveredAfter === null || acknowledgedBefore === null) return false;
+  return responses.some(
+    (response) => response.entryId === event.terminalResponseEntryId && response.continuationTurnId === delivery.continuationTurnId && response.status === "success" && Number.isFinite(response.position) && response.position > deliveredAfter && response.position < acknowledgedBefore
+  );
+}
+function effectiveDeadline(policy, resume, evidence) {
+  if (resume && evidence) {
+    return Math.min(resume.automaticDeadlineAtMs, evidence.acceptedAtMs + HANDOFF_MAX_WINDOW_MS);
+  }
+  return Math.min(policy.automaticDeadlineAtMs, policy.preparedAtMs + HANDOFF_MAX_WINDOW_MS);
+}
+function priorProjection(chain) {
+  return {
+    handoffId: chain.handoffId,
+    commitId: chain.identity?.commitId ?? "",
+    phase: headPhase(chain),
+    accepted: chain.accepted,
+    outcome: chain.commit?.outcome ?? null
+  };
+}
+function applicable(identity, input, path) {
+  if (identity.originSessionId !== input.selection.sessionId) return false;
+  if (!path.has(identity.initiatingTurnId)) return false;
+  return identity.branchAnchorTurnId === null || path.has(identity.branchAnchorTurnId);
+}
+function looksLikeContinuity(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const record = value;
+  if (record.kind === "handoffTransaction" || record.kind === "continuityCommit") return true;
+  return record.kind === "compactionSummary" && record.continuity !== void 0;
+}
+function foldContinuity(input) {
+  const path = new Set(input.selection.pathTurnIds);
+  const chains = /* @__PURE__ */ new Map();
+  const positions = /* @__PURE__ */ new Map();
+  const ownerByEntryId = /* @__PURE__ */ new Map();
+  const observed = /* @__PURE__ */ new Set();
+  const malformed = [];
+  let inapplicable = 0;
+  const records = /* @__PURE__ */ new Map();
+  const context = {
+    positions,
+    records,
+    authorities: input.evidence.resumeAuthorities,
+    sessionId: input.selection.sessionId
+  };
+  const chainFor = (handoffId, position) => {
+    const existing = chains.get(handoffId);
+    if (existing) return existing;
+    const created = newChain(handoffId, position);
+    chains.set(handoffId, created);
+    return created;
+  };
+  for (let position = 0; position < input.entries.length; position += 1) {
+    const raw = input.entries[position];
+    if (isHandoffTransactionEntry(raw) || isContinuityCommitEntry(raw)) {
+      const entryId = raw.turnId;
+      if (!observed.has(entryId)) {
+        observed.add(entryId);
+        positions.set(entryId, position);
+        if (isHandoffTransactionEntry(raw)) records.set(entryId, raw);
+      }
+    }
+  }
+  for (let position = 0; position < input.entries.length; position += 1) {
+    const raw = input.entries[position];
+    const transaction = isHandoffTransactionEntry(raw) ? raw : null;
+    const commit = !transaction && isContinuityCommitEntry(raw) ? raw : null;
+    const carrying = !transaction && !commit && isContinuityCarryingSummary(raw) ? raw : null;
+    if (!transaction && !commit && !carrying) {
+      if (looksLikeContinuity(raw)) {
+        malformed.push({
+          kind: "malformed_continuity_record",
+          entryId: typeof raw.turnId === "string" ? raw.turnId : null,
+          detail: "a record claiming a continuity kind failed structural validation"
+        });
+      }
+      continue;
+    }
+    const identity = transaction?.identity ?? commit?.continuity.identity ?? carrying?.continuity.identity;
+    if (!identity || !applicable(identity, input, path)) {
+      inapplicable += 1;
+      continue;
+    }
+    const entryId = (transaction ?? commit ?? carrying)?.turnId;
+    const owner = ownerByEntryId.get(entryId);
+    if (owner !== void 0 && owner !== identity.handoffId) {
+      const chain2 = chainFor(identity.handoffId, position);
+      fail(chain2, "entry_id_reused", entryId, `entry id is also used by handoff ${owner}`);
+      const other = chains.get(owner);
+      if (other) fail(other, "entry_id_reused", entryId, `entry id is also used by handoff ${identity.handoffId}`);
+      continue;
+    }
+    ownerByEntryId.set(entryId, identity.handoffId);
+    const chain = chainFor(identity.handoffId, position);
+    if (transaction) applyTransactionEvent(chain, transaction, position, context);
+    else if (commit) applyCommit(chain, commit);
+    else if (carrying) applyCarry(chain, carrying.continuity, carrying.turnId, context);
+  }
+  const base = {
+    skipped: { inapplicable, unreadable: input.evidence.unreadableRecords }
+  };
+  if (chains.size === 0) {
+    return {
+      phase: "absent",
+      authority: "none",
+      identity: null,
+      accepted: null,
+      policy: null,
+      commit: null,
+      state: null,
+      attemptsSpent: 0,
+      effectiveDeadlineAtMs: null,
+      missingCommit: null,
+      validated: malformed.length === 0,
+      anomalies: malformed,
+      action: { kind: "none" },
+      priorHandoffs: [],
+      ...base
+    };
+  }
+  const ordered = [...chains.values()].sort((a, b) => a.rootPosition - b.rootPosition);
+  const selected = ordered[ordered.length - 1];
+  const priorHandoffs = ordered.slice(0, -1).map(priorProjection);
+  return finalize(selected, input, positions, records, malformed, priorHandoffs, inapplicable);
+}
+function finalize(chain, input, positions, records, malformed, priorHandoffs, inapplicable) {
+  const anomalies = [...malformed, ...chain.anomalies];
+  const unreadable = input.evidence.unreadableRecords;
+  const identity = chain.identity;
+  const policy = chain.policy;
+  let poisoned = chain.poisoned || malformed.length > 0;
+  if (unreadable > 0 && identity !== null) {
+    anomalies.push({
+      kind: "malformed_record",
+      entryId: null,
+      detail: `${unreadable} unreadable records leave this transaction's evidence unresolved`
+    });
+    poisoned = true;
+  }
+  if (chain.commit && identity && !outcomeRefMatches(chain.commit, identity, input.evidence.outcomeRefs)) {
+    anomalies.push({
+      kind: unreadable > 0 ? "missing_commit_ref" : "unbound_outcome_ref",
+      entryId: chain.commit.entry.turnId,
+      detail: `no ${chain.commit.outcome} record is bound to commit ${identity.commitId}`
+    });
+    poisoned = true;
+  }
+  const phase = headPhase(chain);
+  if (phase === "acknowledged") {
+    const event = chain.head?.event;
+    const ackEntryId = chain.head?.transition.entryId ?? "";
+    const deliveryEntryId = chain.head?.transition.prevEntryId ?? "";
+    const ackRecord = records.get(ackEntryId);
+    const deliveryRecord = records.get(deliveryEntryId);
+    const ackMatches = ackRecord?.event.phase === "acknowledged" && ackRecord.identity.handoffId === chain.handoffId && ackRecord.event.deliveryId === event.deliveryId && ackRecord.event.terminalResponseEntryId === event.terminalResponseEntryId;
+    const deliveryMatches = deliveryRecord?.event.phase === "delivered" && deliveryRecord.identity.handoffId === chain.handoffId && deliveryRecord.event.deliveryId === (chain.delivery?.deliveryId ?? null) && deliveryRecord.event.continuationTurnId === (chain.delivery?.continuationTurnId ?? null);
+    const ackBounds = {
+      deliveredAfter: deliveryMatches ? chain.deliveryPosition ?? positions.get(deliveryEntryId) ?? null : null,
+      acknowledgedBefore: ackMatches ? positions.get(ackEntryId) ?? null : null
+    };
+    if (!acknowledgementSupported(event, chain.delivery, input.evidence.terminalResponses, ackBounds)) {
+      anomalies.push({
+        kind: "acknowledgement_unsupported",
+        entryId: chain.head?.transition.entryId ?? null,
+        detail: "no terminal successful response matches this delivery"
+      });
+      poisoned = true;
+    }
+  }
+  const state = chain.head ? {
+    transition: chain.head.transition,
+    event: chain.head.event,
+    activeResume: chain.activeResume,
+    delivery: chain.delivery
+  } : null;
+  let missingCommit = null;
+  if (!chain.commitPresent && chain.carry && identity && state && !poisoned) {
+    {
+      const original = chain.carry.commit;
+      const rebuilt = {
+        kind: "continuityCommit",
+        turnId: original.entry.turnId,
+        parentTurnId: original.entry.parentTurnId,
+        timestamp: original.entry.timestamp,
+        continuity: {
+          schemaVersion: HANDOFF_SCHEMA_VERSION,
+          identity,
+          accepted: chain.carry.accepted,
+          policy: chain.carry.policy,
+          commit: original,
+          state: { transition: original.transition, event: { phase: "ready" }, activeResume: null, delivery: null }
+        }
+      };
+      if (isContinuityCheckpointPayload(rebuilt.continuity)) {
+        missingCommit = { entry: rebuilt, carriedState: state };
+      } else {
+        anomalies.push({
+          kind: "conflicting_carry",
+          entryId: original.entry.turnId,
+          detail: "the reconstructed commit does not validate"
+        });
+        poisoned = true;
+      }
+    }
+  }
+  const attemptsSpent = chain.head?.transition.attempt ?? 0;
+  const renewalBase = chain.resumeEvidence?.acceptedAtMs ?? null;
+  const clockAmbiguous = !Number.isFinite(input.nowMs) || policy !== null && input.nowMs < policy.preparedAtMs || renewalBase !== null && input.nowMs < renewalBase;
+  const deadline = policy ? effectiveDeadline(policy, chain.activeResume?.authority ?? null, chain.resumeEvidence) : null;
+  const expired = deadline !== null && !clockAmbiguous && input.nowMs >= deadline;
+  const action = resolveAction({
+    historical: input.selection.historical,
+    poisoned,
+    phase,
+    clockAmbiguous,
+    expired,
+    missingCommit,
+    attemptsSpent,
+    policy,
+    delivery: chain.delivery,
+    deliveryPosition: chain.deliveryPosition,
+    responses: input.evidence.terminalResponses,
+    committed: chain.commit !== null,
+    resumeAction: chain.activeResume?.authority.action ?? null
+  });
+  const authority = identity === null ? "none" : action.kind === "none" && phase !== "absent" && phase !== "acknowledged" ? "execution" : "recall_only";
+  return {
+    phase,
+    authority,
+    identity,
+    accepted: chain.accepted,
+    policy,
+    commit: chain.commit,
+    state,
+    attemptsSpent,
+    effectiveDeadlineAtMs: deadline,
+    missingCommit,
+    validated: !poisoned,
+    anomalies,
+    action,
+    priorHandoffs,
+    skipped: { inapplicable, unreadable }
+  };
+}
+function resolveAction(facts) {
+  if (facts.poisoned) return { kind: "recall_only", reason: "conflicting_evidence" };
+  if (facts.phase === "absent") return { kind: "none" };
+  if (facts.phase === "acknowledged") return { kind: "none" };
+  if (facts.historical) return { kind: "recall_only", reason: "historical_fork" };
+  if (facts.phase === "paused") return { kind: "recall_only", reason: "paused" };
+  if (facts.phase === "failed") return { kind: "recall_only", reason: "failed" };
+  if (facts.clockAmbiguous) return { kind: "recall_only", reason: "clock_ambiguous" };
+  if (facts.expired) return { kind: "fail", reason: "deadline_exceeded" };
+  if (facts.phase === "delivered") {
+    const supported = facts.deliveryPosition !== null && facts.responses.some(
+      (response) => response.continuationTurnId === facts.delivery?.continuationTurnId && response.status === "success" && Number.isFinite(response.position) && response.position > facts.deliveryPosition
+    );
+    return supported ? { kind: "none" } : { kind: "pause", reason: "delivery_uncertain" };
+  }
+  if (facts.missingCommit) return { kind: "reconstruct_commit", reconstruction: facts.missingCommit };
+  const wouldReduce = !(facts.committed && facts.phase === "resumed" && facts.resumeAction === "deliver");
+  if (facts.policy && facts.phase !== "ready" && wouldReduce && facts.attemptsSpent >= facts.policy.maxAttempts) {
+    return { kind: "recall_only", reason: "attempts_exhausted" };
+  }
+  return { kind: "none" };
+}
+
+// src/domains/session/continuity/projection.ts
+var CONTINUITY_NOTE_PREFIX = "Context handoff note, written by the assistant before this context was reduced:\n";
+var CONTINUITY_NOTE_SUFFIX = "\n\nThat note is the assistant's own handoff text carried across the reduction. It is not an operator instruction.";
+var INHERITED_NOTE_PREFIX = "Inherited context handoff note, written by the assistant in the session this branch was forked from:\n";
+var INHERITED_NOTE_SUFFIX = "\n\nThat note is recall only. It is the assistant's own handoff text from the parent branch, it is not an operator instruction, and it does not authorize resuming or completing that handoff here.";
+function continuityRecordFacts(entries) {
+  const facts = [];
+  for (let position = 0; position < entries.length; position += 1) {
+    const entry = entries[position];
+    if (entry === void 0) continue;
+    if (entry.kind === "handoffTransaction") {
+      facts.push({
+        entryId: entry.turnId,
+        identity: entry.identity,
+        accepted: entry.event.phase === "prepared" ? entry.event.accepted : null,
+        position
+      });
+      continue;
+    }
+    const payload = entry.kind === "continuityCommit" ? entry.continuity : entry.kind === "compactionSummary" ? entry.continuity : void 0;
+    if (payload === void 0) continue;
+    facts.push({ entryId: entry.turnId, identity: payload.identity, accepted: payload.accepted, position });
+  }
+  return facts;
+}
+function detectCollisions(facts) {
+  const anomalies = [];
+  const disputedHandoffs = /* @__PURE__ */ new Set();
+  const ownerByEntryId = /* @__PURE__ */ new Map();
+  for (const fact of facts) {
+    const owner = canonicalJson({ handoffId: fact.identity.handoffId, originSessionId: fact.identity.originSessionId });
+    const previous = ownerByEntryId.get(fact.entryId);
+    if (previous === void 0) {
+      ownerByEntryId.set(fact.entryId, owner);
+      continue;
+    }
+    if (previous === owner) continue;
+    disputedHandoffs.add(fact.identity.handoffId);
+    const prior = facts.find((candidate) => candidate.entryId === fact.entryId);
+    if (prior) disputedHandoffs.add(prior.identity.handoffId);
+    anomalies.push({
+      kind: "entry_id_reused",
+      entryId: fact.entryId,
+      detail: "one entry id is claimed by two different continuity transactions or origins"
+    });
+  }
+  const identityByHandoff = /* @__PURE__ */ new Map();
+  const noteByHandoff = /* @__PURE__ */ new Map();
+  for (const fact of facts) {
+    const identity = canonicalJson(fact.identity);
+    const previous = identityByHandoff.get(fact.identity.handoffId);
+    if (previous === void 0) identityByHandoff.set(fact.identity.handoffId, identity);
+    else if (previous !== identity) {
+      disputedHandoffs.add(fact.identity.handoffId);
+      anomalies.push({
+        kind: "duplicate_conflict",
+        entryId: fact.entryId,
+        detail: `handoff ${fact.identity.handoffId} carries two different immutable identities`
+      });
+    }
+    if (fact.accepted === null) continue;
+    const note = canonicalJson(fact.accepted);
+    const priorNote = noteByHandoff.get(fact.identity.handoffId);
+    if (priorNote === void 0) noteByHandoff.set(fact.identity.handoffId, note);
+    else if (priorNote !== note) {
+      disputedHandoffs.add(fact.identity.handoffId);
+      anomalies.push({
+        kind: "duplicate_conflict",
+        entryId: fact.entryId,
+        detail: `handoff ${fact.identity.handoffId} carries two different accepted notes`
+      });
+    }
+  }
+  return { anomalies, disputedHandoffs };
+}
+function noteAnchor(facts, note) {
+  if (note === null) return null;
+  for (const fact of facts) {
+    if (fact.identity.handoffId === note.handoffId) return fact.entryId;
+  }
+  return null;
+}
+function messageTurnIds(entries) {
+  return entries.filter((entry) => entry.kind === "message").map((entry) => entry.turnId);
+}
+function inheritedPrefix(entries, fork) {
+  if (fork.headerParentTurnId !== void 0 && fork.headerParentTurnId !== fork.parentTurnId) {
+    return { problem: "the session header and metadata disagree about the fork message" };
+  }
+  const boundary = entries.findIndex((entry) => entry.turnId === fork.parentTurnId);
+  if (boundary < 0) return { problem: `the fork message ${fork.parentTurnId} is not present in this ledger` };
+  return { prefix: entries.slice(0, boundary + 1) };
+}
+function recallFromFold(fold, originSessionId, disputed) {
+  const notes = [];
+  if (fold.identity !== null && fold.accepted !== null && !disputed.has(fold.identity.handoffId)) {
+    notes.push({
+      originSessionId,
+      handoffId: fold.identity.handoffId,
+      commitId: fold.identity.commitId,
+      note: fold.accepted.note,
+      phase: fold.phase,
+      provenance: "inherited",
+      validated: fold.validated
+    });
+  }
+  for (const prior of fold.priorHandoffs) {
+    if (prior.accepted === null || disputed.has(prior.handoffId)) continue;
+    notes.push({
+      originSessionId,
+      handoffId: prior.handoffId,
+      commitId: prior.commitId,
+      note: prior.accepted.note,
+      phase: prior.phase,
+      // A prior handoff is a recall projection of an earlier completed cycle,
+      // never independently finalized authority.
+      provenance: "inherited_prior",
+      validated: fold.validated
+    });
+  }
+  return notes;
+}
+function resolveContinuityProjection(input) {
+  const facts = continuityRecordFacts(input.entries);
+  if (facts.length === 0) {
+    return {
+      current: null,
+      note: null,
+      inherited: [],
+      anomalies: [],
+      authoritySuppressed: false,
+      noteAnchorTurnId: null
+    };
+  }
+  const collisions = detectCollisions(facts);
+  const anomalies = [...collisions.anomalies];
+  const pathTurnIds = input.pathTurnIds ?? messageTurnIds(input.entries);
+  const nowMs = input.nowMs ?? Date.now();
+  const current = input.sessionId === void 0 ? null : foldContinuity({
+    entries: input.entries,
+    selection: { sessionId: input.sessionId, pathTurnIds, historical: input.historical ?? false },
+    // Evidence for the full ledger, resolved over the full ledger. Every
+    // position in it indexes this same array.
+    evidence: resolveContinuityEvidence({
+      entries: input.entries,
+      unreadableRecords: input.unreadableRecords ?? 0
+    }),
+    nowMs
+  });
+  const inherited = [];
+  const foreignOrigins = /* @__PURE__ */ new Set();
+  for (const fact of facts) {
+    if (fact.identity.originSessionId !== input.sessionId) foreignOrigins.add(fact.identity.originSessionId);
+  }
+  let boundaryUnresolved = false;
+  if (foreignOrigins.size > 0) {
+    if (input.fork === void 0) {
+      boundaryUnresolved = true;
+      anomalies.push({
+        kind: "malformed_continuity_record",
+        entryId: null,
+        detail: `this ledger holds continuity records from ${foreignOrigins.size} other origin session(s) but publishes no fork binding; they are not projected`
+      });
+    } else {
+      const bounded = inheritedPrefix(input.entries, input.fork);
+      if ("problem" in bounded) {
+        boundaryUnresolved = true;
+        anomalies.push({
+          kind: "malformed_continuity_record",
+          entryId: null,
+          detail: `inherited boundary unresolved: ${bounded.problem}`
+        });
+      } else {
+        const prefix = bounded.prefix;
+        const prefixEvidence = resolveContinuityEvidence({
+          entries: prefix,
+          unreadableRecords: input.unreadableRecords ?? 0
+        });
+        const prefixPath = input.pathTurnIds ?? messageTurnIds(prefix);
+        const eligible = [...new Set(continuityRecordFacts(prefix).map((fact) => fact.identity.originSessionId))].filter(
+          (origin) => origin !== input.sessionId
+        );
+        for (const originSessionId of eligible) {
+          const fold = foldContinuity({
+            entries: prefix,
+            // The origin is the record's own, unchanged. `historical: true` is
+            // the honest description of the projection: another branch's
+            // transaction, which the fold answers recall-only in every phase.
+            selection: { sessionId: originSessionId, pathTurnIds: prefixPath, historical: true },
+            evidence: prefixEvidence,
+            nowMs
+          });
+          inherited.push(...recallFromFold(fold, originSessionId, collisions.disputedHandoffs));
+        }
+      }
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = inherited.filter((entry) => {
+    const key = canonicalJson({ h: entry.handoffId, c: entry.commitId, o: entry.originSessionId, n: entry.note });
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+  const authoritySuppressed = boundaryUnresolved || current !== null && current.identity !== null && collisions.disputedHandoffs.has(current.identity.handoffId);
+  const published = current === null ? null : authoritySuppressed ? {
+    ...current,
+    authority: current.authority === "none" ? "none" : "recall_only",
+    validated: false,
+    action: { kind: "recall_only", reason: "conflicting_evidence" },
+    missingCommit: null,
+    anomalies: [...current.anomalies, ...anomalies]
+  } : current;
+  const note = published === null || published.identity === null || published.accepted === null ? null : {
+    note: published.accepted.note,
+    handoffId: published.identity.handoffId,
+    commitId: published.identity.commitId,
+    originSessionId: published.identity.originSessionId,
+    phase: published.phase,
+    authority: published.authority
+  };
+  return {
+    current: published,
+    note,
+    inherited: deduped,
+    anomalies,
+    authoritySuppressed,
+    noteAnchorTurnId: noteAnchor(facts, note)
+  };
+}
+function continuityReplayText(note) {
+  return `${CONTINUITY_NOTE_PREFIX}${note.note}${CONTINUITY_NOTE_SUFFIX}`;
+}
+function inheritedContinuityReplayText(note) {
+  return `${INHERITED_NOTE_PREFIX}${note.note}${INHERITED_NOTE_SUFFIX}`;
+}
+function continuityReplayBlocks(projection) {
+  const blocks = projection.inherited.map(inheritedContinuityReplayText);
+  if (projection.note !== null && projection.note.authority !== "none") {
+    blocks.push(continuityReplayText(projection.note));
+  }
+  return blocks;
+}
+function continuityProjectionTokens(projection) {
+  let total = 0;
+  for (const block of continuityReplayBlocks(projection)) {
+    total += estimateAgentMessageTokens({ role: "user", payload: { text: block } });
+  }
+  return total;
+}
+
+// src/domains/session/protected-artifacts.ts
+init_esm_shims();
+function protectedArtifactEntryFromArtifact(artifact, context) {
+  const entry = {
+    kind: "protectedArtifact",
+    parentTurnId: context.parentTurnId,
+    action: "protect",
+    artifact: artifactSnapshot(artifact)
+  };
+  if (context.toolName !== void 0) entry.toolName = context.toolName;
+  if (context.toolCallId !== void 0) entry.toolCallId = context.toolCallId;
+  if (context.runId !== void 0) entry.runId = context.runId;
+  if (context.correlationId !== void 0) entry.correlationId = context.correlationId;
+  return entry;
+}
+function protectedArtifactFromSessionEntry(entry) {
+  return protectedArtifactFromSnapshot(entry.artifact);
+}
+function protectedArtifactStateFromSessionEntries(entries) {
+  let state = { artifacts: [] };
+  const protectedEntries = entries.map((entry, index) => ({ entry, index })).filter((item) => item.entry.kind === "protectedArtifact").sort(compareProtectedEntryPositions);
+  for (const item of protectedEntries) {
+    if (item.entry.action !== "protect") continue;
+    state = protectArtifact(state, protectedArtifactFromSessionEntry(item.entry));
+  }
+  return state;
+}
+function artifactSnapshot(artifact) {
+  const snapshot = {
+    path: artifact.path,
+    protectedAt: artifact.protectedAt,
+    reason: artifact.reason,
+    source: artifact.source
+  };
+  if (artifact.validationCommand !== void 0) snapshot.validationCommand = artifact.validationCommand;
+  if (artifact.validationExitCode !== void 0) snapshot.validationExitCode = artifact.validationExitCode;
+  return snapshot;
+}
+function protectedArtifactFromSnapshot(snapshot) {
+  const artifact = {
+    path: snapshot.path,
+    protectedAt: snapshot.protectedAt,
+    reason: snapshot.reason,
+    source: snapshot.source
+  };
+  if (snapshot.validationCommand !== void 0) artifact.validationCommand = snapshot.validationCommand;
+  if (snapshot.validationExitCode !== void 0) artifact.validationExitCode = snapshot.validationExitCode;
+  return artifact;
+}
+function compareProtectedEntryPositions(left, right) {
+  return compareStrings(left.entry.timestamp, right.entry.timestamp) || compareStrings(left.entry.turnId, right.entry.turnId) || left.index - right.index;
+}
+function compareStrings(left, right) {
+  if (left < right) return -1;
+  if (left > right) return 1;
+  return 0;
+}
+
+// src/domains/session/usage.ts
+init_esm_shims();
+function numberAt(source, key) {
+  const value = source[key];
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+function reasoningTokensOf(usage) {
+  const direct = numberAt(usage, "reasoning") || numberAt(usage, "reasoningTokens");
+  if (direct > 0) return direct;
+  const details = usage.outputTokensDetails ?? usage.completionTokensDetails;
+  if (details && typeof details === "object") return numberAt(details, "reasoningTokens");
+  return 0;
+}
+function stringAt(source, ...keys) {
+  for (const key of keys) {
+    const value = source[key];
+    if (typeof value === "string" && value.trim().length > 0) return value;
+  }
+  return null;
+}
+function ledgerUsageCalls(entries, defaults = {}) {
+  const calls = [];
+  let currentTarget = defaults.target ?? null;
+  let currentModel = defaults.model ?? null;
+  for (const entry of entries) {
+    if (entry?.kind === "compactionSummary") {
+      const usage2 = entry.usage;
+      if (!usage2 || usage2.totalTokens <= 0) continue;
+      calls.push({
+        providerId: usage2.targetId ?? currentTarget ?? "unknown",
+        attributedModelId: usage2.modelId ?? currentModel ?? "unknown",
+        requestedModelId: usage2.modelId ?? currentModel ?? "unknown",
+        responseModelIdObservation: { state: "not-observed" },
+        input: usage2.input,
+        output: usage2.output,
+        cacheRead: usage2.cacheRead,
+        cacheWrite: usage2.cacheWrite,
+        ...usage2.cacheWrite1h === void 0 ? {} : { cacheWrite1h: usage2.cacheWrite1h },
+        reasoningTokens: usage2.reasoning,
+        totalTokens: usage2.totalTokens,
+        costUsd: usage2.cost.total,
+        // A split turn runs two summarization streams under one entry; the
+        // provider served that many calls even though one row records them.
+        apiCalls: Math.max(1, Math.round(usage2.apiCalls))
+      });
+      continue;
+    }
+    if (entry?.kind === "modelChange") {
+      const change = entry;
+      if (typeof change.target === "string" && change.target.length > 0) currentTarget = change.target;
+      else if (typeof change.provider === "string" && change.provider.length > 0) currentTarget = change.provider;
+      if (typeof change.modelId === "string" && change.modelId.length > 0) currentModel = change.modelId;
+      continue;
+    }
+    if (entry?.kind !== "message" || entry.role !== "assistant") continue;
+    const payload = entry.payload;
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)) continue;
+    const record = payload;
+    const rawUsage = record.usage;
+    if (!rawUsage || typeof rawUsage !== "object" || Array.isArray(rawUsage)) continue;
+    const usage = rawUsage;
+    const input = numberAt(usage, "input");
+    const output = numberAt(usage, "output");
+    const cacheRead = numberAt(usage, "cacheRead");
+    const cacheWrite = numberAt(usage, "cacheWrite");
+    const totalTokens = numberAt(usage, "totalTokens") || input + output + cacheRead + cacheWrite;
+    if (totalTokens === 0) continue;
+    const cost = usage.cost;
+    const costUsd = cost && typeof cost === "object" ? numberAt(cost, "total") : 0;
+    const requestedModelId = currentModel ?? stringAt(record, "model") ?? "unknown";
+    const differingResponseModelId = stringAt(record, "responseModel");
+    const responseModelIdObservation = responseModelIdObservationFromRecord(record, "legacy-difference-only");
+    calls.push({
+      providerId: currentTarget ?? stringAt(record, "provider", "api") ?? "unknown",
+      attributedModelId: attributedModelId(responseModelIdObservation, requestedModelId, differingResponseModelId),
+      requestedModelId,
+      responseModelIdObservation,
+      input,
+      output,
+      cacheRead,
+      cacheWrite,
+      ...typeof usage.cacheWrite1h === "number" ? { cacheWrite1h: numberAt(usage, "cacheWrite1h") } : {},
+      reasoningTokens: reasoningTokensOf(usage),
+      totalTokens,
+      costUsd
+    });
+  }
+  return calls;
+}
+
+// src/domains/session/index.ts
+var SessionDomainModule = {
+  manifest: SessionManifest,
+  createExtension: createSessionBundle
+};
+
+// src/domains/session/archive-readers.ts
+var ROUTING_NOTICE_CUSTOM_TYPE = "clio-coder.routing-notice";
+var LEGACY_ROUTING_NOTICE_CUSTOM_TYPE = "clio.routing-notice";
+function normalizeReleasedCustomType(entry) {
+  if (entry.kind !== "custom" || entry.customType !== LEGACY_ROUTING_NOTICE_CUSTOM_TYPE) return entry;
+  return { ...entry, customType: ROUTING_NOTICE_CUSTOM_TYPE };
+}
+async function readAuditRows(stateDir) {
+  const root = join3(stateDir, "audit");
+  let files;
+  try {
+    files = await readdir(root);
+  } catch (error) {
+    const err = error;
+    if (err.code === "ENOENT") return { rows: [], errors: [] };
+    return { rows: [], errors: [`audit root read error: ${err.message ?? String(err)}`] };
+  }
+  const rows = [];
+  const errors = [];
+  for (const file of files.filter((name) => name.endsWith(".jsonl")).sort(compareStrings2)) {
+    const path = join3(root, file);
+    let raw;
+    try {
+      raw = await readFile(path, "utf8");
+    } catch (error) {
+      const err = error;
+      errors.push(`${path}: ${err.message ?? String(err)}`);
+      continue;
+    }
+    const lines = raw.split("\n");
+    for (let index = 0; index < lines.length; index += 1) {
+      const line = lines[index];
+      if (line === void 0 || line.length === 0) continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        errors.push(`${path}:${index + 1}: invalid JSON: ${message}`);
+        continue;
+      }
+      if (!isRecord(parsed)) {
+        errors.push(`${path}:${index + 1}: expected object`);
+        continue;
+      }
+      const auditKind = readOptionalString(parsed.kind) ?? "tool_call";
+      rows.push({
+        file,
+        line: index + 1,
+        row: parsed,
+        ts: readOptionalString(parsed.ts),
+        auditKind,
+        correlationId: readOptionalString(parsed.correlationId) ?? ""
+      });
+    }
+  }
+  return { rows, errors };
+}
+async function readSessionEntriesForId(stateDir, sessionId) {
+  const root = join3(stateDir, "sessions");
+  let cwdHashes;
+  try {
+    cwdHashes = await readdir(root);
+  } catch (error) {
+    const err = error;
+    if (err.code === "ENOENT") return { entries: [], missing: true, errors: [] };
+    return { entries: [], missing: false, errors: [`session root read error: ${err.message ?? String(err)}`] };
+  }
+  for (const cwdHash of cwdHashes.sort(compareStrings2)) {
+    const currentPath = join3(root, cwdHash, sessionId, "current.jsonl");
+    let raw;
+    let source = currentPath;
+    try {
+      raw = await readFile(currentPath, "utf8");
+    } catch (error) {
+      const err = error;
+      if (err.code === "ENOENT") {
+        const tmpPath = `${currentPath}.tmp`;
+        try {
+          raw = await readFile(tmpPath, "utf8");
+          source = tmpPath;
+        } catch {
+          continue;
+        }
+      } else if (err.code === "ENOTDIR") {
+        continue;
+      } else {
+        return { entries: [], missing: false, errors: [`${currentPath}: ${err.message ?? String(err)}`] };
+      }
+    }
+    const result = parseSessionEntries(raw, source);
+    try {
+      const meta = JSON.parse(await readFile(join3(root, cwdHash, sessionId, "meta.json"), "utf8"));
+      if (isRecord(meta) && typeof meta.pinnedLeafTurnId === "string") result.leafTurnId = meta.pinnedLeafTurnId;
+    } catch {
+    }
+    return result;
+  }
+  return { entries: [], missing: true, errors: [] };
+}
+function parseSessionEntries(raw, source) {
+  const entries = [];
+  const errors = [];
+  const lines = raw.split("\n");
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (line === void 0 || line.trim().length === 0) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      errors.push(`${source}:${index + 1}: invalid JSON: ${message}`);
+      continue;
+    }
+    if (isSessionHeader(parsed)) continue;
+    if (isSessionEntry(parsed)) {
+      entries.push(normalizeReleasedCustomType(parsed));
+      continue;
+    }
+    errors.push(
+      `session ledger contains an unreadable entry (missing kind discriminant): ${source}. Remove or compact the session to reset.`
+    );
+  }
+  return { entries, missing: false, errors };
+}
+async function listSessionLedgerRefs(stateDir, onlyCwdHash) {
+  const root = join3(stateDir, "sessions");
+  let cwdHashes;
+  try {
+    cwdHashes = await readdir(root);
+  } catch {
+    return [];
+  }
+  const refs = [];
+  for (const cwdHash of cwdHashes.sort(compareStrings2)) {
+    if (onlyCwdHash !== void 0 && cwdHash !== onlyCwdHash) continue;
+    let sessionIds;
+    try {
+      sessionIds = await readdir(join3(root, cwdHash));
+    } catch {
+      continue;
+    }
+    for (const sessionId of sessionIds.sort(compareStrings2)) {
+      refs.push({ cwdHash, sessionId, path: join3(root, cwdHash, sessionId, "current.jsonl") });
+    }
+  }
+  return refs;
+}
+function readOptionalString(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function compareStrings2(a, b) {
+  return a.localeCompare(b);
+}
+
+export {
+  emptyResponseModelIdObservationCounts,
+  addResponseModelIdObservationCount,
+  addResponseModelIdObservationCounts,
+  responseModelIdObservationCountsLabel,
+  responseModelIdObservationFromRecord,
+  attributedModelId,
+  buildTurnPreview,
+  readAuditRows,
+  readSessionEntriesForId,
+  parseSessionEntries,
+  listSessionLedgerRefs,
+  createContinuityPersistencePorts,
+  resolveContinuityEvidence,
+  validateContinuityNote,
+  resolveContinuityProjection,
+  continuityReplayText,
+  continuityReplayBlocks,
+  continuityProjectionTokens,
+  protectedArtifactEntryFromArtifact,
+  protectedArtifactFromSessionEntry,
+  protectedArtifactStateFromSessionEntries,
+  ledgerUsageCalls,
+  SessionDomainModule
+};
+//# sourceMappingURL=chunk-GPTR6OTU.js.map