muonroi-cli 1.7.2 → 1.8.0

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