@zhushanwen/zcode-session-source 0.2.0

package/dist/index.js

@@ -0,0 +1,1129 @@
+// src/recovery.ts
+import { copyFileSync, existsSync, mkdtempSync, readdirSync, rmSync, statSync, writeFileSync } from "fs";
+import { basename, join } from "path";
+import { tmpdir } from "os";
+
+// src/sqlite-driver.ts
+async function importSqliteModule() {
+  const bunGlobal = globalThis.Bun;
+  if (typeof bunGlobal !== "undefined") {
+    const bunSqliteModuleId = "bun:sqlite";
+    const mod2 = await import(bunSqliteModuleId);
+    if (typeof mod2.Database !== "function") {
+      throw new Error("bun:sqlite \u53EF\u7528\u4F46\u7F3A Database \u5BFC\u51FA\uFF08bun \u7248\u672C\u5F02\u5E38\uFF09");
+    }
+    return mod2;
+  }
+  const nodeSqliteModuleId = "node:sqlite";
+  const mod = await import(nodeSqliteModuleId).catch(() => void 0);
+  if (typeof mod?.DatabaseSync !== "function") {
+    throw new Error("\u5F53\u524D node \u8FD0\u884C\u65F6\u4E0D\u652F\u6301 node:sqlite\uFF08\u9700 >=22.13\uFF09\uFF0C\u4E14\u5BBF\u4E3B\u975E bun \u8FD0\u884C\u65F6");
+  }
+  return mod;
+}
+var cachedDriver;
+async function loadSqliteDriver() {
+  if (cachedDriver) return cachedDriver;
+  const mod = await importSqliteModule();
+  const bunGlobal = globalThis.Bun;
+  if (typeof bunGlobal !== "undefined") {
+    const Database = mod.Database;
+    cachedDriver = {
+      id: "bun:sqlite",
+      open(path, opts) {
+        const db = new Database(path, { readonly: opts.readOnly });
+        const rawPrepare = db.prepare.bind(db);
+        return {
+          prepare(sql) {
+            const stmt = rawPrepare(sql);
+            return {
+              all: (...args) => stmt.all(...args),
+              get: (...args) => {
+                const row = stmt.get(...args);
+                return row === null ? void 0 : row;
+              }
+            };
+          },
+          close: () => db.close()
+        };
+      }
+    };
+  } else {
+    const DatabaseSync = mod.DatabaseSync;
+    cachedDriver = {
+      id: "node:sqlite",
+      open(path, opts) {
+        return new DatabaseSync(path, { readOnly: opts.readOnly });
+      }
+    };
+  }
+  return cachedDriver;
+}
+function toSqliteFileUri(dbPath, immutable) {
+  const encoded = dbPath.replaceAll("%", "%25").replaceAll("?", "%3F").replaceAll("#", "%23");
+  return immutable ? `file:${encoded}?immutable=1` : `file:${encoded}`;
+}
+
+// src/recovery.ts
+var SNAPSHOT_TMP_PREFIX = "taiji-zcode-snap-";
+var KIB = 1024;
+var SNAPSHOT_MAX_DB_KIB = 256;
+var SNAPSHOT_MAX_DB_BYTES = SNAPSHOT_MAX_DB_KIB * KIB * KIB;
+var REQUIRED_TABLES = ["session", "message", "part"];
+function walPathOf(dbPath) {
+  return `${dbPath}-wal`;
+}
+var SqliteUnreadableError = class extends Error {
+  attempted;
+  constructor(attempted, message) {
+    super(message);
+    this.name = "SqliteUnreadableError";
+    this.attempted = attempted;
+  }
+};
+async function tryOpen(dbPath, opts = {}) {
+  const driver = await loadSqliteDriver();
+  const target = opts.immutable ? toSqliteFileUri(dbPath, true) : dbPath;
+  const db = driver.open(target, { readOnly: true });
+  try {
+    const rows = db.prepare("SELECT name FROM sqlite_master WHERE type = 'table'").all();
+    const tableNames = [];
+    for (const row of rows) {
+      if (typeof row === "object" && row !== null) {
+        const name = row.name;
+        if (typeof name === "string") tableNames.push(name);
+      }
+    }
+    return { db, tableNames };
+  } catch (err) {
+    try {
+      db.close();
+    } catch (err2) {
+      console.debug("recovery: close after failed probe not attributed (best-effort)", err2);
+    }
+    throw err;
+  }
+}
+function tablesPresent(tableNames) {
+  const set = new Set(tableNames);
+  return REQUIRED_TABLES.every((t) => set.has(t));
+}
+function closeQuietly(db) {
+  try {
+    db.close();
+  } catch (err) {
+    console.debug("recovery: readonly connection close failed (best-effort)", err);
+  }
+}
+async function openWithRecovery(dbPath) {
+  const attempted = [];
+  const skipNotes = [];
+  let lastError;
+  try {
+    const opened = await tryOpen(dbPath);
+    return toResult(opened, "L1-direct");
+  } catch (err) {
+    attempted.push("L1-direct");
+    lastError = err;
+  }
+  const walPresent = existsSync(walPathOf(dbPath));
+  if (walPresent) {
+    skipNotes.push("-wal present: L2 immutable and L3 snapshot gated off (silent data loss / rollback guard)");
+  } else {
+    try {
+      const opened = await tryOpen(dbPath, { immutable: true });
+      return toResult(opened, "L2-immutable");
+    } catch (err) {
+      attempted.push("L2-immutable");
+      lastError = err;
+    }
+    let dbBytes = -1;
+    try {
+      dbBytes = statSync(dbPath).size;
+    } catch (err) {
+      console.debug("recovery: statSync failed, db size treated as unknown (best-effort)", err);
+    }
+    if (dbBytes > SNAPSHOT_MAX_DB_BYTES) {
+      skipNotes.push(
+        `L3 rejected by size gate: db is ${dbBytes} bytes (> ${SNAPSHOT_MAX_DB_BYTES}), copy refused`
+      );
+    } else {
+      try {
+        const snap = await openViaSnapshot(dbPath);
+        return {
+          db: snap.db,
+          via: "L3-snapshot",
+          dispose() {
+            closeQuietly(snap.db);
+            rmSync(snap.snapshotDir, { recursive: true, force: true });
+          }
+        };
+      } catch (err) {
+        attempted.push("L3-snapshot");
+        lastError = err;
+      }
+    }
+  }
+  const parts = [`zcode session db unreadable (recovery ladder exhausted): ${dbPath}`];
+  if (skipNotes.length > 0) parts.push(skipNotes.join("; "));
+  const detail = lastError instanceof Error ? lastError.message : String(lastError);
+  parts.push(`last failure: ${detail}`);
+  throw new SqliteUnreadableError(attempted, parts.join(" \u2014 "));
+}
+function toResult(opened, via) {
+  return {
+    db: opened.db,
+    via,
+    dispose() {
+      closeQuietly(opened.db);
+    }
+  };
+}
+async function openViaSnapshot(dbPath) {
+  const dbBytes = statSync(dbPath).size;
+  if (dbBytes > SNAPSHOT_MAX_DB_BYTES) {
+    throw new SqliteUnreadableError(
+      [],
+      `snapshot refused by size gate: db is ${dbBytes} bytes (> ${SNAPSHOT_MAX_DB_BYTES}), copy refused`
+    );
+  }
+  const snapshotDir = mkdtempSync(join(tmpdir(), SNAPSHOT_TMP_PREFIX));
+  let opened;
+  try {
+    const snapDb = join(snapshotDir, basename(dbPath));
+    copyFileSync(dbPath, snapDb);
+    writeFileSync(`${snapDb}-wal`, "");
+    opened = await tryOpen(snapDb);
+    if (!tablesPresent(opened.tableNames)) {
+      throw new Error(
+        `snapshot db failed table-set validation: expected ${REQUIRED_TABLES.join("/")}, found ${opened.tableNames.length > 0 ? [...opened.tableNames].sort().join("/") : "(none)"}`
+      );
+    }
+    return { db: opened.db, tableNames: opened.tableNames, snapshotDir };
+  } catch (err) {
+    if (opened) closeQuietly(opened.db);
+    rmSync(snapshotDir, { recursive: true, force: true });
+    throw err;
+  }
+}
+
+// src/sqlite-access.ts
+import { existsSync as existsSync2 } from "fs";
+import { homedir } from "os";
+import { join as join2 } from "path";
+import { ZCODE_HOST_DB_SUFFIX, ZCODE_ISOLATED_DB_SEGMENTS } from "@zhushanwen/subagent-engine-sdk";
+function hostZcodeDbPath() {
+  return join2(homedir(), ...ZCODE_HOST_DB_SUFFIX);
+}
+function zcodeIsolatedDbPath(dataDir) {
+  return join2(dataDir, ...ZCODE_ISOLATED_DB_SEGMENTS);
+}
+function zcodeImportDbAllowlist(dataDir) {
+  return [zcodeIsolatedDbPath(dataDir), hostZcodeDbPath()];
+}
+var KNOWN_ZCODE_SCHEMA_VERSIONS = ["0.16.5"];
+var ZcodeSchemaDriftError = class extends Error {
+  /** 观测到的版本（表不可读时为 undefined——两种归因经此字段区分，不拆两个错误类）。 */
+  observedVersion;
+  constructor(observedVersion, message) {
+    super(message);
+    this.name = "ZcodeSchemaDriftError";
+    this.observedVersion = observedVersion;
+  }
+};
+function asString(v, col) {
+  if (typeof v !== "string") throw new Error(`session \u8868 ${col} \u5217\u7C7B\u578B\u5F02\u5E38\uFF08\u671F\u671B string\uFF0C\u5B9E\u9645 ${typeof v}\uFF09`);
+  return v;
+}
+function asNumber(v, col) {
+  if (typeof v !== "number" || !Number.isFinite(v)) throw new Error(`session \u8868 ${col} \u5217\u7C7B\u578B\u5F02\u5E38\uFF08\u671F\u671B number\uFF0C\u5B9E\u9645 ${typeof v}\uFF09`);
+  return v;
+}
+function rowToSessionRow(row) {
+  if (typeof row !== "object" || row === null) throw new Error("session \u8868\u8FD4\u56DE\u975E\u5BF9\u8C61\u884C");
+  const r = row;
+  return {
+    id: asString(r.id, "id"),
+    title: asString(r.title, "title"),
+    directory: asString(r.directory, "directory"),
+    taskType: asString(r.task_type, "task_type"),
+    timeCreated: asNumber(r.time_created, "time_created"),
+    timeUpdated: asNumber(r.time_updated, "time_updated")
+  };
+}
+function parseRowData(raw, ctx) {
+  if (typeof raw !== "string") {
+    throw new Error(`${ctx} \u5217\u7C7B\u578B\u5F02\u5E38\uFF08\u671F\u671B JSON \u5B57\u7B26\u4E32\uFF0C\u5B9E\u9645 ${typeof raw}\uFF09`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(`${ctx} \u4E0D\u662F\u5408\u6CD5 JSON\uFF08${err instanceof Error ? err.message : String(err)}\uFF09`);
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error(`${ctx} \u89E3\u6790\u540E\u975E\u5BF9\u8C61\uFF08\u5B9E\u9645 ${parsed === null ? "null" : Array.isArray(parsed) ? "array" : typeof parsed}\uFF09`);
+  }
+  return parsed;
+}
+function wrapDb(db) {
+  return {
+    listCandidateSessions(opts) {
+      const sql = "SELECT id, title, directory, task_type, time_created, time_updated FROM session WHERE task_type != 'subagent_child' ORDER BY time_updated DESC" + (opts?.limit !== void 0 ? " LIMIT ?" : "");
+      const rows = opts?.limit !== void 0 ? db.prepare(sql).all(opts.limit) : db.prepare(sql).all();
+      return rows.map(rowToSessionRow);
+    },
+    getSessionRow(id) {
+      const row = db.prepare("SELECT id, title, directory, task_type, time_created, time_updated FROM session WHERE id = ?").get(id);
+      return row === void 0 ? void 0 : rowToSessionRow(row);
+    },
+    getSessionTranscript(sessionId) {
+      const rows = db.prepare(
+        "SELECT m.id AS mid, m.sequence AS mseq, m.data AS mdata, p.sequence AS pseq, p.data AS pdata FROM message m LEFT JOIN part p ON p.message_id = m.id WHERE m.session_id = ? ORDER BY m.sequence, p.sequence"
+      ).all(sessionId);
+      const messages = [];
+      let current;
+      for (const row of rows) {
+        if (typeof row !== "object" || row === null) throw new Error("message/part \u8054\u5408\u67E5\u8BE2\u8FD4\u56DE\u975E\u5BF9\u8C61\u884C");
+        const r = row;
+        const mid = asString(r.mid, "message.id");
+        if (current?.id !== mid) {
+          current = {
+            id: mid,
+            sequence: asNumber(r.mseq, "message.sequence"),
+            data: parseRowData(r.mdata, `message(${mid}).data`),
+            parts: []
+          };
+          messages.push(current);
+        }
+        if (r.pseq !== null && r.pseq !== void 0 && r.pdata !== null && r.pdata !== void 0) {
+          current.parts.push(parseRowData(r.pdata, `part(message=${mid}).data`));
+        }
+      }
+      return messages;
+    },
+    candidatesByteSize(sessionIds) {
+      if (sessionIds.length === 0) return /* @__PURE__ */ new Map();
+      const placeholders = sessionIds.map(() => "?").join(", ");
+      const rows = db.prepare(
+        `SELECT session_id AS sid, SUM(length(CAST(data AS BLOB))) AS bytes FROM part WHERE session_id IN (${placeholders}) GROUP BY session_id`
+      ).all(...sessionIds);
+      const sizes = /* @__PURE__ */ new Map();
+      for (const row of rows) {
+        if (typeof row !== "object" || row === null) continue;
+        const r = row;
+        if (typeof r.sid !== "string") continue;
+        if (typeof r.bytes !== "number") {
+          console.warn(
+            `[zcode-session-source] candidatesByteSize \u884C bytes \u975E number\uFF08\u5B9E\u9645 ${typeof r.bytes}\uFF09\uFF0C\u8BE5\u4F1A\u8BDD\u5927\u5C0F\u672A\u77E5\uFF1AsessionId=${r.sid}`
+          );
+          continue;
+        }
+        sizes.set(r.sid, r.bytes);
+      }
+      return sizes;
+    },
+    readSchemaVersion() {
+      try {
+        const row = db.prepare("SELECT app_version FROM schema_migration ORDER BY time_applied DESC LIMIT 1").get();
+        if (typeof row === "object" && row !== null) {
+          const v = row.app_version;
+          if (typeof v === "string" && v.length > 0) return v;
+        }
+        return void 0;
+      } catch {
+        return void 0;
+      }
+    },
+    close() {
+      try {
+        db.close();
+      } catch (err) {
+        void err;
+      }
+    }
+  };
+}
+function assertKnownSchema(db) {
+  let observedVersion;
+  try {
+    const row = db.prepare("SELECT app_version FROM schema_migration ORDER BY time_applied DESC LIMIT 1").get();
+    if (typeof row === "object" && row !== null) {
+      const v = row.app_version;
+      if (typeof v === "string" && v.length > 0) observedVersion = v;
+    }
+  } catch {
+    throw new ZcodeSchemaDriftError(
+      void 0,
+      `zcode session db schema_migration unreadable (expected one of: ${KNOWN_ZCODE_SCHEMA_VERSIONS.join("/")})`
+    );
+  }
+  if (observedVersion === void 0 || !KNOWN_ZCODE_SCHEMA_VERSIONS.includes(observedVersion)) {
+    throw new ZcodeSchemaDriftError(
+      observedVersion,
+      `zcode session db schema version unknown: ${observedVersion ?? "(absent)"} (known: ${KNOWN_ZCODE_SCHEMA_VERSIONS.join("/")})`
+    );
+  }
+}
+async function openZcodeSessionDb(dbPath) {
+  if (!existsSync2(dbPath)) {
+    throw new Error(`db \u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${dbPath}`);
+  }
+  const opened = await openWithRecovery(dbPath);
+  try {
+    assertKnownSchema(opened.db);
+  } catch (err) {
+    opened.dispose();
+    throw err;
+  }
+  return { db: wrapDb(opened.db), via: opened.via, dispose: opened.dispose };
+}
+
+// src/converter.ts
+import { normalizeZcodeRowId } from "@zhushanwen/session-core";
+
+// src/normalize.ts
+var NORMALIZED_ID_RE = /^[A-Za-z0-9]([A-Za-z0-9-]*[A-Za-z0-9])?$/;
+var SESS_PREFIX = "sess_";
+function normalizeZcodeSessionId(raw) {
+  const stripped = raw.startsWith(SESS_PREFIX) ? raw.slice(SESS_PREFIX.length) : raw;
+  const replaced = stripped.replaceAll("_", "-");
+  if (replaced.length === 0) {
+    throw new Error(
+      `zcode \u4F1A\u8BDD id \u5F52\u4E00\u5316\u540E\u4E3A\u7A7A\uFF08\u539F\u59CB id=\u300C${raw}\u300D\uFF09\uFF1A\u8BE5 id \u5F62\u6001\u8D85\u51FA\u5DF2\u9A8C\u8BC1\u57DF\uFF08sess_<uuid>\uFF09`
+    );
+  }
+  if (replaced.includes("_")) {
+    throw new Error(
+      `zcode \u4F1A\u8BDD id \u5F52\u4E00\u5316\u540E\u4ECD\u542B\u4E0B\u5212\u7EBF\uFF08\u539F\u59CB id=\u300C${raw}\u300D\u2192\u300C${replaced}\u300D\uFF09\uFF1A\u7834\u574F\u300C\u6587\u4EF6\u540D\u5C3E\u6BB5 == header.id\u300D\u4E0D\u53D8\u91CF`
+    );
+  }
+  if (!NORMALIZED_ID_RE.test(replaced)) {
+    throw new Error(
+      `zcode \u4F1A\u8BDD id \u5F52\u4E00\u5316\u540E\u542B\u975E\u6CD5\u5B57\u7B26\u6216\u9996\u5C3E\u975E\u5B57\u6BCD\u6570\u5B57\uFF08\u539F\u59CB id=\u300C${raw}\u300D\u2192\u300C${replaced}\u300D\uFF0C\u5408\u6CD5\u96C6 = \u5B57\u6BCD\u6570\u5B57\u4E0E\u300C-\u300D\u4E14\u9996\u5C3E\u5B57\u6BCD\u6570\u5B57\uFF09\uFF1A\u8BE5 id \u5F62\u6001\u8D85\u51FA\u5DF2\u9A8C\u8BC1\u57DF\uFF08sess_<uuid>\uFF09`
+    );
+  }
+  return replaced;
+}
+var zcodeCandidateKey = normalizeZcodeSessionId;
+
+// src/semantics.ts
+var SEMANTICS_KINDS = Object.freeze([
+  "user_prompt",
+  "slash_command",
+  "system_reminder",
+  "background_notification",
+  "subagent_notification",
+  "todo_reminder",
+  "rewind_notice",
+  "fork_notice",
+  "timeline_event",
+  "compact_summary",
+  "shared_context",
+  "assistant_response"
+]);
+var SEMANTICS_ORIGINS = Object.freeze([
+  "real_user",
+  "agent_runtime",
+  "system",
+  "migration",
+  "import"
+]);
+var MESSAGE_SOURCES = Object.freeze([
+  "background_task",
+  "fork",
+  "goal_state_change",
+  "goal-continuation",
+  "plugin_reference",
+  "rewind",
+  "selection_side_chat",
+  "subagent",
+  "subagent_message",
+  "todo_reminder",
+  "workflow_launch",
+  "shared_context"
+]);
+var LEGACY_METADATA_SOURCES = Object.freeze([
+  "agent_control_message",
+  "background_task",
+  "goal-continuation",
+  "goal_completion_verification",
+  "goal_state_change",
+  "plugin_reference",
+  "queued_system_notification",
+  "resume_goal_state",
+  "resume_referenced_session_context",
+  "rewind",
+  "selection_side_chat",
+  "subagent",
+  "subagent_message",
+  "target_continuation",
+  "task_notification",
+  "task_status",
+  "todo_reminder"
+]);
+var PROJECTION_POLICIES = Object.freeze([
+  "realUserInput",
+  "visibleAssistant",
+  "providerContextOnly",
+  "hiddenSynthetic",
+  "timelineOnly",
+  "compactSummary"
+]);
+var SEMANTICS_KIND_SET = new Set(SEMANTICS_KINDS);
+var SEMANTICS_ORIGIN_SET = new Set(SEMANTICS_ORIGINS);
+var MESSAGE_SOURCE_SET = new Set(MESSAGE_SOURCES);
+var LEGACY_METADATA_SOURCE_SET = new Set(LEGACY_METADATA_SOURCES);
+var PROJECTION_POLICY_SET = new Set(PROJECTION_POLICIES);
+
+// src/projection.ts
+var MODEL_ONLY = "model-only";
+var FORK = "fork";
+var GOAL_CONTINUATION_PREFIX = '<system-reminder source="goal-continuation">';
+var SYSTEM_REMINDER_TAG = "<system-reminder>";
+var GOAL_CONTINUATION_SENTINEL = "Continue working toward the active session goal.";
+var GOAL_STATE_SENTINEL = "Current session goal state";
+var REWIND_APPLIED_TEXTS = Object.freeze([
+  "Conversation rewind applied.",
+  "Workspace rewind applied."
+]);
+var TASK_NOTIFICATION_TAG = "<task-notification>";
+var SUBAGENT_NOTIFICATION_TAG = "<subagent-notification>";
+var GOAL_CONTINUATION_SOURCE = "goal-continuation";
+function asRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v) ? v : void 0;
+}
+function asNonEmptyString(v) {
+  return typeof v === "string" && v.length > 0 ? v : void 0;
+}
+function inClosedSet(v, set) {
+  return typeof v === "string" && set.has(v);
+}
+function messageSource(data, parts) {
+  const metadata = asRecord(data.metadata);
+  const semantics = asRecord(data.semantics);
+  return data.source ?? asNonEmptyString(metadata?.source) ?? semantics?.source ?? parts.map((p) => asNonEmptyString(asRecord(p.metadata)?.source)).find((s) => s !== void 0);
+}
+function isSyntheticMessage(data, parts) {
+  return data.synthetic === true || parts.some((p) => p.synthetic === true);
+}
+function hasModelOnlyPart(parts) {
+  return parts.some((p) => {
+    const metadata = asRecord(p.metadata);
+    return metadata?.visibility === MODEL_ONLY || asNonEmptyString(metadata?.source) === GOAL_CONTINUATION_SOURCE;
+  });
+}
+function hasSessionForkContext(metadata) {
+  return asRecord(metadata?.forkContext)?.kind === "session_fork";
+}
+function isTimelineOnlyMessage(data, parts) {
+  if (asRecord(data.semantics)?.kind === "timeline_event") return true;
+  const metadata = asRecord(data.metadata);
+  if (data.source === FORK || asNonEmptyString(metadata?.source) === FORK) return true;
+  return parts.some((p) => {
+    const partMetadata = asRecord(p.metadata);
+    return p.type === "timeline" || hasSessionForkContext(partMetadata) || p.type === "compaction" && (typeof partMetadata?.timelineStatus === "string" || typeof p.summaryMessageId === "string");
+  });
+}
+function hasLegacyReminderText(parts) {
+  const text = textFromParts(parts).trimStart();
+  return text.startsWith(GOAL_CONTINUATION_PREFIX) || text.startsWith(SYSTEM_REMINDER_TAG) && (text.includes(GOAL_CONTINUATION_SENTINEL) || text.includes(GOAL_STATE_SENTINEL)) || REWIND_APPLIED_TEXTS.some((t) => text.includes(t));
+}
+function hasLegacyNotifyText(parts) {
+  const text = textFromParts(parts).trimStart();
+  return text.startsWith(TASK_NOTIFICATION_TAG) || text.startsWith(SUBAGENT_NOTIFICATION_TAG);
+}
+function textFromParts(parts) {
+  return parts.filter((p) => p.type === "text" && p.ignored !== true).map((p) => p.text ?? "").join("");
+}
+function isUnclassifiedByClosedSets(semantics, src) {
+  if (semantics && !inClosedSet(semantics.kind, SEMANTICS_KIND_SET)) return true;
+  if (semantics && !inClosedSet(semantics.origin, SEMANTICS_ORIGIN_SET)) return true;
+  return src !== void 0 && !(typeof src === "string" && (MESSAGE_SOURCE_SET.has(src) || LEGACY_METADATA_SOURCE_SET.has(src)));
+}
+function classifyBySemanticsBranches(semantics, data) {
+  if (semantics.kind === "timeline_event") return "timelineOnly";
+  if (semantics.origin === "real_user" && data.synthetic !== true && data.visibility !== MODEL_ONLY) {
+    return "realUserInput";
+  }
+  if (data.role === "assistant" && semantics.kind === "assistant_response" && semantics.uiVisibility === "visible" && semantics.transcriptVisibility === "visible") {
+    return "visibleAssistant";
+  }
+  if (semantics.providerVisibility === "visible") return "providerContextOnly";
+  if (semantics.kind === "fork_notice") return "timelineOnly";
+  if (semantics.origin === "agent_runtime" || semantics.uiVisibility === "hidden" || semantics.transcriptVisibility === "hidden") {
+    return "hiddenSynthetic";
+  }
+  return void 0;
+}
+function classifyLegacyFallback(data, parts, src) {
+  if (data.visibility === MODEL_ONLY || hasModelOnlyPart(parts)) return "providerContextOnly";
+  if (isTimelineOnlyMessage(data, parts)) return "timelineOnly";
+  if (src === FORK) return "timelineOnly";
+  if (typeof src === "string" && LEGACY_METADATA_SOURCE_SET.has(src)) return "providerContextOnly";
+  if (hasLegacyReminderText(parts)) return "providerContextOnly";
+  if (isSyntheticMessage(data, parts) && hasLegacyNotifyText(parts)) return "providerContextOnly";
+  if (isSyntheticMessage(data, parts)) return "hiddenSynthetic";
+  return data.role === "assistant" ? "visibleAssistant" : "realUserInput";
+}
+function classifyMessage(data, parts) {
+  const semantics = asRecord(data.semantics);
+  const src = messageSource(data, parts);
+  if (isUnclassifiedByClosedSets(semantics, src)) return "unclassified";
+  if (semantics?.kind === "compact_summary" || data.summary !== void 0) return "compactSummary";
+  if (semantics) {
+    const bySemantics = classifyBySemanticsBranches(semantics, data);
+    if (bySemantics !== void 0) return bySemantics;
+  }
+  return classifyLegacyFallback(data, parts, src);
+}
+
+// src/assistant-mapping.ts
+var STOP_REASON_MAP = Object.freeze({
+  "tool-calls": "toolUse",
+  stop: "stop",
+  completed: "stop",
+  length: "length",
+  interrupted: "aborted",
+  failed: "error",
+  stream_recovery_discarded: "error",
+  start_plan_admission_retry_discarded: "error"
+});
+function mapStopReason(zcodeFinish) {
+  return typeof zcodeFinish === "string" ? STOP_REASON_MAP[zcodeFinish] ?? "stop" : "stop";
+}
+function unsealedStopReason(data) {
+  const error = isRecord(data.error) ? data.error : void 0;
+  if (error === void 0) return "stop";
+  const errData = isRecord(error.data) ? error.data : void 0;
+  const turnResult = typeof errData?.turnResult === "string" ? errData.turnResult : void 0;
+  if (turnResult === "cancelled") return "aborted";
+  return "error";
+}
+function zeroUsage() {
+  return {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    reasoning: 0,
+    totalTokens: 0,
+    cost: { total: 0 }
+  };
+}
+function usageFromStepFinish(partData) {
+  const tokens = partData.tokens;
+  if (!isRecord(tokens)) return { usage: void 0, degradation: void 0 };
+  const cache = isRecord(tokens.cache) ? tokens.cache : {};
+  const input = asFinite(tokens.input);
+  const output = asFinite(tokens.output);
+  const cacheRead = asFinite(cache.read);
+  const cacheWrite = asFinite(cache.write);
+  const reasoning = asFinite(tokens.reasoning);
+  const totalTokens = asFinite(tokens.total);
+  const costTotal = asFinite(partData.cost);
+  const usage = {
+    ...input !== void 0 && { input },
+    ...output !== void 0 && { output },
+    ...cacheRead !== void 0 && { cacheRead },
+    ...cacheWrite !== void 0 && { cacheWrite },
+    ...reasoning !== void 0 && { reasoning },
+    ...totalTokens !== void 0 && { totalTokens },
+    ...costTotal !== void 0 && { cost: { total: costTotal } }
+  };
+  if (Object.keys(usage).length === 0) {
+    return {
+      usage: void 0,
+      degradation: "step-finish tokens/cost \u5206\u91CF\u5168\u90E8\u4E0D\u53EF\u89E3\uFF0C\u6574\u6761 usage \u4E0D\u5199\uFF08\u96F6\u503C\u515C\u5E95\uFF09"
+    };
+  }
+  return { usage, degradation: void 0 };
+}
+function isRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function asFinite(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : void 0;
+}
+function asNonEmptyString2(v) {
+  return typeof v === "string" && v.length > 0 ? v : void 0;
+}
+
+// src/compaction.ts
+function summaryBodyOf(data) {
+  const summary = isRecord(data.summary) ? data.summary : void 0;
+  return asNonEmptyString2(summary?.body);
+}
+function partHasTimelineStatus(part) {
+  if (typeof part.timelineStatus === "string") return true;
+  const metadata = isRecord(part.metadata) ? part.metadata : void 0;
+  return typeof metadata?.timelineStatus === "string";
+}
+function resolveFirstKeptEntryId(tier1, lastEmittedId, ownId) {
+  if (tier1 !== void 0) return tier1;
+  if (lastEmittedId !== null) return lastEmittedId;
+  return ownId;
+}
+function compactionPartDisposition(msg, part, messageIds, mergeable) {
+  const summaryId = asNonEmptyString2(part.summaryMessageId);
+  if (summaryId !== void 0) {
+    if (!messageIds.has(summaryId)) return { disposition: "dangling" };
+    if (mergeable.has(summaryId)) return { disposition: "merged", summaryId };
+    return void 0;
+  }
+  const semantics = isRecord(msg.data.semantics) ? msg.data.semantics : void 0;
+  if (semantics?.kind === "compact_summary" && mergeable.has(msg.id)) {
+    return { disposition: "merged", summaryId: msg.id };
+  }
+  if (msg.data.role === "user" && !partHasTimelineStatus(part) && mergeable.has(msg.id)) {
+    return { disposition: "merged", summaryId: msg.id };
+  }
+  return void 0;
+}
+function precomputeCompactionAssociation(messages, policies) {
+  const messageIds = new Set(messages.map((msg) => msg.id));
+  const mergeable = /* @__PURE__ */ new Set();
+  for (const [i, msg] of messages.entries()) {
+    if (policies[i] === "compactSummary" && summaryBodyOf(msg.data) !== void 0) mergeable.add(msg.id);
+  }
+  const linkedParts = /* @__PURE__ */ new Map();
+  const compactionDisposition = /* @__PURE__ */ new WeakMap();
+  for (const msg of messages) {
+    for (const part of msg.parts) {
+      if (part.type !== "compaction") continue;
+      const result = compactionPartDisposition(msg, part, messageIds, mergeable);
+      if (result === void 0) continue;
+      if (result.disposition === "dangling") {
+        compactionDisposition.set(part, "dangling");
+        continue;
+      }
+      compactionDisposition.set(part, "merged");
+      const list = linkedParts.get(result.summaryId);
+      if (list !== void 0) list.push(part);
+      else linkedParts.set(result.summaryId, [part]);
+    }
+  }
+  return { linkedParts, compactionDisposition };
+}
+
+// src/converter.ts
+var DEGRADATION_PREVIEW_MAX = 80;
+function pushDegradation(degradations, text, messageId) {
+  degradations.push({
+    code: "dropped_transient",
+    count: 1,
+    ...messageId !== void 0 && {
+      sample: { messageId, preview: text.slice(0, DEGRADATION_PREVIEW_MAX) }
+    }
+  });
+}
+function degradationMeta(data) {
+  const semantics = isRecord(data.semantics) ? data.semantics : void 0;
+  const kind = typeof semantics?.kind === "string" ? semantics.kind : void 0;
+  const metadata = isRecord(data.metadata) ? data.metadata : void 0;
+  let source;
+  if (typeof data.source === "string") source = data.source;
+  else if (typeof metadata?.source === "string") source = metadata.source;
+  return { ...kind !== void 0 && { kind }, ...source !== void 0 && { source } };
+}
+function isToolPreservedSource(source) {
+  return source.startsWith("background_") || source.startsWith("subagent_") || source === "subagent";
+}
+function droppedMessageCode(data) {
+  const { source } = degradationMeta(data);
+  return source !== void 0 && isToolPreservedSource(source) ? "dropped_redundant" : "dropped_transient";
+}
+function messageTextPreview(parts) {
+  return parts.filter((p) => p.type === "text" && p.ignored !== true).map((p) => typeof p.text === "string" ? p.text : "").join("");
+}
+var TOOL_NAME_MAP = Object.freeze({
+  Edit: "edit",
+  Bash: "bash",
+  Read: "read",
+  Write: "write",
+  Grep: "grep",
+  Glob: "glob",
+  Skill: "skill"
+});
+function mapToolName(zcodeTool) {
+  return TOOL_NAME_MAP[zcodeTool] ?? zcodeTool;
+}
+var EntryChain = class {
+  counter = 0;
+  lastId = null;
+  next() {
+    this.counter += 1;
+    const id = normalizeZcodeRowId(this.counter);
+    const parentId = this.lastId;
+    this.lastId = id;
+    return { id, parentId };
+  }
+  /** 最后一条已发射 entry 的 id（无则 null）——D2 firstKeptEntryId ② 级锚（紧邻前驱）。 */
+  last() {
+    return this.lastId;
+  }
+  /**
+   * 下一个 id 预览（不推进计数器）。compaction entry 的 ③ 级锚 = 其自身 id，而 id 由
+   * 发射时才生成、firstKeptEntryId 又必须在发射前进入 payload——peek 让两者解耦，
+   * next() 产出的 id 与 peek 结果严格一致（同一确定性公式）。
+   */
+  peek() {
+    return normalizeZcodeRowId(this.counter + 1);
+  }
+};
+var MESSAGE_ROLES = /* @__PURE__ */ new Set(["user", "assistant", "toolResult"]);
+var RAW_JSON_SNIPPET_CHARS = 120;
+function toCanonicalEntry(raw) {
+  const type = raw.type;
+  const id = raw.id;
+  const parentId = raw.parentId;
+  if (typeof type !== "string" || type.length === 0) {
+    throw new Error(`converter \u5185\u90E8\u9519\u8BEF\uFF1Aentry \u7F3A type\uFF08${JSON.stringify(raw).slice(0, RAW_JSON_SNIPPET_CHARS)}\uFF09`);
+  }
+  if (typeof id !== "string" || id.length === 0) {
+    throw new Error(`converter \u5185\u90E8\u9519\u8BEF\uFF1Aentry \u7F3A id\uFF08type=${type}\uFF09`);
+  }
+  if (parentId !== null && typeof parentId !== "string") {
+    throw new Error(`converter \u5185\u90E8\u9519\u8BEF\uFF1Aentry parentId \u975E string|null\uFF08type=${type}\uFF0Cid=${id}\uFF09`);
+  }
+  const message = raw.message;
+  if (message !== void 0) {
+    if (!isRecord(message) || typeof message.role !== "string" || !MESSAGE_ROLES.has(message.role)) {
+      throw new Error(`converter \u5185\u90E8\u9519\u8BEF\uFF1Aentry message.role \u975E\u6CD5\uFF08type=${type}\uFF0Cid=${id}\uFF09`);
+    }
+  }
+  return raw;
+}
+function newSegment() {
+  return { content: [], toolResults: [], startMs: void 0 };
+}
+function toolResultShape(state, partData, msgId, degradations) {
+  const status = state.status;
+  const output = state.output;
+  if (status === "error") {
+    const errText = typeof state.error === "string" ? state.error : typeof output === "string" ? output : "";
+    return { content: [{ type: "text", text: errText }], isError: true };
+  }
+  if (typeof output === "string") {
+    return { content: [{ type: "text", text: output }], isError: false };
+  }
+  if (output === null || output === void 0) {
+    return { content: [], isError: false };
+  }
+  if (isRecord(output)) {
+    return { content: [], details: output, isError: false };
+  }
+  pushDegradation(
+    degradations,
+    `tool\u300C${String(partData.tool)}\u300Doutput \u5F62\u6001\u8D85\u51FA\u5DF2\u9A8C\u8BC1\u57DF\uFF08typeof ${typeof output}\uFF09\uFF0C\u8DF3\u8FC7\u8F93\u51FA\uFF1Amessage=${msgId}`,
+    msgId
+  );
+  return { content: [], isError: false };
+}
+function convertZcodeTranscript(messages, session) {
+  const degradations = [];
+  const entries = [];
+  const sessionCreatedMs = asFinite(session.timeCreated);
+  const headerTimestamp = sessionCreatedMs !== void 0 ? new Date(sessionCreatedMs).toISOString() : void 0;
+  if (sessionCreatedMs === void 0) {
+    pushDegradation(
+      degradations,
+      `session.timeCreated \u4E0D\u53EF\u89E3\uFF08${String(session.timeCreated)}\uFF09\uFF0Cheader/message \u65F6\u95F4\u6233\u7F3A\u7701\uFF1A\u4E0D\u4F2A\u9020 1970`
+    );
+  }
+  const header = {
+    id: normalizeZcodeSessionId(session.id),
+    ...headerTimestamp !== void 0 && { timestamp: headerTimestamp }
+  };
+  const chain = new EntryChain();
+  const emitEntry = (type, timestamp, rest) => {
+    const { id, parentId } = chain.next();
+    const entry = toCanonicalEntry({ type, id, parentId, ...timestamp !== void 0 && { timestamp }, ...rest });
+    entries.push(entry);
+    return entry.id;
+  };
+  const messageIdToEntryId = /* @__PURE__ */ new Map();
+  const policies = messages.map((msg) => classifyMessage(msg.data, msg.parts));
+  const { linkedParts, compactionDisposition } = precomputeCompactionAssociation(messages, policies);
+  const dropGroups = /* @__PURE__ */ new Map();
+  const recordDroppedMessage = (degradation) => {
+    const key = `${degradation.code}|${degradation.kind ?? ""}|${degradation.source ?? ""}`;
+    const existing = dropGroups.get(key);
+    if (existing === void 0) {
+      dropGroups.set(key, { ...degradation });
+      return;
+    }
+    existing.count += degradation.count;
+  };
+  const deps = {
+    chain,
+    linkedParts,
+    compactionDisposition,
+    degradations,
+    messageIdToEntryId,
+    recordDroppedMessage
+  };
+  emitEntry("session_info", headerTimestamp, typeof session.title === "string" && session.title.length > 0 ? { name: session.title } : {});
+  for (const [msgIndex, msg] of messages.entries()) {
+    const policy = policies[msgIndex];
+    const time = isRecord(msg.data.time) ? msg.data.time : {};
+    const createdMs = asFinite(time.created) ?? sessionCreatedMs;
+    const createdIso = createdMs !== void 0 ? new Date(createdMs).toISOString() : headerTimestamp;
+    const emitForMessage = (type, timestamp, rest) => {
+      const entryId = emitEntry(type, timestamp, rest);
+      if (!messageIdToEntryId.has(msg.id)) messageIdToEntryId.set(msg.id, entryId);
+    };
+    convertMessageByPolicy(msg, policy, createdMs, createdIso, emitForMessage, deps);
+  }
+  degradations.push(...dropGroups.values());
+  return { header, entries, degradations };
+}
+function convertMessageByPolicy(msg, policy, createdMs, createdIso, emitForMessage, deps) {
+  switch (policy) {
+    case "realUserInput":
+      convertUserMessage(msg, createdMs, createdIso, emitForMessage, deps.degradations, deps.compactionDisposition);
+      break;
+    case "visibleAssistant":
+      convertAssistantMessage(msg, msg.data, createdMs, createdIso, emitForMessage, deps.degradations, deps.compactionDisposition);
+      break;
+    case "compactSummary":
+      emitCompactSummary(msg, createdMs, createdIso, emitForMessage, deps);
+      break;
+    case "providerContextOnly":
+    case "hiddenSynthetic":
+    case "timelineOnly":
+      deps.recordDroppedMessage({ code: droppedMessageCode(msg.data), count: 1, ...degradationMeta(msg.data) });
+      break;
+    case "unclassified":
+      deps.recordDroppedMessage({
+        code: "unclassified",
+        count: 1,
+        ...degradationMeta(msg.data),
+        sample: { messageId: msg.id, preview: messageTextPreview(msg.parts).slice(0, DEGRADATION_PREVIEW_MAX) }
+      });
+      break;
+    default: {
+      const exhaustive = policy;
+      throw new Error(`\u672A\u5904\u7406\u7684\u6295\u5F71\u7B56\u7565\uFF1A${String(exhaustive)}`);
+    }
+  }
+}
+function emitCompactSummary(msg, createdMs, createdIso, emitForMessage, deps) {
+  const body = summaryBodyOf(msg.data);
+  if (body === void 0) {
+    convertUserMessage(msg, createdMs, createdIso, emitForMessage, deps.degradations, deps.compactionDisposition);
+    deps.degradations.push({ code: "compaction_unlinked", count: 1, ...degradationMeta(msg.data) });
+    return;
+  }
+  const anchor = deps.linkedParts.get(msg.id)?.[0];
+  let tokensBefore;
+  let anchorMs;
+  let tailId;
+  if (anchor !== void 0) {
+    tokensBefore = asFinite(anchor.preCompactTokenCount);
+    anchorMs = partStartTime(anchor);
+    tailId = asNonEmptyString2(anchor.tail_start_id);
+  }
+  const tsMs = anchorMs ?? createdMs;
+  const tier1 = tailId !== void 0 ? deps.messageIdToEntryId.get(tailId) : void 0;
+  const ownId = deps.chain.peek();
+  emitForMessage("compaction", tsMs !== void 0 ? new Date(tsMs).toISOString() : createdIso, {
+    summary: body,
+    firstKeptEntryId: resolveFirstKeptEntryId(tier1, deps.chain.last(), ownId),
+    ...tokensBefore !== void 0 && { tokensBefore },
+    ...anchor !== void 0 && { details: anchor }
+  });
+  for (const part of msg.parts) {
+    if (part.type === "compaction" && deps.compactionDisposition.get(part) === "dangling") {
+      handleNonTextPart(part, msg, createdMs, createdIso, emitForMessage, deps.degradations, deps.compactionDisposition);
+    }
+  }
+}
+function convertUserMessage(msg, createdMs, createdIso, emitEntry, degradations, compactionDisposition) {
+  const content = [];
+  for (const part of msg.parts) {
+    const type = part.type;
+    if (type === "text") {
+      pushTextPart(part, content, msg.id, degradations);
+      continue;
+    }
+    if (type === "file") {
+      pushDegradation(degradations, `user \u6D88\u606F file part \u4E22\u5F03\uFF08zcode-artifact \u5F15\u7528\u65E0\u6CD5\u642C\u8FD0\uFF0CD6\uFF09\uFF1Amessage=${msg.id}`, msg.id);
+      continue;
+    }
+    handleNonTextPart(part, msg, createdMs, createdIso, emitEntry, degradations, compactionDisposition);
+  }
+  emitEntry("message", createdIso, {
+    message: { role: "user", content, ...createdMs !== void 0 && { timestamp: createdMs } }
+  });
+}
+function convertAssistantMessage(msg, data, createdMs, createdIso, emitEntry, degradations, compactionDisposition) {
+  const providerId = typeof data.providerId === "string" ? data.providerId : void 0;
+  const modelId = typeof data.modelId === "string" ? data.modelId : void 0;
+  let segment = newSegment();
+  const closeSegment = (finishReason, usage) => {
+    if (segment.content.length === 0) return;
+    const tsMs = segment.startMs ?? createdMs;
+    const tsIso = tsMs !== void 0 ? new Date(tsMs).toISOString() : createdIso;
+    emitEntry("message", tsIso, {
+      message: {
+        role: "assistant",
+        content: segment.content,
+        ...tsMs !== void 0 && { timestamp: tsMs },
+        ...providerId !== void 0 && { provider: providerId },
+        ...modelId !== void 0 && { model: modelId },
+        // 产物不变量门：usage 恒在场（缺 → 零值兜底，zeroUsage 注释）
+        usage: usage ?? zeroUsage(),
+        // 段有 step-finish 收口 → 采信其 finish；未收口段（取消/失败尾段）→ 消息级
+        // data.error 优先，无 error 证据才 'stop' 保底（T3c 事故补强）
+        stopReason: finishReason !== void 0 ? mapStopReason(finishReason) : unsealedStopReason(data)
+      }
+    });
+    for (const toolResult of segment.toolResults) {
+      emitEntry("message", tsIso, { message: { ...toolResult, ...tsMs !== void 0 && { timestamp: tsMs } } });
+    }
+    segment = newSegment();
+  };
+  for (const part of msg.parts) {
+    const type = part.type;
+    if (type === "step-start") {
+      closeSegment(void 0, void 0);
+      continue;
+    }
+    if (type === "step-finish") {
+      const { usage, degradation } = usageFromStepFinish(part);
+      if (degradation !== void 0) pushDegradation(degradations, `${degradation}\uFF1Amessage=${msg.id}`, msg.id);
+      closeSegment(part.reason, usage);
+      continue;
+    }
+    if (type === "text") {
+      if (segment.startMs === void 0) segment.startMs = partStartTime(part);
+      pushTextPart(part, segment.content, msg.id, degradations);
+      continue;
+    }
+    if (type === "reasoning") {
+      if (segment.startMs === void 0) segment.startMs = partStartTime(part);
+      const thinking = part.text;
+      if (typeof thinking !== "string") {
+        pushDegradation(degradations, `reasoning part \u6587\u672C\u5F62\u6001\u5F02\u5E38\uFF08${typeof thinking}\uFF09\u8DF3\u8FC7\uFF1Amessage=${msg.id}`, msg.id);
+        continue;
+      }
+      segment.content.push({ type: "thinking", thinking });
+      continue;
+    }
+    if (type === "tool") {
+      convertToolPart(part, msg, segment, degradations);
+      continue;
+    }
+    handleNonTextPart(part, msg, createdMs, createdIso, emitEntry, degradations, compactionDisposition);
+  }
+  closeSegment(void 0, void 0);
+}
+function toolCallArguments(input, toolName, callId, msgId, degradations) {
+  if (input === void 0 || input === null) return {};
+  if (isRecord(input)) return input;
+  pushDegradation(
+    degradations,
+    `tool\u300C${toolName}\u300Dinput \u5F62\u6001\u8D85\u51FA\u5DF2\u9A8C\u8BC1\u57DF\uFF08typeof ${typeof input}\uFF09\uFF0C\u6309\u7A7A\u5165\u53C2\u8F6C\u6362\uFF1AcallID=${callId}`,
+    msgId
+  );
+  return {};
+}
+function registerTruncatedOutput(state, msgData, degradations) {
+  const partMetadata = isRecord(state.metadata) ? state.metadata : void 0;
+  const serialization = partMetadata !== void 0 && isRecord(partMetadata.serialization) ? partMetadata.serialization : void 0;
+  if (serialization?.truncated === true) {
+    degradations.push({ code: "truncated_output", count: 1, ...degradationMeta(msgData) });
+  }
+}
+function convertToolPart(part, msg, segment, degradations) {
+  const callId = part.callID;
+  const toolName = part.tool;
+  const state = part.state;
+  if (typeof callId !== "string" || typeof toolName !== "string" || !isRecord(state)) {
+    pushDegradation(degradations, `tool part \u7ED3\u6784\u5F02\u5E38\uFF08callID/tool/state \u5F62\u6001\uFF09\u6574\u5BF9\u4E22\u5F03\uFF1Amessage=${msg.id}`, msg.id);
+    return;
+  }
+  const status = state.status;
+  if (status !== "completed" && status !== "error") {
+    pushDegradation(
+      degradations,
+      `\u672A\u5B8C\u6210 tool\uFF08status=${String(status)}\uFF09\u6574\u5BF9\u4E22\u5F03\uFF08D7\uFF0C\u9632 dangling toolCall\uFF09\uFF1AcallID=${callId} tool=${toolName}`,
+      msg.id
+    );
+    return;
+  }
+  const args = toolCallArguments(state.input, toolName, callId, msg.id, degradations);
+  const mappedName = mapToolName(toolName);
+  segment.content.push({ type: "toolCall", id: callId, name: mappedName, arguments: args });
+  const shape = toolResultShape(state, part, msg.id, degradations);
+  registerTruncatedOutput(state, msg.data, degradations);
+  segment.toolResults.push({
+    role: "toolResult",
+    toolCallId: callId,
+    toolName: mappedName,
+    content: shape.content,
+    ...shape.details !== void 0 && { details: shape.details },
+    ...shape.isError && { isError: true }
+  });
+}
+function handleNonTextPart(part, msg, createdMs, createdIso, emitEntry, degradations, compactionDisposition) {
+  const type = part.type;
+  if (type === "compaction") {
+    const disposition = compactionDisposition.get(part);
+    if (disposition === "merged") return;
+    if (disposition === "dangling") {
+      degradations.push({ code: "compaction_unlinked", count: 1, ...degradationMeta(msg.data) });
+    }
+    const tsMs = partStartTime(part) ?? createdMs;
+    emitEntry("custom", tsMs !== void 0 ? new Date(tsMs).toISOString() : createdIso, {
+      customType: "zcode-import:compaction",
+      data: part
+    });
+    return;
+  }
+  if (type === "timeline") {
+    return;
+  }
+  pushDegradation(degradations, `\u672A\u77E5 part type\u300C${String(type)}\u300D\u8DF3\u8FC7\uFF08\u524D\u5411\u517C\u5BB9\uFF09\uFF1Amessage=${msg.id}`, msg.id);
+}
+function pushTextPart(part, content, msgId, degradations) {
+  const text = part.text;
+  if (typeof text !== "string") {
+    pushDegradation(degradations, `text part \u6587\u672C\u5F62\u6001\u5F02\u5E38\uFF08${typeof text}\uFF09\u8DF3\u8FC7\uFF1Amessage=${msgId}`, msgId);
+    return;
+  }
+  content.push({ type: "text", text });
+}
+function partStartTime(part) {
+  return isRecord(part.time) ? asFinite(part.time.start) : void 0;
+}
+
+// src/read.ts
+async function readZcodeSession(dbPath, sessionId) {
+  const handle = await openZcodeSessionDb(dbPath);
+  try {
+    const row = handle.db.getSessionRow(sessionId);
+    if (!row) {
+      throw new Error(
+        `\u8BE5\u4F1A\u8BDD\u5DF2\u4E0D\u5728 zcode \u5E93\u4E2D\uFF08sessionId=${sessionId}\uFF09\uFF1A\u8BE5 id \u53EF\u80FD\u5DF2\u88AB zcode \u4FA7\u56DE\u6536\u6216\u4ECE\u672A\u843D\u5E93`
+      );
+    }
+    const transcript = handle.db.getSessionTranscript(sessionId);
+    return convertZcodeTranscript(transcript, { id: sessionId, title: row.title, timeCreated: row.timeCreated });
+  } finally {
+    handle.dispose();
+  }
+}
+export {
+  SqliteUnreadableError,
+  ZcodeSchemaDriftError,
+  convertZcodeTranscript,
+  hostZcodeDbPath,
+  normalizeZcodeSessionId,
+  openZcodeSessionDb,
+  readZcodeSession,
+  zcodeCandidateKey,
+  zcodeImportDbAllowlist,
+  zcodeIsolatedDbPath
+};