muonroi-cli 1.8.1 → 1.8.4

package/dist/src/ops/doctor.test.js

@@ -1,97 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-// RED phase: import module under test (will fail until doctor.ts is created)
-import { formatDoctorReport, runDoctor } from "./doctor.js";
-describe("doctor — runDoctor returns 10 checks", () => {
-    beforeEach(() => {
-        // Mock fetch to avoid real network calls in tests
-        vi.stubGlobal("fetch", vi.fn().mockResolvedValue({ ok: false, status: 503 }));
-    });
-    afterEach(() => {
-        vi.unstubAllGlobals();
-        vi.restoreAllMocks();
-    });
-    it("returns exactly 10 CheckResult entries (dotnet added in VERIFY F1)", async () => {
-        const results = await runDoctor();
-        expect(results).toHaveLength(10);
-    });
-    it("each CheckResult has valid name, status, and detail fields", async () => {
-        const results = await runDoctor();
-        const validStatuses = ["pass", "warn", "fail"];
-        for (const r of results) {
-            expect(typeof r.name).toBe("string");
-            expect(r.name.length).toBeGreaterThan(0);
-            expect(validStatuses).toContain(r.status);
-            expect(typeof r.detail).toBe("string");
-            expect(r.detail.length).toBeGreaterThan(0);
-        }
-    });
-    it("includes expected check names", async () => {
-        const results = await runDoctor();
-        const names = results.map((r) => r.name);
-        expect(names).toContain("bun_version");
-        expect(names).toContain("os");
-        expect(names).toContain("key_presence");
-        expect(names).toContain("ollama");
-        expect(names).toContain("dotnet");
-        expect(names).toContain("ee.health");
-        expect(names).toContain("ee.brain");
-        expect(names).toContain("qdrant");
-        expect(names).toContain("error_rate");
-    });
-    it("unreachable services return warn (not fail or throw)", async () => {
-        vi.stubGlobal("fetch", vi.fn().mockRejectedValue(new Error("Network unreachable")));
-        const results = await runDoctor();
-        const ollamaCheck = results.find((r) => r.name === "ollama");
-        const eeCheck = results.find((r) => r.name === "ee.health");
-        const qdrantCheck = results.find((r) => r.name === "qdrant");
-        expect(ollamaCheck.status).toBe("warn");
-        expect(eeCheck.status).toBe("warn");
-        expect(qdrantCheck.status).toBe("warn");
-    });
-});
-describe("doctor — bun_version check", () => {
-    afterEach(() => {
-        vi.unstubAllGlobals();
-        vi.restoreAllMocks();
-    });
-    it("returns pass when bun version >= 1.3.13", async () => {
-        vi.stubGlobal("fetch", vi.fn().mockResolvedValue({ ok: false, status: 503 }));
-        // In test environment: process.versions.bun may or may not be set
-        // We just verify bun_version is one of the valid statuses
-        const results = await runDoctor();
-        const bunCheck = results.find((r) => r.name === "bun_version");
-        expect(["pass", "fail", "warn"]).toContain(bunCheck.status);
-        expect(bunCheck.detail).toMatch(/Bun|Not running/);
-    });
-});
-describe("doctor — formatDoctorReport", () => {
-    it("contains [PASS] icon for passing check", () => {
-        const results = [{ name: "os", status: "pass", detail: "linux 5.15" }];
-        const report = formatDoctorReport(results);
-        expect(report).toContain("[PASS]");
-        expect(report).toContain("os");
-    });
-    it("contains [WARN] icon for warn check", () => {
-        const results = [{ name: "ollama", status: "warn", detail: "Ollama VPS unreachable" }];
-        const report = formatDoctorReport(results);
-        expect(report).toContain("[WARN]");
-    });
-    it("contains [FAIL] icon for fail check", () => {
-        const results = [{ name: "bun_version", status: "fail", detail: "Not running under Bun" }];
-        const report = formatDoctorReport(results);
-        expect(report).toContain("[FAIL]");
-    });
-    it("includes summary line with counts", () => {
-        const results = [
-            { name: "os", status: "pass", detail: "linux" },
-            { name: "ollama", status: "warn", detail: "unreachable" },
-            { name: "bun_version", status: "fail", detail: "missing" },
-        ];
-        const report = formatDoctorReport(results);
-        expect(report).toContain("Summary:");
-        expect(report).toContain("1 pass");
-        expect(report).toContain("1 warn");
-        expect(report).toContain("1 fail");
-    });
-});
-//# sourceMappingURL=doctor.test.js.map

package/dist/src/orchestrator/__tests__/agent-base-url-switch.test.d.ts

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

package/dist/src/orchestrator/__tests__/agent-base-url-switch.test.js

@@ -1,77 +0,0 @@
-/**
- * Regression: Agent.setModel / Agent.setApiKey must NOT carry a previous
- * provider's default baseURL into the new provider's factory.
- *
- * Evidence (session 2492d6579b1d, see DB `interaction_logs.error api` row
- * with metadata 'The supported API model names are deepseek-v4-pro or
- * deepseek-v4-flash, but you passed deepseek-ai/DeepSeek-V4-Flash.'):
- *
- * Before the fix, switching defaultProvider from deepseek → siliconflow via
- * the UI left this.baseURL = "https://api.deepseek.com" from startup. The
- * setModel rebuild path constructed a SiliconflowStrategy factory but bound
- * it to the DeepSeek apiBase, so requests landed at api.deepseek.com with a
- * SiliconFlow-prefixed model id, which DeepSeek rejected with the literal
- * error string above.
- *
- * This test exercises the public Agent surface to confirm the fix detects a
- * stale "this is another provider's default apiBase" baseURL and drops it.
- */
-import { afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
-import { loadCatalog } from "../../models/registry.js";
-import { apiBaseFor } from "../../providers/endpoints.js";
-import { Agent } from "../orchestrator.js";
-describe("Agent provider switch — baseURL hygiene", () => {
-    beforeAll(async () => {
-        await loadCatalog();
-    });
-    beforeEach(() => {
-        // Tests run in-process with no real key persistence; skip session DB to
-        // keep the assertions on pure provider/URL state.
-        process.env.MUONROI_TEST_NO_PERSIST = "1";
-        process.env.MUONROI_TEST_NO_KEYCHAIN = "1";
-    });
-    afterEach(() => {
-        delete process.env.MUONROI_TEST_NO_PERSIST;
-        delete process.env.MUONROI_TEST_NO_KEYCHAIN;
-    });
-    it("setModel drops stale baseURL when switching to a different provider", () => {
-        const agent = new Agent("sk-test-deepseek", apiBaseFor("deepseek"), "deepseek-v4-flash", undefined, {
-            persistSession: false,
-        });
-        expect(agent.getProviderId()).toBe("deepseek");
-        expect(agent.baseURL).toBe(apiBaseFor("deepseek"));
-        agent.setModel("deepseek-ai/DeepSeek-V4-Flash");
-        expect(agent.getProviderId()).toBe("siliconflow");
-        // Stale DS apiBase must be dropped so the SF factory binds to SF's URL.
-        expect(agent.baseURL).toBeNull();
-    });
-    it("setModel preserves a genuine custom baseURL (not a known provider apiBase)", () => {
-        const customURL = "https://proxy.internal.example.com/v1";
-        const agent = new Agent("sk-test", customURL, "deepseek-v4-flash", undefined, {
-            persistSession: false,
-        });
-        expect(agent.baseURL).toBe(customURL);
-        agent.setModel("deepseek-ai/DeepSeek-V4-Flash");
-        // Custom URL doesn't match any known provider apiBase → kept as override.
-        expect(agent.baseURL).toBe(customURL);
-    });
-    it("setModel does NOT drop baseURL when staying on the same provider", () => {
-        const agent = new Agent("sk-test", apiBaseFor("siliconflow"), "alibaba/Qwen3-30B-A3B-Instruct-2507", undefined, {
-            persistSession: false,
-        });
-        expect(agent.getProviderId()).toBe("siliconflow");
-        agent.setModel("deepseek-ai/DeepSeek-V4-Flash");
-        expect(agent.getProviderId()).toBe("siliconflow");
-        expect(agent.baseURL).toBe(apiBaseFor("siliconflow"));
-    });
-    it("setApiKey drops a stale apiBase that targets a different provider", () => {
-        const agent = new Agent(undefined, undefined, "deepseek-ai/DeepSeek-V4-Flash", undefined, {
-            persistSession: false,
-        });
-        expect(agent.getProviderId()).toBe("siliconflow");
-        // Caller hands setApiKey a stale DeepSeek apiBase — must be dropped.
-        agent.setApiKey("sk-test", apiBaseFor("deepseek"));
-        expect(agent.baseURL).toBeNull();
-    });
-});
-//# sourceMappingURL=agent-base-url-switch.test.js.map

package/dist/src/orchestrator/__tests__/auto-commit.test.d.ts

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

package/dist/src/orchestrator/__tests__/auto-commit.test.js

@@ -1,142 +0,0 @@
-import { execFileSync } from "node:child_process";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join, resolve } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { blockingErrorsForFile, buildFileListSubject, isAutoCommitEnabled, isCliArtifactPath, isCommitGateEnabled, isExcludedPath, isSensitivePath, parsePorcelainPaths, pathsForCommitGate, splitCommitMessage, } from "../auto-commit.js";
-function diag(severity) {
-    return {
-        message: "x",
-        severity,
-        range: { start: { line: 0, character: 0 }, end: { line: 0, character: 1 } },
-    };
-}
-function diagFile(filePath, severities) {
-    return { filePath, serverId: "ts", diagnostics: severities.map(diag) };
-}
-describe("auto-commit pure helpers", () => {
-    it("parses porcelain output incl. rename + quoted paths", () => {
-        const out = ' M src/a.ts\n?? new file.txt\nR  old.ts -> src/b.ts\nA  "with space.ts"\n';
-        const set = parsePorcelainPaths(out);
-        expect(set.has("src/a.ts")).toBe(true);
-        expect(set.has("new file.txt")).toBe(true);
-        // rename keeps ONLY the new path
-        expect(set.has("src/b.ts")).toBe(true);
-        expect(set.has("old.ts")).toBe(false);
-        // quoted path with a space is unquoted
-        expect(set.has("with space.ts")).toBe(true);
-    });
-    it("flags sensitive paths and lets normal source through", () => {
-        expect(isSensitivePath(".env")).toBe(true);
-        expect(isSensitivePath(".env.local")).toBe(true);
-        expect(isSensitivePath("config/app.key")).toBe(true);
-        expect(isSensitivePath("certs/server.pem")).toBe(true);
-        expect(isSensitivePath("src/db-secret.ts")).toBe(true);
-        // .muonroi-cli/ is categorized as a CLI artifact (excluded), not a "secret".
-        expect(isSensitivePath(".muonroi-cli/state.json")).toBe(false);
-        expect(isExcludedPath(".muonroi-cli/state.json")).toBe(true);
-        expect(isSensitivePath("src/index.ts")).toBe(false);
-        expect(isSensitivePath("README.md")).toBe(false);
-    });
-    it("excludes CLI-generated artifacts + build junk (the 11-file-leak fix)", () => {
-        expect(isCliArtifactPath(".muonroi-flow/state.md")).toBe(true);
-        expect(isCliArtifactPath(".muonroi-flow/runs/abc/manifest.md")).toBe(true);
-        expect(isCliArtifactPath(".muonroi-cli/session.db")).toBe(true);
-        expect(isCliArtifactPath(".muonroi-harness-roots.json")).toBe(true);
-        expect(isCliArtifactPath("node_modules/x/index.js")).toBe(true);
-        expect(isCliArtifactPath("dist/bundle.js")).toBe(true);
-        expect(isCliArtifactPath("debug.log")).toBe(true);
-        expect(isCliArtifactPath("src/greeting.txt")).toBe(false);
-        // isExcludedPath unions secrets + artifacts
-        expect(isExcludedPath(".env")).toBe(true);
-        expect(isExcludedPath(".muonroi-flow/state.md")).toBe(true);
-        expect(isExcludedPath("greeting.txt")).toBe(false);
-    });
-    it("backstop subject lists files + stays bounded (never the raw prompt)", () => {
-        expect(buildFileListSubject(["src/a.ts", "src/b.ts"])).toBe("chore: update 2 file(s) — a.ts, b.ts");
-        expect(buildFileListSubject(["a.ts", "b.ts", "c.ts", "d.ts", "e.ts"])).toContain("+2 more");
-        expect(buildFileListSubject(Array.from({ length: 20 }, (_, i) => `file${i}.ts`)).length).toBeLessThanOrEqual(72);
-    });
-    it("splits an agent-authored message: subject <=72, body kept, attribution deduped", () => {
-        expect(splitCommitMessage("feat: add X\r\n\r\nbody line")).toEqual({ subject: "feat: add X", body: "body line" });
-        expect(splitCommitMessage("x".repeat(200)).subject.length).toBeLessThanOrEqual(72);
-        // an attribution the agent already added is dropped (we append exactly one)
-        expect(splitCommitMessage("feat: y\nCoding by - Muonroi-CLI")).toEqual({ subject: "feat: y", body: "" });
-    });
-    it("is disabled under the unit-test runner so the suite never commits", () => {
-        // VITEST is set while this runs → must be false regardless of MUONROI_AUTO_COMMIT.
-        expect(isAutoCommitEnabled()).toBe(false);
-    });
-});
-describe("G1 commit quality gate", () => {
-    it("commit gate is disabled under the unit-test runner (specs commit fixtures freely)", () => {
-        // Mirrors isAutoCommitEnabled — VITEST is set, so the gate must be off here.
-        expect(isCommitGateEnabled()).toBe(false);
-    });
-    describe("blockingErrorsForFile — errors-only + per-file scope", () => {
-        it("returns severity-1 (error) diagnostics for the staged file", () => {
-            const abs = resolve("foo.ts");
-            const errs = blockingErrorsForFile([diagFile("foo.ts", [1, 1])], abs);
-            expect(errs).toHaveLength(2);
-        });
-        it("treats a missing severity as an error (LSP default is 1)", () => {
-            const abs = resolve("foo.ts");
-            expect(blockingErrorsForFile([diagFile("foo.ts", [undefined])], abs)).toHaveLength(1);
-        });
-        it("ignores warnings/infos (severity >= 2) — they never block a commit", () => {
-            const abs = resolve("foo.ts");
-            expect(blockingErrorsForFile([diagFile("foo.ts", [2, 3, 4])], abs)).toHaveLength(0);
-        });
-        it("ignores errors reported against a DIFFERENT file (cross-file breakage doesn't block)", () => {
-            const abs = resolve("foo.ts");
-            // An error on other.ts must not block a commit of foo.ts.
-            expect(blockingErrorsForFile([diagFile("other.ts", [1, 1])], abs)).toHaveLength(0);
-        });
-        it("mixes: keeps only this file's errors out of a multi-file, multi-severity set", () => {
-            const abs = resolve("foo.ts");
-            const errs = blockingErrorsForFile([diagFile("foo.ts", [1, 2, 3]), diagFile("bar.ts", [1, 1])], abs);
-            expect(errs).toHaveLength(1); // only foo.ts's single severity-1
-        });
-        it("empty diagnostics → no blockers (non-source / no-LSP-server files pass)", () => {
-            expect(blockingErrorsForFile([], resolve("README.md"))).toEqual([]);
-        });
-    });
-});
-describe("pathsForCommitGate — bash `git commit` gate path set (real git)", () => {
-    let dir;
-    const g = (args) => execFileSync("git", args, { cwd: dir, stdio: "pipe" });
-    beforeEach(() => {
-        dir = mkdtempSync(join(tmpdir(), "commit-gate-"));
-        g(["init", "-q"]);
-        g(["config", "user.email", "t@t.t"]);
-        g(["config", "user.name", "t"]);
-    });
-    afterEach(() => rmSync(dir, { recursive: true, force: true }));
-    it("returns only the already-staged set for a plain `git commit`", async () => {
-        writeFileSync(join(dir, "a.ts"), "export const a = 1;\n");
-        writeFileSync(join(dir, "b.ts"), "export const b = 2;\n");
-        g(["add", "a.ts"]); // b.ts left untracked
-        const paths = await pathsForCommitGate(dir, { broadAdd: false, commitAll: false });
-        expect(paths).toEqual(["a.ts"]);
-    });
-    it("adds tracked modifications that `git commit -a` will auto-stage", async () => {
-        writeFileSync(join(dir, "a.ts"), "export const a = 1;\n");
-        g(["add", "a.ts"]);
-        g(["commit", "-qm", "init", "--no-verify"]); // temp fixture repo — hook-free by design
-        writeFileSync(join(dir, "a.ts"), "export const a = 99;\n"); // modify tracked, NOT re-staged
-        // plain commit sees nothing staged; commit -a includes the modification.
-        expect(await pathsForCommitGate(dir, { broadAdd: false, commitAll: false })).toEqual([]);
-        expect(await pathsForCommitGate(dir, { broadAdd: false, commitAll: true })).toContain("a.ts");
-    });
-    it("includes the whole working tree for a chained broad `git add -A` (add not yet run)", async () => {
-        writeFileSync(join(dir, "a.ts"), "export const a = 1;\n"); // untracked
-        writeFileSync(join(dir, "c.ts"), "export const c = 3;\n"); // untracked
-        // Nothing staged at pre-exec time → plain set is empty…
-        expect(await pathsForCommitGate(dir, { broadAdd: false, commitAll: false })).toEqual([]);
-        // …but `git add -A` would stage both, so the broad path enumerates them.
-        const broad = await pathsForCommitGate(dir, { broadAdd: true, commitAll: false });
-        expect(broad).toContain("a.ts");
-        expect(broad).toContain("c.ts");
-    });
-});
-//# sourceMappingURL=auto-commit.test.js.map

package/dist/src/orchestrator/__tests__/batch-turn-runner.test.d.ts

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

package/dist/src/orchestrator/__tests__/batch-turn-runner.test.js

@@ -1,164 +0,0 @@
-// Phase 12.5-03 — BatchTurnRunner unit tests.
-//
-// Focused smoke: confirms the DI surface (BatchTurnRunnerDeps) is wired
-// correctly and that the abort + retry invariants hold without exercising
-// the (stub) batch API. The Phase 0 batch stubs throw, so every successful
-// path through `run()` here goes via the catch-block — that's exactly what
-// we want to assert (transient retry + abort + recordUsage guard).
-import { beforeAll, describe, expect, it } from "vitest";
-import { getTestModels, getTestProviders } from "../../__test-helpers__/catalog-fixtures.js";
-import { loadCatalog } from "../../models/registry.js";
-import { BatchTurnRunner } from "../batch-turn-runner.js";
-beforeAll(async () => {
-    await loadCatalog();
-});
-function makeBashStub() {
-    return {
-        getCwd: () => process.cwd(),
-        getSandboxMode: () => "off",
-        getSandboxSettings: () => ({}),
-    };
-}
-function makeDeps(overrides = {}) {
-    const messages = [];
-    let compactedThisTurn = false;
-    const counters = {
-        appendCompletedTurn: 0,
-        discardAbortedTurn: 0,
-        recordUsage: 0,
-        compactedFlags: [],
-    };
-    const deps = {
-        messages,
-        bash: makeBashStub(),
-        mode: "agent",
-        maxToolRounds: 50,
-        hardMaxToolRounds: 60,
-        maxTokens: 16_384,
-        schedules: {},
-        sendTelegramFile: null,
-        getSessionId: () => null,
-        getCompactedThisTurn: () => compactedThisTurn,
-        setCompactedThisTurn: (v) => {
-            compactedThisTurn = v;
-            counters.compactedFlags.push(v);
-        },
-        setLastProviderOptionsShape: () => { },
-        getBatchClientOptions: () => ({ apiKey: "test-key" }),
-        getCompactionSettings: (_cw) => ({
-            thresholdPct: 0.85,
-            keepRecentTokens: 4096,
-            reserveTokens: 16_384,
-        }),
-        compactForContext: async () => true,
-        postTurnCompact: async () => { },
-        createTools: () => ({}),
-        runTask: async () => ({ success: true, output: "" }),
-        runDelegation: async () => ({ success: true, output: "" }),
-        readDelegation: async () => ({ success: true, output: "" }),
-        listDelegations: async () => ({ success: true, output: "" }),
-        killDelegation: async () => ({ success: true, output: "" }),
-        executeBatchToolCall: async (_tools, _call) => ({
-            input: {},
-            result: { success: true, output: "" },
-        }),
-        appendCompletedTurn: () => {
-            counters.appendCompletedTurn++;
-        },
-        discardAbortedTurn: () => {
-            counters.discardAbortedTurn++;
-        },
-        recordUsage: () => {
-            counters.recordUsage++;
-        },
-        ...overrides,
-    };
-    return { deps, counters };
-}
-function makeArgs(signal, providerStub) {
-    const testModels = getTestModels();
-    const testProviders = getTestProviders();
-    return {
-        userModelMessage: { role: "user", content: "hello" },
-        userEnrichedMessage: { role: "user", content: "hello" },
-        observer: undefined,
-        provider: (providerStub ?? {}),
-        subagents: [],
-        system: "",
-        runtime: {
-            modelId: testModels.fast,
-            modelInfo: { provider: testProviders.default, contextWindow: 131_072 },
-            model: {},
-            providerOptions: {},
-            unsupportedParams: [],
-        },
-        modelInfo: { contextWindow: 131_072 },
-        signal,
-    };
-}
-async function drain(gen) {
-    const out = [];
-    for await (const chunk of gen)
-        out.push(chunk);
-    return out;
-}
-describe("BatchTurnRunner DI invariants (12.5-03)", () => {
-    it("constructs with deps and exposes run()", () => {
-        const { deps } = makeDeps();
-        const runner = new BatchTurnRunner(deps);
-        expect(typeof runner.run).toBe("function");
-    });
-    it("yields [Cancelled] when signal is already aborted and calls discardAbortedTurn", async () => {
-        // Force compactForContext to throw a non-transient error fast so the
-        // catch-block runs without hitting the retry exponential-backoff sleep.
-        const { deps, counters } = makeDeps({
-            compactForContext: async () => {
-                throw new Error("synthetic compact failure (non-transient)");
-            },
-        });
-        const runner = new BatchTurnRunner(deps);
-        const ctrl = new AbortController();
-        ctrl.abort();
-        const chunks = await drain(runner.run(makeArgs(ctrl.signal)));
-        // catch sees signal.aborted → emits "[Cancelled]" and discards the turn.
-        expect(chunks.some((c) => c.content === "\n\n[Cancelled]")).toBe(true);
-        expect(counters.discardAbortedTurn).toBe(1);
-        expect(counters.appendCompletedTurn).toBe(0);
-    });
-    it("flips compactedThisTurn to false at the top of every turn", async () => {
-        const { deps, counters } = makeDeps({
-            compactForContext: async () => {
-                throw new Error("synthetic non-transient");
-            },
-        });
-        const runner = new BatchTurnRunner(deps);
-        const ctrl = new AbortController();
-        ctrl.abort(); // skip retry sleep
-        await drain(runner.run(makeArgs(ctrl.signal)));
-        expect(counters.compactedFlags[0]).toBe(false);
-    });
-    it("does NOT call recordUsage when totalUsage is empty (hasUsage guard)", async () => {
-        const { deps, counters } = makeDeps({
-            compactForContext: async () => {
-                throw new Error("synthetic non-transient");
-            },
-        });
-        const runner = new BatchTurnRunner(deps);
-        const ctrl = new AbortController();
-        // Pre-abort so we hit the catch's `signal.aborted` early-return: that
-        // path discards the turn (no appendCompletedTurn and no recordUsage).
-        ctrl.abort();
-        await drain(runner.run(makeArgs(ctrl.signal)));
-        expect(counters.recordUsage).toBe(0);
-        expect(counters.appendCompletedTurn).toBe(0);
-        expect(counters.discardAbortedTurn).toBe(1);
-    });
-    it("propagates messages array reference (deps.messages mutation visible)", () => {
-        const { deps } = makeDeps();
-        const newMsg = { role: "assistant", content: "test" };
-        deps.messages.push(newMsg);
-        expect(deps.messages.length).toBe(1);
-        expect(deps.messages[0]).toBe(newMsg);
-    });
-});
-//# sourceMappingURL=batch-turn-runner.test.js.map

package/dist/src/orchestrator/__tests__/council-manager.test.d.ts

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

package/dist/src/orchestrator/__tests__/council-manager.test.js

@@ -1,148 +0,0 @@
-// Phase 12.1-02 — CouncilManager unit tests.
-//
-// Smoke-only: state isolation, resolver registration/buffering lifecycle,
-// outcome parser fallback. Heavy integration is covered by
-// src/council/__tests__/*.test.ts.
-import { describe, expect, it } from "vitest";
-import { CouncilManager } from "../council-manager.js";
-function makeDeps(overrides = {}) {
-    return {
-        getModelId: () => "test-model",
-        getSessionId: () => null,
-        hasSessionStore: () => false,
-        getMessages: () => [],
-        getBash: () => ({ getCwd: () => process.cwd() }),
-        getMode: () => "agent",
-        ...overrides,
-    };
-}
-describe("CouncilManager — state isolation", () => {
-    it("each instance owns its own stats", () => {
-        const a = new CouncilManager(makeDeps());
-        const b = new CouncilManager(makeDeps());
-        a.resetStats(1000);
-        b.resetStats(2000);
-        expect(a.stats.startMs).toBe(1000);
-        expect(b.stats.startMs).toBe(2000);
-        // Bump a's calls — b stays at zero.
-        a.stats.calls = 5;
-        expect(b.stats.calls).toBe(0);
-    });
-    it("synthesis state is per-instance", () => {
-        const a = new CouncilManager(makeDeps());
-        const b = new CouncilManager(makeDeps());
-        a.setLastSynthesis("from-a");
-        b.setLastSynthesis("from-b");
-        expect(a.lastSynthesis).toBe("from-a");
-        expect(b.lastSynthesis).toBe("from-b");
-    });
-    it("continuation flag is per-instance", () => {
-        const a = new CouncilManager(makeDeps());
-        const b = new CouncilManager(makeDeps());
-        a.setContinuation(true);
-        expect(a.isContinuation).toBe(true);
-        expect(b.isContinuation).toBe(false);
-    });
-});
-describe("CouncilManager — question resolver lifecycle", () => {
-    it("buffers question answers that arrive before the responder registers", async () => {
-        const m = new CouncilManager(makeDeps());
-        m.respondToQuestion("qid-1", "buffered-answer");
-        const promise = m.createQuestionResponder()("qid-1");
-        await expect(promise).resolves.toBe("buffered-answer");
-    });
-    it("resolves a pending question when the answer arrives later", async () => {
-        const m = new CouncilManager(makeDeps());
-        const promise = m.createQuestionResponder()("qid-2");
-        m.respondToQuestion("qid-2", "later-answer");
-        await expect(promise).resolves.toBe("later-answer");
-    });
-    it("drains the buffered slot exactly once per question id", async () => {
-        const m = new CouncilManager(makeDeps());
-        m.respondToQuestion("qid-3", "first");
-        await expect(m.createQuestionResponder()("qid-3")).resolves.toBe("first");
-        // Second responder for the same id must wait for a new answer.
-        const stalled = m.createQuestionResponder()("qid-3");
-        let settled = false;
-        void stalled.then(() => {
-            settled = true;
-        });
-        await new Promise((r) => setTimeout(r, 10));
-        expect(settled).toBe(false);
-        m.respondToQuestion("qid-3", "second");
-        await expect(stalled).resolves.toBe("second");
-    });
-});
-describe("CouncilManager — preflight resolver lifecycle", () => {
-    it("buffers preflight approvals before the responder registers", async () => {
-        const m = new CouncilManager(makeDeps());
-        m.respondToPreflight("pf-1", false);
-        await expect(m.createPreflightResponder()("pf-1")).resolves.toBe(false);
-    });
-    it("resolves pending preflight when approval arrives later", async () => {
-        const m = new CouncilManager(makeDeps());
-        const promise = m.createPreflightResponder()("pf-2");
-        m.respondToPreflight("pf-2", true);
-        await expect(promise).resolves.toBe(true);
-    });
-});
-describe("CouncilManager — parseOutcome fallback", () => {
-    it("returns null on non-JSON synthesis", () => {
-        const m = new CouncilManager(makeDeps());
-        expect(m.parseOutcome("no json here", "topic")).toBeNull();
-    });
-    it("returns null when required fields are missing", () => {
-        const m = new CouncilManager(makeDeps());
-        expect(m.parseOutcome('{"type":"decision"}', "topic")).toBeNull();
-        expect(m.parseOutcome('{"summary":"only summary"}', "topic")).toBeNull();
-    });
-    it("parses a well-formed decision outcome", () => {
-        const m = new CouncilManager(makeDeps());
-        const parsed = m.parseOutcome('{"type":"decision","summary":"do X","agreed":["a"],"tradeoffs":[],"recommendation":"X"}', "topic");
-        expect(parsed?.type).toBe("decision");
-        expect(parsed?.summary).toBe("do X");
-        expect(parsed?.agreed).toEqual(["a"]);
-    });
-});
-describe("CouncilManager — buildContext", () => {
-    it("returns empty string when there are no messages", () => {
-        const m = new CouncilManager(makeDeps({ getMessages: () => [] }));
-        expect(m.buildContext()).toBe("");
-    });
-    it("includes recent user messages", () => {
-        const msgs = [
-            { role: "user", content: "hello world" },
-            { role: "assistant", content: "ack" },
-            { role: "user", content: "second user turn" },
-        ];
-        const m = new CouncilManager(makeDeps({ getMessages: () => msgs }));
-        const ctx = m.buildContext();
-        expect(ctx).toContain("hello world");
-        expect(ctx).toContain("second user turn");
-    });
-    it("surfaces previous council memories", () => {
-        const msgs = [
-            { role: "system", content: "[Council Memory] previous outcome" },
-            { role: "user", content: "current ask" },
-        ];
-        const m = new CouncilManager(makeDeps({ getMessages: () => msgs }));
-        const ctx = m.buildContext();
-        expect(ctx).toContain("Previous Council Outcomes");
-        expect(ctx).toContain("previous outcome");
-    });
-});
-describe("CouncilManager — hasMultiProviderConfig", () => {
-    it("returns false for single-provider role models", () => {
-        const m = new CouncilManager(makeDeps());
-        expect(m.hasMultiProviderConfig({ implement: "claude-sonnet-4-6", verify: "claude-haiku-4" })).toBe(false);
-    });
-    it("returns true when models span multiple providers", () => {
-        const m = new CouncilManager(makeDeps());
-        expect(m.hasMultiProviderConfig({ implement: "claude-sonnet-4-6", verify: "gpt-4o-mini" })).toBe(true);
-    });
-    it("returns false for empty config", () => {
-        const m = new CouncilManager(makeDeps());
-        expect(m.hasMultiProviderConfig({})).toBe(false);
-    });
-});
-//# sourceMappingURL=council-manager.test.js.map

package/dist/src/orchestrator/__tests__/cross-turn-dedup.test.d.ts

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