muonroi-cli 1.8.4 → 1.8.5

package/dist/src/storage/transcript.js

@@ -99,6 +99,119 @@ export function loadTranscriptState(sessionId) {
 export function loadTranscript(sessionId) {
     return loadTranscriptState(sessionId).messages;
 }
+/**
+ * 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 function loadSessionChainTranscriptState(sessionId) {
+    const chain = getSessionChain(sessionId);
+    if (chain.length <= 1) {
+        return loadTranscriptState(sessionId);
+    }
+    const records = [];
+    for (const sid of chain) {
+        const rows = loadMessageRows(sid);
+        const messages = rows.map((row) => JSON.parse(row.message_json));
+        const seqs = rows.map((row) => row.seq);
+        const timestamps = rows.map((row) => new Date(row.created_at));
+        const effective = buildEffectiveTranscript(messages, seqs, timestamps, loadLatestCompaction(sid));
+        for (let i = 0; i < effective.messages.length; i++) {
+            records.push({
+                sessionId: sid,
+                message: effective.messages[i],
+                seq: effective.seqs[i],
+                timestamp: effective.timestamps[i],
+            });
+        }
+    }
+    // getSessionChain already orders sessions by creation time. Preserve each
+    // session's internal effective-transcript order (especially compaction
+    // summaries, which must precede their kept tail) instead of re-sorting by
+    // individual message timestamps.
+    return {
+        messages: records.map((r) => r.message),
+        seqs: records.map((r) => (r.sessionId === sessionId ? r.seq : null)),
+        timestamps: records.map((r) => r.timestamp),
+        compaction: loadLatestCompaction(sessionId),
+    };
+}
+/**
+ * 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 function getSessionChainInfos(sessionId) {
+    const chain = getSessionChain(sessionId);
+    if (chain.length === 0)
+        return [];
+    const db = getDatabase();
+    const placeholders = chain.map(() => "?").join(",");
+    let rows = [];
+    try {
+        rows = db
+            .prepare(`
+        SELECT s.id, s.parent_session_id, s.kind, s.model, s.status, s.created_at,
+               (SELECT COUNT(*) FROM messages m WHERE m.session_id = s.id) AS msgs
+        FROM sessions s
+        WHERE s.id IN (${placeholders})
+      `)
+            .all(...chain);
+    }
+    catch (err) {
+        logger.error("storage", "getSessionChainInfos query failed", {
+            sessionId,
+            message: err?.message,
+        });
+        return [];
+    }
+    const byId = new Map(rows.map((r) => [r.id, r]));
+    const depthOf = (id) => {
+        let depth = 0;
+        let cur = id;
+        const seen = new Set();
+        while (cur && !seen.has(cur)) {
+            seen.add(cur);
+            const parent = byId.get(cur)?.parent_session_id ?? null;
+            // Only count parents that are inside this chain (the walk-up root has none).
+            if (parent && byId.has(parent)) {
+                depth++;
+                cur = parent;
+            }
+            else {
+                break;
+            }
+        }
+        return depth;
+    };
+    const nodes = chain
+        .map((id) => byId.get(id))
+        .filter((r) => r !== undefined)
+        .map((r) => ({
+        id: r.id,
+        kind: r.kind ?? null,
+        model: r.model,
+        status: r.status,
+        messageCount: r.msgs,
+        parentId: r.parent_session_id,
+        depth: depthOf(r.id),
+        isCurrent: r.id === sessionId,
+    }));
+    // Render order: shallowest first (root → children → grandchildren) so the rail
+    // always shows the parent on top with descendants indented under it. Ties keep
+    // getSessionChain's created_at order. A stable index-carrying sort — chain
+    // created_at can tie at second granularity, so depth is the deterministic key.
+    const chainIndex = new Map(nodes.map((n, i) => [n.id, i]));
+    return nodes.sort((a, b) => a.depth - b.depth || chainIndex.get(a.id) - chainIndex.get(b.id));
+}
 export function getNextMessageSequence(sessionId) {
     return getNextSequence(getDatabase(), sessionId);
 }
@@ -150,6 +263,7 @@ export function appendMessages(sessionId, messages) {
             const createdAt = new Date().toISOString();
             insertedSeqs.push(seq);
             insertMessage.run(sessionId, seq, message.role, JSON.stringify(message), createdAt);
+            indexMessageInFts(db, sessionId, seq, message.role, JSON.stringify(message));
             if (message.role === "assistant" && Array.isArray(message.content)) {
                 for (const part of message.content) {
                     if (part.type !== "tool-call")
@@ -212,9 +326,13 @@ export function persistToolCallWriteAhead(sessionId, messageSeq, toolCallId, too
       `)
             .run(sessionId, messageSeq, toolCallId, toolName, argsJson, now);
     }
-    catch {
-        // Fail-open: write-ahead is best-effort. The post-stream UPDATE path
-        // will still finalize the row from `appendMessages(...)`.
+    catch (err) {
+        logger.error("storage", `[transcript] persistToolCallWriteAhead failed: ${err.message}`, {
+            sessionId,
+            messageSeq,
+            toolCallId,
+            toolName,
+        });
     }
 }
 /**
@@ -253,16 +371,20 @@ export function persistToolCallWriteAhead(sessionId, messageSeq, toolCallId, too
 export function persistMessageWriteAhead(sessionId, seq, role, messageJson) {
     const now = new Date().toISOString();
     try {
-        getDatabase()
-            .prepare(`
+        const db = getDatabase();
+        db.prepare(`
         INSERT OR IGNORE INTO messages (
           session_id, seq, role, message_json, created_at, status
         ) VALUES (?, ?, ?, ?, ?, 'pending')
-      `)
-            .run(sessionId, seq, role, messageJson, now);
+      `).run(sessionId, seq, role, messageJson, now);
+        indexMessageInFts(db, sessionId, seq, role, messageJson);
     }
-    catch {
-        /* fail-open */
+    catch (err) {
+        logger.error("storage", `[transcript] persistMessageWriteAhead failed: ${err.message}`, {
+            sessionId,
+            seq,
+            role,
+        });
     }
 }
 /**
@@ -282,8 +404,8 @@ export function markMessageCompleted(sessionId, seq) {
       `)
             .run(sessionId, seq);
     }
-    catch {
-        /* fail-open */
+    catch (err) {
+        logger.error("storage", `[transcript] markMessageCompleted failed: ${err.message}`, { sessionId, seq });
     }
 }
 /**
@@ -304,8 +426,8 @@ export function markMessageErrored(sessionId, seq) {
       `)
             .run(sessionId, seq);
     }
-    catch {
-        /* fail-open */
+    catch (err) {
+        logger.error("storage", `[transcript] markMessageErrored failed: ${err.message}`, { sessionId, seq });
     }
 }
 /**
@@ -721,4 +843,153 @@ export function getLastTodoWriteArgs(sessionId) {
     }
     return 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 function persistApprovedPlan(sessionId, planText) {
+    if (!sessionId || !planText)
+        return;
+    const db = getDatabase();
+    const toolCallId = `approved-plan-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const now = new Date().toISOString();
+    try {
+        db.prepare(`
+      INSERT OR REPLACE INTO tool_calls (session_id, message_seq, tool_call_id, tool_name, args_json, status, started_at, completed_at)
+      VALUES (?, 0, ?, '__approved_plan', ?, 'completed', ?, ?)
+    `).run(sessionId, toolCallId, planText, now, now);
+    }
+    catch {
+        /* best-effort persistence; never block the turn */
+    }
+}
+/** Load the most recent persisted approved plan for this session (or parent chain). */
+export function getLastApprovedPlan(sessionId) {
+    const chain = getSessionChain(sessionId);
+    const db = getDatabase();
+    for (let i = chain.length - 1; i >= 0; i--) {
+        try {
+            // 1) Prefer our synthetic persisted row (written by setPlanContext + persistApprovedPlan).
+            const synthetic = db
+                .prepare(`
+          SELECT args_json
+          FROM tool_calls
+          WHERE session_id = ? AND tool_name = '__approved_plan'
+          ORDER BY id DESC
+          LIMIT 1
+        `)
+                .get(chain[i]);
+            if (synthetic?.args_json) {
+                return synthetic.args_json;
+            }
+            // 2) Fallback: scan real plan tool_calls (respond_plan / generate_plan) written by
+            //    council, PIL response-tools, or generate_plan UI. Extract a human-readable slice.
+            const planRow = db
+                .prepare(`
+          SELECT args_json, tool_name
+          FROM tool_calls
+          WHERE session_id = ? AND tool_name IN ('respond_plan', 'generate_plan')
+          ORDER BY id DESC
+          LIMIT 1
+        `)
+                .get(chain[i]);
+            if (planRow?.args_json) {
+                try {
+                    const parsed = JSON.parse(planRow.args_json);
+                    // respond_plan shape typically has { steps, assumptions?, risks? } or { plan: {...} }
+                    const candidate = parsed?.plan ?? parsed;
+                    if (candidate && (Array.isArray(candidate.steps) || typeof candidate === "object")) {
+                        return JSON.stringify(candidate, null, 2);
+                    }
+                    // generate_plan may carry raw text or { content, steps }
+                    if (typeof parsed === "string")
+                        return parsed;
+                    if (parsed && typeof parsed === "object")
+                        return JSON.stringify(parsed, null, 2);
+                }
+                catch {
+                    // not JSON — return as-is (may be a raw string payload)
+                    if (typeof planRow.args_json === "string" && planRow.args_json.trim().length > 0) {
+                        return planRow.args_json;
+                    }
+                }
+            }
+        }
+        catch {
+            // ignore and check parent
+        }
+    }
+    return null;
+}
+function indexMessageInFts(db, sessionId, seq, role, messageJsonStr) {
+    db.prepare(`DELETE FROM session_history_fts WHERE session_id = ? AND seq = ?`).run(sessionId, seq);
+    let message;
+    try {
+        message = JSON.parse(messageJsonStr);
+    }
+    catch (err) {
+        logger.error("storage", `[transcript] Failed to parse message JSON for FTS indexing: ${err.message}`, {
+            sessionId,
+            seq,
+            role,
+        });
+        return;
+    }
+    let content = "";
+    let toolName = "";
+    let toolArgs = "";
+    let toolOutput = "";
+    const msgContent = message.content;
+    if (typeof msgContent === "string") {
+        content = msgContent;
+    }
+    else if (Array.isArray(msgContent)) {
+        const textParts = [];
+        const toolNames = [];
+        const argParts = [];
+        const outputParts = [];
+        for (const part of msgContent) {
+            if (part && typeof part === "object") {
+                if (part.type === "text" && typeof part.text === "string") {
+                    textParts.push(part.text);
+                }
+                else if (part.type === "tool-call" && typeof part.toolName === "string") {
+                    toolNames.push(part.toolName);
+                    if (part.input !== undefined) {
+                        argParts.push(typeof part.input === "string" ? part.input : JSON.stringify(part.input));
+                    }
+                }
+                else if (part.type === "tool-result" && typeof part.toolName === "string") {
+                    toolNames.push(part.toolName);
+                    if (part.output !== undefined) {
+                        outputParts.push(typeof part.output === "string" ? part.output : JSON.stringify(part.output));
+                    }
+                }
+            }
+        }
+        content = textParts.join("\n").trim();
+        toolName = toolNames.join(", ").trim();
+        toolArgs = argParts.join("\n").trim();
+        toolOutput = outputParts.join("\n").trim();
+    }
+    try {
+        db.prepare(`
+      INSERT INTO session_history_fts (session_id, seq, role, tool_name, content, tool_args, tool_output)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(sessionId, seq, role, toolName || null, content || null, toolArgs || null, toolOutput || null);
+    }
+    catch (err) {
+        logger.error("storage", `[transcript] Failed to execute FTS indexing query: ${err.message}`, {
+            sessionId,
+            seq,
+            role,
+        });
+        throw err;
+    }
+}
 //# sourceMappingURL=transcript.js.map

package/dist/src/tools/file.d.ts

@@ -14,5 +14,20 @@ export interface FileResult {
     lspDiagnostics?: LspDiagnosticFile[];
 }
 export declare function readFile(filePath: string, cwd: string, startLine?: number, endLine?: number, tracker?: FileTracker): FileResult;
+/**
+ * O1 — read MULTIPLE files in ONE tool call. This is the lossless batching
+ * lever: a single `read_file` carrying N paths is ONE tool_call, so it is
+ * NEVER split by `splitParallelToolCalls` (which only reshapes assistant turns
+ * with >1 tool_calls) — the ≥50% fresh-input cut holds on every provider,
+ * including the kimi/glm/deepseek-go sequential-split cohort.
+ *
+ * Quality gate (council regression vector "partial multi-path reads"): each
+ * file is capped INDEPENDENTLY at `perFileCap` with an EXPLICIT truncation
+ * marker, so no file is ever silently dropped by a downstream head/tail
+ * whole-result cap. With `perFileCap = floor(MAX_TOOL_OUTPUT_CHARS / n)` the
+ * concatenated total stays under the registry cap, making the outer
+ * `truncateOutput` a no-op — every requested file is represented.
+ */
+export declare function readFiles(filePaths: string[], cwd: string, tracker?: FileTracker, perFileCap?: number): FileResult;
 export declare function writeFile(filePath: string, content: string, cwd: string, tracker?: FileTracker): Promise<FileResult>;
 export declare function editFile(filePath: string, oldString: string, newString: string, cwd: string, tracker?: FileTracker): Promise<FileResult>;

package/dist/src/tools/file.js

@@ -51,6 +51,38 @@ export function readFile(filePath, cwd, startLine, endLine, tracker) {
         return { success: false, output: `Failed to read file: ${msg}` };
     }
 }
+/**
+ * O1 — read MULTIPLE files in ONE tool call. This is the lossless batching
+ * lever: a single `read_file` carrying N paths is ONE tool_call, so it is
+ * NEVER split by `splitParallelToolCalls` (which only reshapes assistant turns
+ * with >1 tool_calls) — the ≥50% fresh-input cut holds on every provider,
+ * including the kimi/glm/deepseek-go sequential-split cohort.
+ *
+ * Quality gate (council regression vector "partial multi-path reads"): each
+ * file is capped INDEPENDENTLY at `perFileCap` with an EXPLICIT truncation
+ * marker, so no file is ever silently dropped by a downstream head/tail
+ * whole-result cap. With `perFileCap = floor(MAX_TOOL_OUTPUT_CHARS / n)` the
+ * concatenated total stays under the registry cap, making the outer
+ * `truncateOutput` a no-op — every requested file is represented.
+ */
+export function readFiles(filePaths, cwd, tracker, perFileCap) {
+    if (filePaths.length === 0) {
+        return { success: false, output: "read_file: no paths provided (file_path or file_paths required)" };
+    }
+    const parts = [];
+    for (const filePath of filePaths) {
+        const r = readFile(filePath, cwd, undefined, undefined, tracker);
+        let out = r.output;
+        if (perFileCap && perFileCap > 0 && out.length > perFileCap) {
+            // Head-truncate this ONE file with an explicit, self-describing marker.
+            // Never silently elide: the model is told this file was cut and how to
+            // get the rest (single read + line range).
+            out = `${out.slice(0, perFileCap)}\n... [${out.length - perFileCap} chars of ${filePath} truncated in this batch read — read it singly with start_line/end_line for the rest] ...`;
+        }
+        parts.push(out);
+    }
+    return { success: true, output: parts.join("\n\n") };
+}
 export async function writeFile(filePath, content, cwd, tracker) {
     try {
         const full = resolvePath(filePath, cwd);

package/dist/src/tools/native-tools.js

@@ -86,6 +86,10 @@ export function registerNativeMuonroiTools(tools, opts = {}) {
                 const { feedbackEE } = await import("../ee/search.js");
                 const { sessionRecallLedger } = await import("../ee/recall-ledger.js");
                 const result = await feedbackEE(id, collection, verdict, reason);
+                // A queued result (brain unreachable → durably enqueued) counts as success:
+                // the agent has discharged its rating, so clear the ledger regardless. This
+                // is what stops the mandatory-rating gate from looping while the brain is
+                // down — the previous "return early, don't clear" path re-nagged every turn.
                 if (!result.ok)
                     return errLine("feedback_failed", result.error ?? "feedback POST failed");
                 const clearedId = result.resolvedId ?? id;
@@ -96,6 +100,7 @@ export function registerNativeMuonroiTools(tools, opts = {}) {
                     id: clearedId,
                     verdict: result.verdict,
                     ...(result.reason ? { reason: result.reason } : {}),
+                    ...(result.queued ? { queued: true } : {}),
                     pendingRemaining: sessionRecallLedger.pendingCount(),
                 });
             }

package/dist/src/tools/registry.d.ts

@@ -15,6 +15,8 @@ interface ToolRegistryOpts {
     listDelegations?: () => Promise<ToolResult>;
     killDelegation?: (id: string) => Promise<ToolResult>;
     modelId?: string;
+    /** L1 model depth tier — gates gsd_plan_review registration. */
+    depthTier?: "quick" | "standard" | "heavy";
     consultParentSession?: (question: string) => Promise<string>;
     /**
      * When false, the 3 vision-proxy tools (analyze_image, ask_vision_proxy,
@@ -31,6 +33,7 @@ interface ToolRegistryOpts {
      * isolated state (legacy per-closure behaviour).
      */
     sessionId?: string;
+    runDebate?: (topic: string) => Promise<string>;
 }
 /**
  * Phase 4R: session-scoped bash repeat detector state.