muonroi-cli 1.4.0 → 1.4.1

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

@@ -1,170 +0,0 @@
-/**
- * src/storage/ui-interaction-log.ts
- *
- * Typed, fail-open helpers for persisting UI lifecycle events (askcard
- * open/answered/cancel, sprint stage transitions, sprint halt, route
- * decisions) into `interaction_logs` with event_type='ui_interaction'.
- *
- * The matching LiveEvent payloads are emitted to the harness sidechannel
- * for E2E tests — these helpers persist the *same* events so that
- * `/export` can render an Interaction Timeline section reconstructing
- * what the user did (which option, which key, at what step).
- *
- * All calls are fire-and-forget — DB errors must never break the UI flow.
- */
-
-import { logInteraction } from "./interaction-log.js";
-
-export type UIInteractionSubtype =
-  | "route_decision"
-  | "sprint_stage"
-  | "sprint_halt"
-  | "askcard_open"
-  | "askcard_answered"
-  | "askcard_cancel"
-  | "halt_card_open"
-  | "halt_card_answered"
-  | "init_new_step"
-  | "init_new_submitted"
-  | "init_new_result"
-  | "init_new_resume"
-  | "init_new_retry";
-
-interface RouteDecisionPayload {
-  path: "hot-path" | "council" | "maintain";
-  complexity: string;
-  forceCouncil: boolean;
-  /** PIL sufficiency gaps that forced the Council path (empty when complete). */
-  sufficiencyMissing?: readonly string[];
-  runId: string;
-}
-
-interface SprintStagePayload {
-  sprintIndex: number;
-  stage: "planning" | "implementation" | "verification" | "judgment";
-  runId: string;
-}
-
-interface SprintHaltPayload {
-  sprintN: number;
-  reason: string;
-  runId: string;
-}
-
-interface AskcardOpenPayload {
-  questionId: string;
-  question: string;
-  phase: string;
-  optionCount: number;
-  defaultIndex?: number;
-  /**
-   * The rendered option labels, in order. Persisted so a DB / `usage forensics`
-   * audit can measure WHAT the "Recommended" badge pointed at — not just its
-   * index. Without it, recommend-correctness (e.g. the scope-card "Entire
-   * project" fix) was unverifiable from past sessions: metadata only carried
-   * optionCount + defaultIndex, never the labels.
-   */
-  optionLabels?: string[];
-  /** Convenience: optionLabels[defaultIndex] — the recommended option's label. */
-  recommendedLabel?: string;
-}
-
-interface AskcardAnsweredPayload {
-  questionId: string;
-  answerKind: string;
-  answerText: string;
-  /**
-   * The label of the chosen option as rendered to the user. Lets `usage
-   * forensics` and the export timeline answer "what was actually selected"
-   * without cross-referencing the matching askcard_open row — e.g. when
-   * answerText is "accept" the label still carries the underlying
-   * recommendation value ("Recommended: 'saas' — …").
-   */
-  selectedOptionLabel?: string;
-}
-
-interface AskcardCancelPayload {
-  questionId: string;
-}
-
-interface HaltCardOpenPayload {
-  reason: string;
-  optionCount: number;
-  optionIds: string[];
-}
-
-interface HaltCardAnsweredPayload {
-  chosenId: string;
-  chosenLabel: string;
-  index: number;
-}
-
-interface InitNewStepPayload {
-  from: string;
-  to: string;
-}
-
-interface InitNewSubmittedPayload {
-  projectName: string;
-  feStack: string;
-  bbTemplate: string | null;
-  packageCount: number;
-}
-
-interface InitNewResultPayload {
-  outcome: "done" | "error";
-  message: string;
-  usedDotnetTemplate?: boolean;
-  /**
-   * Plan 23-fix — true when this result came from a manual retry in the
-   * error state (no re-running of council debate). Lets forensics see
-   * how often the retry path fires vs first-attempt success.
-   */
-  viaRetry?: boolean;
-}
-
-interface InitNewResumePayload {
-  projectDir: string;
-  templateName: string;
-  originalPrompt: string;
-  /** Plan 23-fix — set when resume followed a retry rather than first scaffold. */
-  viaRetry?: boolean;
-}
-
-interface InitNewRetryPayload {
-  projectName: string;
-  feStack: string;
-  bbTemplate: string | null;
-}
-
-type Payload =
-  | { subtype: "route_decision"; data: RouteDecisionPayload }
-  | { subtype: "sprint_stage"; data: SprintStagePayload }
-  | { subtype: "sprint_halt"; data: SprintHaltPayload }
-  | { subtype: "askcard_open"; data: AskcardOpenPayload }
-  | { subtype: "askcard_answered"; data: AskcardAnsweredPayload }
-  | { subtype: "askcard_cancel"; data: AskcardCancelPayload }
-  | { subtype: "halt_card_open"; data: HaltCardOpenPayload }
-  | { subtype: "halt_card_answered"; data: HaltCardAnsweredPayload }
-  | { subtype: "init_new_step"; data: InitNewStepPayload }
-  | { subtype: "init_new_submitted"; data: InitNewSubmittedPayload }
-  | { subtype: "init_new_result"; data: InitNewResultPayload }
-  | { subtype: "init_new_resume"; data: InitNewResumePayload }
-  | { subtype: "init_new_retry"; data: InitNewRetryPayload };
-
-/**
- * Persist a UI lifecycle event. Caller passes a discriminated payload so
- * downstream consumers (export renderer, future analytics) can rely on a
- * fixed shape per subtype without parsing free-form JSON.
- */
-export function logUIInteraction(sessionId: string | undefined | null, payload: Payload): void {
-  if (!sessionId) return;
-  try {
-    logInteraction(sessionId, "ui_interaction", {
-      eventSubtype: payload.subtype,
-      data: payload.data as unknown as Record<string, unknown>,
-    });
-  } catch {
-    // Fail-open
-  }
-}

package/src/storage/usage-cap.test.ts

@@ -1,59 +0,0 @@
-import { promises as fs } from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { atomicWriteJSON } from "./atomic-io.js";
-import { loadUsage, saveUsage } from "./usage-cap.js";
-
-let tmpDir: string;
-
-beforeEach(async () => {
-  tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "usage-test-"));
-});
-
-afterEach(async () => {
-  await fs.rm(tmpDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-});
-
-function currentMonthUTC(): string {
-  const d = new Date();
-  const yyyy = d.getUTCFullYear();
-  const mm = String(d.getUTCMonth() + 1).padStart(2, "0");
-  return `${yyyy}-${mm}`;
-}
-
-describe("loadUsage", () => {
-  it("Test 7: bootstraps usage.json when absent", async () => {
-    const state = await loadUsage(tmpDir);
-    expect(state.current_month_utc).toBe(currentMonthUTC());
-    expect(state.current_usd).toBe(0);
-    expect(state.reservations).toEqual([]);
-
-    // File must be written
-    const raw = await fs.readFile(path.join(tmpDir, "usage.json"), "utf8");
-    const parsed = JSON.parse(raw);
-    expect(parsed.current_usd).toBe(0);
-  });
-
-  it("Test 9: auto-resets on stale month", async () => {
-    // Write a state with a past month
-    await atomicWriteJSON(path.join(tmpDir, "usage.json"), {
-      current_month_utc: "2026-03",
-      current_usd: 5.5,
-      reservations: [],
-    });
-
-    const state = await loadUsage(tmpDir);
-    expect(state.current_month_utc).toBe(currentMonthUTC());
-    expect(state.current_usd).toBe(0);
-  });
-});
-
-describe("saveUsage", () => {
-  it("Test 8: round-trips via loadUsage", async () => {
-    const initial = await loadUsage(tmpDir);
-    await saveUsage({ ...initial, current_usd: 1.23 }, tmpDir);
-    const loaded = await loadUsage(tmpDir);
-    expect(loaded.current_usd).toBe(1.23);
-  });
-});

package/src/storage/usage-cap.ts

@@ -1,81 +0,0 @@
-import * as os from "node:os";
-import * as path from "node:path";
-import { atomicReadJSON, atomicWriteJSON } from "./atomic-io.js";
-
-/**
- * TUI-owned monthly usage state stored at ~/.muonroi-cli/usage.json.
- *
- * Phase 0 scope: schema + atomic IO + boot read + month-rollover only.
- * No enforcement, no thresholds, no auto-downgrade — those land in Phase 1 USAGE-02..05/07.
- *
- * Architecture anti-pattern 4: this file is owned exclusively by the TUI process.
- */
-export interface UsageState {
-  current_month_utc: string; // "YYYY-MM" e.g. "2026-04"
-  current_usd: number; // running spend this month
-  reservations: Array<{
-    id: string;
-    usd: number;
-    createdAtMs: number;
-    model?: string;
-    provider?: string;
-    est_input_tokens?: number;
-    est_output_tokens?: number;
-  }>; // Phase 1 fills
-  thresholds_fired_this_month?: number[]; // e.g. [50, 80] -- used by thresholds.ts to dedupe per month
-}
-
-function currentMonthUTC(d: Date = new Date()): string {
-  const yyyy = d.getUTCFullYear();
-  const mm = String(d.getUTCMonth() + 1).padStart(2, "0");
-  return `${yyyy}-${mm}`;
-}
-
-/**
- * Resolve the ~/.muonroi-cli/ home directory.
- * Priority: explicit override → MUONROI_CLI_HOME env → os.homedir()/.muonroi-cli
- */
-function muonroiHome(override?: string): string {
-  return override ?? process.env.MUONROI_CLI_HOME ?? path.join(os.homedir(), ".muonroi-cli");
-}
-
-function defaultState(): UsageState {
-  return { current_month_utc: currentMonthUTC(), current_usd: 0, reservations: [], thresholds_fired_this_month: [] };
-}
-
-/**
- * Load usage state from ~/.muonroi-cli/usage.json.
- * - If absent: writes and returns a fresh default state.
- * - If month has rolled over: resets current_usd to 0 and rewrites the file.
- * Accepts an optional homeOverride for test isolation.
- */
-export async function loadUsage(homeOverride?: string): Promise<UsageState> {
-  const filePath = path.join(muonroiHome(homeOverride), "usage.json");
-  const existing = await atomicReadJSON<UsageState>(filePath);
-  if (!existing) {
-    const state = defaultState();
-    await atomicWriteJSON(filePath, state);
-    return state;
-  }
-  // Month rollover: reset spend if the stored month is stale
-  if (existing.current_month_utc !== currentMonthUTC()) {
-    const reset: UsageState = {
-      current_month_utc: currentMonthUTC(),
-      current_usd: 0,
-      reservations: [],
-      thresholds_fired_this_month: [],
-    };
-    await atomicWriteJSON(filePath, reset);
-    return reset;
-  }
-  return existing;
-}
-
-/**
- * Persist usage state atomically to ~/.muonroi-cli/usage.json.
- * Accepts an optional homeOverride for test isolation.
- */
-export async function saveUsage(state: UsageState, homeOverride?: string): Promise<void> {
-  const filePath = path.join(muonroiHome(homeOverride), "usage.json");
-  await atomicWriteJSON(filePath, state);
-}

package/src/storage/usage.ts

@@ -1,117 +0,0 @@
-import { getModelInfo } from "../models/registry.js";
-import type { UsageEvent, UsageSource } from "../types/index";
-import { getDatabase } from "./db";
-
-interface UsageRow {
-  id: number;
-  session_id: string;
-  message_seq: number | null;
-  source: UsageSource;
-  model: string;
-  input_tokens: number;
-  output_tokens: number;
-  total_tokens: number;
-  cost_micros: number;
-  created_at: string;
-  cache_read_tokens: number;
-  cache_creation_tokens: number;
-}
-
-export interface TokenUsageLike {
-  inputTokens?: number;
-  outputTokens?: number;
-  totalTokens?: number;
-  cacheReadTokens?: number;
-  cacheCreationTokens?: number;
-}
-
-export function recordUsageEvent(
-  sessionId: string,
-  source: UsageSource,
-  model: string,
-  usage?: TokenUsageLike,
-  messageSeq?: number | null,
-  pilActive = false,
-  enrichmentDelta = 0,
-  providerOptionsShape: string | null = null,
-): void {
-  if (!usage) return;
-
-  const inputTokens = usage.inputTokens ?? 0;
-  const outputTokens = usage.outputTokens ?? 0;
-  const totalTokens = usage.totalTokens ?? inputTokens + outputTokens;
-  if (inputTokens <= 0 && outputTokens <= 0 && totalTokens <= 0) return;
-
-  const cacheReadTokens = usage.cacheReadTokens ?? 0;
-  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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `)
-    .run(
-      sessionId,
-      messageSeq ?? null,
-      source,
-      model,
-      inputTokens,
-      outputTokens,
-      totalTokens,
-      costMicros,
-      new Date().toISOString(),
-      pilActive ? 1 : 0,
-      enrichmentDelta,
-      cacheReadTokens,
-      cacheCreationTokens,
-      providerOptionsShape,
-    );
-}
-
-export function getSessionTotalTokens(sessionId: string): number {
-  const row = getDatabase()
-    .prepare(`
-    SELECT COALESCE(SUM(total_tokens), 0) AS total_tokens
-    FROM usage_events
-    WHERE session_id = ?
-  `)
-    .get(sessionId) as { total_tokens: number } | undefined;
-
-  return row?.total_tokens ?? 0;
-}
-
-export function listSessionUsage(sessionId: string): UsageEvent[] {
-  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
-  `)
-    .all(sessionId) as UsageRow[];
-
-  return rows.map((row) => ({
-    id: row.id,
-    sessionId: row.session_id,
-    messageSeq: row.message_seq,
-    source: row.source,
-    model: row.model,
-    inputTokens: row.input_tokens,
-    outputTokens: row.output_tokens,
-    totalTokens: row.total_tokens,
-    costMicros: row.cost_micros,
-    createdAt: new Date(row.created_at),
-    cacheReadTokens: row.cache_read_tokens ?? 0,
-    cacheCreationTokens: row.cache_creation_tokens ?? 0,
-  }));
-}
-
-function estimateCostMicros(model: string, inputTokens: number, outputTokens: number, cacheReadTokens = 0): number {
-  const info = getModelInfo(model);
-  if (!info) return 0;
-  const cachedPrice = info.cachedInputPrice ?? info.inputPrice * 0.1;
-  const nonCachedInput = Math.max(0, inputTokens - cacheReadTokens);
-  return Math.round(nonCachedInput * info.inputPrice + cacheReadTokens * cachedPrice + outputTokens * info.outputPrice);
-}

package/src/storage/workspaces.ts

@@ -1,84 +0,0 @@
-import { createHash } from "crypto";
-import fs from "fs";
-import path from "path";
-import type { WorkspaceInfo } from "../types/index";
-import { findGitRoot } from "../utils/git-root";
-import { getDatabase } from "./db";
-
-interface WorkspaceRow {
-  id: string;
-  scope_key: string;
-  canonical_path: string;
-  git_root: string | null;
-  display_name: string;
-  last_seen_at: string;
-}
-
-export interface ResolvedWorkspace {
-  scopeKey: string;
-  canonicalPath: string;
-  gitRoot: string | null;
-  displayName: string;
-}
-
-export function ensureWorkspace(cwd: string): WorkspaceInfo {
-  const resolved = resolveWorkspace(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
-  `).run({
-    id,
-    scope_key: resolved.scopeKey,
-    canonical_path: resolved.canonicalPath,
-    git_root: resolved.gitRoot,
-    display_name: resolved.displayName,
-    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 = ?
-  `)
-    .get(resolved.scopeKey) as WorkspaceRow | undefined;
-
-  if (!row) {
-    throw new Error(`Failed to resolve workspace for ${cwd}`);
-  }
-
-  return toWorkspaceInfo(row);
-}
-
-export function resolveWorkspace(cwd: string): ResolvedWorkspace {
-  const canonicalPath = fs.realpathSync.native(cwd);
-  const gitRoot = findGitRoot(canonicalPath);
-  const scopePath = gitRoot || canonicalPath;
-
-  return {
-    scopeKey: scopePath,
-    canonicalPath,
-    gitRoot,
-    displayName: path.basename(scopePath) || "workspace",
-  };
-}
-
-function toWorkspaceInfo(row: WorkspaceRow): WorkspaceInfo {
-  return {
-    id: row.id,
-    scopeKey: row.scope_key,
-    canonicalPath: row.canonical_path,
-    gitRoot: row.git_root,
-    displayName: row.display_name,
-    lastSeenAt: new Date(row.last_seen_at),
-  };
-}

package/src/tools/__tests__/vision-gate.test.ts

@@ -1,66 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { messagesHaveImagePart, VISION_TOOL_NAMES, visionToolsNeeded } from "../vision-gate.js";
-
-describe("visionToolsNeeded", () => {
-  it("drops vision tools for a pure-text turn with no image anywhere", () => {
-    expect(visionToolsNeeded({ userMessage: "what is this project about?", messages: [], cachedImageCount: 0 })).toBe(
-      false,
-    );
-    expect(visionToolsNeeded({ userMessage: "fix the auth bug in src/auth/login.ts" })).toBe(false);
-  });
-
-  it("keeps vision tools when the message text references an image", () => {
-    for (const msg of [
-      "analyze screenshot.png",
-      "what does this diagram show?",
-      "review the figma mockup",
-      "here is a data:image/png;base64,AAAA",
-      "phân tích cái ảnh này giúp tôi",
-    ]) {
-      expect(visionToolsNeeded({ userMessage: msg })).toBe(true);
-    }
-  });
-
-  it("keeps vision tools when the turn carries an image content part (attachment)", () => {
-    const messages = [
-      {
-        role: "user",
-        content: [
-          { type: "text", text: "what is this?" },
-          { type: "image", mediaType: "image/png", data: "BASE64" },
-        ],
-      },
-    ];
-    expect(visionToolsNeeded({ userMessage: "what is this?", messages })).toBe(true);
-  });
-
-  it("keeps vision tools when earlier turns cached images (follow-up queries)", () => {
-    expect(visionToolsNeeded({ userMessage: "what color is the button?", cachedImageCount: 2 })).toBe(true);
-  });
-
-  it("keeps vision tools on a continuation that already used tools (BUG-A guard)", () => {
-    expect(visionToolsNeeded({ userMessage: "continue", priorTurnHadTools: true })).toBe(true);
-  });
-
-  it("exports exactly the three vision tool ids (todo_write / core tools excluded)", () => {
-    expect([...VISION_TOOL_NAMES]).toEqual(["analyze_image", "ask_vision_proxy", "list_vision_cache"]);
-    expect(VISION_TOOL_NAMES).not.toContain("todo_write");
-    expect(VISION_TOOL_NAMES).not.toContain("read_file");
-  });
-});
-
-describe("messagesHaveImagePart", () => {
-  it("detects an image part by type", () => {
-    expect(messagesHaveImagePart([{ role: "user", content: [{ type: "image", data: "x" }] }])).toBe(true);
-  });
-
-  it("detects an image part by mediaType prefix", () => {
-    expect(messagesHaveImagePart([{ role: "user", content: [{ type: "file", mediaType: "image/jpeg" }] }])).toBe(true);
-  });
-
-  it("returns false for text-only content and malformed input", () => {
-    expect(messagesHaveImagePart([{ role: "user", content: [{ type: "text", text: "hi" }] }])).toBe(false);
-    expect(messagesHaveImagePart([{ role: "user", content: "plain string" }])).toBe(false);
-    expect(messagesHaveImagePart(undefined)).toBe(false);
-  });
-});

package/src/tools/bash-output-cache.test.ts

@@ -1,113 +0,0 @@
-import { beforeEach, describe, expect, it } from "vitest";
-import {
-  clearBashOutputCache,
-  getBashRun,
-  listBashRunIds,
-  nextBashRunId,
-  recordBashRun,
-  sliceBashOutput,
-  stripAnsi,
-} from "./bash-output-cache.js";
-
-beforeEach(() => clearBashOutputCache());
-
-describe("stripAnsi", () => {
-  it("removes CSI color sequences", () => {
-    expect(stripAnsi("red text")).toBe("red text");
-  });
-  it("removes vitest's clear-line + cursor-move sequences", () => {
-    expect(stripAnsi(" PASS test.ts")).toBe(" PASS test.ts");
-  });
-  it("returns input unchanged when no ANSI codes present", () => {
-    expect(stripAnsi("plain text")).toBe("plain text");
-  });
-});
-
-describe("recordBashRun / getBashRun", () => {
-  it("round-trips a record", () => {
-    const id = nextBashRunId();
-    recordBashRun({ id, command: "ls", stdout: "a\nb", stderr: "", exitCode: 0, durationMs: 12 });
-    const r = getBashRun(id);
-    expect(r?.command).toBe("ls");
-    expect(r?.stdout).toBe("a\nb");
-  });
-
-  it("returns null for unknown id", () => {
-    expect(getBashRun("bash-9999")).toBeNull();
-  });
-
-  it("LRU evicts oldest entry past 50", () => {
-    for (let i = 0; i < 60; i++) {
-      recordBashRun({ id: `bash-${i}`, command: "c", stdout: "x", stderr: "", exitCode: 0, durationMs: 1 });
-    }
-    expect(listBashRunIds().length).toBe(50);
-    expect(getBashRun("bash-0")).toBeNull();
-    expect(getBashRun("bash-59")).not.toBeNull();
-  });
-
-  it("getBashRun touches LRU (most recently used)", () => {
-    for (let i = 0; i < 50; i++) {
-      recordBashRun({ id: `bash-${i}`, command: "c", stdout: "x", stderr: "", exitCode: 0, durationMs: 1 });
-    }
-    // Touch bash-0 to make it freshest.
-    getBashRun("bash-0");
-    recordBashRun({ id: "bash-50", command: "c", stdout: "x", stderr: "", exitCode: 0, durationMs: 1 });
-    // bash-1 (the next-oldest after bash-0 was touched) should be evicted.
-    expect(getBashRun("bash-0")).not.toBeNull();
-    expect(getBashRun("bash-1")).toBeNull();
-  });
-});
-
-describe("sliceBashOutput", () => {
-  const record = {
-    id: "bash-x",
-    command: "vitest",
-    stdout: ["FAIL test/a.spec.ts", "PASS test/b.spec.ts", "ERROR something", "PASS test/c.spec.ts", "Done"].join("\n"),
-    stderr: "",
-    exitCode: 1,
-    durationMs: 100,
-    completedAt: new Date().toISOString(),
-  };
-
-  it("head returns first N lines", () => {
-    expect(sliceBashOutput(record, { mode: "head", lines: 2 }).text).toBe("FAIL test/a.spec.ts\nPASS test/b.spec.ts");
-  });
-
-  it("tail returns last N lines", () => {
-    expect(sliceBashOutput(record, { mode: "tail", lines: 2 }).text).toBe("PASS test/c.spec.ts\nDone");
-  });
-
-  it("grep filters by regex", () => {
-    const r = sliceBashOutput(record, { mode: "grep", pattern: "FAIL|ERROR" });
-    expect(r.text).toBe("FAIL test/a.spec.ts\nERROR something");
-    expect(r.matchedLines).toBe(2);
-  });
-
-  it("grep respects caseInsensitive", () => {
-    const r = sliceBashOutput(record, { mode: "grep", pattern: "fail", caseInsensitive: true });
-    expect(r.matchedLines).toBe(1);
-  });
-
-  it("lines extracts a range", () => {
-    expect(sliceBashOutput(record, { mode: "lines", range: "2-4" }).text).toBe(
-      "PASS test/b.spec.ts\nERROR something\nPASS test/c.spec.ts",
-    );
-  });
-
-  it("rejects malformed range", () => {
-    const r = sliceBashOutput(record, { mode: "lines", range: "garbage" });
-    expect(r.ok).toBe(false);
-  });
-
-  it("rejects invalid regex without throwing", () => {
-    const r = sliceBashOutput(record, { mode: "grep", pattern: "[" });
-    expect(r.ok).toBe(false);
-    expect(r.text).toMatch(/Invalid regex/);
-  });
-
-  it("merges stderr into output for slicing", () => {
-    const withErr = { ...record, stderr: "stderr line" };
-    const r = sliceBashOutput(withErr, { mode: "full" });
-    expect(r.text).toContain("[stderr]\nstderr line");
-  });
-});