muonroi-cli 1.8.4 → 1.9.0

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 });
     }
 }
 /**
@@ -482,13 +604,19 @@ export function buildChatEntries(sessionId) {
     catch (err) {
         logger.error("storage", "Failed to load session metadata for chain in buildChatEntries", { error: err });
     }
+    // One read per session in the chain — the prompt/answer reconciliation below
+    // and the render walk both need every session's records.
+    const recordsBySession = new Map();
+    for (const sid of chain) {
+        recordsBySession.set(sid, buildEffectiveMessageRecords(sid));
+    }
     // Map each child sub-session's initial user prompt to its creation timestamp
     const childPrompts = new Map();
     for (let i = 1; i < chain.length; i++) {
         const sid = chain[i];
         const meta = sessionMeta.get(sid);
         if (meta && meta.parent_session_id) {
-            const records = buildEffectiveMessageRecords(sid);
+            const records = recordsBySession.get(sid) ?? [];
             const firstUser = records.find((r) => r.message.role === "user");
             if (firstUser) {
                 const content = renderUserContent(firstUser.message.content);
@@ -498,14 +626,38 @@ export function buildChatEntries(sessionId) {
             }
         }
     }
+    // When a sub-session finishes, the orchestrator absorbs its LAST assistant
+    // message into the PARENT (salvageSubSessionOutput + appendCompletedTurn,
+    // orchestrator.ts) so the parent keeps context continuity. That content is
+    // therefore persisted in BOTH sessions, and the chain walk below would render
+    // the final answer twice. Keep the parent's copy — it sits in the timeline
+    // where the user actually asked — and drop the child's, mirroring how the
+    // child's duplicated user prompt is handled above.
+    const absorbedByChild = new Map();
+    for (let i = 1; i < chain.length; i++) {
+        const sid = chain[i];
+        const parentId = sessionMeta.get(sid)?.parent_session_id;
+        if (!parentId)
+            continue;
+        const parentRecords = recordsBySession.get(parentId);
+        if (!parentRecords)
+            continue;
+        const text = lastAssistantText(recordsBySession.get(sid) ?? []);
+        if (text && parentRecords.some((r) => r.message.role === "assistant" && assistantText(r.message) === text)) {
+            absorbedByChild.set(sid, text);
+        }
+    }
     const callMap = new Map();
     const entries = [];
     const renderedResponseCallIds = new Set();
     let lastTimestamp;
     for (let i = 0; i < chain.length; i++) {
         const sid = chain[i];
-        const records = buildEffectiveMessageRecords(sid);
+        const records = recordsBySession.get(sid) ?? [];
         const isChildSession = i > 0;
+        // Only the single message the parent absorbed is dropped, so a child that
+        // legitimately repeats itself still renders its other turns.
+        let absorbedPending = absorbedByChild.get(sid);
         for (let j = 0; j < records.length; j++) {
             const { message, timestamp } = records[j];
             lastTimestamp = timestamp;
@@ -536,8 +688,15 @@ export function buildChatEntries(sessionId) {
                 continue;
             }
             if (message.role === "assistant") {
+                // Call first regardless: it registers this message's tool-calls in
+                // callMap, which the tool-result branch below needs even when the
+                // message itself is skipped as an absorbed duplicate.
                 const text = renderAssistantContent(message.content, callMap);
                 if (text) {
+                    if (absorbedPending !== undefined && text === absorbedPending) {
+                        absorbedPending = undefined;
+                        continue;
+                    }
                     entries.push({ type: "assistant", content: text, timestamp });
                 }
                 continue;
@@ -622,6 +781,23 @@ export function buildChatEntries(sessionId) {
     logger.debug("storage", "Built chat entries successfully", { sessionId, count: entries.length });
     return entries;
 }
+/** Rendered text of an assistant message, with no callMap side effect. */
+function assistantText(message) {
+    return renderAssistantContent(message.content, new Map());
+}
+/**
+ * Text of the session's LAST assistant message — the one the sub-session
+ * absorption path hands to the parent. Empty when that message carried only
+ * tool-calls (nothing renders, so nothing can duplicate).
+ */
+function lastAssistantText(records) {
+    for (let i = records.length - 1; i >= 0; i--) {
+        const message = records[i].message;
+        if (message.role === "assistant")
+            return assistantText(message);
+    }
+    return "";
+}
 function getNextSequence(db, sessionId) {
     const row = db
         .prepare(`
@@ -721,4 +897,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/git-safety.d.ts

@@ -90,6 +90,25 @@ export interface StagingBlockResult {
  *   2. Setting MUONROI_ALLOW_BROAD_STAGE=1 (escape hatch, logged to decision-log).
  */
 export declare function checkSensitiveStaging(cwd: string): StagingBlockResult;
+export type DestructiveKind = "checkout-discard" | "restore" | "reset-hard" | "clean" | "stash-drop" | "rm-tracked";
+export interface DestructiveShape {
+    kind: DestructiveKind | null;
+    /** true when the risk is untracked files (clean) rather than tracked mods. */
+    untrackedRisk: boolean;
+}
+export declare function analyzeDestructiveGit(command: string): DestructiveShape;
+export interface DestructiveBlockResult {
+    blocked: boolean;
+    kind: DestructiveKind | null;
+    message: string;
+}
+/**
+ * Pre-execution guard: block a working-tree-destroying command when it would
+ * actually discard uncommitted work. Returns blocked=false (no message) when
+ * the command is non-destructive, when nothing is at risk, or when the user set
+ * the escape hatch. Deterministic + cheap (a couple of git plumbing calls).
+ */
+export declare function checkDestructiveOp(command: string, cwd: string): DestructiveBlockResult;
 /**
  * @deprecated Use checkSensitiveStaging() for hard-blocking.
  * Kept for call sites that emit a trailing warning (non-broad-stage contexts).