muonroi-cli 1.4.0 → 1.4.1

package/src/orchestrator/__tests__/write-ahead.test.ts

@@ -1,162 +0,0 @@
-/**
- * src/orchestrator/__tests__/write-ahead.test.ts
- *
- * Phase A4 — write-ahead persistence for tool_calls.
- *
- * The orchestrator's streamText loop now persists a `pending` row in
- * `tool_calls` the moment the model emits a `tool-call` part — BEFORE
- * the tool executes. If the stream throws between this point and
- * `appendCompletedTurn(...)`, the row remains as `pending`, giving
- * `usage forensics <prefix>` a recoverable trail of what input the model
- * passed (previously this row would never have been written → silent
- * cost-leak forensic gap).
- *
- * Strategy: bun:sqlite is mocked globally for vitest (see
- * src/__test-stubs__/vitest-setup.ts). We mock the storage `db` module to
- * inject a fake SQLiteDatabase that records prepare() calls, then verify
- * `persistToolCallWriteAhead` and `markToolCallErrored` shape their SQL
- * correctly.
- */
-
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-interface PreparedStatementCall {
-  sql: string;
-  runArgs: unknown[];
-}
-
-const preparedCalls: PreparedStatementCall[] = [];
-let dbShouldThrow = false;
-
-vi.mock("../../storage/db", () => {
-  const makeDb = () => ({
-    prepare: (sql: string) => ({
-      run: (...args: unknown[]) => {
-        preparedCalls.push({ sql, runArgs: args });
-        return undefined;
-      },
-      get: () => undefined,
-      all: () => [],
-    }),
-    exec: () => undefined,
-    pragma: () => undefined,
-    transaction: <T>(fn: () => T) => fn,
-    close: () => undefined,
-  });
-  return {
-    getDatabase: () => {
-      if (dbShouldThrow) throw new Error("simulated SQL failure");
-      return makeDb();
-    },
-    withTransaction: <T>(fn: (db: unknown) => T) => fn(makeDb()),
-  };
-});
-
-// Import AFTER the mock so the helper picks up the mocked db module.
-import { markToolCallErrored, persistToolCallWriteAhead } from "../../storage/transcript";
-
-describe("A4: write-ahead tool_calls persistence", () => {
-  beforeEach(() => {
-    preparedCalls.length = 0;
-  });
-
-  afterEach(() => {
-    preparedCalls.length = 0;
-  });
-
-  describe("persistToolCallWriteAhead", () => {
-    it("inserts a tool_calls row with status='pending' BEFORE tool execution", () => {
-      persistToolCallWriteAhead(
-        "session-xyz",
-        42,
-        "tool-call-abc",
-        "read_file",
-        JSON.stringify({ path: "/etc/hosts" }),
-      );
-
-      expect(preparedCalls).toHaveLength(1);
-      const call = preparedCalls[0]!;
-      expect(call.sql).toMatch(/INSERT OR IGNORE INTO tool_calls/);
-      expect(call.sql).toMatch(/'pending'/);
-      // started_at populated, completed_at NULL.
-      expect(call.sql).toMatch(/completed_at/);
-      expect(call.sql).toMatch(/NULL/);
-
-      // Run args: sessionId, messageSeq, toolCallId, toolName, argsJson, timestamp
-      expect(call.runArgs).toContain("session-xyz");
-      expect(call.runArgs).toContain(42);
-      expect(call.runArgs).toContain("tool-call-abc");
-      expect(call.runArgs).toContain("read_file");
-      const argsJsonArg = call.runArgs.find((a) => typeof a === "string" && a.includes("/etc/hosts"));
-      expect(argsJsonArg).toBeTruthy();
-    });
-
-    it("is fail-open: a thrown SQL error does NOT propagate to the orchestrator", () => {
-      dbShouldThrow = true;
-      try {
-        expect(() => persistToolCallWriteAhead("session-y", 1, "tc-1", "bash", "{}")).not.toThrow();
-      } finally {
-        dbShouldThrow = false;
-      }
-    });
-
-    it("accepts -1 as a sentinel message_seq when prediction is unavailable", () => {
-      persistToolCallWriteAhead("session-zzz", -1, "tc-2", "grep", "{}");
-
-      expect(preparedCalls).toHaveLength(1);
-      expect(preparedCalls[0]!.runArgs).toContain(-1);
-    });
-  });
-
-  describe("markToolCallErrored", () => {
-    it("updates the row to status='errored' with a completed_at timestamp", () => {
-      markToolCallErrored("session-a", "tc-99", "tool execution threw");
-
-      expect(preparedCalls).toHaveLength(1);
-      const call = preparedCalls[0]!;
-      expect(call.sql).toMatch(/UPDATE tool_calls/);
-      expect(call.sql).toMatch(/SET status = 'errored'/);
-      expect(call.sql).toMatch(/completed_at = \?/);
-
-      expect(call.runArgs).toContain("session-a");
-      expect(call.runArgs).toContain("tc-99");
-    });
-
-    it("truncates extreme error messages to 500 chars in the fallback args_json", () => {
-      const huge = "x".repeat(2_000);
-      markToolCallErrored("session-b", "tc-100", huge);
-
-      expect(preparedCalls).toHaveLength(1);
-      const call = preparedCalls[0]!;
-      const fallbackArgsJson = call.runArgs.find((a) => typeof a === "string" && a.startsWith('{"error":')) as
-        | string
-        | undefined;
-      expect(fallbackArgsJson).toBeDefined();
-      // Parsed shape: {"error":"xxx...xxx"} — payload <= 500 chars + JSON overhead.
-      expect(fallbackArgsJson!.length).toBeLessThan(600);
-    });
-
-    it("is fail-open: a thrown SQL error does NOT propagate", () => {
-      dbShouldThrow = true;
-      try {
-        expect(() => markToolCallErrored("session-c", "tc-200", "boom")).not.toThrow();
-      } finally {
-        dbShouldThrow = false;
-      }
-    });
-  });
-
-  describe("integration: pending → completed handoff via appendMessages", () => {
-    it("documents the contract: write-ahead uses INSERT OR IGNORE so post-stream UPDATE finalizes the same row", () => {
-      // This test pins the SQL contract — appendMessages() in transcript.ts
-      // uses the same (session_id, tool_call_id) UNIQUE constraint to UPDATE
-      // the pending row to status='completed' after the turn settles.
-      //
-      // If a future refactor switches write-ahead to plain INSERT, the
-      // post-stream path would hit a UNIQUE constraint violation and the
-      // whole turn-persistence transaction would roll back.
-      persistToolCallWriteAhead("s", 1, "tc-shared", "bash", "{}");
-      expect(preparedCalls[0]!.sql).toContain("INSERT OR IGNORE");
-    });
-  });
-});

package/src/orchestrator/abort.test.ts

@@ -1,37 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { createAbortContext } from "./abort.js";
-
-describe("AbortContext", () => {
-  it("Test 1: initial state — not aborted", () => {
-    const ctx = createAbortContext();
-    expect(ctx.signal.aborted).toBe(false);
-    expect(ctx.isAborted()).toBe(false);
-    expect(ctx.reason()).toBeUndefined();
-  });
-
-  it("Test 1: after abort — signal is aborted and reason is captured", () => {
-    const ctx = createAbortContext();
-    ctx.abort("test");
-    expect(ctx.signal.aborted).toBe(true);
-    expect(ctx.isAborted()).toBe(true);
-    expect(ctx.reason()).toBe("test");
-  });
-
-  it("Test 2: abort is idempotent — second call does not throw", () => {
-    const ctx = createAbortContext();
-    expect(() => {
-      ctx.abort("first");
-      ctx.abort("second");
-    }).not.toThrow();
-    // Reason captured from first call only
-    expect(ctx.reason()).toBe("first");
-  });
-
-  it("Test 2: abort with no reason is idempotent", () => {
-    const ctx = createAbortContext();
-    ctx.abort();
-    ctx.abort("later");
-    expect(ctx.isAborted()).toBe(true);
-    expect(ctx.reason()).toBeUndefined();
-  });
-});

package/src/orchestrator/abort.ts

@@ -1,51 +0,0 @@
-/**
- * AbortContext — single-owner AbortController wrapper for the orchestrator.
- *
- * Rules:
- * - One AbortContext per user message turn (created fresh by the orchestrator).
- * - The signal is threaded into streamText, tool runner, and EE intercept calls.
- * - abort() is idempotent — safe to call from multiple signal paths (SIGINT,
- *   EE timeout, etc.). First call wins; subsequent calls are no-ops.
- *
- * Mitigates: Pitfall 2 (orchestrator-level abort safely terminates all I/O).
- * References: TUI-04, 00-CONTEXT.md decision — orchestrator owns controller.
- */
-
-export interface AbortContext {
-  /** The underlying AbortSignal — thread this into every async I/O call. */
-  signal: AbortSignal;
-
-  /**
-   * Abort the context with an optional reason string.
-   * Safe to call multiple times — only the first call has effect.
-   */
-  abort(reason?: string): void;
-
-  /** Returns true once abort() has been called. */
-  isAborted(): boolean;
-
-  /** Returns the reason string passed to the first abort() call, or undefined. */
-  reason(): string | undefined;
-}
-
-/**
- * Creates a fresh AbortContext.  Call once per user message turn.
- */
-export function createAbortContext(): AbortContext {
-  const controller = new AbortController();
-  let _reason: string | undefined;
-
-  return {
-    signal: controller.signal,
-
-    abort(reason?: string) {
-      if (controller.signal.aborted) return; // idempotent
-      _reason = reason;
-      controller.abort(reason);
-    },
-
-    isAborted: () => controller.signal.aborted,
-
-    reason: () => _reason,
-  };
-}

package/src/orchestrator/agent-options.ts

@@ -1,167 +0,0 @@
-import type { ModelInfo, ToolCall, ToolResult } from "../types/index";
-import type { PermissionMode } from "../utils/permission-mode.js";
-import type { SandboxMode, SandboxSettings } from "../utils/settings";
-import type { ShellSettings } from "../utils/shell";
-import type { AbortContext } from "./abort.js";
-import type { PendingCallsLog } from "./pending-calls.js";
-
-// ---------------------------------------------------------------------------
-// Re-export types from shared runtime module for back-compat
-// ---------------------------------------------------------------------------
-
-export type { ProviderFactory as LegacyProvider, ResolvedModelRuntime } from "../providers/runtime.js";
-
-/** @deprecated Use ModelInfo from "../types/index" instead. */
-export type ModelInfoStub = ModelInfo;
-
-// Batch API type stubs
-export interface BatchClientOptions {
-  apiKey: string;
-  baseURL?: string;
-  signal?: AbortSignal;
-}
-
-export interface CouncilOutcome {
-  type: "decision" | "action_items" | "plan_update" | "resolve_question";
-  summary: string;
-  agreed: string[];
-  tradeoffs: string[];
-  recommendation: string;
-  actionItems?: string[];
-  planUpdate?: string;
-  resolvedQuestion?: { question: string; answer: string };
-}
-
-// Council role ANSI color codes for terminal UI
-export const COUNCIL_ROLE_COLORS: Record<string, string> = {
-  implement: "\x1b[36m", // Cyan
-  verify: "\x1b[33m", // Yellow
-  research: "\x1b[35m", // Magenta
-  leader: "\x1b[32m", // Green
-};
-export const COUNCIL_COLOR_RESET = "\x1b[0m";
-export const COUNCIL_COLOR_BG: Record<string, string> = {
-  implement: "\x1b[46m", // Cyan background
-  verify: "\x1b[43m", // Yellow background
-  research: "\x1b[45m", // Magenta background
-  leader: "\x1b[42m", // Green background
-};
-
-export interface BatchChatMessage {
-  role: string;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  content: any;
-  tool_call_id?: string;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  tool_calls?: any[];
-  name?: string;
-}
-
-export interface BatchFunctionTool {
-  type: "function";
-  function: { name: string; description?: string; parameters?: unknown };
-}
-
-export interface BatchToolCall {
-  id: string;
-  type: "function";
-  function: { name: string; arguments: string };
-}
-
-export interface BatchChatCompletionRequest {
-  model: string;
-  messages: BatchChatMessage[];
-  tools?: BatchFunctionTool[];
-  temperature?: number;
-  max_tokens?: number;
-  reasoning_effort?: string;
-}
-
-export interface BatchChatCompletionResponse {
-  choices: Array<{
-    message: { role: string; content: string | null; tool_calls?: BatchToolCall[] };
-    finish_reason: string;
-  }>;
-  usage?: {
-    prompt_tokens: number;
-    completion_tokens: number;
-    total_tokens: number;
-    input_tokens?: number;
-    output_tokens?: number;
-    cost_in_usd_ticks?: number;
-  };
-}
-
-export type ProcessMessageFinishReason = "stop" | "length" | "content-filter" | "tool-calls" | "error" | "other";
-
-export interface ProcessMessageUsage {
-  inputTokens?: number;
-  outputTokens?: number;
-  totalTokens?: number;
-  costUsdTicks?: number;
-  cacheReadTokens?: number;
-  cacheCreationTokens?: number;
-  /**
-   * Input tokens that did NOT hit a server-side cache. Populated when the
-   * provider reports a cache-miss split (e.g. DeepSeek `prompt_cache_miss_tokens`,
-   * OpenAI `prompt_tokens_details.cached_tokens` derivative). When undefined,
-   * downstream consumers should compute it as
-   * `max(0, inputTokens - cacheReadTokens - cacheCreationTokens)`.
-   */
-  noCacheInputTokens?: number;
-}
-
-export interface ProcessMessageStepStart {
-  stepNumber: number;
-  timestamp: number;
-}
-
-export interface ProcessMessageStepFinish {
-  stepNumber: number;
-  timestamp: number;
-  finishReason: ProcessMessageFinishReason;
-  usage: ProcessMessageUsage;
-}
-
-export interface ProcessMessageToolStart {
-  toolCall: ToolCall;
-  timestamp: number;
-}
-
-export interface ProcessMessageToolFinish {
-  toolCall: ToolCall;
-  toolResult: ToolResult;
-  timestamp: number;
-}
-
-export interface ProcessMessageError {
-  message: string;
-  timestamp: number;
-}
-
-export interface ProcessMessageObserver {
-  onStepStart?(info: ProcessMessageStepStart): void;
-  onStepFinish?(info: ProcessMessageStepFinish): void;
-  onToolStart?(info: ProcessMessageToolStart): void;
-  onToolFinish?(info: ProcessMessageToolFinish): void;
-  onError?(info: ProcessMessageError): void;
-}
-
-export interface AgentOptions {
-  persistSession?: boolean;
-  session?: string;
-  sandboxMode?: SandboxMode;
-  sandboxSettings?: SandboxSettings;
-  /** Shell used by the bash tool. Falls back to user/project settings, then platform auto-detect. */
-  shellSettings?: ShellSettings;
-  batchApi?: boolean;
-  /** Optional external AbortContext (from src/index.ts SIGINT handler). When provided,
-   *  the orchestrator uses its signal instead of creating a new AbortController per turn.
-   *  TUI-04: Ctrl+C mid-tool-call abort safety. */
-  abortContext?: AbortContext;
-  /** Optional PendingCallsLog for Pitfall 9 staged-write tracking per tool call. */
-  pendingCalls?: PendingCallsLog;
-  /** Permission mode controlling which tool calls require manual approval.
-   *  safe (default) = confirm all; auto-edit = auto-approve file ops; yolo = auto-approve all. */
-  permissionMode?: PermissionMode;
-}

package/src/orchestrator/agent.test.ts

@@ -1,191 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-async function importAgentModule() {
-  vi.resetModules();
-  const { loadCatalog } = await import("../models/registry.js");
-  await loadCatalog();
-  vi.doMock("../storage/index", () => ({
-    appendCompaction: vi.fn(),
-    appendMessages: vi.fn(() => []),
-    appendSystemMessage: vi.fn(() => 0),
-    buildChatEntries: vi.fn(() => []),
-    getNextMessageSequence: vi.fn(() => 0),
-    getSessionTotalTokens: vi.fn(() => 0),
-    loadTranscript: vi.fn(() => []),
-    loadTranscriptState: vi.fn(() => ({ messages: [], seqs: [] })),
-    recordUsageEvent: vi.fn(),
-    SessionStore: class {
-      getWorkspace() {
-        return null;
-      }
-      openSession() {
-        return null;
-      }
-      createSession() {
-        return null;
-      }
-      setModel() {}
-      getRequiredSession() {
-        return null;
-      }
-      setMode() {}
-      touchSession() {}
-    },
-  }));
-
-  return import("./orchestrator");
-}
-
-afterEach(() => {
-  vi.restoreAllMocks();
-  vi.resetModules();
-  vi.doUnmock("../storage/index.js");
-});
-
-describe("Agent class", { timeout: 30_000 }, () => {
-  it("constructs with default options", async () => {
-    const { Agent } = await importAgentModule();
-    const agent = new Agent(undefined, undefined, undefined, undefined, {
-      persistSession: false,
-    });
-    expect(agent).toBeDefined();
-    expect(agent.getMode()).toBe("agent");
-  });
-
-  it("can switch mode", async () => {
-    const { Agent } = await importAgentModule();
-    const agent = new Agent(undefined, undefined, undefined, undefined, {
-      persistSession: false,
-    });
-    agent.setMode("plan");
-    expect(agent.getMode()).toBe("plan");
-    agent.setMode("ask");
-    expect(agent.getMode()).toBe("ask");
-    agent.setMode("agent");
-    expect(agent.getMode()).toBe("agent");
-  });
-
-  it("returns a model string", async () => {
-    const { Agent } = await importAgentModule();
-    const agent = new Agent(undefined, undefined, undefined, undefined, {
-      persistSession: false,
-    });
-    const model = agent.getModel();
-    expect(typeof model).toBe("string");
-    expect(model.length).toBeGreaterThan(0);
-  });
-
-  it("can set model", async () => {
-    const { Agent } = await importAgentModule();
-    const agent = new Agent(undefined, undefined, undefined, undefined, {
-      persistSession: false,
-    });
-    agent.setModel("claude-sonnet-4-6-20250514");
-    expect(agent.getModel()).toBe("claude-sonnet-4-6-20250514");
-  });
-
-  it("constructs with sandbox mode", async () => {
-    const { Agent } = await importAgentModule();
-    const agent = new Agent(undefined, undefined, undefined, undefined, {
-      persistSession: false,
-      sandboxMode: "shuru",
-    });
-    expect(agent.getSandboxMode()).toBe("shuru");
-  });
-
-  it("defaults sandbox mode to off", async () => {
-    const { Agent } = await importAgentModule();
-    const agent = new Agent(undefined, undefined, undefined, undefined, {
-      persistSession: false,
-    });
-    expect(agent.getSandboxMode()).toBe("off");
-  });
-
-  it("constructs with sandbox settings", async () => {
-    const { Agent } = await importAgentModule();
-    const settings = { allowNet: true, cpus: 4 };
-    const agent = new Agent(undefined, undefined, undefined, undefined, {
-      persistSession: false,
-      sandboxMode: "shuru",
-      sandboxSettings: settings,
-    });
-    expect(agent.getSandboxSettings()).toEqual(settings);
-  });
-
-  it("buffers council question answers that arrive before the resolver is registered", async () => {
-    // Headless auto-answer race: respondToCouncilQuestion fires after the
-    // chunk yields but BEFORE the council generator's await on
-    // respondToQuestion(qid) registers a resolver. The buffer must catch
-    // the answer so the eventual Promise resolves immediately.
-    //
-    // This behavior lives on CouncilManager (extracted from Agent in Phase 12.1-02).
-    // We test it here via CouncilManager directly since _createQuestionResponder
-    // was never a method on Agent.
-    const { CouncilManager } = await import("./council-manager");
-    const stubDeps = {
-      getModelId: () => "stub",
-      getSessionId: () => null,
-      hasSessionStore: () => false,
-      getMessages: () => [],
-      getBash: () => ({}) as never,
-      getMode: () => "agent" as const,
-    };
-    const m = new CouncilManager(stubDeps);
-
-    m.respondToQuestion("qid-1", "buffered-answer");
-    const promise = m.createQuestionResponder()("qid-1");
-    await expect(promise).resolves.toBe("buffered-answer");
-
-    // After consumption the buffer slot is gone — a second responder waits.
-    const stalled = m.createQuestionResponder()("qid-1");
-    let settled = false;
-    void stalled.then(() => {
-      settled = true;
-    });
-    await new Promise((r) => setTimeout(r, 10));
-    expect(settled).toBe(false);
-    m.respondToQuestion("qid-1", "second");
-    await expect(stalled).resolves.toBe("second");
-  });
-
-  it("buffers council preflight approvals before the resolver registers", async () => {
-    const { CouncilManager } = await import("./council-manager");
-    const stubDeps = {
-      getModelId: () => "stub",
-      getSessionId: () => null,
-      hasSessionStore: () => false,
-      getMessages: () => [],
-      getBash: () => ({}) as never,
-      getMode: () => "agent" as const,
-    };
-    const m = new CouncilManager(stubDeps);
-    m.respondToPreflight("pf-1", false);
-    await expect(m.createPreflightResponder()("pf-1")).resolves.toBe(false);
-  });
-
-  it("respects MUONROI_MAX_TOKENS env var", async () => {
-    vi.stubEnv("MUONROI_MAX_TOKENS", "32768");
-    const { Agent } = await importAgentModule();
-    const agent = new Agent(undefined, undefined, undefined, undefined, {
-      persistSession: false,
-    });
-    expect(agent).toBeDefined();
-  });
-
-  it("constructs with permission mode", async () => {
-    const { Agent } = await importAgentModule();
-    const agent = new Agent(undefined, undefined, undefined, undefined, {
-      persistSession: false,
-      permissionMode: "yolo",
-    });
-    expect(agent).toBeDefined();
-  });
-
-  it("constructs with explicit model parameter", async () => {
-    const { Agent } = await importAgentModule();
-    const agent = new Agent(undefined, undefined, "claude-sonnet-4-6-20250514", undefined, {
-      persistSession: false,
-    });
-    expect(agent.getModel()).toBe("claude-sonnet-4-6-20250514");
-  });
-});