muonroi-cli 1.8.3 → 1.8.5

package/dist/src/storage/migrations.js

@@ -1,4 +1,4 @@
-const LATEST_DB_VERSION = 8;
+const LATEST_DB_VERSION = 10;
 export function applyMigrations(db) {
     const version = Number(db.pragma("user_version", { simple: true })) || 0;
     if (version >= LATEST_DB_VERSION)
@@ -13,9 +13,9 @@ export function applyMigrations(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.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");
         }
@@ -34,24 +34,24 @@ export function applyMigrations(db) {
             db.pragma("user_version = 4");
         }
         if (version < 5) {
-            db.exec(`
-        CREATE TABLE IF NOT EXISTS interaction_logs (
-          id INTEGER PRIMARY KEY AUTOINCREMENT,
-          session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
-          event_type TEXT NOT NULL,
-          event_subtype TEXT,
-          model TEXT,
-          duration_ms INTEGER,
-          input_tokens INTEGER,
-          output_tokens INTEGER,
-          metadata_json TEXT,
-          created_at TEXT NOT NULL
-        ) STRICT;
-
-        CREATE INDEX IF NOT EXISTS idx_interaction_logs_session
-          ON interaction_logs(session_id, created_at DESC);
-        CREATE INDEX IF NOT EXISTS idx_interaction_logs_event_type
-          ON interaction_logs(event_type, created_at DESC);
+            db.exec(`
+        CREATE TABLE IF NOT EXISTS interaction_logs (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+          event_type TEXT NOT NULL,
+          event_subtype TEXT,
+          model TEXT,
+          duration_ms INTEGER,
+          input_tokens INTEGER,
+          output_tokens INTEGER,
+          metadata_json TEXT,
+          created_at TEXT NOT NULL
+        ) STRICT;
+
+        CREATE INDEX IF NOT EXISTS idx_interaction_logs_session
+          ON interaction_logs(session_id, created_at DESC);
+        CREATE INDEX IF NOT EXISTS idx_interaction_logs_event_type
+          ON interaction_logs(event_type, created_at DESC);
       `);
             db.pragma("user_version = 5");
         }
@@ -96,117 +96,187 @@ export function applyMigrations(db) {
             db.exec("CREATE INDEX IF NOT EXISTS idx_sessions_parent_id ON sessions(parent_session_id)");
             db.pragma("user_version = 8");
         }
+        if (version < 9) {
+            db.exec(`
+        CREATE VIRTUAL TABLE IF NOT EXISTS session_history_fts USING fts5(
+          session_id UNINDEXED,
+          seq UNINDEXED,
+          role UNINDEXED,
+          tool_name UNINDEXED,
+          content,
+          tool_args,
+          tool_output
+        );
+
+        CREATE TRIGGER IF NOT EXISTS t_sessions_delete_fts
+        AFTER DELETE ON sessions
+        BEGIN
+          DELETE FROM session_history_fts WHERE session_id = old.id;
+        END;
+      `);
+            db.pragma("user_version = 9");
+        }
+        if (version < 10) {
+            // Thread-aware resume. The resume picker groups sessions by conversation
+            // tree; `kind` distinguishes the two kinds of child (both previously only
+            // set parent_session_id, indistinguishable) and `root_session_id`
+            // denormalizes the tree root so the picker groups without a recursive CTE.
+            const cols = db.prepare("PRAGMA table_info(sessions)").all();
+            const colNames = new Set(cols.map((c) => c.name));
+            if (!colNames.has("kind")) {
+                db.exec("ALTER TABLE sessions ADD COLUMN kind TEXT NOT NULL DEFAULT 'conversation'");
+            }
+            if (!colNames.has("root_session_id")) {
+                db.exec("ALTER TABLE sessions ADD COLUMN root_session_id TEXT");
+            }
+            db.exec("CREATE INDEX IF NOT EXISTS idx_sessions_root ON sessions(workspace_id, root_session_id)");
+            backfillSessionTrees(db);
+            db.pragma("user_version = 10");
+        }
     });
     migrate();
 }
+/**
+ * Backfill kind + root_session_id for pre-v10 rows.
+ *
+ * - Rows with no parent become their own root (kind 'conversation').
+ * - Rows WITH a parent are marked 'rotation' — historical data cannot tell
+ *   rotation apart from sub-agent spawns, and marking them 'rotation' collapses
+ *   them under their root rather than risking hiding a real conversation.
+ * - root_session_id propagates down the parent chain via a bounded fixpoint
+ *   loop (chains are shallow; the bound also guards against FK cycles).
+ */
+function backfillSessionTrees(db) {
+    // Roots: own id, keep default kind 'conversation'.
+    db.exec("UPDATE sessions SET root_session_id = id WHERE parent_session_id IS NULL AND root_session_id IS NULL");
+    // Children of a real parent → rotation (default kind was 'conversation').
+    db.exec("UPDATE sessions SET kind = 'rotation' WHERE parent_session_id IS NOT NULL");
+    // Propagate root down the chain until no row changes (bounded to 100 passes).
+    for (let i = 0; i < 100; i++) {
+        db.exec(`
+      UPDATE sessions
+      SET root_session_id = (SELECT p.root_session_id FROM sessions p WHERE p.id = sessions.parent_session_id)
+      WHERE root_session_id IS NULL
+        AND parent_session_id IS NOT NULL
+        AND (SELECT p.root_session_id FROM sessions p WHERE p.id = sessions.parent_session_id) IS NOT NULL
+    `);
+        const remaining = db
+            .prepare("SELECT COUNT(*) AS c FROM sessions WHERE root_session_id IS NULL AND parent_session_id IS NOT NULL")
+            .get();
+        if (!remaining || remaining.c === 0)
+            break;
+    }
+    // Any leftover (orphaned/cyclic parent chains) → treat as its own root.
+    db.exec("UPDATE sessions SET root_session_id = id WHERE root_session_id IS NULL");
+}
 function createInitialSchema(db) {
-    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,
-      parent_session_id TEXT REFERENCES sessions(id) ON DELETE SET NULL,
-      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,
-      status TEXT,
-      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_sessions_parent_id
-      ON sessions(parent_session_id);
-    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);
+    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,
+      parent_session_id TEXT REFERENCES sessions(id) ON DELETE SET NULL,
+      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,
+      status TEXT,
+      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_sessions_parent_id
+      ON sessions(parent_session_id);
+    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) {
-    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);
+    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);
   `);
 }
 //# sourceMappingURL=migrations.js.map

package/dist/src/storage/session-experience-store.js

@@ -70,8 +70,8 @@ function parseCounts(json) {
 export function selectSessionExperience(sessionId) {
     try {
         const row = getDatabase()
-            .prepare(`SELECT metadata_json FROM interaction_logs
-         WHERE session_id = ? AND event_type = ?
+            .prepare(`SELECT metadata_json FROM interaction_logs
+         WHERE session_id = ? AND event_type = ?
          ORDER BY created_at DESC, id DESC LIMIT 1`)
             .get(sessionId, EVENT_TYPE);
         return parseCounts(row?.metadata_json ?? null);
@@ -150,8 +150,8 @@ export function computeExperienceAggregate(rows, limit = 100) {
 export function aggregateSessionExperience(limit = 100) {
     try {
         const rows = getDatabase()
-            .prepare(`SELECT session_id, metadata_json, created_at FROM interaction_logs
-         WHERE event_type = ?
+            .prepare(`SELECT session_id, metadata_json, created_at FROM interaction_logs
+         WHERE event_type = ?
          ORDER BY created_at DESC, id DESC`)
             .all(EVENT_TYPE);
         return computeExperienceAggregate(rows, limit);

package/dist/src/storage/sessions.d.ts

@@ -1,4 +1,5 @@
-import type { AgentMode, SessionInfo, SessionStatus, WorkspaceInfo } from "../types/index.js";
+import type { AgentMode, ResumeEntry, SessionInfo, SessionKind, SessionStatus, WorkspaceInfo } from "../types/index.js";
+import { type SQLiteDatabase } from "./db.js";
 export declare class SessionStore {
     private readonly workspace;
     constructor(cwd: string);
@@ -6,18 +7,22 @@ export declare class SessionStore {
     openSession(selector: string | undefined, model: string, mode: AgentMode, cwd: string): SessionInfo;
     createSession(model: string, mode: AgentMode, cwd: string): SessionInfo;
     /**
-     * List recent sessions in this workspace (most recently updated first).
-     * Used by the `/sessions` slash command for resume picking.
-     *
-     * Only sessions that actually have a persisted message are returned. Every
-     * CLI launch WITHOUT `--session` opens a fresh empty session, and test /
-     * harness runs leave behind title-only stubs — without this filter the picker
-     * fills with empty rows that resume to a blank screen, so a user picking one
-     * thinks resume is broken.
+     * Link a freshly-created session as a child of `parentId`, tagging its `kind`
+     * and inheriting the parent's `root_session_id` so the whole tree shares one
+     * root. Replaces the ad-hoc `UPDATE sessions SET parent_session_id = ?` the
+     * orchestrator previously hand-wrote (which never set kind/root).
      */
-    listRecentSessions(limit?: number): SessionInfo[];
+    linkChild(childId: string, parentId: string, kind: SessionKind): void;
+    listRecentSessions(limit?: number): ResumeEntry[];
     getLatestSession(): SessionInfo | null;
     getSessionById(id: string): SessionInfo | null;
+    /**
+     * Authoritative session kind ("conversation" | "rotation" | "subagent").
+     * SessionInfo omits `kind`, so callers that need to know whether a session is
+     * a forked child (e.g. the turn_tool_load instrument) read it here. Returns
+     * null when the session row is absent.
+     */
+    getSessionKind(id: string): SessionKind | null;
     getRequiredSession(id: string): SessionInfo;
     setStatus(id: string, status: SessionStatus): void;
     setTitle(id: string, title: string | null): void;
@@ -25,4 +30,17 @@ export declare class SessionStore {
     setMode(id: string, mode: AgentMode): void;
     touchSession(id: string, cwd: string): void;
 }
+/**
+ * One row per conversation tree for the `/sessions` resume picker.
+ *
+ * - Groups by `root_session_id`; sub-agent sessions (`kind='subagent'`) are
+ *   internal side-conversations and are excluded entirely.
+ * - Only trees with at least one persisted message surface (hides empty stub
+ *   rows every keyless CLI launch creates).
+ * - The row's `title`/`created_at` come from the tree ROOT; `resume_id`,
+ *   `model`, `updated_at`, `status` come from the LATEST leaf (the active tail
+ *   of a rotation chain), so Enter resumes into the live session, not the
+ *   compacted root. Ordered by tree activity, newest first.
+ */
+export declare function queryResumeList(db: SQLiteDatabase, workspaceId: string, limit: number): ResumeEntry[];
 export { getSessionDir } from "./session-dir.js";

package/dist/src/storage/sessions.js

@@ -43,12 +43,12 @@ export class SessionStore {
         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
-      )
+        db.prepare(`
+      INSERT INTO sessions (
+        id, workspace_id, title, model, mode, cwd_at_start, cwd_last, status, created_at, updated_at, kind, root_session_id
+      ) VALUES (
+        @id, @workspace_id, NULL, @model, @mode, @cwd_at_start, @cwd_last, 'active', @created_at, @updated_at, 'conversation', @id
+      )
     `).run({
             id,
             workspace_id: this.workspace.id,
@@ -62,50 +62,52 @@ export class SessionStore {
         return this.getRequiredSession(id);
     }
     /**
-     * List recent sessions in this workspace (most recently updated first).
-     * Used by the `/sessions` slash command for resume picking.
-     *
-     * Only sessions that actually have a persisted message are returned. Every
-     * CLI launch WITHOUT `--session` opens a fresh empty session, and test /
-     * harness runs leave behind title-only stubs — without this filter the picker
-     * fills with empty rows that resume to a blank screen, so a user picking one
-     * thinks resume is broken.
+     * Link a freshly-created session as a child of `parentId`, tagging its `kind`
+     * and inheriting the parent's `root_session_id` so the whole tree shares one
+     * root. Replaces the ad-hoc `UPDATE sessions SET parent_session_id = ?` the
+     * orchestrator previously hand-wrote (which never set kind/root).
      */
+    linkChild(childId, parentId, kind) {
+        const db = getDatabase();
+        const parent = db.prepare("SELECT root_session_id FROM sessions WHERE id = ?").get(parentId);
+        const root = parent?.root_session_id ?? parentId;
+        db.prepare("UPDATE sessions SET parent_session_id = ?, kind = ?, root_session_id = ?, updated_at = ? WHERE id = ?").run(parentId, kind, root, new Date().toISOString(), childId);
+    }
     listRecentSessions(limit = 20) {
-        const rows = getDatabase()
-            .prepare(`
-      SELECT s.id, s.workspace_id, s.title, s.model, s.mode, s.cwd_at_start, s.cwd_last, s.status, s.created_at, s.updated_at
-      FROM sessions s
-      WHERE s.workspace_id = ?
-        AND EXISTS (SELECT 1 FROM messages m WHERE m.session_id = s.id)
-      ORDER BY s.updated_at DESC
-      LIMIT ?
-    `)
-            .all(this.workspace.id, limit);
-        return rows.map(toSessionInfo);
+        return queryResumeList(getDatabase(), this.workspace.id, limit);
     }
     getLatestSession() {
         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
+            .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);
         return row ? toSessionInfo(row) : null;
     }
     getSessionById(id) {
         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 = ?
+            .prepare(`
+      SELECT id, workspace_id, title, model, mode, cwd_at_start, cwd_last, status, created_at, updated_at
+      FROM sessions
+      WHERE id = ?
     `)
             .get(id);
         return row ? toSessionInfo(row) : null;
     }
+    /**
+     * Authoritative session kind ("conversation" | "rotation" | "subagent").
+     * SessionInfo omits `kind`, so callers that need to know whether a session is
+     * a forked child (e.g. the turn_tool_load instrument) read it here. Returns
+     * null when the session row is absent.
+     */
+    getSessionKind(id) {
+        const row = getDatabase().prepare("SELECT kind FROM sessions WHERE id = ?").get(id);
+        return row?.kind ?? null;
+    }
     getRequiredSession(id) {
         const session = this.getSessionById(id);
         if (!session) {
@@ -116,49 +118,49 @@ export class SessionStore {
     setStatus(id, status) {
         const now = new Date().toISOString();
         getDatabase()
-            .prepare(`
-      UPDATE sessions
-      SET status = ?, updated_at = ?
-      WHERE id = ?
+            .prepare(`
+      UPDATE sessions
+      SET status = ?, updated_at = ?
+      WHERE id = ?
     `)
             .run(status, now, id);
     }
     setTitle(id, title) {
         const now = new Date().toISOString();
         getDatabase()
-            .prepare(`
-      UPDATE sessions
-      SET title = ?, updated_at = ?
-      WHERE id = ?
+            .prepare(`
+      UPDATE sessions
+      SET title = ?, updated_at = ?
+      WHERE id = ?
     `)
             .run(title, now, id);
     }
     setModel(id, model) {
         const now = new Date().toISOString();
         getDatabase()
-            .prepare(`
-      UPDATE sessions
-      SET model = ?, updated_at = ?
-      WHERE id = ?
+            .prepare(`
+      UPDATE sessions
+      SET model = ?, updated_at = ?
+      WHERE id = ?
     `)
             .run(model, now, id);
     }
     setMode(id, mode) {
         const now = new Date().toISOString();
         getDatabase()
-            .prepare(`
-      UPDATE sessions
-      SET mode = ?, updated_at = ?
-      WHERE id = ?
+            .prepare(`
+      UPDATE sessions
+      SET mode = ?, updated_at = ?
+      WHERE id = ?
     `)
             .run(mode, now, id);
     }
     touchSession(id, cwd) {
         getDatabase()
-            .prepare(`
-      UPDATE sessions
-      SET cwd_last = ?, updated_at = ?
-      WHERE id = ?
+            .prepare(`
+      UPDATE sessions
+      SET cwd_last = ?, updated_at = ?
+      WHERE id = ?
     `)
             .run(cwd, new Date().toISOString(), id);
     }
@@ -180,6 +182,61 @@ function toSessionInfo(row) {
         updatedAt: new Date(row.updated_at),
     };
 }
+/**
+ * One row per conversation tree for the `/sessions` resume picker.
+ *
+ * - Groups by `root_session_id`; sub-agent sessions (`kind='subagent'`) are
+ *   internal side-conversations and are excluded entirely.
+ * - Only trees with at least one persisted message surface (hides empty stub
+ *   rows every keyless CLI launch creates).
+ * - The row's `title`/`created_at` come from the tree ROOT; `resume_id`,
+ *   `model`, `updated_at`, `status` come from the LATEST leaf (the active tail
+ *   of a rotation chain), so Enter resumes into the live session, not the
+ *   compacted root. Ordered by tree activity, newest first.
+ */
+export function queryResumeList(db, workspaceId, limit) {
+    const rows = db
+        .prepare(`
+      WITH candidates AS (
+        SELECT s.id, s.workspace_id, s.title, s.model, s.mode, s.cwd_at_start,
+               s.cwd_last, s.status, s.created_at, s.updated_at, s.root_session_id
+        FROM sessions s
+        WHERE s.workspace_id = ?
+          AND s.kind != 'subagent'
+          AND EXISTS (SELECT 1 FROM messages m WHERE m.session_id = s.id)
+      ),
+      ranked AS (
+        SELECT c.*,
+               ROW_NUMBER() OVER (
+                 PARTITION BY c.root_session_id
+                 ORDER BY c.updated_at DESC, c.id DESC
+               ) AS rn
+        FROM candidates c
+      )
+      SELECT
+        r.root_session_id                          AS id,
+        r.id                                       AS resume_id,
+        COALESCE(root.title, r.title)              AS title,
+        r.model                                    AS model,
+        r.mode                                     AS mode,
+        COALESCE(root.cwd_at_start, r.cwd_at_start) AS cwd_at_start,
+        r.cwd_last                                 AS cwd_last,
+        r.status                                   AS status,
+        COALESCE(root.created_at, r.created_at)    AS created_at,
+        r.updated_at                               AS updated_at,
+        r.workspace_id                             AS workspace_id
+      FROM ranked r
+      LEFT JOIN sessions root ON root.id = r.root_session_id
+      WHERE r.rn = 1
+      ORDER BY r.updated_at DESC
+      LIMIT ?
+    `)
+        .all(workspaceId, limit);
+    return rows.map(toResumeEntry);
+}
+function toResumeEntry(row) {
+    return { ...toSessionInfo(row), resumeId: row.resume_id };
+}
 // ─────────────────────────────────────────────────────────────────────────────
 // B-3: Re-export getSessionDir from the isolated session-dir module.
 //

package/dist/src/storage/transcript-view.js

@@ -10,7 +10,7 @@ export function buildEffectiveTranscript(messages, seqs, timestamps, compaction)
     }
     const firstKeptIndex = seqs.findIndex((seq) => seq >= compaction.firstKeptSeq);
     let keptIndex = firstKeptIndex >= 0 ? firstKeptIndex : messages.length;
-    // Anti-mù / Resilience: if firstKeptSeq landed on a `tool` message (e.g. due to seq array 
+    // Anti-mù / Resilience: if firstKeptSeq landed on a `tool` message (e.g. due to seq array
     // misalignment or forced cut), we MUST step back to include its preceding `assistant` message.
     // Otherwise Vercel AI SDK throws: "Messages with role 'tool' must be a response to a preceding message with 'tool_calls'"
     if (keptIndex > 0 && messages[keptIndex]?.role === "tool") {