muonroi-cli 1.4.0 → 1.4.1

package/src/maintain/types.ts

@@ -1,49 +0,0 @@
-/**
- * types.ts — Mode C (Maintain) data model.
- * P14: MaintenanceTask + CodebaseIntel shapes.
- * No runtime logic here — pure type declarations.
- */
-
-export type MaintenanceTaskKind = "bug" | "feature" | "refactor" | "chore" | "docs";
-
-export interface MaintenanceTask {
-  id: string; // ULID via crypto.randomUUID()
-  kind: MaintenanceTaskKind;
-  title: string; // 1-line summary
-  description: string; // user's verbatim prompt + parsed details
-  reproSteps?: string;
-  expectedBehavior?: string;
-  observedBehavior?: string;
-  acceptance_criteria: string[]; // 1-3 assertions
-  candidateFiles: string[]; // from P14 — populated post-intel
-  impactRadius: string[];
-  regressionTestFiles: string[];
-  status: "queued" | "in_progress" | "blocked" | "done" | "abandoned";
-  pr?: {
-    branch: string;
-    diff: string;
-    title: string;
-    body: string;
-    createdViaGh?: boolean;
-    url?: string;
-  };
-  createdAtUtc: string;
-  updatedAtUtc: string;
-}
-
-export interface CandidateFile {
-  path: string; // workspace-relative
-  reason: string; // why we picked it
-  matchScore: number; // 0-1
-}
-
-export interface CodebaseIntel {
-  cwd: string;
-  repoMap: string; // truncated to ~2KB
-  repoMapSource: "existing" | "generated"; // tracks D4 decision
-  candidateFiles: CandidateFile[]; // top 5, sorted desc by matchScore
-  impactRadius: string[]; // files that import any candidate
-  regressionTests: string[]; // existing test files referencing candidates
-  detectedFrameworks: string[]; // ["dotnet", "next", "react", "python", "rust", ...]
-  capturedAtUtc: string;
-}

package/src/mcp/__tests__/auto-setup.test.ts

@@ -1,88 +0,0 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-const tmpHome = path.join(os.tmpdir(), `muonroi-cli-auto-setup-${process.pid}`);
-
-describe("ensureDefaultMcpServers — research servers", () => {
-  let origHome: string | undefined;
-  let origUserProfile: string | undefined;
-
-  beforeEach(() => {
-    fs.mkdirSync(tmpHome, { recursive: true });
-    origHome = process.env.HOME;
-    origUserProfile = process.env.USERPROFILE;
-    process.env.HOME = tmpHome;
-    process.env.USERPROFILE = tmpHome;
-    vi.resetModules();
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpHome, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-    if (origHome === undefined) delete process.env.HOME;
-    else process.env.HOME = origHome;
-    if (origUserProfile === undefined) delete process.env.USERPROFILE;
-    else process.env.USERPROFILE = origUserProfile;
-  });
-
-  it("registers context7 + fetch + tavily for a fresh user", async () => {
-    const { ensureDefaultMcpServers } = await import("../auto-setup.js");
-    const merged = ensureDefaultMcpServers();
-    const ids = merged.map((s) => s.id);
-    expect(ids).toContain("context7");
-    expect(ids).toContain("fetch");
-    expect(ids).toContain("tavily");
-  });
-
-  it("context7 and fetch default to enabled", async () => {
-    const { ensureDefaultMcpServers } = await import("../auto-setup.js");
-    const merged = ensureDefaultMcpServers();
-    const c7 = merged.find((s) => s.id === "context7");
-    const fetchEntry = merged.find((s) => s.id === "fetch");
-    expect(c7?.enabled).toBe(true);
-    expect(fetchEntry?.enabled).toBe(true);
-  });
-
-  it("tavily defaults to disabled (key not yet provided)", async () => {
-    const { ensureDefaultMcpServers } = await import("../auto-setup.js");
-    const merged = ensureDefaultMcpServers();
-    const tavily = merged.find((s) => s.id === "tavily");
-    expect(tavily?.enabled).toBe(false);
-  });
-
-  it("does NOT overwrite an existing tavily entry already configured by user", async () => {
-    const settingsPath = path.join(tmpHome, ".muonroi-cli", "user-settings.json");
-    fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
-    fs.writeFileSync(
-      settingsPath,
-      JSON.stringify({
-        mcp: {
-          servers: [
-            {
-              id: "tavily",
-              label: "Tavily Web Search",
-              enabled: true,
-              transport: "stdio",
-              command: "npx",
-              args: ["-y", "tavily-mcp"],
-            },
-          ],
-        },
-      }),
-    );
-    const { ensureDefaultMcpServers } = await import("../auto-setup.js");
-    const merged = ensureDefaultMcpServers();
-    const tavily = merged.find((s) => s.id === "tavily");
-    expect(tavily?.enabled).toBe(true); // user's setting preserved
-  });
-
-  it("is idempotent across repeated calls (no duplicate ids)", async () => {
-    const { ensureDefaultMcpServers } = await import("../auto-setup.js");
-    const first = ensureDefaultMcpServers();
-    const second = ensureDefaultMcpServers();
-    expect(second.map((s) => s.id).sort()).toEqual(first.map((s) => s.id).sort());
-    const ids = second.map((s) => s.id);
-    expect(new Set(ids).size).toBe(ids.length);
-  });
-});

package/src/mcp/__tests__/cap-tool-result.test.ts

@@ -1,65 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { MAX_TOOL_OUTPUT_CHARS } from "../../tools/registry.js";
-import { capMcpToolResult } from "../cap-tool-result.js";
-
-const cap = 1_000;
-
-describe("capMcpToolResult()", () => {
-  it("truncates an over-cap string result", () => {
-    const big = "X".repeat(cap + 5_000);
-    const out = capMcpToolResult(big, cap);
-    expect(typeof out).toBe("string");
-    expect((out as string).length).toBeLessThan(big.length);
-    expect(out as string).toContain("truncated");
-  });
-
-  it("leaves an under-cap string result unchanged", () => {
-    const small = "hello world";
-    expect(capMcpToolResult(small, cap)).toBe(small);
-  });
-
-  it("truncates a huge text part inside a content result", () => {
-    const big = "Y".repeat(cap + 5_000);
-    const result = { type: "content", value: [{ type: "text", text: big }] };
-    const out = capMcpToolResult(result, cap) as { type: string; value: Array<{ type: string; text: string }> };
-    expect(out.type).toBe("content");
-    expect(out.value[0]!.text.length).toBeLessThan(big.length);
-    expect(out.value[0]!.text).toContain("truncated");
-  });
-
-  it("leaves non-text parts (e.g. images) untouched", () => {
-    const image = { type: "image", data: "BASE64DATA", mediaType: "image/png" };
-    const result = { type: "content", value: [image] };
-    const out = capMcpToolResult(result, cap) as { value: unknown[] };
-    expect(out.value[0]).toEqual(image);
-  });
-
-  it("enforces a cumulative budget across multiple text parts", () => {
-    const partLen = cap; // each part alone is exactly the cap
-    const result = {
-      type: "content",
-      value: [
-        { type: "text", text: "A".repeat(partLen) },
-        { type: "text", text: "B".repeat(partLen) },
-        { type: "text", text: "C".repeat(partLen) },
-      ],
-    };
-    const out = capMcpToolResult(result, cap) as { value: Array<{ type: string; text: string }> };
-    const total = out.value.reduce((n, p) => n + p.text.length, 0);
-    // First part consumes the budget; later parts are elided to short markers,
-    // so the combined text stays close to the cap (plus small marker overhead).
-    expect(total).toBeLessThan(cap * 2);
-    expect(out.value[2]!.text).toContain("omitted");
-  });
-
-  it("returns structured (non-content, non-string) results unchanged", () => {
-    const structured = { ok: true, rows: [1, 2, 3] };
-    expect(capMcpToolResult(structured, cap)).toEqual(structured);
-  });
-
-  it("defaults to MAX_TOOL_OUTPUT_CHARS when no cap is passed", () => {
-    const big = "Z".repeat(MAX_TOOL_OUTPUT_CHARS + 10_000);
-    const out = capMcpToolResult(big) as string;
-    expect(out.length).toBeLessThan(big.length);
-  });
-});

package/src/mcp/__tests__/ee-tools.test.ts

@@ -1,248 +0,0 @@
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { createRecallLedger, sessionRecallLedger } from "../../ee/recall-ledger.js";
-import { registerEETools } from "../ee-tools.js";
-
-// Minimal harness: register tools onto a real McpServer, then invoke a tool's
-// handler by reaching into the registered tool. We test the handler via the
-// public callTool path using an in-process client would be heavier; instead we
-// capture handlers through a thin fake that records registrations.
-function collectTools(register: (s: McpServer) => void) {
-  const handlers: Record<string, (args: unknown) => Promise<unknown>> = {};
-  const fake = {
-    registerTool(name: string, _def: unknown, handler: (args: unknown) => Promise<unknown>) {
-      handlers[name] = handler;
-    },
-  } as unknown as McpServer;
-  register(fake);
-  return handlers;
-}
-
-function textOf(result: unknown): unknown {
-  // result is { content: [{ type:"text", text }], isError? }
-  const r = result as { content: Array<{ text: string }>; isError?: boolean };
-  return { json: JSON.parse(r.content[0]!.text), isError: r.isError };
-}
-function rawTextOf(result: unknown): { text: string; isError?: boolean } {
-  const r = result as { content: Array<{ text: string }>; isError?: boolean };
-  return { text: r.content[0]!.text, isError: r.isError };
-}
-
-describe("ee-tools", () => {
-  // Isolate the process-singleton ledger + gate env between tests so default-ledger
-  // tests never inherit pending debt or a gate mode from a prior test.
-  beforeEach(() => {
-    sessionRecallLedger.reset();
-    delete process.env.EXPERIENCE_RECALL_FEEDBACK_GATE;
-    delete process.env.EXPERIENCE_RECALL_FEEDBACK_THRESHOLD;
-  });
-  afterEach(() => {
-    sessionRecallLedger.reset();
-    delete process.env.EXPERIENCE_RECALL_FEEDBACK_GATE;
-    delete process.env.EXPERIENCE_RECALL_FEEDBACK_THRESHOLD;
-  });
-
-  it("ee_query returns the compact recall index (raw text + count footer, not JSON)", async () => {
-    const handlers = collectTools((s) =>
-      registerEETools(s, {
-        recall: async (q) => ({
-          text: `recall:${q} [id:abc col:experience-behavioral]`,
-          entries: [{ id: "abc", collection: "experience-behavioral" }],
-          count: 1,
-        }),
-        health: async () => ({ ok: true, status: 200 }),
-      }),
-    );
-    const out = rawTextOf(await handlers["ee_query"]!({ query: "redactor" }));
-    expect(out.isError).toBeFalsy();
-    expect(out.text).toContain("recall:redactor");
-    expect(out.text).toContain("[id:abc col:experience-behavioral]"); // handle preserved for exp-feedback
-    expect(out.text).toContain("[recall: 1 entries"); // count footer
-    expect(() => JSON.parse(out.text)).toThrow(); // no longer a JSON dump
-  });
-
-  it("ee_query caps an oversized recall index so it cannot overflow the MCP token cap", async () => {
-    const handlers = collectTools((s) =>
-      registerEETools(s, {
-        recall: async () => ({ text: "x".repeat(50_000), entries: [], count: 42 }),
-        health: async () => ({ ok: true, status: 200 }),
-      }),
-    );
-    const out = rawTextOf(await handlers["ee_query"]!({ query: "wide", maxChars: 6000 }));
-    expect(out.isError).toBeFalsy();
-    expect(out.text.length).toBeLessThan(7000); // capped, not the full 50k dump
-    expect(out.text).toContain("truncated");
-    expect(out.text).toContain("42 entries");
-  });
-
-  it("ee_query forwards the project scope to recall", async () => {
-    let seenProject: string | undefined;
-    const handlers = collectTools((s) =>
-      registerEETools(s, {
-        recall: async (_q, o) => {
-          seenProject = o.project;
-          return { text: null, entries: [], count: 0 };
-        },
-        health: async () => ({ ok: true, status: 200 }),
-      }),
-    );
-    await handlers["ee_query"]!({ query: "scope filter", project: "storyflow" });
-    expect(seenProject).toBe("storyflow");
-  });
-
-  it("ee_query returns ee_unavailable when recall yields null", async () => {
-    const handlers = collectTools((s) =>
-      registerEETools(s, { recall: async () => null, health: async () => ({ ok: false, status: 0 }) }),
-    );
-    const out = textOf(await handlers["ee_query"]!({ query: "x" })) as { json: { error?: string }; isError?: boolean };
-    expect(out.isError).toBe(true);
-    expect(out.json.error).toBe("ee_unavailable");
-  });
-
-  it("ee_health returns the injected status", async () => {
-    const handlers = collectTools((s) =>
-      registerEETools(s, { recall: async () => null, health: async () => ({ ok: true, status: 200 }) }),
-    );
-    const out = textOf(await handlers["ee_health"]!({})) as { json: { ok: boolean; status: number } };
-    expect(out.json).toEqual({ ok: true, status: 200 });
-  });
-
-  it("ee_health returns ee_unavailable when health throws", async () => {
-    const handlers = collectTools((s) =>
-      registerEETools(s, {
-        recall: async () => null,
-        health: async () => {
-          throw new Error("boom");
-        },
-      }),
-    );
-    const out = textOf(await handlers["ee_health"]!({})) as { json: { error?: string }; isError?: boolean };
-    expect(out.isError).toBe(true);
-    expect(out.json.error).toBe("ee_unavailable");
-  });
-
-  // ─── feedback gate (Layer 2) + ee_feedback (Layer 1) ───────────────────────
-
-  it("ee_feedback maps followed→FOLLOWED, clears the ledger debt, reports remaining", async () => {
-    const ledger = createRecallLedger();
-    ledger.record([{ id: "abc", collection: "experience-behavioral" }], "redactor");
-    expect(ledger.pendingCount()).toBe(1);
-    let seen: { id: string; collection: string; verdict: string; reason?: string } | null = null;
-    const handlers = collectTools((s) =>
-      registerEETools(s, {
-        ledger,
-        feedback: async (id, collection, verdict, reason) => {
-          seen = { id, collection, verdict, reason };
-          return { ok: true, resolvedId: id, verdict: verdict === "followed" ? "FOLLOWED" : verdict };
-        },
-      }),
-    );
-    const out = textOf(
-      await handlers["ee_feedback"]!({ id: "abc", collection: "experience-behavioral", verdict: "followed" }),
-    ) as { json: { ok: boolean; pendingRemaining: number }; isError?: boolean };
-    expect(out.isError).toBeFalsy();
-    expect(seen).toEqual({ id: "abc", collection: "experience-behavioral", verdict: "followed", reason: undefined });
-    expect(out.json.ok).toBe(true);
-    expect(out.json.pendingRemaining).toBe(0); // debt cleared
-    expect(ledger.pendingCount()).toBe(0);
-  });
-
-  it("ee_feedback requires a reason for verdict=noise", async () => {
-    const handlers = collectTools((s) => registerEETools(s, { feedback: async () => ({ ok: true }) }));
-    const out = textOf(
-      await handlers["ee_feedback"]!({ id: "x", collection: "experience-selfqa", verdict: "noise" }),
-    ) as { json: { error?: string }; isError?: boolean };
-    expect(out.isError).toBe(true);
-    expect(out.json.error).toBe("reason_required");
-  });
-
-  it("ee_feedback surfaces a feedback_failed error and keeps the debt unrated", async () => {
-    const ledger = createRecallLedger();
-    ledger.record([{ id: "abc", collection: "experience-behavioral" }], "q");
-    const handlers = collectTools((s) =>
-      registerEETools(s, { ledger, feedback: async () => ({ ok: false, error: "HTTP 500" }) }),
-    );
-    const out = textOf(
-      await handlers["ee_feedback"]!({ id: "abc", collection: "experience-behavioral", verdict: "ignored" }),
-    ) as { json: { error?: string; message?: string }; isError?: boolean };
-    expect(out.isError).toBe(true);
-    expect(out.json.error).toBe("feedback_failed");
-    expect(ledger.pendingCount()).toBe(1); // NOT cleared on failure
-  });
-
-  it("ee_query soft gate: a later recall is prefixed with the prior unrated debt", async () => {
-    const ledger = createRecallLedger();
-    const handlers = collectTools((s) =>
-      registerEETools(s, {
-        ledger,
-        recall: async (q) => ({
-          text: `recall:${q} [id:dup col:experience-behavioral]`,
-          entries: [{ id: q === "first" ? "id1" : "id2", collection: "experience-behavioral" }],
-          count: 1,
-        }),
-        health: async () => ({ ok: true, status: 200 }),
-      }),
-    );
-    // First recall — no prior debt, so no gate prefix.
-    const first = rawTextOf(await handlers["ee_query"]!({ query: "first" }));
-    expect(first.text).not.toContain("still unrated");
-    expect(ledger.pendingCount()).toBe(1);
-    // Second recall — the prior id1 is still unrated → soft prefix, but recall still returned.
-    const second = rawTextOf(await handlers["ee_query"]!({ query: "second" }));
-    expect(second.isError).toBeFalsy();
-    expect(second.text).toContain("still unrated");
-    expect(second.text).toContain("id1");
-    expect(second.text).toContain("recall:second"); // the actual recall is still delivered
-    expect(ledger.pendingCount()).toBe(2);
-  });
-
-  it("ee_query hard gate: refuses a new recall once unrated debt hits the threshold", async () => {
-    process.env.EXPERIENCE_RECALL_FEEDBACK_GATE = "hard";
-    process.env.EXPERIENCE_RECALL_FEEDBACK_THRESHOLD = "2";
-    const ledger = createRecallLedger();
-    ledger.record(
-      [
-        { id: "a", collection: "experience-behavioral" },
-        { id: "b", collection: "experience-selfqa" },
-      ],
-      "earlier",
-    );
-    let recallCalled = false;
-    const handlers = collectTools((s) =>
-      registerEETools(s, {
-        ledger,
-        recall: async () => {
-          recallCalled = true;
-          return { text: "should not run", entries: [], count: 0 };
-        },
-      }),
-    );
-    const out = textOf(await handlers["ee_query"]!({ query: "blocked" })) as {
-      json: { error?: string; message?: string };
-      isError?: boolean;
-    };
-    expect(out.isError).toBe(true);
-    expect(out.json.error).toBe("feedback_required");
-    expect(out.json.message).toContain("FEEDBACK GATE");
-    expect(recallCalled).toBe(false); // brain call NOT spent while debt unpaid
-  });
-
-  it("ee_query gate=off disables the ledger entirely", async () => {
-    process.env.EXPERIENCE_RECALL_FEEDBACK_GATE = "off";
-    const ledger = createRecallLedger();
-    const handlers = collectTools((s) =>
-      registerEETools(s, {
-        ledger,
-        recall: async (q) => ({
-          text: `r:${q}`,
-          entries: [{ id: "z", collection: "experience-behavioral" }],
-          count: 1,
-        }),
-        health: async () => ({ ok: true, status: 200 }),
-      }),
-    );
-    await handlers["ee_query"]!({ query: "one" });
-    await handlers["ee_query"]!({ query: "two" });
-    expect(ledger.pendingCount()).toBe(0); // nothing stamped when gate is off
-  });
-});

package/src/mcp/__tests__/forensics-tools.test.ts

@@ -1,66 +0,0 @@
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { describe, expect, it } from "vitest";
-import type { CostForensicsSummary } from "../../cli/cost-forensics.js";
-import { registerForensicsTools } from "../forensics-tools.js";
-
-function collectTools(register: (s: McpServer) => void) {
-  const handlers: Record<string, (args: unknown) => Promise<unknown>> = {};
-  const fake = {
-    registerTool(name: string, _def: unknown, handler: (args: unknown) => Promise<unknown>) {
-      handlers[name] = handler;
-    },
-  } as unknown as McpServer;
-  register(fake);
-  return handlers;
-}
-function parse(result: unknown) {
-  const r = result as { content: Array<{ text: string }>; isError?: boolean };
-  return { json: JSON.parse(r.content[0]!.text), isError: r.isError };
-}
-
-const fakeSummary = (id: string): CostForensicsSummary =>
-  ({
-    sessionId: id,
-    rowCount: 1,
-    userPromptCount: 1,
-    toolCallCount: 0,
-    totalInput: 100,
-    totalOutput: 50,
-    totalCacheRead: 0,
-    totalCacheCreation: 0,
-    totalCostUsd: 0.01,
-    cacheHitRatio: 0,
-    peakSingleCallInput: 100,
-    events: [],
-  }) as CostForensicsSummary;
-
-describe("forensics-tools", () => {
-  it("usage_forensics returns the summary for a unique prefix", async () => {
-    const handlers = collectTools((s) =>
-      registerForensicsTools(s, { resolve: () => ["sess123"], collect: (id) => fakeSummary(id) }),
-    );
-    const out = parse(await handlers["usage_forensics"]!({ prefix: "sess" }));
-    expect(out.isError).toBeFalsy();
-    expect(out.json.sessionId).toBe("sess123");
-    expect(out.json.peakSingleCallInput).toBe(100);
-  });
-
-  it("usage_forensics returns not_found for zero matches", async () => {
-    const handlers = collectTools((s) =>
-      registerForensicsTools(s, { resolve: () => [], collect: () => fakeSummary("x") }),
-    );
-    const out = parse(await handlers["usage_forensics"]!({ prefix: "nope" }));
-    expect(out.isError).toBe(true);
-    expect(out.json.error).toBe("not_found");
-  });
-
-  it("usage_forensics returns ambiguous for multiple matches", async () => {
-    const handlers = collectTools((s) =>
-      registerForensicsTools(s, { resolve: () => ["a1", "a2"], collect: () => fakeSummary("a1") }),
-    );
-    const out = parse(await handlers["usage_forensics"]!({ prefix: "a" }));
-    expect(out.isError).toBe(true);
-    expect(out.json.error).toBe("ambiguous");
-    expect(out.json.matches).toEqual(["a1", "a2"]);
-  });
-});

package/src/mcp/__tests__/harness-driver-action-tools.spec.ts

@@ -1,116 +0,0 @@
-import type { Driver } from "@muonroi/agent-harness-core/driver";
-import { registerActionTools } from "@muonroi/agent-harness-core/mcp-server";
-import { describe, expect, it } from "vitest";
-
-type ToolCb = (input: Record<string, unknown>) => Promise<unknown>;
-
-function makeFakeServer() {
-  const tools = new Map<string, ToolCb>();
-  return {
-    server: {
-      registerTool: (name: string, _config: unknown, cb: ToolCb) => {
-        tools.set(name, cb);
-        return undefined;
-      },
-    } as any,
-    invoke: async (name: string, input: Record<string, unknown> = {}) => {
-      const cb = tools.get(name);
-      if (!cb) throw new Error(`tool not registered: ${name}`);
-      return cb(input);
-    },
-    names: () => Array.from(tools.keys()),
-  };
-}
-
-type Calls = { presses: string[]; sequences: string[][]; types: string[]; focuses: string[] };
-
-function makeStubDriver(calls: Calls, opts: { focusThrows?: boolean } = {}): Driver {
-  return {
-    snapshot: () => null,
-    changes_since: () => null,
-    press: (k: string) => {
-      calls.presses.push(k);
-    },
-    press_sequence: (ks: string[]) => {
-      calls.sequences.push(ks);
-    },
-    type: (t: string) => {
-      calls.types.push(t);
-    },
-    focus: (s: string) => {
-      if (opts.focusThrows) throw new Error("focus: expected 1 match, got 2");
-      calls.focuses.push(s);
-    },
-    wait_for: async () => {},
-    query: () => null,
-    queryAll: () => [],
-    count: () => 0,
-    expect: () => true,
-    last_event: () => null,
-    events: () => ({
-      [Symbol.asyncIterator]: () => ({ next: async () => ({ value: undefined as any, done: true as const }) }),
-    }),
-    render_text: () => "",
-    _ingest: () => {},
-    _closeAllSubscribers: () => {},
-  };
-}
-
-describe("registerActionTools", () => {
-  it("registers all 4 action tools", () => {
-    const fake = makeFakeServer();
-    registerActionTools(fake.server, () => makeStubDriver({ presses: [], sequences: [], types: [], focuses: [] }));
-    expect(fake.names().sort()).toEqual(["tui.focus", "tui.press", "tui.press_sequence", "tui.type"]);
-  });
-
-  it("tui.press dispatches to driver.press", async () => {
-    const calls: Calls = { presses: [], sequences: [], types: [], focuses: [] };
-    const fake = makeFakeServer();
-    registerActionTools(fake.server, () => makeStubDriver(calls));
-    const r: any = await fake.invoke("tui.press", { key: "Enter" });
-    expect(calls.presses).toEqual(["Enter"]);
-    expect(r.content[0].text).toBe("ok");
-  });
-
-  it("tui.press_sequence dispatches to driver.press_sequence", async () => {
-    const calls: Calls = { presses: [], sequences: [], types: [], focuses: [] };
-    const fake = makeFakeServer();
-    registerActionTools(fake.server, () => makeStubDriver(calls));
-    await fake.invoke("tui.press_sequence", { keys: ["Down", "Down", "Enter"] });
-    expect(calls.sequences).toEqual([["Down", "Down", "Enter"]]);
-  });
-
-  it("tui.type dispatches to driver.type", async () => {
-    const calls: Calls = { presses: [], sequences: [], types: [], focuses: [] };
-    const fake = makeFakeServer();
-    registerActionTools(fake.server, () => makeStubDriver(calls));
-    await fake.invoke("tui.type", { text: "hello world" });
-    expect(calls.types).toEqual(["hello world"]);
-  });
-
-  it("tui.focus dispatches to driver.focus", async () => {
-    const calls: Calls = { presses: [], sequences: [], types: [], focuses: [] };
-    const fake = makeFakeServer();
-    registerActionTools(fake.server, () => makeStubDriver(calls));
-    await fake.invoke("tui.focus", { selector: "role=button" });
-    expect(calls.focuses).toEqual(["role=button"]);
-  });
-
-  it("tui.focus returns isError on ambiguous selector", async () => {
-    const fake = makeFakeServer();
-    registerActionTools(fake.server, () =>
-      makeStubDriver({ presses: [], sequences: [], types: [], focuses: [] }, { focusThrows: true }),
-    );
-    const r: any = await fake.invoke("tui.focus", { selector: "role=listitem" });
-    expect(r.isError).toBe(true);
-    expect(JSON.parse(r.content[0].text).error).toBe("focus_failed");
-  });
-
-  it("returns no_driver error when getDriver returns null", async () => {
-    const fake = makeFakeServer();
-    registerActionTools(fake.server, () => null);
-    const r: any = await fake.invoke("tui.press", { key: "x" });
-    expect(r.isError).toBe(true);
-    expect(JSON.parse(r.content[0].text).error).toBe("no_driver");
-  });
-});