muonroi-cli 1.8.1 → 1.8.3

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

@@ -1 +0,0 @@
-export {};

package/dist/src/mcp/__tests__/ee-tools.test.js

@@ -1,226 +0,0 @@
-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) {
-    const handlers = {};
-    const fake = {
-        registerTool(name, _def, handler) {
-            handlers[name] = handler;
-        },
-    };
-    register(fake);
-    return handlers;
-}
-function textOf(result) {
-    // result is { content: [{ type:"text", text }], isError? }
-    const r = result;
-    return { json: JSON.parse(r.content[0].text), isError: r.isError };
-}
-function rawTextOf(result) {
-    const r = result;
-    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;
-        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" }));
-        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({}));
-        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({}));
-        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 = 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" }));
-        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" }));
-        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" }));
-        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" }));
-        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
-    });
-    // ─── ee_write (Layer 1 — agent records a new lesson) ───────────────────────
-    it("ee_write forwards the lesson to the write helper and returns the new id", async () => {
-        let seen = null;
-        const handlers = collectTools((s) => registerEETools(s, {
-            write: async (lesson, opts) => {
-                seen = { lesson, opts };
-                return { ok: true, id: "new-point-1" };
-            },
-        }));
-        const out = textOf(await handlers.ee_write({
-            lesson: "always call flushFrob() before reindex or reads go stale",
-            title: "reindex pitfall",
-            project: "experience-engine",
-        }));
-        expect(out.isError).toBeFalsy();
-        expect(out.json.ok).toBe(true);
-        expect(out.json.id).toBe("new-point-1");
-        expect(out.json.collection).toBe("experience-behavioral");
-        expect(seen.lesson).toContain("flushFrob");
-        expect(seen.opts.collection).toBe("experience-behavioral");
-        expect(seen.opts.projectSlug).toBe("experience-engine");
-    });
-    it("ee_write surfaces write_failed when the write helper fails", async () => {
-        const handlers = collectTools((s) => registerEETools(s, { write: async () => ({ ok: false, error: "import-memory HTTP 500" }) }));
-        const out = textOf(await handlers.ee_write({ lesson: "a sufficiently long lesson body here" }));
-        expect(out.isError).toBe(true);
-        expect(out.json.error).toBe("write_failed");
-    });
-});
-//# sourceMappingURL=ee-tools.test.js.map

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

@@ -1 +0,0 @@
-export {};

package/dist/src/mcp/__tests__/forensics-tools.test.js

@@ -1,54 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { registerForensicsTools } from "../forensics-tools.js";
-function collectTools(register) {
-    const handlers = {};
-    const fake = {
-        registerTool(name, _def, handler) {
-            handlers[name] = handler;
-        },
-    };
-    register(fake);
-    return handlers;
-}
-function parse(result) {
-    const r = result;
-    return { json: JSON.parse(r.content[0].text), isError: r.isError };
-}
-const fakeSummary = (id) => ({
-    sessionId: id,
-    rowCount: 1,
-    userPromptCount: 1,
-    toolCallCount: 0,
-    totalInput: 100,
-    totalOutput: 50,
-    totalCacheRead: 0,
-    totalCacheCreation: 0,
-    totalCostUsd: 0.01,
-    cacheHitRatio: 0,
-    peakSingleCallInput: 100,
-    events: [],
-    experience: null,
-});
-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"]);
-    });
-});
-//# sourceMappingURL=forensics-tools.test.js.map

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

@@ -1 +0,0 @@
-export {};

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

@@ -1,103 +0,0 @@
-import { registerActionTools } from "@muonroi/agent-harness-core/mcp-server";
-import { describe, expect, it } from "vitest";
-function makeFakeServer() {
-    const tools = new Map();
-    return {
-        server: {
-            registerTool: (name, _config, cb) => {
-                tools.set(name, cb);
-                return undefined;
-            },
-        },
-        invoke: async (name, input = {}) => {
-            const cb = tools.get(name);
-            if (!cb)
-                throw new Error(`tool not registered: ${name}`);
-            return cb(input);
-        },
-        names: () => Array.from(tools.keys()),
-    };
-}
-function makeStubDriver(calls, opts = {}) {
-    return {
-        snapshot: () => null,
-        changes_since: () => null,
-        press: (k) => {
-            calls.presses.push(k);
-        },
-        press_sequence: (ks) => {
-            calls.sequences.push(ks);
-        },
-        type: (t) => {
-            calls.types.push(t);
-        },
-        focus: (s) => {
-            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, done: true }) }),
-        }),
-        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 = { presses: [], sequences: [], types: [], focuses: [] };
-        const fake = makeFakeServer();
-        registerActionTools(fake.server, () => makeStubDriver(calls));
-        const r = 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 = { 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 = { 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 = { 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 = 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 = await fake.invoke("tui.press", { key: "x" });
-        expect(r.isError).toBe(true);
-        expect(JSON.parse(r.content[0].text).error).toBe("no_driver");
-    });
-});
-//# sourceMappingURL=harness-driver-action-tools.spec.js.map

package/dist/src/mcp/__tests__/harness-driver-async-tools.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/mcp/__tests__/harness-driver-async-tools.spec.js

@@ -1,112 +0,0 @@
-import { registerAsyncTools } from "@muonroi/agent-harness-core/mcp-server";
-import { describe, expect, it } from "vitest";
-function makeFakeServer() {
-    const tools = new Map();
-    return {
-        server: {
-            registerTool: (name, _config, cb) => {
-                tools.set(name, cb);
-            },
-        },
-        invoke: async (name, input = {}) => {
-            const cb = tools.get(name);
-            if (!cb)
-                throw new Error(`tool not registered: ${name}`);
-            return cb(input);
-        },
-        names: () => Array.from(tools.keys()),
-    };
-}
-function makeStubDriver(opts = {}) {
-    return {
-        snapshot: () => null,
-        changes_since: () => null,
-        press: () => { },
-        press_sequence: () => { },
-        type: () => { },
-        focus: () => { },
-        wait_for: async () => {
-            if (opts.waitRejects)
-                throw new Error("wait_for timeout after 30ms");
-        },
-        query: () => null,
-        queryAll: () => [],
-        count: () => 0,
-        expect: () => opts.expectResult ?? true,
-        last_event: (() => opts.lastEvent ?? null),
-        events: () => ({
-            [Symbol.asyncIterator]: () => ({ next: async () => ({ value: undefined, done: true }) }),
-        }),
-        render_text: () => "",
-        _ingest: () => { },
-        _closeAllSubscribers: () => { },
-    };
-}
-describe("registerAsyncTools", () => {
-    it("registers all 4 async tools", () => {
-        const fake = makeFakeServer();
-        registerAsyncTools(fake.server, () => makeStubDriver(), { onStop: () => { } });
-        expect(fake.names().sort()).toEqual(["tui.expect", "tui.last_event", "tui.stop", "tui.wait_for"]);
-    });
-    it("tui.wait_for returns ok on success", async () => {
-        const fake = makeFakeServer();
-        registerAsyncTools(fake.server, () => makeStubDriver(), { onStop: () => { } });
-        const r = await fake.invoke("tui.wait_for", { idle: true, timeoutMs: 1000 });
-        expect(r.content[0].text).toBe("ok");
-    });
-    it("tui.wait_for returns isError on timeout", async () => {
-        const fake = makeFakeServer();
-        registerAsyncTools(fake.server, () => makeStubDriver({ waitRejects: true }), { onStop: () => { } });
-        const r = await fake.invoke("tui.wait_for", { selector: "role=missing", timeoutMs: 30 });
-        expect(r.isError).toBe(true);
-        expect(JSON.parse(r.content[0].text).error).toBe("timeout");
-    });
-    it("tui.expect returns 'true' string", async () => {
-        const fake = makeFakeServer();
-        registerAsyncTools(fake.server, () => makeStubDriver({ expectResult: true }), { onStop: () => { } });
-        const r = await fake.invoke("tui.expect", { selector: "x", predicate: {} });
-        expect(r.content[0].text).toBe("true");
-    });
-    it("tui.expect returns 'false' string", async () => {
-        const fake = makeFakeServer();
-        registerAsyncTools(fake.server, () => makeStubDriver({ expectResult: false }), { onStop: () => { } });
-        const r = await fake.invoke("tui.expect", { selector: "x", predicate: {} });
-        expect(r.content[0].text).toBe("false");
-    });
-    it("tui.last_event returns event JSON or null", async () => {
-        const evt = { t: "event", kind: "toast", level: "info", text: "hi" };
-        const fake = makeFakeServer();
-        registerAsyncTools(fake.server, () => makeStubDriver({ lastEvent: evt }), { onStop: () => { } });
-        const r = await fake.invoke("tui.last_event", { kind: "toast" });
-        expect(JSON.parse(r.content[0].text).kind).toBe("toast");
-    });
-    it("tui.last_event returns null when no event", async () => {
-        const fake = makeFakeServer();
-        registerAsyncTools(fake.server, () => makeStubDriver(), { onStop: () => { } });
-        const r = await fake.invoke("tui.last_event", { kind: "stream.delta" });
-        expect(JSON.parse(r.content[0].text)).toBeNull();
-    });
-    it("tui.stop invokes onStop", async () => {
-        let stopped = false;
-        const fake = makeFakeServer();
-        registerAsyncTools(fake.server, () => makeStubDriver(), {
-            onStop: () => {
-                stopped = true;
-            },
-        });
-        const r = await fake.invoke("tui.stop");
-        expect(stopped).toBe(true);
-        expect(r.content[0].text).toBe("ok");
-    });
-    it("returns no_driver error when getDriver returns null (wait_for/expect/last_event)", async () => {
-        const fake = makeFakeServer();
-        registerAsyncTools(fake.server, () => null, { onStop: () => { } });
-        const a = await fake.invoke("tui.wait_for", { idle: true });
-        expect(a.isError).toBe(true);
-        const b = await fake.invoke("tui.expect", { selector: "x", predicate: {} });
-        expect(b.isError).toBe(true);
-        const c = await fake.invoke("tui.last_event", { kind: "toast" });
-        expect(c.isError).toBe(true);
-    });
-});
-//# sourceMappingURL=harness-driver-async-tools.spec.js.map

package/dist/src/mcp/__tests__/harness-driver-read-tools.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/mcp/__tests__/harness-driver-read-tools.spec.js

@@ -1,124 +0,0 @@
-import { registerReadTools } from "@muonroi/agent-harness-core/mcp-server";
-import { describe, expect, it } from "vitest";
-function makeFakeServer() {
-    const tools = new Map();
-    return {
-        server: {
-            registerTool: (name, _config, cb) => {
-                tools.set(name, cb);
-                return undefined;
-            },
-        },
-        invoke: async (name, input = {}) => {
-            const cb = tools.get(name);
-            if (!cb)
-                throw new Error(`tool not registered: ${name}`);
-            return cb(input);
-        },
-        names: () => Array.from(tools.keys()),
-    };
-}
-function makeStubDriver(frame, nodes) {
-    return {
-        snapshot: () => frame,
-        changes_since: (seq) => (frame.seq > seq ? frame : null),
-        press: () => { },
-        press_sequence: () => { },
-        type: () => { },
-        focus: () => { },
-        wait_for: async () => { },
-        query: (sel) => sel === "ambiguous-error"
-            ? (() => {
-                throw new Error("ambiguous: 2 matches");
-            })()
-            : (nodes[0] ?? null),
-        queryAll: () => nodes,
-        count: () => nodes.length,
-        expect: () => true,
-        last_event: () => null,
-        events: () => ({
-            [Symbol.asyncIterator]: () => ({ next: async () => ({ value: undefined, done: true }) }),
-        }),
-        render_text: () => "[rendered]",
-        _ingest: () => { },
-        _closeAllSubscribers: () => { },
-    };
-}
-const sampleFrame = {
-    mode: "live",
-    version: "0.4.0",
-    seq: 7,
-    ts: 0,
-    nodes: [{ id: "n1", role: "button", name: "Send" }],
-};
-describe("registerReadTools", () => {
-    it("registers all 6 read tools", () => {
-        const fake = makeFakeServer();
-        registerReadTools(fake.server, () => makeStubDriver(sampleFrame, sampleFrame.nodes));
-        expect(fake.names().sort()).toEqual([
-            "tui.changes_since",
-            "tui.count",
-            "tui.query",
-            "tui.query_all",
-            "tui.render_text",
-            "tui.snapshot",
-        ]);
-    });
-    it("tui.snapshot returns serialized frame", async () => {
-        const fake = makeFakeServer();
-        registerReadTools(fake.server, () => makeStubDriver(sampleFrame, sampleFrame.nodes));
-        const r = await fake.invoke("tui.snapshot");
-        expect(JSON.parse(r.content[0].text).seq).toBe(7);
-    });
-    it("tui.changes_since returns null when seq is current", async () => {
-        const fake = makeFakeServer();
-        registerReadTools(fake.server, () => makeStubDriver(sampleFrame, sampleFrame.nodes));
-        const r = await fake.invoke("tui.changes_since", { seq: 7 });
-        expect(JSON.parse(r.content[0].text)).toBeNull();
-    });
-    it("tui.changes_since returns frame when seq < current", async () => {
-        const fake = makeFakeServer();
-        registerReadTools(fake.server, () => makeStubDriver(sampleFrame, sampleFrame.nodes));
-        const r = await fake.invoke("tui.changes_since", { seq: 0 });
-        expect(JSON.parse(r.content[0].text).seq).toBe(7);
-    });
-    it("tui.query returns the single node", async () => {
-        const fake = makeFakeServer();
-        registerReadTools(fake.server, () => makeStubDriver(sampleFrame, sampleFrame.nodes));
-        const r = await fake.invoke("tui.query", { selector: "role=button" });
-        expect(JSON.parse(r.content[0].text).id).toBe("n1");
-    });
-    it("tui.query returns isError on ambiguous", async () => {
-        const fake = makeFakeServer();
-        registerReadTools(fake.server, () => makeStubDriver(sampleFrame, sampleFrame.nodes));
-        const r = await fake.invoke("tui.query", { selector: "ambiguous-error" });
-        expect(r.isError).toBe(true);
-        expect(JSON.parse(r.content[0].text).error).toBe("ambiguous");
-    });
-    it("tui.query_all returns array", async () => {
-        const fake = makeFakeServer();
-        registerReadTools(fake.server, () => makeStubDriver(sampleFrame, sampleFrame.nodes));
-        const r = await fake.invoke("tui.query_all", { selector: "*" });
-        expect(JSON.parse(r.content[0].text)).toHaveLength(1);
-    });
-    it("tui.count returns numeric string", async () => {
-        const fake = makeFakeServer();
-        registerReadTools(fake.server, () => makeStubDriver(sampleFrame, sampleFrame.nodes));
-        const r = await fake.invoke("tui.count", { selector: "*" });
-        expect(r.content[0].text).toBe("1");
-    });
-    it("tui.render_text returns string", async () => {
-        const fake = makeFakeServer();
-        registerReadTools(fake.server, () => makeStubDriver(sampleFrame, sampleFrame.nodes));
-        const r = await fake.invoke("tui.render_text");
-        expect(r.content[0].text).toBe("[rendered]");
-    });
-    it("returns no_driver error when getDriver returns null", async () => {
-        const fake = makeFakeServer();
-        registerReadTools(fake.server, () => null);
-        const r = await fake.invoke("tui.snapshot");
-        expect(r.isError).toBe(true);
-        expect(JSON.parse(r.content[0].text).error).toBe("no_driver");
-    });
-});
-//# sourceMappingURL=harness-driver-read-tools.spec.js.map

package/dist/src/mcp/__tests__/harness-driver-security.spec.d.ts

@@ -1 +0,0 @@
-export {};