muonroi-cli 1.7.2 → 1.8.1

package/dist/src/storage/transcript.js

@@ -1,5 +1,6 @@
 import { getCompactionSummaryText } from "../orchestrator/compaction.js";
 import { getResponseTaskType, isResponseTool } from "../pil/response-tools.js";
+import { logger } from "../utils/logger.js";
 import { getDatabase, withTransaction } from "./db.js";
 import { extractToolResultFromOutput, getOutputKind, isOutputSuccess } from "./tool-results.js";
 import { buildEffectiveTranscript } from "./transcript-view.js";
@@ -327,16 +328,15 @@ export function markMessageErrored(sessionId, seq) {
  */
 export function sweepStalePendingRows(staleAfterMs = 5 * 60 * 1000) {
     const cutoff = new Date(Date.now() - staleAfterMs).toISOString();
-    const now = new Date().toISOString();
     try {
         const db = getDatabase();
         const toolCalls = db
             .prepare(`
         UPDATE tool_calls
-        SET status = 'aborted', completed_at = ?
+        SET status = 'aborted', completed_at = started_at
         WHERE status = 'pending' AND started_at < ?
       `)
-            .run(now, cutoff);
+            .run(cutoff);
         const messages = db
             .prepare(`
         UPDATE messages
@@ -379,90 +379,247 @@ export function appendCompaction(sessionId, firstKeptSeq, summary, tokensBefore)
     `).run(new Date().toISOString(), sessionId);
     });
 }
-export function buildChatEntries(sessionId) {
-    const toolResults = loadStoredToolResults(sessionId);
-    const callMap = new Map();
-    const entries = [];
-    for (const row of buildEffectiveMessageRecords(sessionId)) {
-        const { message, timestamp } = row;
-        if (message.role === "user") {
-            const content = renderUserContent(message.content);
-            if (content) {
-                entries.push({ type: "user", content, timestamp });
+export function revertLatestCompaction(sessionId) {
+    withTransaction((db) => {
+        db.prepare(`
+      DELETE FROM compactions 
+      WHERE session_id = ? 
+      AND id = (SELECT MAX(id) FROM compactions WHERE session_id = ?)
+    `).run(sessionId, sessionId);
+        db.prepare(`
+      UPDATE sessions
+      SET updated_at = ?
+      WHERE id = ?
+    `).run(new Date().toISOString(), sessionId);
+    });
+}
+export function getSessionChain(sessionId) {
+    logger.debug("storage", "Resolving session chain", { sessionId });
+    const db = getDatabase();
+    // 1. Walk up to the root parent
+    let rootId = sessionId;
+    const visitedUp = new Set();
+    while (rootId && !visitedUp.has(rootId)) {
+        visitedUp.add(rootId);
+        try {
+            const row = db.prepare("SELECT parent_session_id FROM sessions WHERE id = ?").get(rootId);
+            if (row?.parent_session_id) {
+                rootId = row.parent_session_id;
             }
-            continue;
+            else {
+                break;
+            }
+        }
+        catch {
+            break;
         }
-        if (message.role === "system") {
-            const summaryText = getCompactionSummaryText(message);
-            const content = summaryText ?? (typeof message.content === "string" ? message.content.trim() : "");
-            if (content && !isInternalCouncilMarker(content)) {
-                // A compaction checkpoint is internal context-management, NOT the
-                // assistant's answer. Tag it with a source label so the UI renders it
-                // as a clearly-marked, collapsible checkpoint instead of dumping the
-                // raw "## Goal / ## Context For Suffix" scaffolding as a chat reply.
-                entries.push(summaryText !== null
-                    ? { type: "assistant", content, timestamp, sourceLabel: "⋯ context checkpoint (auto-compacted)" }
-                    : { type: "assistant", content, timestamp });
+    }
+    // 2. Find all descendants of the root session using a BFS queue to handle multiple child branches
+    const allIds = new Set([rootId]);
+    const queue = [rootId];
+    while (queue.length > 0) {
+        const currentId = queue.shift();
+        try {
+            const children = db.prepare("SELECT id FROM sessions WHERE parent_session_id = ?").all(currentId);
+            for (const child of children) {
+                if (!allIds.has(child.id)) {
+                    allIds.add(child.id);
+                    queue.push(child.id);
+                }
             }
-            continue;
         }
-        if (message.role === "assistant") {
-            const text = renderAssistantContent(message.content, callMap);
-            if (text) {
-                entries.push({ type: "assistant", content: text, timestamp });
+        catch (err) {
+            logger.error("storage", `Failed to query child sessions for ${currentId} during walk`, { error: err });
+        }
+    }
+    // 3. Sort chronologically by querying the database for all matched sessions ordered by created_at
+    let chain = [];
+    try {
+        const placeholders = Array.from(allIds)
+            .map(() => "?")
+            .join(",");
+        const sortedRows = db
+            .prepare(`
+      SELECT id FROM sessions 
+      WHERE id IN (${placeholders}) 
+      ORDER BY created_at ASC
+    `)
+            .all(...Array.from(allIds));
+        chain = sortedRows.map((r) => r.id);
+    }
+    catch (err) {
+        logger.error("storage", `Failed to sort session chain for root ${rootId}`, { error: err });
+        // Fallback to unsorted array if query fails
+        chain = Array.from(allIds);
+    }
+    logger.debug("storage", "Resolved session chain successfully", { sessionId, chainLength: chain.length, chain });
+    return chain;
+}
+export function buildChatEntries(sessionId) {
+    const chain = getSessionChain(sessionId);
+    logger.debug("storage", "Building chat entries from session chain", { sessionId, chainLength: chain.length });
+    const toolResults = new Map();
+    for (const sid of chain) {
+        const results = loadStoredToolResults(sid);
+        for (const [k, v] of results) {
+            toolResults.set(k, v);
+        }
+    }
+    // Load parent/child session metadata to reconcile user prompt timestamps across rotation/sub-session boundaries
+    const db = getDatabase();
+    const sessionMeta = new Map();
+    try {
+        if (chain.length > 1) {
+            const placeholders = chain.map(() => "?").join(",");
+            const rows = db
+                .prepare(`SELECT id, parent_session_id, created_at FROM sessions WHERE id IN (${placeholders})`)
+                .all(...chain);
+            for (const r of rows) {
+                sessionMeta.set(r.id, { parent_session_id: r.parent_session_id, created_at: r.created_at });
             }
-            continue;
         }
-        if (message.role === "tool" && Array.isArray(message.content)) {
-            for (const part of message.content) {
-                if (part.type !== "tool-result")
+    }
+    catch (err) {
+        logger.error("storage", "Failed to load session metadata for chain in buildChatEntries", { error: err });
+    }
+    // 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 firstUser = records.find((r) => r.message.role === "user");
+            if (firstUser) {
+                const content = renderUserContent(firstUser.message.content);
+                if (content) {
+                    childPrompts.set(content, new Date(meta.created_at));
+                }
+            }
+        }
+    }
+    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 isChildSession = i > 0;
+        for (let j = 0; j < records.length; j++) {
+            const { message, timestamp } = records[j];
+            lastTimestamp = timestamp;
+            if (message.role === "user") {
+                const content = renderUserContent(message.content);
+                if (isChildSession && childPrompts.has(content)) {
+                    // Skip B's user message because it's a duplicate of A's user message
+                    continue;
+                }
+                if (content) {
+                    entries.push({ type: "user", content, timestamp });
+                }
+                continue;
+            }
+            if (message.role === "system") {
+                const summaryText = getCompactionSummaryText(message);
+                if (isChildSession && j === 0 && summaryText !== null) {
+                    // Skip the first message in a child session if it's the parent compaction summary
+                    // to keep the visual timeline clean, since the user already sees the parent history.
                     continue;
-                // Response tools (respond_general/analyze/plan/...) are the model's
-                // TERMINAL structured answer (identity execute — the payload lives in
-                // the call args and is echoed in the result). The live stream yields
-                // them as a `structured_response` chunk (message-processor.ts:2733),
-                // which the UI renders as the answer block. Persisted history MUST
-                // rebuild the SAME entry: finalizeActiveTurn (app.tsx) replaces the
-                // live message list with getChatEntries() on every normal turn, so if
-                // we rebuilt a respond_* result as a bare tool_result the rendered
-                // answer would be silently dropped the instant streaming ended (live
-                // repro session 9d3d371ca1bd: grok investigated, emitted a 10K-char
-                // respond_general, the answer flashed then vanished on turn finalize —
-                // the user saw only the "→ respond_general" indicator). AI SDK v5/v6
-                // wraps tool outputs as `{type:"json", value:{...}}`; unwrap to expose
-                // the schema-shaped payload to the renderer.
-                if (isResponseTool(part.toolName)) {
-                    const rawOutput = part.output;
-                    const unwrapped = rawOutput && typeof rawOutput === "object" && rawOutput.type === "json"
-                        ? (rawOutput.value ?? {})
-                        : (rawOutput ?? {});
+                }
+                const content = summaryText ?? (typeof message.content === "string" ? message.content.trim() : "");
+                if (content && !isInternalCouncilMarker(content)) {
+                    entries.push(summaryText !== null
+                        ? { type: "assistant", content, timestamp, sourceLabel: "⋯ context checkpoint (auto-compacted)" }
+                        : { type: "assistant", content, timestamp });
+                }
+                continue;
+            }
+            if (message.role === "assistant") {
+                const text = renderAssistantContent(message.content, callMap);
+                if (text) {
+                    entries.push({ type: "assistant", content: text, timestamp });
+                }
+                continue;
+            }
+            if (message.role === "tool" && Array.isArray(message.content)) {
+                for (const part of message.content) {
+                    if (part.type !== "tool-result")
+                        continue;
+                    if (isResponseTool(part.toolName)) {
+                        renderedResponseCallIds.add(part.toolCallId);
+                        const rawOutput = part.output;
+                        const unwrapped = rawOutput && typeof rawOutput === "object" && rawOutput.type === "json"
+                            ? (rawOutput.value ?? {})
+                            : (rawOutput ?? {});
+                        entries.push({
+                            type: "structured_response",
+                            content: "",
+                            timestamp,
+                            structuredResponse: {
+                                taskType: getResponseTaskType(part.toolName) ?? part.toolName,
+                                data: unwrapped,
+                            },
+                        });
+                        continue;
+                    }
+                    const toolCall = callMap.get(part.toolCallId) ?? toFallbackToolCall(part.toolCallId, part.toolName);
+                    const toolResult = toolResults.get(part.toolCallId) ??
+                        extractToolResultFromOutput(part.output) ?? {
+                        success: isOutputSuccess(part.output),
+                        output: JSON.stringify(part.output),
+                    };
                     entries.push({
-                        type: "structured_response",
-                        content: "",
+                        type: "tool_result",
+                        content: toolResult.success ? toolResult.output || "Success" : toolResult.error || "Error",
                         timestamp,
-                        structuredResponse: {
-                            taskType: getResponseTaskType(part.toolName) ?? part.toolName,
-                            data: unwrapped,
-                        },
+                        toolCall,
+                        toolResult,
                     });
-                    continue;
                 }
-                const toolCall = callMap.get(part.toolCallId) ?? toFallbackToolCall(part.toolCallId, part.toolName);
-                const toolResult = toolResults.get(part.toolCallId) ??
-                    extractToolResultFromOutput(part.output) ?? {
-                    success: isOutputSuccess(part.output),
-                    output: JSON.stringify(part.output),
-                };
-                entries.push({
-                    type: "tool_result",
-                    content: toolResult.success ? toolResult.output || "Success" : toolResult.error || "Error",
-                    timestamp,
-                    toolCall,
-                    toolResult,
-                });
             }
         }
     }
+    // Recover response-tool answers that were CALLED but never produced a
+    // tool-result row (execution ERRORED). The payload lives in the call args.
+    // Without this, a respond_* that errored after the council debate is dropped
+    // on finalize and only the last debate round stays visible.
+    for (const [callId, call] of callMap) {
+        if (renderedResponseCallIds.has(callId))
+            continue;
+        if (!isResponseTool(call.function.name))
+            continue;
+        let data;
+        try {
+            data = JSON.parse(call.function.arguments || "{}");
+        }
+        catch {
+            // Args unparseable — nothing to recover for this call.
+            continue;
+        }
+        entries.push({
+            type: "structured_response",
+            content: "",
+            timestamp: lastTimestamp ?? new Date(),
+            structuredResponse: {
+                taskType: getResponseTaskType(call.function.name) ?? call.function.name,
+                data,
+            },
+        });
+    }
+    // Adjust parent user message timestamps to match their corresponding child session creation time
+    for (const entry of entries) {
+        if (entry.type === "user") {
+            const content = entry.content.trim();
+            const childTime = childPrompts.get(content);
+            if (childTime) {
+                entry.timestamp = childTime;
+            }
+        }
+    }
+    // Sort entries chronologically by timestamp (stable sort)
+    entries.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+    logger.debug("storage", "Built chat entries successfully", { sessionId, count: entries.length });
     return entries;
 }
 function getNextSequence(db, sessionId) {
@@ -540,4 +697,28 @@ function toFallbackToolCall(toolCallId, toolName) {
         },
     };
 }
+export function getLastTodoWriteArgs(sessionId) {
+    const chain = getSessionChain(sessionId);
+    const db = getDatabase();
+    for (let i = chain.length - 1; i >= 0; i--) {
+        try {
+            const row = db
+                .prepare(`
+          SELECT args_json
+          FROM tool_calls
+          WHERE session_id = ? AND tool_name = 'todo_write'
+          ORDER BY id DESC
+          LIMIT 1
+        `)
+                .get(chain[i]);
+            if (row?.args_json) {
+                return row.args_json;
+            }
+        }
+        catch {
+            // ignore and check parent
+        }
+    }
+    return null;
+}
 //# sourceMappingURL=transcript.js.map

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

@@ -107,6 +107,20 @@ interface InitNewRetryPayload {
     feStack: string;
     bbTemplate: string | null;
 }
+/** Auto-resolved loop-cap event (no user prompt). Replaces the old askcard_open for tool-loop-cap. */
+interface LoopCapAutoPayload {
+    questionId: string;
+    phase: "tool-loop-cap";
+    autoVerdict: "continue" | "stop";
+    kind: "pattern" | "cap";
+    stepNumber: number;
+    /** Only present for pattern kind. */
+    toolName?: string;
+    count?: number;
+    naturalCeiling?: number | null;
+    /** Only present for cap kind. */
+    cap?: number;
+}
 type Payload = {
     subtype: "route_decision";
     data: RouteDecisionPayload;
@@ -146,6 +160,9 @@ type Payload = {
 } | {
     subtype: "init_new_retry";
     data: InitNewRetryPayload;
+} | {
+    subtype: "loop_cap_auto";
+    data: LoopCapAutoPayload;
 };
 /**
  * Persist a UI lifecycle event. Caller passes a discriminated payload so

package/dist/src/storage/usage.js

@@ -1,5 +1,7 @@
 import { getModelInfo } from "../models/registry.js";
+import { logger } from "../utils/logger.js";
 import { getDatabase } from "./db.js";
+import { getSessionChain } from "./transcript.js";
 export function recordUsageEvent(sessionId, source, model, usage, messageSeq, pilActive = false, enrichmentDelta = 0, providerOptionsShape = null) {
     if (!usage)
         return;
@@ -21,24 +23,39 @@ export function recordUsageEvent(sessionId, source, model, usage, messageSeq, pi
         .run(sessionId, messageSeq ?? null, source, model, inputTokens, outputTokens, totalTokens, costMicros, new Date().toISOString(), pilActive ? 1 : 0, enrichmentDelta, cacheReadTokens, cacheCreationTokens, providerOptionsShape);
 }
 export function getSessionTotalTokens(sessionId) {
+    const chain = getSessionChain(sessionId);
+    const placeholders = chain.map(() => "?").join(",");
     const row = getDatabase()
         .prepare(`
     SELECT COALESCE(SUM(total_tokens), 0) AS total_tokens
     FROM usage_events
-    WHERE session_id = ?
+    WHERE session_id IN (${placeholders})
   `)
-        .get(sessionId);
-    return row?.total_tokens ?? 0;
+        .get(...chain);
+    const total = row?.total_tokens ?? 0;
+    logger.debug("storage", "Calculated session total tokens from chain", {
+        sessionId,
+        chainLength: chain.length,
+        totalTokens: total,
+    });
+    return total;
 }
 export function listSessionUsage(sessionId) {
+    const chain = getSessionChain(sessionId);
+    const placeholders = chain.map(() => "?").join(",");
     const rows = getDatabase()
         .prepare(`
     SELECT id, session_id, message_seq, source, model, input_tokens, output_tokens, total_tokens, cost_micros, created_at, cache_read_tokens, cache_creation_tokens
     FROM usage_events
-    WHERE session_id = ?
+    WHERE session_id IN (${placeholders})
     ORDER BY id ASC
   `)
-        .all(sessionId);
+        .all(...chain);
+    logger.debug("storage", "Retrieved session usage events from chain", {
+        sessionId,
+        chainLength: chain.length,
+        eventCount: rows.length,
+    });
     return rows.map((row) => ({
         id: row.id,
         sessionId: row.session_id,

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

@@ -33,6 +33,12 @@ describe("registerNativeMuonroiTools", () => {
         registerNativeMuonroiTools(tools);
         expect(await exec(tools, "ee_feedback", { verdict: "followed" })).toMatch(/invalid_args/);
     });
+    it("ee_write rejects a too-short lesson (no network call)", async () => {
+        const tools = {};
+        registerNativeMuonroiTools(tools);
+        expect(await exec(tools, "ee_write", { lesson: "oops" })).toMatch(/invalid_args/);
+        expect(await exec(tools, "ee_write", {})).toMatch(/invalid_args/);
+    });
     it("selfverify_status returns not_found for an unknown runId (shared JobManager)", async () => {
         const tools = {};
         registerNativeMuonroiTools(tools);

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

@@ -14,7 +14,13 @@ export interface BackgroundProcess {
     exitCode: number | null;
 }
 interface BashToolOptions {
-    sandboxMode?: SandboxMode;
+    /**
+     * Accepted for backward compatibility with callers that pass sandboxMode.
+     * Sandbox has been removed; this value is ignored — mode is always "off".
+     * Will be repurposed when the new sandbox is implemented.
+     * @deprecated
+     */
+    sandboxMode?: string;
     sandboxSettings?: SandboxSettings;
     shellSettings?: ShellSettings;
 }
@@ -22,12 +28,17 @@ export declare class BashTool {
     private cwd;
     private bgProcesses;
     private tmpDir;
-    private sandboxMode;
-    private sandboxSettings;
     private shellSettings;
     private resolvedShell;
-    private sandboxUnsupportedWarned;
+    private sandboxSettings;
     constructor(initialCwd?: string, options?: BashToolOptions);
+    /**
+     * Sandbox has been removed. Always returns "off".
+     * Kept for backward compatibility with orchestrator / stream-runner callers.
+     */
+    getSandboxMode(): SandboxMode;
+    getSandboxSettings(): SandboxSettings;
+    setSandboxSettings(settings: SandboxSettings): void;
     private ensureTmpDir;
     execute(command: string, timeout?: number, abortSignal?: AbortSignal): Promise<ToolResult>;
     startBackground(command: string): Promise<ToolResult>;
@@ -37,29 +48,31 @@ export declare class BashTool {
     cleanup(): Promise<void>;
     getCwd(): string;
     setCwd(next: string): void;
-    getSandboxMode(): SandboxMode;
-    setSandboxMode(mode: SandboxMode): void;
-    /**
-     * The sandbox mode that actually takes effect. When "shuru" is configured but
-     * the current platform cannot run Shuru (non-macOS/arm64), the sandbox is
-     * inert: every wrapped command would fail with the macOS-only error, and the
-     * tool description would still advertise a `/workspace` mount that does not
-     * exist — so the model `cd`s into a phantom dir and abandons verification.
-     * Degrade to "off" (host execution) with a one-time warning so bash keeps
-     * working and the description reflects reality. A stale checked-in project
-     * `sandboxMode: "shuru"` therefore no longer bricks the shell off-platform.
-     */
-    private effectiveSandboxMode;
-    getSandboxSettings(): SandboxSettings;
-    setSandboxSettings(settings: SandboxSettings): void;
     getToolDescription(): string;
     getResolvedShell(): ResolvedShell;
     private spawnInvocation;
+    /**
+     * Pre-execution command preparation.
+     *
+     * Layer 1 — Catastrophic hard-block: checks the command against
+     * CATASTROPHIC_PATTERNS in permission-mode.ts. These are irreversible or
+     * severely dangerous operations that are blocked regardless of permission
+     * mode (safe / auto-edit / yolo) and regardless of sandbox state.
+     *
+     * Layer 2 — Future sandbox: when a new sandbox is wired in, wrap the
+     * command here before returning.
+     */
+    /**
+     * Pre-execution command preparation with two-layer safety.
+     *
+     * Layer 1 — Catastrophic hard-block: checks the command against
+     * CATASTROPHIC_PATTERNS in permission-mode.ts. Returns structured block
+     * result so callers can route to askcard approval flow.
+     *
+     * Layer 2 — Future sandbox: when a new sandbox is wired in, wrap the
+     * command here before returning.
+     */
     private prepareCommand;
-    private formatSandboxRuntimeError;
 }
-export declare function wrapCommandForShuru(cwd: string, command: string, settings?: SandboxSettings): string;
-export declare function shouldRunOnHostInSandboxMode(command: string, settings?: SandboxSettings): boolean;
 export declare function wrapHostBrowserCommand(command: string): string;
-export declare function getSandboxMutationBlockReason(command: string, settings?: SandboxSettings): string | null;
 export {};