muonroi-cli 1.8.1 → 1.8.4

package/dist/src/agent-harness/__tests__/mock-llm.spec.js

@@ -1,91 +0,0 @@
-import { mkdtempSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { createMockLlm } from "@muonroi/agent-harness-core/mock-llm";
-import { describe, expect, it } from "vitest";
-describe("mock-llm", () => {
-    it("returns fixture matching prompt", async () => {
-        const dir = mkdtempSync(join(tmpdir(), "mockllm-"));
-        writeFileSync(join(dir, "fix.json"), JSON.stringify({
-            responses: [{ match: "hello", text: "world" }],
-        }));
-        const m = createMockLlm({ dir });
-        expect(await m.complete({ prompt: "hello there" })).toEqual({ text: "world" });
-    });
-    it("falls back to wildcard", async () => {
-        const dir = mkdtempSync(join(tmpdir(), "mockllm-"));
-        writeFileSync(join(dir, "fix.json"), JSON.stringify({
-            responses: [{ match: "*", text: "default" }],
-        }));
-        const m = createMockLlm({ dir });
-        expect(await m.complete({ prompt: "anything" })).toEqual({ text: "default" });
-    });
-    it("throws on no match without wildcard", async () => {
-        const dir = mkdtempSync(join(tmpdir(), "mockllm-"));
-        writeFileSync(join(dir, "fix.json"), JSON.stringify({
-            responses: [{ match: "specific", text: "x" }],
-        }));
-        const m = createMockLlm({ dir });
-        await expect(m.complete({ prompt: "other" })).rejects.toThrow(/no fixture/);
-    });
-    // ── Sequence mode tests ────────────────────────────────────────────────────
-    it("sequence: consumes entries in order", async () => {
-        const dir = mkdtempSync(join(tmpdir(), "mockllm-seq-"));
-        writeFileSync(join(dir, "seq.json"), JSON.stringify({
-            sequence: [{ text: "first" }, { text: "second" }, { text: "third" }],
-        }));
-        const m = createMockLlm({ dir });
-        expect(await m.complete({ prompt: "anything" })).toEqual({ text: "first" });
-        expect(await m.complete({ prompt: "anything" })).toEqual({ text: "second" });
-        expect(await m.complete({ prompt: "anything" })).toEqual({ text: "third" });
-    });
-    it("sequence: exhausted sequence sticks on last entry", async () => {
-        const dir = mkdtempSync(join(tmpdir(), "mockllm-seq-exhausted-"));
-        writeFileSync(join(dir, "seq.json"), JSON.stringify({
-            sequence: [{ text: "a" }, { text: "b" }],
-        }));
-        const m = createMockLlm({ dir });
-        expect(await m.complete({ prompt: "p" })).toEqual({ text: "a" });
-        expect(await m.complete({ prompt: "p" })).toEqual({ text: "b" });
-        // Exhausted — keeps returning last entry
-        expect(await m.complete({ prompt: "p" })).toEqual({ text: "b" });
-        expect(await m.complete({ prompt: "p" })).toEqual({ text: "b" });
-    });
-    it("sequence: entry with match constraint is skipped when prompt doesn't match", async () => {
-        const dir = mkdtempSync(join(tmpdir(), "mockllm-seq-match-"));
-        writeFileSync(join(dir, "seq.json"), JSON.stringify({
-            sequence: [{ text: "matched", match: "keyword" }, { text: "fallback" }],
-        }));
-        const m = createMockLlm({ dir });
-        // First call: prompt lacks the required term — skips first seq entry, falls through to second
-        expect(await m.complete({ prompt: "unrelated prompt text" })).toEqual({ text: "fallback" });
-    });
-    it("sequence: entry with match constraint is consumed when prompt includes it", async () => {
-        const dir = mkdtempSync(join(tmpdir(), "mockllm-seq-match2-"));
-        writeFileSync(join(dir, "seq.json"), JSON.stringify({
-            sequence: [{ text: "matched", match: "keyword" }, { text: "second" }],
-        }));
-        const m = createMockLlm({ dir });
-        // First call includes keyword — consumes first entry
-        expect(await m.complete({ prompt: "has keyword in it" })).toEqual({ text: "matched" });
-        // Second call — advances to second entry
-        expect(await m.complete({ prompt: "anything" })).toEqual({ text: "second" });
-    });
-    it("sequence and responses fixtures coexist: sequence tried first", async () => {
-        const dir = mkdtempSync(join(tmpdir(), "mockllm-mixed-"));
-        // responses fixture
-        writeFileSync(join(dir, "a-responses.json"), JSON.stringify({
-            responses: [{ match: "*", text: "from-responses" }],
-        }));
-        // sequence fixture (alphabetically after, but tried first by design)
-        writeFileSync(join(dir, "b-sequence.json"), JSON.stringify({
-            sequence: [{ text: "from-sequence" }],
-        }));
-        const m = createMockLlm({ dir });
-        // First call: sequence wins
-        expect(await m.complete({ prompt: "anything" })).toEqual({ text: "from-sequence" });
-        // Second call: sequence exhausted (sticks on last), still "from-sequence"
-        expect(await m.complete({ prompt: "anything" })).toEqual({ text: "from-sequence" });
-    });
-});
-//# sourceMappingURL=mock-llm.spec.js.map

package/dist/src/agent-harness/__tests__/mock-model.spec.d.ts

@@ -1,5 +0,0 @@
-/**
- * Unit tests for the mock-model helper. Verifies the recording surface and
- * sequential stream semantics that downstream cost-leak specs depend on.
- */
-export {};

package/dist/src/agent-harness/__tests__/mock-model.spec.js

@@ -1,270 +0,0 @@
-/**
- * Unit tests for the mock-model helper. Verifies the recording surface and
- * sequential stream semantics that downstream cost-leak specs depend on.
- */
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { APICallError } from "@ai-sdk/provider";
-import { generateObject, stepCountIs, streamText, tool } from "ai";
-import { afterAll, describe, expect, it } from "vitest";
-import { z } from "zod";
-import { humanizeApiError } from "../../orchestrator/error-utils.js";
-import { createMockModel, loadMockModelFromDir, textOnlyStream, toolCallStream } from "../mock-model.js";
-// biome-ignore lint/suspicious/noExplicitAny: streamText result generic is provider-specific
-async function drainStream(result) {
-    for await (const _ of result.fullStream) {
-        // discard — we only care about the model's recorded calls
-    }
-}
-describe("createMockModel", () => {
-    it("records every doStream call with full options", async () => {
-        const handle = createMockModel({ stream: textOnlyStream("hello") });
-        const result = streamText({
-            model: handle.model,
-            prompt: "say hi",
-            maxOutputTokens: 50,
-            temperature: 0.7,
-        });
-        await drainStream(result);
-        expect(handle.calls.length).toBe(1);
-        expect(handle.calls[0]?.maxOutputTokens).toBe(50);
-        expect(handle.calls[0]?.temperature).toBe(0.7);
-    });
-    it("preserves providerOptions in recorded calls", async () => {
-        const handle = createMockModel({ stream: textOnlyStream("hello") });
-        const result = streamText({
-            model: handle.model,
-            prompt: "say hi",
-            providerOptions: { openai: { promptCacheKey: "abc123" } },
-        });
-        await drainStream(result);
-        expect(handle.calls[0]?.providerOptions).toEqual({
-            openai: { promptCacheKey: "abc123" },
-        });
-    });
-    it("advances the stream sequence across multiple rounds", async () => {
-        const handle = createMockModel({
-            stream: [toolCallStream({ toolCallId: "1", toolName: "echo", input: { msg: "hi" } }), textOnlyStream("done")],
-        });
-        const echoTool = tool({
-            description: "echo",
-            inputSchema: z.object({ msg: z.string() }),
-            execute: async ({ msg }) => `echoed: ${msg}`,
-        });
-        const result = streamText({
-            model: handle.model,
-            prompt: "use echo",
-            tools: { echo: echoTool },
-            stopWhen: stepCountIs(3),
-        });
-        await drainStream(result);
-        expect(handle.calls.length).toBe(2);
-        // Round 1 sees only the user message; round 2 sees the tool result too.
-        expect(handle.calls[1]?.prompt.length).toBeGreaterThan(handle.calls[0]?.prompt.length ?? 0);
-    });
-    it("repeats the last stream entry when sequence is exhausted", async () => {
-        const handle = createMockModel({ stream: [textOnlyStream("once")] });
-        // Drive two calls — second should silently reuse the last entry.
-        for (let i = 0; i < 2; i++) {
-            const r = streamText({ model: handle.model, prompt: `q${i}` });
-            await drainStream(r);
-        }
-        expect(handle.calls.length).toBe(2);
-    });
-    it("reset() clears doStreamCalls and rewinds the sequence index", async () => {
-        const handle = createMockModel({
-            stream: [textOnlyStream("first"), textOnlyStream("second")],
-        });
-        const r1 = streamText({ model: handle.model, prompt: "q1" });
-        await drainStream(r1);
-        expect(handle.calls.length).toBe(1);
-        handle.reset();
-        expect(handle.calls.length).toBe(0);
-        // After reset, the sequence index is back at 0 → next call gets "first" again.
-        const r2 = streamText({ model: handle.model, prompt: "q2" });
-        await drainStream(r2);
-        expect(handle.calls.length).toBe(1);
-    });
-    it("doGenerate backs generateObject with the configured JSON (council debate-planner path)", async () => {
-        const handle = createMockModel({
-            stream: textOnlyStream("unused"),
-            generate: JSON.stringify({ name: "counter", count: 3 }),
-        });
-        const { object } = await generateObject({
-            model: handle.model,
-            schema: z.object({ name: z.string(), count: z.number() }),
-            prompt: "plan the build",
-        });
-        expect(object).toEqual({ name: "counter", count: 3 });
-    });
-    it("doGenerate sequences across calls and repeats the last entry when exhausted", async () => {
-        const handle = createMockModel({
-            stream: textOnlyStream("unused"),
-            generate: [JSON.stringify({ n: 1 }), JSON.stringify({ n: 2 })],
-        });
-        const schema = z.object({ n: z.number() });
-        const a = await generateObject({ model: handle.model, schema, prompt: "1" });
-        const b = await generateObject({ model: handle.model, schema, prompt: "2" });
-        const c = await generateObject({ model: handle.model, schema, prompt: "3" });
-        expect(a.object.n).toBe(1);
-        expect(b.object.n).toBe(2);
-        expect(c.object.n).toBe(2); // exhausted → last entry repeats
-    });
-    it("doGenerate defaults to {} when no generate fixture is supplied (caller retry/fallback runs)", async () => {
-        const handle = createMockModel({ stream: textOnlyStream("unused") });
-        // An empty object fails a required-field schema → generateObject rejects,
-        // which is exactly what lets debate-planner fall through to its retry path.
-        await expect(generateObject({ model: handle.model, schema: z.object({ required: z.string() }), prompt: "x" })).rejects.toBeTruthy();
-    });
-    it("textOnlyStream emits a well-formed finish chunk", () => {
-        const chunks = textOnlyStream("hi");
-        const finish = chunks.find((c) => c.type === "finish");
-        expect(finish?.finishReason.unified).toBe("stop");
-        expect(finish?.usage.outputTokens.total).toBeGreaterThan(0);
-    });
-    it("toolCallStream emits a tool-calls finish reason", () => {
-        const chunks = toolCallStream({ toolCallId: "x", toolName: "t", input: {} });
-        const finish = chunks.find((c) => c.type === "finish");
-        expect(finish?.finishReason.unified).toBe("tool-calls");
-    });
-});
-describe("loadMockModelFromDir", () => {
-    // Hermetic temp dirs so tests don't depend on tests/harness/fixtures layout.
-    const tmpDirs = [];
-    function mkFixtureDir(model) {
-        const dir = mkdtempSync(join(tmpdir(), "mock-model-fx-"));
-        writeFileSync(join(dir, "fixture.json"), JSON.stringify({ model }), "utf8");
-        tmpDirs.push(dir);
-        return dir;
-    }
-    afterAll(() => {
-        for (const d of tmpDirs) {
-            try {
-                rmSync(d, { recursive: true, force: true });
-            }
-            catch {
-                // ignore — best-effort cleanup
-            }
-        }
-    });
-    it("propagates unsupportedParams from the fixture file", async () => {
-        const dir = mkFixtureDir({
-            provider: "mock",
-            modelId: "mock-gpt",
-            stream: textOnlyStream("hello"),
-            unsupportedParams: ["maxOutputTokens"],
-        });
-        const handle = await loadMockModelFromDir(dir);
-        expect(handle).not.toBeNull();
-        expect(handle?.unsupportedParams).toEqual(["maxOutputTokens"]);
-        // Sanity: the model itself is usable downstream.
-        const r = streamText({ model: handle.model, prompt: "hi" });
-        await drainStream(r);
-        expect(handle?.calls.length).toBe(1);
-    });
-    it("propagates defaultProviderOptions from the fixture file", async () => {
-        const dir = mkFixtureDir({
-            provider: "mock",
-            modelId: "mock-gpt",
-            stream: textOnlyStream("hello"),
-            defaultProviderOptions: { openai: { store: false } },
-        });
-        const handle = await loadMockModelFromDir(dir);
-        expect(handle).not.toBeNull();
-        expect(handle?.defaultProviderOptions).toEqual({ openai: { store: false } });
-    });
-    it("propagates generate (doGenerate JSON) from the fixture file for generateObject", async () => {
-        const dir = mkFixtureDir({
-            provider: "mock",
-            modelId: "mock-gpt",
-            stream: textOnlyStream("unused"),
-            generate: JSON.stringify({ ok: true, label: "built" }),
-        });
-        const handle = await loadMockModelFromDir(dir);
-        expect(handle).not.toBeNull();
-        const { object } = await generateObject({
-            model: handle.model,
-            schema: z.object({ ok: z.boolean(), label: z.string() }),
-            prompt: "go",
-        });
-        expect(object).toEqual({ ok: true, label: "built" });
-    });
-    it("constructs an APICallError from a structured error fixture (drives the humanizeApiError 5xx branch)", async () => {
-        // A pure-JSON fixture cannot otherwise build an APICallError (it arrives as
-        // a plain string). buildFixtureError() in mock-model.ts upgrades a structured
-        // `error` object carrying a statusCode into a real APICallError so harness/
-        // unit specs can exercise the orchestrator's status-aware 5xx path.
-        const dir = mkFixtureDir({
-            provider: "mock",
-            modelId: "mock-gpt",
-            stream: [
-                [
-                    { type: "stream-start", warnings: [] },
-                    {
-                        type: "error",
-                        error: {
-                            apiCallError: true,
-                            statusCode: 500,
-                            message: "AI_APICallError: Request failed",
-                            responseBody: JSON.stringify({ code: 60000, message: "Request failed: Unknown error." }),
-                            url: "https://api.siliconflow.cn/v1/chat/completions",
-                            isRetryable: true,
-                        },
-                    },
-                    {
-                        type: "finish",
-                        finishReason: { unified: "error", raw: null },
-                        usage: {
-                            inputTokens: { total: 0, noCache: 0, cacheRead: null, cacheWrite: null },
-                            outputTokens: { total: 0, text: 0, reasoning: null },
-                        },
-                    },
-                ],
-            ],
-        });
-        const handle = await loadMockModelFromDir(dir);
-        expect(handle).not.toBeNull();
-        const r = streamText({ model: handle.model, prompt: "hi" });
-        let errPart = null;
-        for await (const part of r.fullStream) {
-            if (part.type === "error")
-                errPart = part;
-        }
-        expect(errPart).not.toBeNull();
-        expect(APICallError.isInstance(errPart?.error)).toBe(true);
-        expect((errPart?.error).statusCode).toBe(500);
-        // The 5xx branch must surface the canned actionable text + (HTTP 500) and
-        // SUPPRESS the opaque provider body (the SiliconFlow "Unknown error" mask).
-        const msg = humanizeApiError(errPart?.error);
-        expect(msg).toContain("HTTP 500");
-        expect(msg.toLowerCase()).toContain("try again later");
-        expect(msg).not.toContain("Unknown error");
-        expect(msg).not.toContain("Request failed");
-    });
-    it("supports multi-round stream arrays from the fixture file", async () => {
-        const dir = mkFixtureDir({
-            provider: "mock",
-            modelId: "mock-gpt",
-            // Nested array → one entry consumed per doStream call.
-            stream: [toolCallStream({ toolCallId: "1", toolName: "echo", input: { msg: "hi" } }), textOnlyStream("done")],
-        });
-        const handle = await loadMockModelFromDir(dir);
-        expect(handle).not.toBeNull();
-        const echoTool = tool({
-            description: "echo",
-            inputSchema: z.object({ msg: z.string() }),
-            execute: async ({ msg }) => `echoed: ${msg}`,
-        });
-        const r = streamText({
-            model: handle.model,
-            prompt: "use echo",
-            tools: { echo: echoTool },
-            stopWhen: stepCountIs(3),
-        });
-        await drainStream(r);
-        expect(handle?.calls.length).toBe(2);
-        expect(handle?.calls[1]?.prompt.length).toBeGreaterThan(handle?.calls[0]?.prompt.length ?? 0);
-    });
-});
-//# sourceMappingURL=mock-model.spec.js.map

package/dist/src/agent-harness/__tests__/predicate.spec.d.ts

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

package/dist/src/agent-harness/__tests__/predicate.spec.js

@@ -1,27 +0,0 @@
-import { evaluatePredicate, predicateSchema } from "@muonroi/agent-harness-core/predicate";
-import { describe, expect, it } from "vitest";
-const node = { id: "x", role: "button", name: "Send", focus: true };
-describe("predicate", () => {
-    it("parses a field-op predicate", () => {
-        const p = predicateSchema.parse({ field: "name", op: "eq", rhs: "Send" });
-        expect(evaluatePredicate(p, node)).toBe(true);
-    });
-    it("parses a flag predicate", () => {
-        const p = predicateSchema.parse({ flag: "focus", value: true });
-        expect(evaluatePredicate(p, node)).toBe(true);
-    });
-    it("supports all/any/not", () => {
-        const p = predicateSchema.parse({
-            all: [{ field: "name", op: "contains", rhs: "Sen" }, { not: { flag: "disabled", value: true } }],
-        });
-        expect(evaluatePredicate(p, node)).toBe(true);
-    });
-    it("rejects unknown shapes", () => {
-        expect(() => predicateSchema.parse({ field: "x", op: "weird", rhs: "y" })).toThrow();
-    });
-    it("rejects rhs longer than 200 chars (ReDoS guard)", () => {
-        const huge = "a".repeat(201);
-        expect(() => predicateSchema.parse({ field: "name", op: "regex", rhs: huge })).toThrow();
-    });
-});
-//# sourceMappingURL=predicate.spec.js.map

package/dist/src/agent-harness/__tests__/protocol.spec.d.ts

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

package/dist/src/agent-harness/__tests__/protocol.spec.js

@@ -1,56 +0,0 @@
-import { describe, expect, it } from "vitest";
-describe("protocol types", () => {
-    it("compiles a minimal LiveFrame", () => {
-        const frame = {
-            mode: "live",
-            version: "0.4.0",
-            seq: 0,
-            ts: 0,
-            nodes: [],
-        };
-        expect(frame.mode).toBe("live");
-    });
-    it("compiles a UINode with all flags", () => {
-        const node = {
-            id: "a",
-            role: "button",
-            name: "OK",
-            focus: true,
-            selected: true,
-            disabled: true,
-            hidden: true,
-            state: "loading",
-            props: { pct: 50 },
-            children: [],
-        };
-        expect(node.id).toBe("a");
-    });
-    it("compiles a DesignSpec with state patches", () => {
-        const spec = {
-            mode: "design",
-            version: "0.4.0",
-            scenes: [
-                {
-                    id: "s1",
-                    name: "Composer",
-                    layout: { id: "root", role: "dialog" },
-                    states: [{ name: "loading", patches: [{ id: "root", state: "loading" }] }],
-                },
-            ],
-        };
-        expect(spec.scenes.length).toBe(1);
-    });
-    it("compiles a stream.delta LiveEvent", () => {
-        const e = { t: "event", kind: "stream.delta", target: "x", text: "y" };
-        expect(e.kind).toBe("stream.delta");
-    });
-    it("compiles a toast LiveEvent", () => {
-        const e = { t: "event", kind: "toast", level: "error", text: "boom" };
-        expect(e.level).toBe("error");
-    });
-    it("compiles an idle LiveEvent", () => {
-        const e = { t: "idle" };
-        expect(e.t).toBe("idle");
-    });
-});
-//# sourceMappingURL=protocol.spec.js.map

package/dist/src/agent-harness/__tests__/schema.spec.d.ts

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

package/dist/src/agent-harness/__tests__/schema.spec.js

@@ -1,76 +0,0 @@
-import { readdirSync, readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import Ajv from "ajv/dist/2020.js";
-import { describe, expect, it } from "vitest";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const schema = JSON.parse(readFileSync(new URL("../../../docs/agent-harness/schema.json", import.meta.url), "utf8"));
-const ajv = new Ajv({ strict: false });
-ajv.addSchema(schema);
-describe("schema fixtures", () => {
-    const examplesDir = join(__dirname, "../../../docs/agent-harness/examples");
-    const files = readdirSync(examplesDir).filter((f) => f.endsWith(".json"));
-    for (const f of files) {
-        it(`${f} matches schema`, () => {
-            const data = JSON.parse(readFileSync(join(examplesDir, f), "utf8"));
-            const def = data.mode === "live" ? "LiveFrame" : "DesignSpec";
-            const validate = ajv.compile({
-                $ref: `${schema.$id}#/definitions/${def}`,
-            });
-            const ok = validate(data);
-            if (!ok)
-                console.error(validate.errors);
-            expect(ok).toBe(true);
-        });
-    }
-});
-describe("schema rejects invalid data", () => {
-    it("rejects a LiveFrame missing mode", () => {
-        const validate = ajv.compile({
-            $ref: `${schema.$id}#/definitions/LiveFrame`,
-        });
-        const badData = {
-            version: "0.3.0",
-            seq: 0,
-            ts: 0,
-            nodes: [],
-        };
-        expect(validate(badData)).toBe(false);
-    });
-    it("rejects a LiveFrame with extra unknown field", () => {
-        const validate = ajv.compile({
-            $ref: `${schema.$id}#/definitions/LiveFrame`,
-        });
-        const badData = {
-            mode: "live",
-            version: "0.3.0",
-            seq: 0,
-            ts: 0,
-            nodes: [],
-            extra: "x",
-        };
-        expect(validate(badData)).toBe(false);
-    });
-    it("rejects a DesignSpec where a StatePatch includes children", () => {
-        const validate = ajv.compile({
-            $ref: `${schema.$id}#/definitions/StatePatch`,
-        });
-        const badData = {
-            id: "root",
-            children: [],
-        };
-        expect(validate(badData)).toBe(false);
-    });
-    it("rejects a UINode with invalid role value", () => {
-        const validate = ajv.compile({
-            $ref: `${schema.$id}#/definitions/UINode`,
-        });
-        const badData = {
-            id: "test",
-            role: "notarole",
-        };
-        expect(validate(badData)).toBe(false);
-    });
-});
-//# sourceMappingURL=schema.spec.js.map

package/dist/src/agent-harness/__tests__/selector.spec.d.ts

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

package/dist/src/agent-harness/__tests__/selector.spec.js

@@ -1,70 +0,0 @@
-import { parseSelector } from "@muonroi/agent-harness-core/selector";
-import { describe, expect, it } from "vitest";
-describe("selector parser", () => {
-    it("parses key=value", () => {
-        expect(parseSelector('role=button name="Send"')).toEqual({
-            terms: [
-                { key: "role", op: "=", value: "button" },
-                { key: "name", op: "=", value: "Send" },
-            ],
-            combinators: [" "],
-        });
-    });
-    it("parses contains and regex ops", () => {
-        expect(parseSelector("name~=Send name*=^Send$").terms.map((t) => t.op)).toEqual(["~=", "*="]);
-    });
-    it("parses flags", () => {
-        expect(parseSelector("focus selected").terms).toEqual([
-            { key: "__flag", op: "=", value: "focus" },
-            { key: "__flag", op: "=", value: "selected" },
-        ]);
-    });
-    it("parses [index=N]", () => {
-        const s = parseSelector("role=listitem [index=2]");
-        expect(s.terms.find((t) => t.key === "__index")?.value).toBe("2");
-    });
-    it("parses child combinator", () => {
-        const s = parseSelector("role=dialog >> role=button");
-        expect(s.combinators).toEqual([">>"]);
-    });
-    it("parses dotted prop key", () => {
-        expect(parseSelector("props.scrollTop=5").terms[0].key).toBe("props.scrollTop");
-    });
-});
-import { matchSelector } from "@muonroi/agent-harness-core/selector";
-const tree = {
-    id: "root",
-    role: "dialog",
-    children: [
-        { id: "composer", role: "textbox", focus: true, value: "hello" },
-        { id: "send", role: "button", name: "Send" },
-        {
-            id: "list",
-            role: "listbox",
-            children: [
-                { id: "i0", role: "listitem", name: "A" },
-                { id: "i1", role: "listitem", name: "B", selected: true },
-                { id: "i2", role: "listitem", name: "C" },
-            ],
-        },
-    ],
-};
-describe("matcher", () => {
-    it("matches role=button name=Send", () => {
-        const hits = matchSelector(tree, 'role=button name="Send"');
-        expect(hits.map((n) => n.id)).toEqual(["send"]);
-    });
-    it("matches contains op", () => {
-        const hits = matchSelector(tree, "name~=Sen");
-        expect(hits.map((n) => n.id)).toEqual(["send"]);
-    });
-    it("matches focus flag", () => {
-        const hits = matchSelector(tree, "focus");
-        expect(hits.map((n) => n.id)).toEqual(["composer"]);
-    });
-    it("matches [index=N] under listbox", () => {
-        const hits = matchSelector(tree, "role=listbox >> role=listitem [index=2]");
-        expect(hits.map((n) => n.id)).toEqual(["i2"]);
-    });
-});
-//# sourceMappingURL=selector.spec.js.map

package/dist/src/agent-harness/__tests__/sidechannel.spec.d.ts

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

package/dist/src/agent-harness/__tests__/sidechannel.spec.js

@@ -1,29 +0,0 @@
-// src/agent-harness/__tests__/sidechannel.spec.ts
-import { createLineSplitter, createSidechannelWriter, parseSidechannelLine, } from "@muonroi/agent-harness-core/transports/sidechannel";
-import { describe, expect, it } from "vitest";
-describe("sidechannel framing", () => {
-    it("serializes a message as a single JSONL line", () => {
-        const line = createSidechannelWriter.serialize({ t: "idle" });
-        expect(line.endsWith("\n")).toBe(true);
-        expect(line.split("\n").filter(Boolean).length).toBe(1);
-    });
-    it("rejects messages over 1 MiB", () => {
-        const huge = "x".repeat(1024 * 1024 + 1);
-        expect(() => createSidechannelWriter.serialize({ t: "event", kind: "stream.delta", target: "a", text: huge })).toThrow(/exceeds 1 MiB/);
-    });
-    it("parses a valid line", () => {
-        expect(parseSidechannelLine('{"t":"idle"}\n')).toEqual({ t: "idle" });
-    });
-    it("throws on invalid JSON", () => {
-        expect(() => parseSidechannelLine("not json\n")).toThrow();
-    });
-});
-describe("line splitter", () => {
-    it("ignores empty lines", () => {
-        const got = [];
-        const split = createLineSplitter((l) => got.push(l));
-        split("a\n\nb\n");
-        expect(got).toEqual(["a\n", "b\n"]);
-    });
-});
-//# sourceMappingURL=sidechannel.spec.js.map

package/dist/src/agent-harness/__tests__/spec-helpers.spec.d.ts

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