muonroi-cli 1.8.4 → 1.8.5

package/dist/src/self-qa/agentic-loop.js

@@ -148,8 +148,8 @@ export async function createLLMBrain(opts) {
     const retryOnEmpty = opts.retryOnEmpty !== false;
     // @ai-sdk/openai-compatible's chat schema exposes `strictJsonSchema: false`
     // for providers that don't honour OpenAI's strict JSON schema mode.
-    // DeepSeek (and DeepSeek-compatible providers like SiliconFlow) only
-    // support `response_format: {type: "json_object"}` — they reject the full
+    // DeepSeek only supports `response_format: {type: "json_object"}` — it
+    // rejects the full
     // schema response_format. Setting strictJsonSchema=false makes AI SDK fall
     // back to lenient json_object mode silently (no "responseFormat not
     // supported" warning) while still steering the model toward JSON output.
@@ -161,7 +161,7 @@ export async function createLLMBrain(opts) {
     const mergedProviderOptions = {
         ...(runtime.providerOptions ?? {}),
     };
-    if (provider === "deepseek" || provider === "siliconflow") {
+    if (provider === "deepseek") {
         mergedProviderOptions[provider] = {
             ...(mergedProviderOptions[provider] ?? {}),
             strictJsonSchema: false,

package/dist/src/{ui/state → state}/active-run.d.ts

@@ -21,6 +21,25 @@ export declare const activeRunStore: {
     clearActiveRun: () => void;
     subscribe: (fn: Listener) => (() => void);
 };
+/**
+ * Single canonical writer for "which run is the workspace focused on".
+ * Writes the durable pointer (`state.md` `Active Run`) AND the in-memory cache
+ * atomically, so disk and StatusBar/reporter never drift (F8 follow-up).
+ *
+ * The disk write is idempotent with `ensureRunScoped`'s earlier write for the
+ * same runId — routing the focus moment through here just guarantees they agree.
+ */
+export declare function setWorkspaceFocus(flowDir: string, focus: {
+    runId: string;
+    productSlug: string;
+    reason?: string;
+}): Promise<void>;
+/**
+ * Clear the workspace focus cache when a run ends (shipped / halted).
+ * Cache-only by design: the durable `Active Run` pointer is left intact as a
+ * historical marker so `/ideal phases` still resolves the last run post-ship.
+ */
+export declare function clearWorkspaceFocus(): void;
 /** Test helper: reset to initial state. */
 export declare function __resetActiveRunStoreForTests(): void;
 export {};

package/dist/src/{ui/state → state}/active-run.js

@@ -37,6 +37,27 @@ function makeActiveRunStore() {
     };
 }
 export const activeRunStore = makeActiveRunStore();
+/**
+ * Single canonical writer for "which run is the workspace focused on".
+ * Writes the durable pointer (`state.md` `Active Run`) AND the in-memory cache
+ * atomically, so disk and StatusBar/reporter never drift (F8 follow-up).
+ *
+ * The disk write is idempotent with `ensureRunScoped`'s earlier write for the
+ * same runId — routing the focus moment through here just guarantees they agree.
+ */
+export async function setWorkspaceFocus(flowDir, focus) {
+    const { setActiveRunId } = await import("../flow/run-manager.js");
+    await setActiveRunId(flowDir, focus.runId);
+    activeRunStore.setActiveRun(focus.runId, flowDir, focus.productSlug);
+}
+/**
+ * Clear the workspace focus cache when a run ends (shipped / halted).
+ * Cache-only by design: the durable `Active Run` pointer is left intact as a
+ * historical marker so `/ideal phases` still resolves the last run post-ship.
+ */
+export function clearWorkspaceFocus() {
+    activeRunStore.clearActiveRun();
+}
 /** Test helper: reset to initial state. */
 export function __resetActiveRunStoreForTests() {
     activeRunStore.clearActiveRun();

package/dist/src/{ui/status-bar/store.d.ts → state/status-bar-store.d.ts}

@@ -1,9 +1,12 @@
 /**
- * src/ui/status-bar/store.ts
+ * src/state/status-bar-store.ts
  *
  * Status bar store: subscribable atom holding model/provider/tier/tokens/USD/degraded.
  * wireStatusBar() connects to routerStore (Plan 03), subscribeThresholds (Plan 04),
  * and subscribeDowngrade (Plan 05).
+ *
+ * Presentation-agnostic state — lives outside src/ui so the headless core
+ * (orchestrator/tool-engine/stream-runner) can read it without importing ui/.
  */
 export interface SprintProgressSegment {
     /** Active sprint index (1-based). */

package/dist/src/{ui/status-bar/store.js → state/status-bar-store.js}

@@ -1,15 +1,18 @@
 /**
- * src/ui/status-bar/store.ts
+ * src/state/status-bar-store.ts
  *
  * Status bar store: subscribable atom holding model/provider/tier/tokens/USD/degraded.
  * wireStatusBar() connects to routerStore (Plan 03), subscribeThresholds (Plan 04),
  * and subscribeDowngrade (Plan 05).
+ *
+ * Presentation-agnostic state — lives outside src/ui so the headless core
+ * (orchestrator/tool-engine/stream-runner) can read it without importing ui/.
  */
-import { getCircuitState } from "../../ee/client.js";
-import { routerStore } from "../../router/store.js";
-import { subscribeDowngrade } from "../../usage/downgrade.js";
-import { subscribeThresholds } from "../../usage/thresholds.js";
-import { activeRunStore } from "../state/active-run.js";
+import { getCircuitState } from "../ee/client.js";
+import { routerStore } from "../router/store.js";
+import { subscribeDowngrade } from "../usage/downgrade.js";
+import { subscribeThresholds } from "../usage/thresholds.js";
+import { activeRunStore } from "./active-run.js";
 function makeStore() {
     let state = {
         provider: "",
@@ -141,8 +144,8 @@ export function wireStatusBar() {
         }
         try {
             // Lazy import to avoid circular dependency at module load time.
-            const { readBacklog } = await import("../../product-loop/backlog-store.js");
-            const { readSprintPlan } = await import("../../product-loop/sprint-store.js");
+            const { readBacklog } = await import("../product-loop/backlog-store.js");
+            const { readSprintPlan } = await import("../product-loop/sprint-store.js");
             const [backlog, sprintPlan] = await Promise.all([
                 readBacklog(run.flowDir, run.runId).catch(() => null),
                 readSprintPlan(run.flowDir, run.runId).catch(() => null),
@@ -276,4 +279,4 @@ export function __resetStatusBarStoreForTests() {
     });
     wired = false;
 }
-//# sourceMappingURL=store.js.map
+//# sourceMappingURL=status-bar-store.js.map

package/dist/src/state/turn-trace.d.ts

@@ -0,0 +1,43 @@
+/**
+ * src/state/turn-trace.ts
+ *
+ * Pipeline debug-trace state — the toggle flag + recorded per-turn traces.
+ *
+ * Presentation-agnostic: the headless core (tool-engine, message-processor)
+ * records traces here without importing src/ui. The /debug slash command
+ * (src/ui/slash/debug.ts) owns the human formatting and toggling on top of
+ * this state.
+ */
+export interface PipelineStep {
+    name: string;
+    duration_ms: number;
+    input_summary: string;
+    output_summary: string;
+    tokens_saved?: number;
+}
+export interface TurnTrace {
+    turn_id: number;
+    timestamp: number;
+    raw_prompt: string;
+    steps: PipelineStep[];
+    model_requested: string;
+    model_used: string;
+    routed: boolean;
+    input_tokens: number;
+    output_tokens: number;
+    cache_read_tokens: number;
+    cost_usd: number;
+    estimated_savings: SavingsEstimate;
+}
+export interface SavingsEstimate {
+    pil_tokens_saved: number;
+    cache_tokens_saved: number;
+    router_cost_saved_usd: number;
+    total_tokens_saved: number;
+    total_cost_saved_usd: number;
+}
+export declare function isDebugEnabled(): boolean;
+export declare function setDebugEnabled(value: boolean): void;
+export declare function recordTurnTrace(trace: TurnTrace): void;
+export declare function getLastTrace(): TurnTrace | null;
+export declare function getAllTraces(): readonly TurnTrace[];

package/dist/src/state/turn-trace.js

@@ -0,0 +1,32 @@
+/**
+ * src/state/turn-trace.ts
+ *
+ * Pipeline debug-trace state — the toggle flag + recorded per-turn traces.
+ *
+ * Presentation-agnostic: the headless core (tool-engine, message-processor)
+ * records traces here without importing src/ui. The /debug slash command
+ * (src/ui/slash/debug.ts) owns the human formatting and toggling on top of
+ * this state.
+ */
+let debugEnabled = false;
+const turnTraces = [];
+export function isDebugEnabled() {
+    return debugEnabled;
+}
+export function setDebugEnabled(value) {
+    debugEnabled = value;
+}
+export function recordTurnTrace(trace) {
+    if (!debugEnabled)
+        return;
+    turnTraces.push(trace);
+    if (turnTraces.length > 50)
+        turnTraces.shift();
+}
+export function getLastTrace() {
+    return turnTraces[turnTraces.length - 1] ?? null;
+}
+export function getAllTraces() {
+    return turnTraces;
+}
+//# sourceMappingURL=turn-trace.js.map

package/dist/src/storage/db.js

@@ -9,7 +9,8 @@ let db = null;
 // async would be a much larger refactor.
 const requireSync = createRequire(import.meta.url);
 export function getDatabasePath() {
-    const dir = path.join(os.homedir(), ".muonroi-cli");
+    const home = process.env.HOME ?? process.env.USERPROFILE ?? os.homedir();
+    const dir = path.join(home, ".muonroi-cli");
     fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
     return path.join(dir, "muonroi.db");
 }

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

@@ -3,7 +3,7 @@ export { loadConfig, type MuonroiConfig } from "./config.js";
 export { getDatabasePath } from "./db.js";
 export { type InteractionEventType, logInteraction } from "./interaction-log.js";
 export { SessionStore } from "./sessions.js";
-export { appendCompaction, appendMessages, appendSystemMessage, buildChatEntries, getLastTodoWriteArgs, getNextMessageSequence, getSessionChain, loadLatestCompaction, loadRawTranscript, loadTranscript, loadTranscriptState, markMessageCompleted, markMessageErrored, markToolCallErrored, persistMessageWriteAhead, persistToolCallWriteAhead, revertLatestCompaction, } from "./transcript.js";
+export { appendCompaction, appendMessages, appendSystemMessage, buildChatEntries, getLastApprovedPlan, getLastTodoWriteArgs, getNextMessageSequence, getSessionChain, getSessionChainInfos, loadLatestCompaction, loadRawTranscript, loadSessionChainTranscriptState, loadTranscript, loadTranscriptState, markMessageCompleted, markMessageErrored, markToolCallErrored, persistApprovedPlan, persistMessageWriteAhead, persistToolCallWriteAhead, revertLatestCompaction, type SessionChainNode, } from "./transcript.js";
 export { buildEffectiveTranscript, type LoadedTranscriptState, type PersistedCompaction } from "./transcript-view.js";
 export { logUIInteraction, type UIInteractionSubtype } from "./ui-interaction-log.js";
 export { getSessionTotalTokens, listSessionUsage, recordUsageEvent, type TokenUsageLike } from "./usage.js";

package/dist/src/storage/index.js

@@ -4,7 +4,7 @@ export { loadConfig } from "./config.js";
 export { getDatabasePath } from "./db.js";
 export { logInteraction } from "./interaction-log.js";
 export { SessionStore } from "./sessions.js";
-export { appendCompaction, appendMessages, appendSystemMessage, buildChatEntries, getLastTodoWriteArgs, getNextMessageSequence, getSessionChain, loadLatestCompaction, loadRawTranscript, loadTranscript, loadTranscriptState, markMessageCompleted, markMessageErrored, markToolCallErrored, persistMessageWriteAhead, persistToolCallWriteAhead, revertLatestCompaction, } from "./transcript.js";
+export { appendCompaction, appendMessages, appendSystemMessage, buildChatEntries, getLastApprovedPlan, getLastTodoWriteArgs, getNextMessageSequence, getSessionChain, getSessionChainInfos, loadLatestCompaction, loadRawTranscript, loadSessionChainTranscriptState, loadTranscript, loadTranscriptState, markMessageCompleted, markMessageErrored, markToolCallErrored, persistApprovedPlan, persistMessageWriteAhead, persistToolCallWriteAhead, revertLatestCompaction, } from "./transcript.js";
 export { buildEffectiveTranscript } from "./transcript-view.js";
 export { logUIInteraction } from "./ui-interaction-log.js";
 export { getSessionTotalTokens, listSessionUsage, recordUsageEvent } from "./usage.js";

package/dist/src/storage/interaction-log.d.ts

@@ -4,7 +4,7 @@
  * Fire-and-forget interaction logging for detailed user-agent event tracking.
  * All calls are fail-open — logging never breaks the main flow.
  */
-export type InteractionEventType = "user_message" | "agent_response" | "tool_call" | "tool_result" | "compaction" | "routing" | "pil" | "error" | "model_switch" | "council" | "ee_intercept" | "ee_judge" | "ee_injection" | "ui_interaction" | "stream_retry" | "f6_synthesis" | "grounding_flag" | "stall_rescue" | "stream_start" | "text_tool_resteer" | "session_experience";
+export type InteractionEventType = "user_message" | "agent_response" | "tool_call" | "tool_result" | "compaction" | "routing" | "pil" | "error" | "model_switch" | "council" | "ee_intercept" | "ee_judge" | "ee_injection" | "ui_interaction" | "stream_retry" | "f6_synthesis" | "grounding_flag" | "stall_rescue" | "stream_start" | "text_tool_resteer" | "turn_tool_load" | "session_experience";
 export interface EEInjectionRow {
     session_id: string;
     event_subtype: string | null;

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)
@@ -96,9 +96,79 @@ 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 (

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

@@ -45,9 +45,9 @@ export class SessionStore {
         const db = getDatabase();
         db.prepare(`
       INSERT INTO sessions (
-        id, workspace_id, title, model, mode, cwd_at_start, cwd_last, status, created_at, updated_at
+        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
+        @id, @workspace_id, NULL, @model, @mode, @cwd_at_start, @cwd_last, 'active', @created_at, @updated_at, 'conversation', @id
       )
     `).run({
             id,
@@ -62,27 +62,19 @@ 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()
@@ -106,6 +98,16 @@ export class SessionStore {
             .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) {
@@ -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") {

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

@@ -5,6 +5,45 @@ export declare function loadLatestCompaction(sessionId: string): PersistedCompac
 export declare function loadRawTranscript(sessionId: string): ModelMessage[];
 export declare function loadTranscriptState(sessionId: string): LoadedTranscriptState;
 export declare function loadTranscript(sessionId: string): ModelMessage[];
+/**
+ * Resume a session together with every session in its conversation tree.
+ *
+ * When a session has spawned child sessions (silent rotations, sub-agents,
+ * sub-sessions), resuming only the parent loses the work that happened in the
+ * children. This loader walks up to the root and then down through all
+ * descendants, applies each session's own compaction, merges the messages
+ * chronologically, and returns them as one flat transcript for the model.
+ *
+ * Sequence numbers from sessions other than the one being resumed are replaced
+ * with `null` so that usage attribution and compaction still belong to the
+ * resumed session.
+ */
+export declare function loadSessionChainTranscriptState(sessionId: string): LoadedTranscriptState;
+/**
+ * One node of the session tree that a single resumed TUI hosts: the root
+ * conversation plus every rotation / sub-agent descendant. Powers the rail's
+ * "Sessions" block so the multi-session structure is visible after resume
+ * (the message content is already merged by loadSessionChainTranscriptState;
+ * this exposes WHICH sessions produced it).
+ */
+export interface SessionChainNode {
+    id: string;
+    kind: "conversation" | "rotation" | "subagent" | null;
+    model: string | null;
+    status: string | null;
+    messageCount: number;
+    parentId: string | null;
+    /** Tree depth: 0 = root, 1 = direct child, … (for indented rendering). */
+    depth: number;
+    /** True for the node whose id was passed to resume (the "current" session). */
+    isCurrent: boolean;
+}
+/**
+ * Enumerate the full session chain (root + all descendants) with per-session
+ * metadata, ordered root-first then by creation time. Read-only; safe to call
+ * on every render. Returns a single-node array for a session with no children.
+ */
+export declare function getSessionChainInfos(sessionId: string): SessionChainNode[];
 export declare function getNextMessageSequence(sessionId: string): number;
 export declare function appendMessages(sessionId: string, messages: ModelMessage[]): number[];
 export declare function appendSystemMessage(sessionId: string, content: string): number | null;
@@ -108,3 +147,15 @@ export declare function revertLatestCompaction(sessionId: string): void;
 export declare function getSessionChain(sessionId: string): string[];
 export declare function buildChatEntries(sessionId: string): ChatEntry[];
 export declare function getLastTodoWriteArgs(sessionId: string): string | null;
+/**
+ * Persist the approved plan text for a session so that "tiếp tục"/"continue"
+ * turns (which are classified as chitchat/general by PIL Pass 0) can re-inject
+ * the APPROVED PLAN section into the system prompt instead of forgetting context.
+ *
+ * Stored as a synthetic tool_call row (tool_name='__approved_plan') so we reuse
+ * the existing schema and getLast* query pattern without a new table/migration.
+ * The planText is stored verbatim in args_json.
+ */
+export declare function persistApprovedPlan(sessionId: string, planText: string): void;
+/** Load the most recent persisted approved plan for this session (or parent chain). */
+export declare function getLastApprovedPlan(sessionId: string): string | null;