pybao-cli 1.5.22 → 1.5.24

package/dist/chunk-HHXEDAUY.js

@@ -0,0 +1,681 @@
+import { createRequire as __pybCreateRequire } from "node:module";
+const require = __pybCreateRequire(import.meta.url);
+import {
+  findGitRoot
+} from "./chunk-KFEHHKZ2.js";
+import {
+  resolveXdgDataPath
+} from "./chunk-2LDISGV5.js";
+
+// src/utils/session/sessionSqlStore.ts
+import { createRequire } from "node:module";
+import { existsSync, mkdirSync } from "fs";
+import { dirname } from "path";
+
+// src/utils/session/sessionStoreConfig.ts
+var cachedFlags = null;
+function parseBooleanFlag(rawValue, defaultValue) {
+  const normalized = String(rawValue ?? "").trim().toLowerCase();
+  if (!normalized) return defaultValue;
+  if (["1", "true", "yes", "on"].includes(normalized)) return true;
+  if (["0", "false", "no", "off"].includes(normalized)) return false;
+  return defaultValue;
+}
+function getSessionStoreFlags() {
+  if (cachedFlags) return cachedFlags;
+  cachedFlags = {
+    sqlWriteEnabled: parseBooleanFlag(
+      process.env.PYB_SESSION_STORE_SQL_WRITE,
+      true
+    ),
+    sqlReadEnabled: parseBooleanFlag(process.env.PYB_SESSION_STORE_SQL_READ, true)
+  };
+  return cachedFlags;
+}
+function getSessionStoreDbPath() {
+  const override = String(process.env.PYB_SESSION_STORE_DB_PATH ?? "").trim();
+  if (override) return override;
+  return resolveXdgDataPath("sessions/session-store.db");
+}
+
+// src/utils/session/sessionStoreSchema.ts
+var SESSION_STORE_SCHEMA_VERSION = 2;
+function applyRuntimePragmas(db) {
+  db.exec(`PRAGMA journal_mode=WAL;`);
+  db.exec(`PRAGMA synchronous=NORMAL;`);
+  db.exec(`PRAGMA busy_timeout=5000;`);
+  db.exec(`PRAGMA foreign_keys=ON;`);
+}
+function ensureSessionStoreSchema(db) {
+  applyRuntimePragmas(db);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS schema_version (
+      name TEXT PRIMARY KEY,
+      version INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS project (
+      id TEXT PRIMARY KEY,
+      cwd TEXT NOT NULL,
+      normalized_cwd TEXT NOT NULL,
+      name TEXT,
+      vcs TEXT,
+      time_created INTEGER NOT NULL,
+      time_updated INTEGER NOT NULL
+    );
+  `);
+  db.exec(`
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_project_normalized_cwd_unique
+    ON project(normalized_cwd);
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS session (
+      id TEXT PRIMARY KEY,
+      project_id TEXT,
+      cwd TEXT,
+      slug TEXT,
+      git_branch TEXT,
+      user_type TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+  `);
+  const sessionColumns = db.prepare(`PRAGMA table_info(session)`).all();
+  if (!sessionColumns.some((col) => col.name === "project_id")) {
+    db.exec(`ALTER TABLE session ADD COLUMN project_id TEXT;`);
+  }
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS message (
+      uuid TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      agent_id TEXT,
+      role TEXT NOT NULL,
+      parent_uuid TEXT,
+      logical_parent_uuid TEXT,
+      request_id TEXT,
+      is_api_error INTEGER NOT NULL DEFAULT 0,
+      time_created INTEGER NOT NULL,
+      raw_message_json TEXT NOT NULL,
+      updated_at INTEGER NOT NULL,
+      FOREIGN KEY(session_id) REFERENCES session(id) ON DELETE CASCADE
+    );
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS part (
+      id TEXT PRIMARY KEY,
+      message_uuid TEXT NOT NULL,
+      session_id TEXT NOT NULL,
+      part_index INTEGER NOT NULL,
+      part_type TEXT NOT NULL,
+      raw_part_json TEXT NOT NULL,
+      time_created INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      FOREIGN KEY(message_uuid) REFERENCES message(uuid) ON DELETE CASCADE,
+      FOREIGN KEY(session_id) REFERENCES session(id) ON DELETE CASCADE
+    );
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS session_meta_event (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      event_type TEXT NOT NULL,
+      payload_json TEXT NOT NULL,
+      time_created INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      FOREIGN KEY(session_id) REFERENCES session(id) ON DELETE CASCADE
+    );
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS session_summary (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      leaf_uuid TEXT,
+      summary TEXT NOT NULL,
+      time_created INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      FOREIGN KEY(session_id) REFERENCES session(id) ON DELETE CASCADE
+    );
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS file_history_snapshot (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL,
+      message_uuid TEXT,
+      snapshot_json TEXT NOT NULL,
+      is_update INTEGER NOT NULL DEFAULT 0,
+      time_created INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      FOREIGN KEY(session_id) REFERENCES session(id) ON DELETE CASCADE
+    );
+  `);
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_message_session_time_uuid
+    ON message(session_id, time_created, uuid);
+  `);
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_part_session_message_part_index
+    ON part(session_id, message_uuid, part_index);
+  `);
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_meta_event_session_time
+    ON session_meta_event(session_id, time_created);
+  `);
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_session_project_updated
+    ON session(project_id, updated_at, id);
+  `);
+  const now = Date.now();
+  db.prepare(
+    `
+    INSERT INTO schema_version (name, version, updated_at)
+    VALUES (?1, ?2, ?3)
+    ON CONFLICT(name) DO UPDATE SET
+      version = excluded.version,
+      updated_at = excluded.updated_at
+  `
+  ).run("session_store", SESSION_STORE_SCHEMA_VERSION, now);
+}
+
+// src/utils/session/sessionProjectIdentity.ts
+import { createHash } from "crypto";
+import { realpathSync } from "fs";
+function defaultRealpath(inputPath) {
+  try {
+    return realpathSync(inputPath);
+  } catch {
+    return inputPath;
+  }
+}
+function normalizeSessionProjectPath(inputPath, options = {}) {
+  const platform = options.platform ?? process.platform;
+  const realpathResolver = options.realpathResolver ?? defaultRealpath;
+  const resolved = realpathResolver(inputPath);
+  let normalized = String(resolved).replace(/\\/g, "/");
+  if (normalized.length > 1) {
+    normalized = normalized.replace(/\/+$/, "");
+  }
+  if (platform === "win32") {
+    normalized = normalized.replace(
+      /^([A-Z]):/,
+      (_m, drive) => `${drive.toLowerCase()}:`
+    );
+    normalized = normalized.toLowerCase();
+  }
+  return normalized;
+}
+function computeSessionProjectId(normalizedCwd) {
+  return createHash("sha256").update(normalizedCwd, "utf8").digest("hex");
+}
+function resolveSessionProjectIdentity(cwd, options = {}) {
+  const gitRootRunner = options.findGitRoot ?? findGitRoot;
+  const repoRoot = gitRootRunner(cwd);
+  const source = repoRoot ? "repo_root" : "cwd";
+  const projectCwd = repoRoot ?? cwd;
+  const normalizedCwd = normalizeSessionProjectPath(projectCwd, options);
+  const projectId = computeSessionProjectId(normalizedCwd);
+  return {
+    source,
+    projectCwd,
+    normalizedCwd,
+    projectId
+  };
+}
+
+// src/utils/session/sessionSqlDualWriteTelemetry.ts
+var state = {
+  successCount: 0,
+  failCount: 0,
+  totalLatencyMs: 0,
+  lastErrorCode: null,
+  projectResolveSuccessCount: 0,
+  projectResolveFailCount: 0
+};
+function recordSessionSqlDualWriteSuccess(latencyMs) {
+  state.successCount += 1;
+  state.totalLatencyMs += Math.max(0, Number(latencyMs) || 0);
+}
+function recordSessionSqlDualWriteFailure(errorCode) {
+  state.failCount += 1;
+  state.lastErrorCode = errorCode ? String(errorCode) : "SESSION_SQL_DUALWRITE_FAILED";
+}
+function recordSessionProjectResolveSuccess() {
+  state.projectResolveSuccessCount += 1;
+}
+function recordSessionProjectResolveFailure() {
+  state.projectResolveFailCount += 1;
+}
+
+// src/utils/session/sessionSqlStore.ts
+var requireForSqlite = createRequire(import.meta.url);
+var cachedDatabaseCtor;
+function getDatabaseCtor() {
+  if (cachedDatabaseCtor !== void 0) return cachedDatabaseCtor;
+  try {
+    const mod = requireForSqlite("bun:sqlite");
+    if (typeof mod?.Database === "function") {
+      cachedDatabaseCtor = mod.Database;
+      return cachedDatabaseCtor;
+    }
+  } catch {
+  }
+  cachedDatabaseCtor = null;
+  return null;
+}
+function getDatabaseCtorOrThrow() {
+  const Database = getDatabaseCtor();
+  if (Database) return Database;
+  const error = new Error(
+    "PYB_SESSION_SQL_UNAVAILABLE: bun:sqlite is unavailable for session store"
+  );
+  error.code = "PYB_SESSION_SQL_UNAVAILABLE";
+  throw error;
+}
+function asNullableText(value) {
+  const text = String(value ?? "").trim();
+  return text ? text : null;
+}
+function asRole(value) {
+  return value === "assistant" || value === "progress" ? value : "user";
+}
+function asProjectCwd(value) {
+  const text = String(value ?? "").trim();
+  return text ? text : null;
+}
+function createSessionSqlStore(options) {
+  const dbFilePath = options?.dbFilePath ?? getSessionStoreDbPath();
+  if (!existsSync(dirname(dbFilePath))) {
+    mkdirSync(dirname(dbFilePath), { recursive: true });
+  }
+  const Database = getDatabaseCtorOrThrow();
+  const db = new Database(dbFilePath, { create: true });
+  ensureSessionStoreSchema(db);
+  const upsertProject = db.prepare(`
+    INSERT INTO project (id, cwd, normalized_cwd, name, vcs, time_created, time_updated)
+    VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)
+    ON CONFLICT(id) DO UPDATE SET
+      cwd = excluded.cwd,
+      normalized_cwd = excluded.normalized_cwd,
+      name = COALESCE(excluded.name, project.name),
+      vcs = COALESCE(excluded.vcs, project.vcs),
+      time_updated = excluded.time_updated
+  `);
+  const upsertSession = db.prepare(`
+    INSERT INTO session (id, project_id, cwd, created_at, updated_at)
+    VALUES (?1, ?2, ?3, ?4, ?5)
+    ON CONFLICT(id) DO UPDATE SET
+      project_id = COALESCE(excluded.project_id, session.project_id),
+      cwd = COALESCE(excluded.cwd, session.cwd),
+      updated_at = excluded.updated_at
+  `);
+  const upsertMessage = db.prepare(`
+    INSERT INTO message (
+      uuid, session_id, agent_id, role, parent_uuid, logical_parent_uuid,
+      request_id, is_api_error, time_created, raw_message_json, updated_at
+    )
+    VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11)
+    ON CONFLICT(uuid) DO UPDATE SET
+      session_id = excluded.session_id,
+      agent_id = excluded.agent_id,
+      role = excluded.role,
+      parent_uuid = excluded.parent_uuid,
+      logical_parent_uuid = excluded.logical_parent_uuid,
+      request_id = excluded.request_id,
+      is_api_error = excluded.is_api_error,
+      time_created = excluded.time_created,
+      raw_message_json = excluded.raw_message_json,
+      updated_at = excluded.updated_at
+  `);
+  const upsertPart = db.prepare(`
+    INSERT INTO part (
+      id, message_uuid, session_id, part_index, part_type, raw_part_json, time_created, updated_at
+    )
+    VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8)
+    ON CONFLICT(id) DO UPDATE SET
+      message_uuid = excluded.message_uuid,
+      session_id = excluded.session_id,
+      part_index = excluded.part_index,
+      part_type = excluded.part_type,
+      raw_part_json = excluded.raw_part_json,
+      time_created = excluded.time_created,
+      updated_at = excluded.updated_at
+  `);
+  const upsertSummary = db.prepare(`
+    INSERT INTO session_summary (
+      id, session_id, leaf_uuid, summary, time_created, updated_at
+    )
+    VALUES (?1, ?2, ?3, ?4, ?5, ?6)
+    ON CONFLICT(id) DO UPDATE SET
+      session_id = excluded.session_id,
+      leaf_uuid = excluded.leaf_uuid,
+      summary = excluded.summary,
+      time_created = excluded.time_created,
+      updated_at = excluded.updated_at
+  `);
+  const upsertMetaEvent = db.prepare(`
+    INSERT INTO session_meta_event (
+      id, session_id, event_type, payload_json, time_created, updated_at
+    )
+    VALUES (?1, ?2, ?3, ?4, ?5, ?6)
+    ON CONFLICT(id) DO UPDATE SET
+      session_id = excluded.session_id,
+      event_type = excluded.event_type,
+      payload_json = excluded.payload_json,
+      time_created = excluded.time_created,
+      updated_at = excluded.updated_at
+  `);
+  const upsertFileHistorySnapshot = db.prepare(`
+    INSERT INTO file_history_snapshot (
+      id, session_id, message_uuid, snapshot_json, is_update, time_created, updated_at
+    )
+    VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)
+    ON CONFLICT(id) DO UPDATE SET
+      session_id = excluded.session_id,
+      message_uuid = excluded.message_uuid,
+      snapshot_json = excluded.snapshot_json,
+      is_update = excluded.is_update,
+      time_created = excluded.time_created,
+      updated_at = excluded.updated_at
+  `);
+  const resolveProjectId = (projectCwd, timeCreated, now) => {
+    if (!projectCwd) return null;
+    try {
+      const identity = resolveSessionProjectIdentity(projectCwd);
+      upsertProject.run(
+        identity.projectId,
+        identity.projectCwd,
+        identity.normalizedCwd,
+        null,
+        null,
+        timeCreated,
+        now
+      );
+      recordSessionProjectResolveSuccess();
+      return identity.projectId;
+    } catch {
+      recordSessionProjectResolveFailure();
+      return null;
+    }
+  };
+  const appendMessages = (messages) => {
+    if (!Array.isArray(messages) || messages.length === 0) return 0;
+    const now = Date.now();
+    const tx = db.transaction((list) => {
+      for (const item of list) {
+        const sessionId = String(item.sessionId ?? "").trim();
+        const uuid = String(item.uuid ?? "").trim();
+        if (!sessionId || !uuid) continue;
+        const timeCreated = Number(item.timeCreated) || now;
+        const projectCwd = asProjectCwd(item.projectCwd);
+        const projectId = resolveProjectId(projectCwd, timeCreated, now);
+        upsertSession.run(sessionId, projectId, projectCwd, timeCreated, now);
+        upsertMessage.run(
+          uuid,
+          sessionId,
+          asNullableText(item.agentId),
+          asRole(item.role),
+          asNullableText(item.parentUuid),
+          asNullableText(item.logicalParentUuid),
+          asNullableText(item.requestId),
+          item.isApiError ? 1 : 0,
+          timeCreated,
+          JSON.stringify(item.rawMessage ?? {}),
+          now
+        );
+      }
+    });
+    tx(messages);
+    return messages.length;
+  };
+  const appendParts = (parts) => {
+    if (!Array.isArray(parts) || parts.length === 0) return 0;
+    const now = Date.now();
+    const tx = db.transaction((list) => {
+      for (const item of list) {
+        const id = String(item.id ?? "").trim();
+        const messageUuid = String(item.messageUuid ?? "").trim();
+        const sessionId = String(item.sessionId ?? "").trim();
+        if (!id || !messageUuid || !sessionId) continue;
+        const timeCreated = Number(item.timeCreated) || now;
+        const projectCwd = asProjectCwd(item.projectCwd);
+        const projectId = resolveProjectId(projectCwd, timeCreated, now);
+        upsertSession.run(sessionId, projectId, projectCwd, timeCreated, now);
+        upsertPart.run(
+          id,
+          messageUuid,
+          sessionId,
+          Number(item.partIndex) || 0,
+          String(item.partType ?? "unknown"),
+          JSON.stringify(item.rawPart ?? {}),
+          timeCreated,
+          now
+        );
+      }
+    });
+    tx(parts);
+    return parts.length;
+  };
+  const appendSessionSummaries = (records) => {
+    if (!Array.isArray(records) || records.length === 0) return 0;
+    const now = Date.now();
+    const tx = db.transaction((list) => {
+      for (const item of list) {
+        const id = String(item.id ?? "").trim();
+        const sessionId = String(item.sessionId ?? "").trim();
+        if (!id || !sessionId) continue;
+        const timeCreated = Number(item.timeCreated) || now;
+        const projectCwd = asProjectCwd(item.projectCwd);
+        const projectId = resolveProjectId(projectCwd, timeCreated, now);
+        upsertSession.run(sessionId, projectId, projectCwd, timeCreated, now);
+        upsertSummary.run(
+          id,
+          sessionId,
+          asNullableText(item.leafUuid),
+          String(item.summary ?? ""),
+          timeCreated,
+          now
+        );
+      }
+    });
+    tx(records);
+    return records.length;
+  };
+  const appendSessionMetaEvents = (records) => {
+    if (!Array.isArray(records) || records.length === 0) return 0;
+    const now = Date.now();
+    const tx = db.transaction((list) => {
+      for (const item of list) {
+        const id = String(item.id ?? "").trim();
+        const sessionId = String(item.sessionId ?? "").trim();
+        if (!id || !sessionId) continue;
+        const timeCreated = Number(item.timeCreated) || now;
+        const projectCwd = asProjectCwd(item.projectCwd);
+        const projectId = resolveProjectId(projectCwd, timeCreated, now);
+        upsertSession.run(sessionId, projectId, projectCwd, timeCreated, now);
+        upsertMetaEvent.run(
+          id,
+          sessionId,
+          String(item.eventType ?? "unknown"),
+          JSON.stringify(item.payload ?? {}),
+          timeCreated,
+          now
+        );
+      }
+    });
+    tx(records);
+    return records.length;
+  };
+  const appendFileHistorySnapshots = (records) => {
+    if (!Array.isArray(records) || records.length === 0) return 0;
+    const now = Date.now();
+    const tx = db.transaction((list) => {
+      for (const item of list) {
+        const id = String(item.id ?? "").trim();
+        const sessionId = String(item.sessionId ?? "").trim();
+        if (!id || !sessionId) continue;
+        const timeCreated = Number(item.timeCreated) || now;
+        const projectCwd = asProjectCwd(item.projectCwd);
+        const projectId = resolveProjectId(projectCwd, timeCreated, now);
+        upsertSession.run(sessionId, projectId, projectCwd, timeCreated, now);
+        upsertFileHistorySnapshot.run(
+          id,
+          sessionId,
+          asNullableText(item.messageUuid),
+          JSON.stringify(item.snapshot ?? {}),
+          item.isSnapshotUpdate ? 1 : 0,
+          timeCreated,
+          now
+        );
+      }
+    });
+    tx(records);
+    return records.length;
+  };
+  const loadMessages = (sessionId, options2 = {}) => {
+    const target = String(sessionId ?? "").trim();
+    if (!target) return [];
+    const fromTime = Number.isFinite(options2.fromTime) ? Number(options2.fromTime) : null;
+    const toTime = Number.isFinite(options2.toTime) ? Number(options2.toTime) : null;
+    const rows = db.prepare(
+      `
+      SELECT
+        session_id, uuid, role, time_created, raw_message_json,
+        agent_id, parent_uuid, logical_parent_uuid, request_id, is_api_error
+      FROM message
+      WHERE session_id = ?1
+        AND (?2 IS NULL OR time_created >= ?2)
+        AND (?3 IS NULL OR time_created <= ?3)
+      ORDER BY time_created ASC, uuid ASC
+    `
+    ).all(target, fromTime, toTime);
+    return rows.map((row) => ({
+      sessionId: String(row.session_id),
+      uuid: String(row.uuid),
+      role: asRole(row.role),
+      timeCreated: Number(row.time_created) || 0,
+      rawMessage: JSON.parse(String(row.raw_message_json ?? "{}")),
+      agentId: asNullableText(row.agent_id),
+      parentUuid: asNullableText(row.parent_uuid),
+      logicalParentUuid: asNullableText(row.logical_parent_uuid),
+      requestId: asNullableText(row.request_id),
+      isApiError: Number(row.is_api_error ?? 0) > 0
+    }));
+  };
+  const loadSessionSummaries = (sessionId) => {
+    const target = String(sessionId ?? "").trim();
+    if (!target) return [];
+    const rows = db.prepare(
+      `
+      SELECT session_id, leaf_uuid, summary, time_created
+      FROM session_summary
+      WHERE session_id = ?1
+      ORDER BY time_created ASC, id ASC
+    `
+    ).all(target);
+    return rows.map((row) => ({
+      sessionId: String(row.session_id),
+      leafUuid: asNullableText(row.leaf_uuid),
+      summary: String(row.summary ?? ""),
+      timeCreated: Number(row.time_created) || 0
+    }));
+  };
+  const loadSessionMetaEvents = (sessionId) => {
+    const target = String(sessionId ?? "").trim();
+    if (!target) return [];
+    const rows = db.prepare(
+      `
+      SELECT session_id, event_type, payload_json, time_created
+      FROM session_meta_event
+      WHERE session_id = ?1
+      ORDER BY time_created ASC, id ASC
+    `
+    ).all(target);
+    return rows.map((row) => ({
+      sessionId: String(row.session_id),
+      eventType: String(row.event_type ?? ""),
+      payload: JSON.parse(String(row.payload_json ?? "{}")),
+      timeCreated: Number(row.time_created) || 0
+    }));
+  };
+  const loadFileHistorySnapshots = (sessionId) => {
+    const target = String(sessionId ?? "").trim();
+    if (!target) return [];
+    const rows = db.prepare(
+      `
+      SELECT session_id, message_uuid, snapshot_json, is_update, time_created
+      FROM file_history_snapshot
+      WHERE session_id = ?1
+      ORDER BY time_created ASC, id ASC
+    `
+    ).all(target);
+    return rows.map((row) => ({
+      sessionId: String(row.session_id),
+      messageUuid: asNullableText(row.message_uuid),
+      snapshot: JSON.parse(String(row.snapshot_json ?? "{}")),
+      isSnapshotUpdate: Number(row.is_update ?? 0) > 0,
+      timeCreated: Number(row.time_created) || 0
+    }));
+  };
+  const findLatestSessionId = (cwd) => {
+    const projectScope = asProjectCwd(cwd);
+    if (projectScope) {
+      const scopeIdentity = resolveSessionProjectIdentity(projectScope);
+      const projectRow = db.prepare(
+        `
+        SELECT id
+        FROM session
+        WHERE project_id = ?1
+        ORDER BY updated_at DESC, id DESC
+        LIMIT 1
+      `
+      ).get(scopeIdentity.projectId);
+      const projectScopedId = asNullableText(projectRow?.id);
+      if (projectScopedId) return projectScopedId;
+      const cwdRow = db.prepare(
+        `
+        SELECT id
+        FROM session
+        WHERE cwd = ?1
+        ORDER BY updated_at DESC, id DESC
+        LIMIT 1
+      `
+      ).get(projectScope);
+      const cwdScopedId = asNullableText(cwdRow?.id);
+      if (cwdScopedId) return cwdScopedId;
+    }
+    const row = db.prepare(
+      `
+      SELECT session_id
+      FROM message
+      ORDER BY time_created DESC, uuid DESC
+      LIMIT 1
+    `
+    ).get();
+    return asNullableText(row?.session_id);
+  };
+  const close = () => {
+    db.close();
+  };
+  return {
+    appendMessages,
+    appendParts,
+    appendSessionSummaries,
+    appendSessionMetaEvents,
+    appendFileHistorySnapshots,
+    loadSessionSummaries,
+    loadSessionMetaEvents,
+    loadFileHistorySnapshots,
+    loadMessages,
+    findLatestSessionId,
+    close
+  };
+}
+
+export {
+  getSessionStoreFlags,
+  getSessionStoreDbPath,
+  recordSessionSqlDualWriteSuccess,
+  recordSessionSqlDualWriteFailure,
+  createSessionSqlStore
+};