muonroi-cli 1.8.4 → 1.9.0

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;