@iowarp/clio-coder 0.4.9 → 0.5.0

package/dist/chunk-EOJPDNUP.js

@@ -0,0 +1,1325 @@
+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-RNDCROSG.js";
+import {
+  stripTokenizerSentinels
+} from "./chunk-MCJKEGHO.js";
+import {
+  isSessionEntry,
+  isSessionHeader
+} from "./chunk-I4Y4WKZR.js";
+import {
+  CURRENT_SESSION_FORMAT_VERSION,
+  appendSessionFileEntry,
+  atomicWrite,
+  createSession,
+  openSession,
+  readSessionFileEntries,
+  readSessionMeta,
+  resumeSession,
+  sessionPaths
+} from "./chunk-EKV4UBCM.js";
+import {
+  protectArtifact
+} from "./chunk-P4GNZPXO.js";
+import {
+  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 join2 } 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 (entry.kind === "compactionSummary" && !atOrBeforeForkPoint) 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/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 = join2(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 = join2(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 = join2(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 = join2(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(join2(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 = join2(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(join2(root, cwdHash));
+    } catch {
+      continue;
+    }
+    for (const sessionId of sessionIds.sort(compareStrings2)) {
+      refs.push({ cwdHash, sessionId, path: join2(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,
+  protectedArtifactEntryFromArtifact,
+  protectedArtifactFromSessionEntry,
+  protectedArtifactStateFromSessionEntries,
+  ledgerUsageCalls,
+  SessionDomainModule
+};
+//# sourceMappingURL=chunk-EOJPDNUP.js.map