muonroi-cli 1.2.0

package/src/storage/atomic-io.test.ts

@@ -0,0 +1,61 @@
+import { promises as fs } from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { atomicReadJSON, atomicWriteJSON } from "./atomic-io.js";
+
+let tmpDir: string;
+
+beforeEach(async () => {
+  tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "atomic-io-test-"));
+});
+
+afterEach(async () => {
+  await fs.rm(tmpDir, { recursive: true, force: true });
+});
+
+describe("atomicWriteJSON", () => {
+  it("Test 1: writes file and removes .tmp on success", async () => {
+    const filePath = path.join(tmpDir, "foo.json");
+    await atomicWriteJSON(filePath, { hello: 1 });
+
+    const raw = await fs.readFile(filePath, "utf8");
+    expect(JSON.parse(raw)).toEqual({ hello: 1 });
+
+    // .tmp must NOT exist after success
+    await expect(fs.access(`${filePath}.tmp`)).rejects.toThrow();
+  });
+
+  it("Test 2: throws on circular reference and does not leave .tmp", async () => {
+    const filePath = path.join(tmpDir, "cyclic.json");
+    // Write a pre-existing file to confirm it remains untouched on error
+    await fs.writeFile(filePath, JSON.stringify({ safe: true }), "utf8");
+
+    // Create a circular object
+    const cyclic: Record<string, unknown> = {};
+    cyclic.self = cyclic;
+
+    await expect(atomicWriteJSON(filePath, cyclic)).rejects.toThrow();
+
+    // Pre-existing file must be untouched
+    const raw = await fs.readFile(filePath, "utf8");
+    expect(JSON.parse(raw)).toEqual({ safe: true });
+
+    // .tmp must NOT exist after failure
+    await expect(fs.access(`${filePath}.tmp`)).rejects.toThrow();
+  });
+});
+
+describe("atomicReadJSON", () => {
+  it("Test 3: returns null for absent file", async () => {
+    const filePath = path.join(tmpDir, "never-written.json");
+    const result = await atomicReadJSON(filePath);
+    expect(result).toBeNull();
+  });
+
+  it("Test 4: throws on corrupted (invalid JSON) file", async () => {
+    const filePath = path.join(tmpDir, "corrupt.json");
+    await fs.writeFile(filePath, "{ this is not valid json }", "utf8");
+    await expect(atomicReadJSON(filePath)).rejects.toThrow();
+  });
+});

package/src/storage/atomic-io.ts

@@ -0,0 +1,62 @@
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+
+/**
+ * Atomically write a JSON value to filePath using .tmp + rename pattern.
+ * Pitfall 9 mitigation: a Ctrl+C between write and rename leaves no dangling state.
+ *
+ * Steps: serialize → ensure parent dir → write to filePath + ".tmp" → rename .tmp → filePath.
+ * On serialize failure, .tmp is never created. On rename failure, .tmp is cleaned up.
+ */
+export async function atomicWriteJSON(filePath: string, value: unknown): Promise<void> {
+  const tmpPath = `${filePath}.tmp`;
+  let serialized: string;
+  try {
+    serialized = JSON.stringify(value, null, 2);
+  } catch (err) {
+    throw new Error(`atomicWriteJSON: failed to serialize value for ${filePath}: ${(err as Error).message}`);
+  }
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  try {
+    await fs.writeFile(tmpPath, serialized, "utf8");
+    await fs.rename(tmpPath, filePath);
+  } catch (err) {
+    // Clean up the .tmp if rename failed mid-flight
+    await fs.unlink(tmpPath).catch(() => {
+      /* ignore */
+    });
+    throw err;
+  }
+}
+
+/**
+ * Atomically write plain text content to filePath using .tmp + rename pattern.
+ * Same durability guarantees as atomicWriteJSON but without JSON serialization.
+ */
+export async function atomicWriteText(filePath: string, content: string): Promise<void> {
+  const tmpPath = `${filePath}.tmp`;
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  try {
+    await fs.writeFile(tmpPath, content, "utf8");
+    await fs.rename(tmpPath, filePath);
+  } catch (err) {
+    await fs.unlink(tmpPath).catch(() => {
+      /* ignore */
+    });
+    throw err;
+  }
+}
+
+/**
+ * Read a JSON file and parse it. Returns null if file is absent (ENOENT).
+ * Throws if the file exists but contains invalid JSON.
+ */
+export async function atomicReadJSON<T>(filePath: string): Promise<T | null> {
+  try {
+    const raw = await fs.readFile(filePath, "utf8");
+    return JSON.parse(raw) as T;
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code === "ENOENT") return null;
+    throw err;
+  }
+}

package/src/storage/config.test.ts

@@ -0,0 +1,33 @@
+import { promises as fs } from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { atomicWriteJSON } from "./atomic-io.js";
+import { loadConfig } from "./config.js";
+
+let tmpDir: string;
+
+beforeEach(async () => {
+  tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "config-test-"));
+});
+
+afterEach(async () => {
+  await fs.rm(tmpDir, { recursive: true, force: true });
+});
+
+describe("loadConfig", () => {
+  it("Test 5: bootstraps default config when ~/.muonroi-cli/config.json absent", async () => {
+    const config = await loadConfig(tmpDir);
+    expect(config.cap.monthly_usd).toBe(15);
+    // File must be written now
+    const raw = await fs.readFile(path.join(tmpDir, "config.json"), "utf8");
+    const parsed = JSON.parse(raw);
+    expect(parsed.cap.monthly_usd).toBe(15);
+  });
+
+  it("Test 6: respects user-provided cap.monthly_usd value", async () => {
+    await atomicWriteJSON(path.join(tmpDir, "config.json"), { cap: { monthly_usd: 30 } });
+    const config = await loadConfig(tmpDir);
+    expect(config.cap.monthly_usd).toBe(30);
+  });
+});

package/src/storage/config.ts

@@ -0,0 +1,49 @@
+import * as os from "node:os";
+import * as path from "node:path";
+import { atomicReadJSON, atomicWriteJSON } from "./atomic-io.js";
+
+/**
+ * TUI-owned cap configuration stored at ~/.muonroi-cli/config.json.
+ *
+ * Architecture anti-pattern 4: cap state is owned exclusively by the TUI process.
+ * EE server must NEVER read or write this file — it only receives per-call context
+ * over HTTP.
+ */
+export interface MuonroiConfig {
+  cap: { monthly_usd: number };
+  ee?: { baseUrl?: string; authToken?: string };
+}
+
+const DEFAULT_CONFIG: MuonroiConfig = {
+  cap: { monthly_usd: 15 },
+  ee: { baseUrl: "http://localhost:8082" },
+};
+
+/**
+ * Resolve the ~/.muonroi-cli/ home directory.
+ * Priority: explicit override → MUONROI_CLI_HOME env → os.homedir()/.muonroi-cli
+ */
+function muonroiHome(override?: string): string {
+  return override ?? process.env.MUONROI_CLI_HOME ?? path.join(os.homedir(), ".muonroi-cli");
+}
+
+/**
+ * Load config from ~/.muonroi-cli/config.json.
+ * If absent, writes and returns the default config (cap.monthly_usd = 15).
+ * Accepts an optional homeOverride for test isolation.
+ */
+export async function loadConfig(homeOverride?: string): Promise<MuonroiConfig> {
+  const home = muonroiHome(homeOverride);
+  const filePath = path.join(home, "config.json");
+  const existing = await atomicReadJSON<MuonroiConfig>(filePath);
+  if (existing) {
+    // Merge so that missing keys fall back to defaults (handles partial user configs)
+    return {
+      ...DEFAULT_CONFIG,
+      ...existing,
+      cap: { ...DEFAULT_CONFIG.cap, ...existing.cap },
+    };
+  }
+  await atomicWriteJSON(filePath, DEFAULT_CONFIG);
+  return DEFAULT_CONFIG;
+}

package/src/storage/db.ts

@@ -0,0 +1,95 @@
+import { Database } from "bun:sqlite";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { applyMigrations } from "./migrations";
+
+export interface SQLiteStatement {
+  run(...params: unknown[]): unknown;
+  get(...params: unknown[]): unknown;
+  all(...params: unknown[]): unknown[];
+}
+
+export interface SQLiteDatabase {
+  exec(sql: string): void;
+  prepare(sql: string): SQLiteStatement;
+  pragma(query: string, options?: { simple?: boolean }): unknown;
+  transaction<T>(fn: () => T): () => T;
+  close(): void;
+}
+
+let db: SQLiteDatabase | null = null;
+
+export function getDatabasePath(): string {
+  const dir = path.join(os.homedir(), ".muonroi-cli");
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  return path.join(dir, "muonroi.db");
+}
+
+export function getDatabase(): SQLiteDatabase {
+  if (db) return db;
+
+  const database = new BunSqliteDatabase(getDatabasePath());
+  database.pragma("journal_mode = WAL");
+  database.pragma("foreign_keys = ON");
+  database.pragma("busy_timeout = 5000");
+  database.pragma("synchronous = NORMAL");
+  applyMigrations(database);
+  db = database;
+  return database;
+}
+
+export function withTransaction<T>(fn: (database: SQLiteDatabase) => T): T {
+  const database = getDatabase();
+  return database.transaction(() => fn(database))();
+}
+
+export function closeDatabase(): void {
+  db?.close();
+  db = null;
+}
+
+class BunSqliteDatabase implements SQLiteDatabase {
+  private readonly db: Database;
+
+  constructor(filename: string) {
+    this.db = new Database(filename, { create: true, strict: true });
+  }
+
+  exec(sql: string): void {
+    this.db.exec(sql);
+  }
+
+  prepare(sql: string): SQLiteStatement {
+    return {
+      run: (...params: unknown[]) => this.db.run(sql, normalizeBinding(params)),
+      get: (...params: unknown[]) => this.db.query(sql).get(normalizeBinding(params)),
+      all: (...params: unknown[]) => this.db.query(sql).all(normalizeBinding(params)),
+    };
+  }
+
+  pragma(query: string, options?: { simple?: boolean }): unknown {
+    if (query.includes("=")) {
+      this.db.exec(`PRAGMA ${query}`);
+      return undefined;
+    }
+
+    const row = this.db.query(`PRAGMA ${query}`).get() as Record<string, unknown> | undefined;
+    if (!options?.simple) return row;
+    if (!row) return undefined;
+    return Object.values(row)[0];
+  }
+
+  transaction<T>(fn: () => T): () => T {
+    return this.db.transaction(fn);
+  }
+
+  close(): void {
+    this.db.close();
+  }
+}
+
+function normalizeBinding(params: unknown[]): unknown {
+  if (params.length === 0) return undefined;
+  return params.length === 1 ? params[0] : params;
+}

package/src/storage/index.ts

@@ -0,0 +1,19 @@
+// Muonroi-specific storage: cap state (atomic IO, config, usage)
+export { atomicReadJSON, atomicWriteJSON } from "./atomic-io.js";
+export { loadConfig, type MuonroiConfig } from "./config.js";
+export { getDatabasePath } from "./db";
+export { SessionStore } from "./sessions";
+export {
+  appendCompaction,
+  appendMessages,
+  appendSystemMessage,
+  buildChatEntries,
+  getNextMessageSequence,
+  loadLatestCompaction,
+  loadRawTranscript,
+  loadTranscript,
+  loadTranscriptState,
+} from "./transcript";
+export { buildEffectiveTranscript, type LoadedTranscriptState, type PersistedCompaction } from "./transcript-view";
+export { getSessionTotalTokens, listSessionUsage, recordUsageEvent, type TokenUsageLike } from "./usage";
+export { loadUsage, saveUsage, type UsageState } from "./usage-cap.js";

package/src/storage/migrations.ts

@@ -0,0 +1,143 @@
+import type { SQLiteDatabase } from "./db";
+
+const LATEST_DB_VERSION = 4;
+
+export function applyMigrations(db: SQLiteDatabase): void {
+  const version = Number(db.pragma("user_version", { simple: true })) || 0;
+  if (version >= LATEST_DB_VERSION) return;
+
+  const migrate = db.transaction(() => {
+    if (version < 1) {
+      createInitialSchema(db);
+      db.pragma("user_version = 1");
+    }
+    if (version < 2) {
+      createCompactionSchema(db);
+      db.pragma("user_version = 2");
+    }
+    if (version < 3) {
+      db.exec(`
+        ALTER TABLE usage_events ADD COLUMN pil_active INTEGER NOT NULL DEFAULT 0;
+        ALTER TABLE usage_events ADD COLUMN enrichment_delta INTEGER NOT NULL DEFAULT 0;
+      `);
+      db.pragma("user_version = 3");
+    }
+    if (version < 4) {
+      db.exec(`
+        ALTER TABLE usage_events ADD COLUMN cache_read_tokens INTEGER NOT NULL DEFAULT 0;
+        ALTER TABLE usage_events ADD COLUMN cache_creation_tokens INTEGER NOT NULL DEFAULT 0;
+      `);
+      db.pragma("user_version = 4");
+    }
+  });
+
+  migrate();
+}
+
+function createInitialSchema(db: SQLiteDatabase): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS workspaces (
+      id TEXT PRIMARY KEY,
+      scope_key TEXT NOT NULL UNIQUE,
+      canonical_path TEXT NOT NULL,
+      git_root TEXT,
+      display_name TEXT NOT NULL,
+      last_seen_at TEXT NOT NULL
+    ) STRICT;
+
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      workspace_id TEXT NOT NULL REFERENCES workspaces(id) ON DELETE CASCADE,
+      title TEXT,
+      model TEXT NOT NULL,
+      mode TEXT NOT NULL,
+      cwd_at_start TEXT NOT NULL,
+      cwd_last TEXT NOT NULL,
+      status TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    ) STRICT;
+
+    CREATE TABLE IF NOT EXISTS messages (
+      session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+      seq INTEGER NOT NULL,
+      role TEXT NOT NULL,
+      message_json TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      PRIMARY KEY (session_id, seq)
+    ) STRICT;
+
+    CREATE TABLE IF NOT EXISTS tool_calls (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+      message_seq INTEGER NOT NULL,
+      tool_call_id TEXT NOT NULL,
+      tool_name TEXT NOT NULL,
+      args_json TEXT NOT NULL,
+      status TEXT NOT NULL,
+      started_at TEXT NOT NULL,
+      completed_at TEXT,
+      UNIQUE(session_id, tool_call_id)
+    ) STRICT;
+
+    CREATE TABLE IF NOT EXISTS tool_results (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      tool_call_row_id INTEGER NOT NULL REFERENCES tool_calls(id) ON DELETE CASCADE,
+      output_kind TEXT NOT NULL,
+      output_json TEXT NOT NULL,
+      success INTEGER NOT NULL,
+      created_at TEXT NOT NULL
+    ) STRICT;
+
+    CREATE TABLE IF NOT EXISTS usage_events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+      message_seq INTEGER,
+      source TEXT NOT NULL,
+      model TEXT NOT NULL,
+      input_tokens INTEGER NOT NULL DEFAULT 0,
+      output_tokens INTEGER NOT NULL DEFAULT 0,
+      total_tokens INTEGER NOT NULL DEFAULT 0,
+      cost_micros INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT NOT NULL,
+      cache_read_tokens INTEGER NOT NULL DEFAULT 0,
+      cache_creation_tokens INTEGER NOT NULL DEFAULT 0
+    ) STRICT;
+
+    CREATE TABLE IF NOT EXISTS compactions (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+      first_kept_seq INTEGER NOT NULL,
+      summary TEXT NOT NULL,
+      tokens_before INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT NOT NULL
+    ) STRICT;
+
+    CREATE INDEX IF NOT EXISTS idx_sessions_workspace_updated
+      ON sessions(workspace_id, updated_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_messages_session_seq
+      ON messages(session_id, seq);
+    CREATE INDEX IF NOT EXISTS idx_tool_calls_session_seq
+      ON tool_calls(session_id, message_seq);
+    CREATE INDEX IF NOT EXISTS idx_usage_events_session_created
+      ON usage_events(session_id, created_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_compactions_session_created
+      ON compactions(session_id, created_at DESC);
+  `);
+}
+
+function createCompactionSchema(db: SQLiteDatabase): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS compactions (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+      first_kept_seq INTEGER NOT NULL,
+      summary TEXT NOT NULL,
+      tokens_before INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT NOT NULL
+    ) STRICT;
+
+    CREATE INDEX IF NOT EXISTS idx_compactions_session_created
+      ON compactions(session_id, created_at DESC);
+  `);
+}

package/src/storage/session-dir.ts

@@ -0,0 +1,37 @@
+/**
+ * B-3: Sibling on-disk audit/staging directory for a session.
+ *
+ * This is NOT the session store.  Sessions remain SQLite ROWS in muonroi.db
+ * via SessionStore (src/storage/sessions.ts).  This sibling directory holds
+ * crash-recovery artifacts only:
+ *   • pending_calls.jsonl  — in-flight tool call log (see orchestrator/pending-calls.ts)
+ *   • *.tmp files          — staged partial writes before atomic rename
+ *
+ * Keeping this module isolated (no bun:sqlite imports) allows it to be loaded
+ * safely in Vitest (Node) test environments.
+ *
+ * Path: <home>/.muonroi-cli/sessions/<sessionId>/
+ *   or  <homeOverride>/sessions/<sessionId>/   (used in tests via MUONROI_CLI_HOME)
+ */
+
+import { promises as fs } from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+/**
+ * Returns the sibling on-disk directory for a session — used as an audit log
+ * and .tmp staging area (pending_calls.jsonl, partial-write .tmp files).
+ *
+ * Creates the directory on demand (idempotent via mkdir recursive).
+ *
+ * @param sessionId      The session identifier (from SessionStore).
+ * @param homeOverride   Optional override for the home base directory.
+ *                       Falls back to MUONROI_CLI_HOME env var, then
+ *                       ~/.muonroi-cli.
+ */
+export async function getSessionDir(sessionId: string, homeOverride?: string): Promise<string> {
+  const home = homeOverride ?? process.env.MUONROI_CLI_HOME ?? path.join(os.homedir(), ".muonroi-cli");
+  const dir = path.join(home, "sessions", sessionId);
+  await fs.mkdir(dir, { recursive: true });
+  return dir;
+}

package/src/storage/sessions.ts

@@ -0,0 +1,178 @@
+import { randomUUID } from "crypto";
+import type { AgentMode, SessionInfo, SessionStatus, WorkspaceInfo } from "../types/index";
+import { getDatabase } from "./db";
+import { ensureWorkspace } from "./workspaces";
+
+interface SessionRow {
+  id: string;
+  workspace_id: string;
+  title: string | null;
+  model: string;
+  mode: AgentMode;
+  cwd_at_start: string;
+  cwd_last: string;
+  status: SessionStatus;
+  created_at: string;
+  updated_at: string;
+}
+
+export class SessionStore {
+  private readonly workspace: WorkspaceInfo;
+
+  constructor(cwd: string) {
+    this.workspace = ensureWorkspace(cwd);
+  }
+
+  getWorkspace(): WorkspaceInfo {
+    return this.workspace;
+  }
+
+  openSession(selector: string | undefined, model: string, mode: AgentMode, cwd: string): SessionInfo {
+    if (!selector) {
+      return this.createSession(model, mode, cwd);
+    }
+
+    if (selector === "latest") {
+      const latest = this.getLatestSession();
+      return latest ?? this.createSession(model, mode, cwd);
+    }
+
+    const session = this.getSessionById(selector);
+    if (!session) {
+      throw new Error(`Session "${selector}" was not found.`);
+    }
+
+    this.touchSession(session.id, cwd);
+    return this.getRequiredSession(session.id);
+  }
+
+  createSession(model: string, mode: AgentMode, cwd: string): SessionInfo {
+    const now = new Date().toISOString();
+    const id = createSessionId();
+    const db = getDatabase();
+
+    db.prepare(`
+      INSERT INTO sessions (
+        id, workspace_id, title, model, mode, cwd_at_start, cwd_last, status, created_at, updated_at
+      ) VALUES (
+        @id, @workspace_id, NULL, @model, @mode, @cwd_at_start, @cwd_last, 'active', @created_at, @updated_at
+      )
+    `).run({
+      id,
+      workspace_id: this.workspace.id,
+      model,
+      mode,
+      cwd_at_start: cwd,
+      cwd_last: cwd,
+      created_at: now,
+      updated_at: now,
+    });
+
+    return this.getRequiredSession(id);
+  }
+
+  getLatestSession(): SessionInfo | null {
+    const row = getDatabase()
+      .prepare(`
+      SELECT id, workspace_id, title, model, mode, cwd_at_start, cwd_last, status, created_at, updated_at
+      FROM sessions
+      WHERE workspace_id = ?
+      ORDER BY updated_at DESC
+      LIMIT 1
+    `)
+      .get(this.workspace.id) as SessionRow | undefined;
+
+    return row ? toSessionInfo(row) : null;
+  }
+
+  getSessionById(id: string): SessionInfo | null {
+    const row = getDatabase()
+      .prepare(`
+      SELECT id, workspace_id, title, model, mode, cwd_at_start, cwd_last, status, created_at, updated_at
+      FROM sessions
+      WHERE id = ?
+    `)
+      .get(id) as SessionRow | undefined;
+
+    return row ? toSessionInfo(row) : null;
+  }
+
+  getRequiredSession(id: string): SessionInfo {
+    const session = this.getSessionById(id);
+    if (!session) {
+      throw new Error(`Session "${id}" was not found.`);
+    }
+    return session;
+  }
+
+  setTitle(id: string, title: string | null): void {
+    const now = new Date().toISOString();
+    getDatabase()
+      .prepare(`
+      UPDATE sessions
+      SET title = ?, updated_at = ?
+      WHERE id = ?
+    `)
+      .run(title, now, id);
+  }
+
+  setModel(id: string, model: string): void {
+    const now = new Date().toISOString();
+    getDatabase()
+      .prepare(`
+      UPDATE sessions
+      SET model = ?, updated_at = ?
+      WHERE id = ?
+    `)
+      .run(model, now, id);
+  }
+
+  setMode(id: string, mode: AgentMode): void {
+    const now = new Date().toISOString();
+    getDatabase()
+      .prepare(`
+      UPDATE sessions
+      SET mode = ?, updated_at = ?
+      WHERE id = ?
+    `)
+      .run(mode, now, id);
+  }
+
+  touchSession(id: string, cwd: string): void {
+    getDatabase()
+      .prepare(`
+      UPDATE sessions
+      SET cwd_last = ?, updated_at = ?
+      WHERE id = ?
+    `)
+      .run(cwd, new Date().toISOString(), id);
+  }
+}
+
+function createSessionId(): string {
+  return randomUUID().replace(/-/g, "").slice(0, 12);
+}
+
+function toSessionInfo(row: SessionRow): SessionInfo {
+  return {
+    id: row.id,
+    workspaceId: row.workspace_id,
+    title: row.title,
+    model: row.model,
+    mode: row.mode,
+    cwdAtStart: row.cwd_at_start,
+    cwdLast: row.cwd_last,
+    status: row.status,
+    createdAt: new Date(row.created_at),
+    updatedAt: new Date(row.updated_at),
+  };
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// B-3: Re-export getSessionDir from the isolated session-dir module.
+//
+// getSessionDir is kept in a separate file (no bun:sqlite import) so it can be
+// safely loaded in Vitest (Node) test environments without pulling in bun:sqlite.
+// ─────────────────────────────────────────────────────────────────────────────
+
+export { getSessionDir } from "./session-dir.js";