muonroi-cli 1.7.1 → 1.8.0

package/dist/src/storage/sessions.js

@@ -43,12 +43,12 @@ export class SessionStore {
         const now = new Date().toISOString();
         const id = createSessionId();
         const db = getDatabase();
-        db.prepare(`
-      INSERT INTO sessions (
-        id, workspace_id, title, model, mode, cwd_at_start, cwd_last, status, created_at, updated_at
-      ) VALUES (
-        @id, @workspace_id, NULL, @model, @mode, @cwd_at_start, @cwd_last, 'active', @created_at, @updated_at
-      )
+        db.prepare(`
+      INSERT INTO sessions (
+        id, workspace_id, title, model, mode, cwd_at_start, cwd_last, status, created_at, updated_at
+      ) VALUES (
+        @id, @workspace_id, NULL, @model, @mode, @cwd_at_start, @cwd_last, 'active', @created_at, @updated_at
+      )
     `).run({
             id,
             workspace_id: this.workspace.id,
@@ -64,37 +64,44 @@ export class SessionStore {
     /**
      * 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.
      */
     listRecentSessions(limit = 20) {
         const rows = getDatabase()
-            .prepare(`
-      SELECT id, workspace_id, title, model, mode, cwd_at_start, cwd_last, status, created_at, updated_at
-      FROM sessions
-      WHERE workspace_id = ?
-      ORDER BY updated_at DESC
-      LIMIT ?
+            .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);
     }
     getLatestSession() {
         const row = getDatabase()
-            .prepare(`
-      SELECT id, workspace_id, title, model, mode, cwd_at_start, cwd_last, status, created_at, updated_at
-      FROM sessions
-      WHERE workspace_id = ?
-      ORDER BY updated_at DESC
-      LIMIT 1
+            .prepare(`
+      SELECT id, workspace_id, title, model, mode, cwd_at_start, cwd_last, status, created_at, updated_at
+      FROM sessions
+      WHERE workspace_id = ?
+      ORDER BY updated_at DESC
+      LIMIT 1
     `)
             .get(this.workspace.id);
         return row ? toSessionInfo(row) : null;
     }
     getSessionById(id) {
         const row = getDatabase()
-            .prepare(`
-      SELECT id, workspace_id, title, model, mode, cwd_at_start, cwd_last, status, created_at, updated_at
-      FROM sessions
-      WHERE id = ?
+            .prepare(`
+      SELECT id, workspace_id, title, model, mode, cwd_at_start, cwd_last, status, created_at, updated_at
+      FROM sessions
+      WHERE id = ?
     `)
             .get(id);
         return row ? toSessionInfo(row) : null;
@@ -109,49 +116,49 @@ export class SessionStore {
     setStatus(id, status) {
         const now = new Date().toISOString();
         getDatabase()
-            .prepare(`
-      UPDATE sessions
-      SET status = ?, updated_at = ?
-      WHERE id = ?
+            .prepare(`
+      UPDATE sessions
+      SET status = ?, updated_at = ?
+      WHERE id = ?
     `)
             .run(status, now, id);
     }
     setTitle(id, title) {
         const now = new Date().toISOString();
         getDatabase()
-            .prepare(`
-      UPDATE sessions
-      SET title = ?, updated_at = ?
-      WHERE id = ?
+            .prepare(`
+      UPDATE sessions
+      SET title = ?, updated_at = ?
+      WHERE id = ?
     `)
             .run(title, now, id);
     }
     setModel(id, model) {
         const now = new Date().toISOString();
         getDatabase()
-            .prepare(`
-      UPDATE sessions
-      SET model = ?, updated_at = ?
-      WHERE id = ?
+            .prepare(`
+      UPDATE sessions
+      SET model = ?, updated_at = ?
+      WHERE id = ?
     `)
             .run(model, now, id);
     }
     setMode(id, mode) {
         const now = new Date().toISOString();
         getDatabase()
-            .prepare(`
-      UPDATE sessions
-      SET mode = ?, updated_at = ?
-      WHERE id = ?
+            .prepare(`
+      UPDATE sessions
+      SET mode = ?, updated_at = ?
+      WHERE id = ?
     `)
             .run(mode, now, id);
     }
     touchSession(id, cwd) {
         getDatabase()
-            .prepare(`
-      UPDATE sessions
-      SET cwd_last = ?, updated_at = ?
-      WHERE id = ?
+            .prepare(`
+      UPDATE sessions
+      SET cwd_last = ?, updated_at = ?
+      WHERE id = ?
     `)
             .run(cwd, new Date().toISOString(), id);
     }

package/dist/src/storage/transcript-view.js

@@ -9,7 +9,13 @@ export function buildEffectiveTranscript(messages, seqs, timestamps, compaction)
         };
     }
     const firstKeptIndex = seqs.findIndex((seq) => seq >= compaction.firstKeptSeq);
-    const keptIndex = firstKeptIndex >= 0 ? firstKeptIndex : messages.length;
+    let keptIndex = firstKeptIndex >= 0 ? firstKeptIndex : messages.length;
+    // 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") {
+        keptIndex -= 1;
+    }
     const keptMessages = messages.slice(keptIndex);
     const keptSeqs = seqs.slice(keptIndex);
     const keptTimestamps = timestamps.slice(keptIndex);

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

@@ -105,3 +105,4 @@ export declare function sweepStalePendingRows(staleAfterMs?: number): {
 export declare function markToolCallErrored(sessionId: string, toolCallId: string, errorMessage: string): void;
 export declare function appendCompaction(sessionId: string, firstKeptSeq: number, summary: string, tokensBefore: number): void;
 export declare function buildChatEntries(sessionId: string): ChatEntry[];
+export declare function getLastTodoWriteArgs(sessionId: string): string | null;

package/dist/src/storage/transcript.js

@@ -383,8 +383,18 @@ export function buildChatEntries(sessionId) {
     const toolResults = loadStoredToolResults(sessionId);
     const callMap = new Map();
     const entries = [];
+    // Response-tool callIds already rendered as a structured_response from a
+    // persisted tool-RESULT row (success path). After the loop we recover any
+    // response tool that was CALLED but produced no result row — i.e. respond_*
+    // whose execution ERRORED (the AI SDK does not persist tool-error parts as
+    // tool-result rows). Its answer lives in the call args; without this it is
+    // dropped on the turn-finalize rebuild and the user sees an empty turn or
+    // only the last council debate round.
+    const renderedResponseCallIds = new Set();
+    let lastTimestamp;
     for (const row of buildEffectiveMessageRecords(sessionId)) {
         const { message, timestamp } = row;
+        lastTimestamp = timestamp;
         if (message.role === "user") {
             const content = renderUserContent(message.content);
             if (content) {
@@ -432,6 +442,7 @@ export function buildChatEntries(sessionId) {
                 // wraps tool outputs as `{type:"json", value:{...}}`; unwrap to expose
                 // the schema-shaped payload to the renderer.
                 if (isResponseTool(part.toolName)) {
+                    renderedResponseCallIds.add(part.toolCallId);
                     const rawOutput = part.output;
                     const unwrapped = rawOutput && typeof rawOutput === "object" && rawOutput.type === "json"
                         ? (rawOutput.value ?? {})
@@ -463,6 +474,33 @@ export function buildChatEntries(sessionId) {
             }
         }
     }
+    // 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,
+            },
+        });
+    }
     return entries;
 }
 function getNextSequence(db, sessionId) {
@@ -540,4 +578,21 @@ function toFallbackToolCall(toolCallId, toolName) {
         },
     };
 }
+export function getLastTodoWriteArgs(sessionId) {
+    try {
+        const row = getDatabase()
+            .prepare(`
+        SELECT args_json
+        FROM tool_calls
+        WHERE session_id = ? AND tool_name = 'todo_write'
+        ORDER BY id DESC
+        LIMIT 1
+      `)
+            .get(sessionId);
+        return row?.args_json ?? null;
+    }
+    catch {
+        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

@@ -12,31 +12,31 @@ export function recordUsageEvent(sessionId, source, model, usage, messageSeq, pi
     const cacheCreationTokens = usage.cacheCreationTokens ?? 0;
     const costMicros = estimateCostMicros(model, inputTokens, outputTokens, cacheReadTokens);
     getDatabase()
-        .prepare(`
-    INSERT INTO usage_events (
-      session_id, message_seq, source, model, input_tokens, output_tokens, total_tokens, cost_micros, created_at,
-      pil_active, enrichment_delta, cache_read_tokens, cache_creation_tokens, provider_options_shape
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        .prepare(`
+    INSERT INTO usage_events (
+      session_id, message_seq, source, model, input_tokens, output_tokens, total_tokens, cost_micros, created_at,
+      pil_active, enrichment_delta, cache_read_tokens, cache_creation_tokens, provider_options_shape
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
   `)
         .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 row = getDatabase()
-        .prepare(`
-    SELECT COALESCE(SUM(total_tokens), 0) AS total_tokens
-    FROM usage_events
-    WHERE session_id = ?
+        .prepare(`
+    SELECT COALESCE(SUM(total_tokens), 0) AS total_tokens
+    FROM usage_events
+    WHERE session_id = ?
   `)
         .get(sessionId);
     return row?.total_tokens ?? 0;
 }
 export function listSessionUsage(sessionId) {
     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 = ?
-    ORDER BY id ASC
+        .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 = ?
+    ORDER BY id ASC
   `)
         .all(sessionId);
     return rows.map((row) => ({

package/dist/src/storage/workspaces.js

@@ -8,14 +8,14 @@ export function ensureWorkspace(cwd) {
     const now = new Date().toISOString();
     const id = createHash("sha1").update(resolved.scopeKey).digest("hex").slice(0, 16);
     const db = getDatabase();
-    db.prepare(`
-    INSERT INTO workspaces (id, scope_key, canonical_path, git_root, display_name, last_seen_at)
-    VALUES (@id, @scope_key, @canonical_path, @git_root, @display_name, @last_seen_at)
-    ON CONFLICT(scope_key) DO UPDATE SET
-      canonical_path = excluded.canonical_path,
-      git_root = excluded.git_root,
-      display_name = excluded.display_name,
-      last_seen_at = excluded.last_seen_at
+    db.prepare(`
+    INSERT INTO workspaces (id, scope_key, canonical_path, git_root, display_name, last_seen_at)
+    VALUES (@id, @scope_key, @canonical_path, @git_root, @display_name, @last_seen_at)
+    ON CONFLICT(scope_key) DO UPDATE SET
+      canonical_path = excluded.canonical_path,
+      git_root = excluded.git_root,
+      display_name = excluded.display_name,
+      last_seen_at = excluded.last_seen_at
   `).run({
         id,
         scope_key: resolved.scopeKey,
@@ -25,10 +25,10 @@ export function ensureWorkspace(cwd) {
         last_seen_at: now,
     });
     const row = db
-        .prepare(`
-    SELECT id, scope_key, canonical_path, git_root, display_name, last_seen_at
-    FROM workspaces
-    WHERE scope_key = ?
+        .prepare(`
+    SELECT id, scope_key, canonical_path, git_root, display_name, last_seen_at
+    FROM workspaces
+    WHERE scope_key = ?
   `)
         .get(resolved.scopeKey);
     if (!row) {

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 {};