muonroi-cli 1.8.1 → 1.8.4

package/dist/src/council/__tests__/evaluator-metrics.test.js

@@ -1,463 +0,0 @@
-/**
- * CQ-08: LeaderEvaluation evidenceDensity/disagreementResolved fields + <0.3 trigger
- * CQ-10: debate-planner falls back to FALLBACK_PLAN when both generateObject and parsePlan fail
- */
-import { beforeEach, describe, expect, it, vi } from "vitest";
-// ── CQ-08: LeaderEvaluation type accepts new metric fields ───────────────────
-describe("CQ-08: LeaderEvaluation type — evidenceDensity and disagreementResolved", () => {
-    it("LeaderEvaluation accepts evidenceDensity as optional number field", () => {
-        const evaluation = {
-            allCriteriaMet: false,
-            criteriaStatus: [],
-            unresolvedPoints: [],
-            needsResearch: false,
-            shouldContinue: true,
-            reason: "test reason",
-            evidenceDensity: 0.25,
-        };
-        expect(evaluation.evidenceDensity).toBe(0.25);
-    });
-    it("LeaderEvaluation accepts disagreementResolved as optional number field", () => {
-        const evaluation = {
-            allCriteriaMet: false,
-            criteriaStatus: [],
-            unresolvedPoints: ["point A"],
-            needsResearch: false,
-            shouldContinue: true,
-            reason: "test",
-            disagreementResolved: 2,
-        };
-        expect(evaluation.disagreementResolved).toBe(2);
-    });
-    it("LeaderEvaluation accepts both evidenceDensity and disagreementResolved together", () => {
-        const evaluation = {
-            allCriteriaMet: true,
-            criteriaStatus: [{ criterion: "accuracy", met: true, evidence: "[CONFIRMED via bash:grep output]" }],
-            unresolvedPoints: [],
-            needsResearch: false,
-            shouldContinue: false,
-            reason: "all criteria met",
-            evidenceDensity: 0.65,
-            disagreementResolved: 3,
-        };
-        expect(evaluation.evidenceDensity).toBe(0.65);
-        expect(evaluation.disagreementResolved).toBe(3);
-    });
-    it("evidenceDensity < 0.3 threshold: value 0.25 is below threshold", () => {
-        // Verify the threshold logic is testable — 0.25 < 0.3 should trigger needsResearch
-        const evidenceDensity = 0.25;
-        const round = 2;
-        const wasNeedsResearch = false;
-        // Simulate debate.ts evaluateDebate logic:
-        // if (!needsResearch && round >= 2 && evidenceDensity < 0.3) { needsResearch = true; }
-        let needsResearch = wasNeedsResearch;
-        if (!needsResearch && round >= 2 && evidenceDensity < 0.3) {
-            needsResearch = true;
-        }
-        expect(needsResearch).toBe(true);
-    });
-    it("evidenceDensity >= 0.3 threshold: value 0.5 does NOT force needsResearch", () => {
-        const evidenceDensity = 0.5;
-        const round = 2;
-        const wasNeedsResearch = false;
-        let needsResearch = wasNeedsResearch;
-        if (!needsResearch && round >= 2 && evidenceDensity < 0.3) {
-            needsResearch = true;
-        }
-        expect(needsResearch).toBe(false);
-    });
-    it("evidenceDensity < 0.3 on round 1 does NOT trigger needsResearch (requires round >= 2)", () => {
-        const evidenceDensity = 0.1;
-        const round = 1; // round 1 — no trigger
-        const wasNeedsResearch = false;
-        let needsResearch = wasNeedsResearch;
-        if (!needsResearch && round >= 2 && evidenceDensity < 0.3) {
-            needsResearch = true;
-        }
-        expect(needsResearch).toBe(false);
-    });
-});
-// ── CQ-08: countCitations and estimateClaims behavior (indirectly via formula) ─
-describe("CQ-08: evidence density calculation logic", () => {
-    it("text with [REFUTED via bash:...] tags increases citation count", () => {
-        // Mirror the countCitations regex from debate.ts:
-        // /\[(REFUTED|CONFIRMED) via [^\]]+\]/g
-        const text = "Claim A [REFUTED via bash:grep found nothing] and claim B [CONFIRMED via bash:ls output].";
-        const matches = text.match(/\[(REFUTED|CONFIRMED) via [^\]]+\]/g);
-        const citationCount = matches?.length ?? 0;
-        expect(citationCount).toBe(2);
-    });
-    it("text without citation tags yields citation count of 0", () => {
-        const text = "This is an unverified claim. Another assertion follows.";
-        const matches = text.match(/\[(REFUTED|CONFIRMED) via [^\]]+\]/g);
-        const citationCount = matches?.length ?? 0;
-        expect(citationCount).toBe(0);
-    });
-    it("countUnverified matches [UNVERIFIED:...] tags", () => {
-        const text = "Some claim [UNVERIFIED: no source for this RTT number] and another [UNVERIFIED].";
-        const matches = text.match(/\[UNVERIFIED[^\]]*\]/g);
-        expect(matches?.length).toBe(2);
-    });
-    it("evidenceDensity = cited / (cited + unverified) — flag-aware metric", () => {
-        // Mirror computeEvidenceDensity from debate.ts.
-        // Old metric was cited / total-sentences which couldn't exceed ~0.05 in
-        // any real debate (most sentences aren't citable claims). New metric only
-        // counts claims that participants explicitly flagged.
-        const text = "Verified fact [CONFIRMED via web_fetch: x]. Verified again [CONFIRMED via grep:found]. " +
-            "Unsure number [UNVERIFIED: typical RTT]. Another unsure [UNVERIFIED: corpus coverage]. " +
-            "Lots of opinion prose that should not affect the density.";
-        const cited = (text.match(/\[(REFUTED|CONFIRMED) via [^\]]+\]/g) ?? []).length;
-        const unverified = (text.match(/\[UNVERIFIED[^\]]*\]/g) ?? []).length;
-        const totalTagged = cited + unverified;
-        const density = totalTagged > 0 ? cited / totalTagged : 0;
-        expect(cited).toBe(2);
-        expect(unverified).toBe(2);
-        expect(density).toBe(0.5);
-    });
-    it("evidenceDensity is 0 when no claims were tagged at all", () => {
-        const text = "This is pure opinion. No tags. No evidence awareness shown.";
-        const cited = (text.match(/\[(REFUTED|CONFIRMED) via [^\]]+\]/g) ?? []).length;
-        const unverified = (text.match(/\[UNVERIFIED[^\]]*\]/g) ?? []).length;
-        const totalTagged = cited + unverified;
-        const density = totalTagged > 0 ? cited / totalTagged : 0;
-        expect(density).toBe(0);
-    });
-    it("evidenceDensity is 1.0 when every tagged claim was verified", () => {
-        const text = "[CONFIRMED via bash:test]. [CONFIRMED via grep:found]. [REFUTED via web:no-match].";
-        const cited = (text.match(/\[(REFUTED|CONFIRMED) via [^\]]+\]/g) ?? []).length;
-        const unverified = (text.match(/\[UNVERIFIED[^\]]*\]/g) ?? []).length;
-        const totalTagged = cited + unverified;
-        const density = totalTagged > 0 ? cited / totalTagged : 0;
-        expect(density).toBe(1.0);
-    });
-});
-// ── P3: Lock-phrase convergence detection ────────────────────────────────────
-describe("P3: convergence ratio over a round's pair-turns", () => {
-    // Mirror LOCK_PHRASES and convergenceRatio from debate.ts — kept in sync
-    // by code review. If the production list grows, this test should mirror
-    // the addition so behaviour stays observable.
-    const LOCK_PHRASES = [
-        /\bever[yi]thing\s+(is\s+)?locked\b/i,
-        /\bfully\s+aligned\b/i,
-        /\bcomplete\s+agreement\b/i,
-        /\bno\s+remaining\s+(disputes|disagreements|concerns)\b/i,
-        /\bdesign\s+(is\s+)?locked\b/i,
-        /\barchitectural\s+decisions\s+(are\s+)?locked\b/i,
-        /\bagree\s+on\s+where\s+we['']?ve\s+landed\b/i,
-        /\bready\s+to\s+(proceed|move|start)\s+to\s+implementation\b/i,
-        /\blet['']?s\s+proceed\s+to\s+implementation\b/i,
-        /\bfinal\s+(position|confirmation)\b/i,
-        /\b(i\s+)?(fully\s+|completely\s+)?(agree|agreed|concur)\s+(with|on)\b/i,
-        /\bsigned?\s+off\b/i,
-        /\bship\s+it\b/i,
-        /\bno\s+(further\s+|more\s+)?(objections?|concerns?|issues?)\b/i,
-        /\bgreen[\s-]?light\b/i,
-        /\blooks?\s+good\s+to\s+(me|go)\b/i,
-        /\bgood\s+to\s+(go|ship|proceed)\b/i,
-        /(^|\s)nh[ấâ]t\s+tr[íi](?=\s|[.,!?;:]|$)/i,
-        /(^|\s)[đd][ồô]ng\s+[ýy]\s+(ho[àa]n\s+to[àa]n|v[ớơ]i)(?=\s|[.,!?;:]|$)/i,
-        /(^|\s)kh[ôo]ng\s+c[òo]n\s+(g[òo]p\s+[ýy]|[ýy]\s+ki[ếê]n|tranh\s+lu[ậâ]n)(?=\s|[.,!?;:]|$)/i,
-        /(^|\s)s[ẵã]n\s+s[àa]ng\s+(tri[ểê]n\s+khai|implement)(?=\s|[.,!?;:]|$)/i,
-        /(^|\s)ch[ốô]t\s+(s[ổô]|l[ạa]i|design)(?=\s|[.,!?;:]|$)/i,
-    ];
-    const NEGATION_HEAD = /\b(don'?t|do\s+not|does\s+not|doesn'?t|cannot|can'?t|not|no(t)?\s+yet|haven'?t|hasn'?t|kh[ôo]ng|ch[ưu]a)\b/i;
-    function looksLocked(text) {
-        if (!text || text.length < 20)
-            return false;
-        for (const re of LOCK_PHRASES) {
-            const match = re.exec(text);
-            if (!match)
-                continue;
-            const windowStart = Math.max(0, match.index - 24);
-            const upstream = text.slice(windowStart, match.index);
-            if (NEGATION_HEAD.test(upstream))
-                continue;
-            return true;
-        }
-        return false;
-    }
-    function convergenceRatio(turns) {
-        const usable = turns.filter((t) => t && t.trim().length >= 20);
-        if (usable.length === 0)
-            return 0;
-        const locked = usable.filter(looksLocked).length;
-        return locked / usable.length;
-    }
-    it("session ea13da132dec round 3 turns trip the 0.8 lock threshold", () => {
-        // Excerpts taken verbatim from the export; each is one pair-turn.
-        const r3Turns = [
-            "I agree with your comprehensive summary. Everything else is locked. I'm satisfied with where we've landed.",
-            "We're fully aligned. Everything Locked. No remaining disputes. The pipeline spec is now: ...",
-            "We're aligned. Two quick confirmations from my side: ... Design locked. The implementation spec can proceed.",
-            "We are in complete agreement on every architectural decision. The implementation specification can proceed.",
-            "All architectural decisions are locked. The only outstanding UX tweak is the short selectionchange dismissal delay.",
-            "All architectural decisions are locked. I'm ready to start drafting the content-script and background-script.",
-        ];
-        const ratio = convergenceRatio(r3Turns);
-        expect(ratio).toBeGreaterThanOrEqual(0.8);
-    });
-    it("returns 0 when no turn contains lock phrases", () => {
-        const turns = [
-            "I still disagree about the debounce timing. 200ms feels sluggish for single-word selections.",
-            "Your argument for batch translation has merit but breaks the offline-first guarantee.",
-        ];
-        expect(convergenceRatio(turns)).toBe(0);
-    });
-    it("ignores empty / too-short turns when computing ratio", () => {
-        const turns = ["", "ok", "All architectural decisions are locked, no remaining disputes."];
-        expect(convergenceRatio(turns)).toBe(1.0);
-    });
-    it("partial convergence (1 of 3 turns locked) is below threshold", () => {
-        const turns = [
-            "Design is locked from my side, ready to proceed.",
-            "I still have concerns about rate-limit handling under high load.",
-            "The auth flow needs another pass — we haven't settled on token rotation.",
-        ];
-        expect(convergenceRatio(turns)).toBeLessThan(0.8);
-    });
-    it("upgrade A: broader EN convergence vocabulary (signed off / ship it / no objections)", () => {
-        const turns = [
-            "Signed off on the proposed architecture, no further concerns from my side.",
-            "I fully agree with the migration plan as outlined.",
-            "Ship it — green-light from the security review perspective.",
-        ];
-        expect(convergenceRatio(turns)).toBe(1.0);
-    });
-    it("upgrade A: Vietnamese convergence vocabulary", () => {
-        const turns = [
-            "Tôi hoàn toàn nhất trí với thiết kế hiện tại, không còn ý kiến gì thêm.",
-            "Đồng ý hoàn toàn với phương án migration, có thể chốt sổ.",
-            "Sẵn sàng triển khai theo spec này, không còn tranh luận gì.",
-        ];
-        expect(convergenceRatio(turns)).toBe(1.0);
-    });
-    it("upgrade A: negation guard prevents false positive on 'don't agree'", () => {
-        const turns = [
-            "I don't agree with the proposed caching layer, performance impact is unclear.",
-            "We do not concur with skipping the integration test phase here.",
-            "Tôi không nhất trí với cách tiếp cận này, có rủi ro về consistency.",
-        ];
-        expect(convergenceRatio(turns)).toBe(0);
-    });
-    it("upgrade A: negation only blocks the matched phrase, downstream agreement still counts", () => {
-        // First clause negates; second clause is a separate positive lock signal far
-        // beyond the 24-char negation window — should still register as locked.
-        const turns = [
-            "I'm not entirely sold on the rollout plan today, but after looking at the metrics overnight everything is locked from my perspective.",
-        ];
-        expect(convergenceRatio(turns)).toBe(1.0);
-    });
-});
-// ── P7: action-item reuse helpers (synthesizePlanFromActionItems shape) ──────
-describe("P7: synthesizePlanFromActionItems — heterogeneous input handling", () => {
-    // Mirror the implementation in src/council/index.ts. Kept in sync by code
-    // review; if the helper signature changes, this test mirrors the update.
-    function synthesizePlanFromActionItems(items) {
-        const total = items.length;
-        const steps = items.map((raw, idx) => {
-            let description;
-            let agent;
-            let hasDeps = false;
-            if (typeof raw === "string") {
-                description = raw;
-            }
-            else if (raw && typeof raw === "object") {
-                const o = raw;
-                const step = typeof o.step === "string" ? o.step : "";
-                const owner = typeof o.owner_lens === "string" ? o.owner_lens : undefined;
-                const time = typeof o.time_estimate === "string" ? ` (${o.time_estimate})` : "";
-                const accept = typeof o.acceptance_criteria === "string" ? ` — accept: ${o.acceptance_criteria}` : "";
-                description = step ? `${step}${time}${accept}` : JSON.stringify(o).slice(0, 200);
-                agent = owner;
-                const deps = o.depends_on;
-                hasDeps =
-                    (Array.isArray(deps) && deps.length > 0) ||
-                        (typeof deps === "string" && deps.trim().length > 0 && deps !== "none");
-            }
-            else {
-                description = String(raw);
-            }
-            const inFirstHalf = idx < total / 2;
-            const inLastThird = idx >= (total * 2) / 3;
-            const priority = hasDeps || inLastThird ? (inLastThird ? "low" : "medium") : inFirstHalf ? "high" : "medium";
-            return { description, agent, priority };
-        });
-        const complexity = total <= 4 ? "trivial" : total <= 9 ? "moderate" : "complex";
-        return { steps, estimatedComplexity: complexity, prerequisites: [] };
-    }
-    it("converts structured action-item objects (session 1a8fb4be3bc3 shape)", () => {
-        const items = [
-            {
-                step: "Init scaffold",
-                owner_lens: "Extension Architect",
-                time_estimate: "2h",
-                depends_on: [],
-                acceptance_criteria: "Manifest valid",
-            },
-            {
-                step: "Capture selection",
-                owner_lens: "Integration Engineer",
-                time_estimate: "4h",
-                depends_on: ["Init scaffold"],
-                acceptance_criteria: "Text extracted",
-            },
-            {
-                step: "Tooltip UI",
-                owner_lens: "Integration Engineer",
-                time_estimate: "6h",
-                depends_on: ["Capture selection"],
-                acceptance_criteria: "Renders near anchor",
-            },
-        ];
-        const plan = synthesizePlanFromActionItems(items);
-        expect(plan.steps).toHaveLength(3);
-        expect(plan.steps[0].description).toContain("Init scaffold");
-        expect(plan.steps[0].description).toContain("2h");
-        expect(plan.steps[0].description).toContain("Manifest valid");
-        expect(plan.steps[0].agent).toBe("Extension Architect");
-        expect(plan.estimatedComplexity).toBe("trivial");
-    });
-    it("falls back gracefully on string items (legacy actionItems shape)", () => {
-        const items = ["First step", "Second step", "Third step", "Fourth step"];
-        const plan = synthesizePlanFromActionItems(items);
-        expect(plan.steps).toHaveLength(4);
-        expect(plan.steps[0].description).toBe("First step");
-        expect(plan.steps[0].agent).toBeUndefined();
-        expect(plan.estimatedComplexity).toBe("trivial");
-    });
-    it("priority heuristic — first-half no-deps → high, depends_on → medium, last third → low", () => {
-        // 9 items so we get clean thirds (0-2 first-third, 3-5 middle, 6-8 last)
-        const items = Array.from({ length: 9 }, (_, i) => ({ step: `Step ${i + 1}`, depends_on: [] }));
-        const plan = synthesizePlanFromActionItems(items);
-        // First half (indexes 0-4) with no deps → high
-        expect(plan.steps[0].priority).toBe("high");
-        expect(plan.steps[3].priority).toBe("high");
-        // Last third (indexes 6-8) → low regardless of deps
-        expect(plan.steps[6].priority).toBe("low");
-        expect(plan.steps[8].priority).toBe("low");
-    });
-    it("estimatedComplexity scales with step count", () => {
-        expect(synthesizePlanFromActionItems(["a", "b", "c"]).estimatedComplexity).toBe("trivial");
-        expect(synthesizePlanFromActionItems(Array.from({ length: 7 }, (_, i) => `s${i}`)).estimatedComplexity).toBe("moderate");
-        expect(synthesizePlanFromActionItems(Array.from({ length: 11 }, (_, i) => `s${i}`)).estimatedComplexity).toBe("complex");
-    });
-});
-// ── CQ-10: planDebate falls back to FALLBACK_PLAN ────────────────────────────
-const FALLBACK_STANCE_NAMES = ["Primary Analyst", "Critical Reviewer"];
-describe("CQ-10: planDebate returns FALLBACK_PLAN after double failure", () => {
-    beforeEach(() => {
-        vi.resetModules();
-    });
-    it("returns FALLBACK_PLAN when both generateObject and retry tracedGenerate fail", async () => {
-        vi.doMock("ai", () => ({
-            generateObject: vi.fn().mockRejectedValue(new Error("Schema validation error")),
-            generateText: vi.fn(),
-        }));
-        vi.doMock("../../providers/keychain.js", () => ({
-            loadKeyForProvider: vi.fn().mockResolvedValue("test-key"),
-        }));
-        vi.doMock("../../providers/runtime.js", () => ({
-            detectProviderForModel: vi.fn().mockReturnValue("openai"),
-            createProviderFactory: vi.fn().mockReturnValue({ factory: {} }),
-            createProviderFactoryAsync: vi.fn().mockResolvedValue({ factory: {} }),
-            resolveModelRuntime: vi.fn().mockReturnValue({ model: {}, providerOptions: undefined }),
-        }));
-        vi.doMock("../prompts.js", () => ({
-            buildDebatePlanPrompt: vi.fn().mockReturnValue({ system: "sys", prompt: "prompt" }),
-        }));
-        // tracedGenerate also fails — both paths exhausted
-        vi.doMock("../llm.js", () => ({
-            // biome-ignore lint/correctness/useYield: mock generator intentionally throws without yielding
-            tracedGenerate: vi.fn().mockImplementation(async function* () {
-                throw new Error("Retry also failed");
-            }),
-        }));
-        const { planDebate } = await import("../debate-planner.js");
-        const spec = {
-            problemStatement: "test problem",
-            constraints: [],
-            successCriteria: [],
-            scope: "test",
-            rawQA: [],
-        };
-        const llm = {};
-        const gen = planDebate(spec, "gpt-4o", llm);
-        let result = await gen.next();
-        while (!result.done) {
-            result = await gen.next();
-        }
-        const plan = result.value;
-        // Must match FALLBACK_PLAN shape
-        expect(plan.stances.map((s) => s.name)).toEqual(FALLBACK_STANCE_NAMES);
-        expect(plan.intentSummary).toContain("planner unavailable");
-    });
-    it("FALLBACK_PLAN intentSummary starts with '(planner unavailable'", async () => {
-        vi.doMock("ai", () => ({
-            generateObject: vi.fn().mockRejectedValue(new Error("API error")),
-            generateText: vi.fn(),
-        }));
-        vi.doMock("../../providers/keychain.js", () => ({
-            loadKeyForProvider: vi.fn().mockResolvedValue("test-key"),
-        }));
-        vi.doMock("../../providers/runtime.js", () => ({
-            detectProviderForModel: vi.fn().mockReturnValue("openai"),
-            createProviderFactory: vi.fn().mockReturnValue({ factory: {} }),
-            createProviderFactoryAsync: vi.fn().mockResolvedValue({ factory: {} }),
-            resolveModelRuntime: vi.fn().mockReturnValue({ model: {}, providerOptions: undefined }),
-        }));
-        vi.doMock("../prompts.js", () => ({
-            buildDebatePlanPrompt: vi.fn().mockReturnValue({ system: "sys", prompt: "prompt" }),
-        }));
-        vi.doMock("../llm.js", () => ({
-            // biome-ignore lint/correctness/useYield: mock generator intentionally throws without yielding
-            tracedGenerate: vi.fn().mockImplementation(async function* () {
-                throw new Error("retry fail");
-            }),
-        }));
-        const { planDebate } = await import("../debate-planner.js");
-        const spec = { problemStatement: "any topic", constraints: [], successCriteria: [], scope: "", rawQA: [] };
-        const gen = planDebate(spec, "gpt-4o", {});
-        let result = await gen.next();
-        while (!result.done) {
-            result = await gen.next();
-        }
-        const plan = result.value;
-        expect(plan.intentSummary).toMatch(/^\(planner unavailable/);
-    });
-    it("FALLBACK_PLAN output shape has 'decision' kind with standard sections", async () => {
-        vi.doMock("ai", () => ({
-            generateObject: vi.fn().mockRejectedValue(new Error("fail")),
-            generateText: vi.fn(),
-        }));
-        vi.doMock("../../providers/keychain.js", () => ({
-            loadKeyForProvider: vi.fn().mockResolvedValue("test-key"),
-        }));
-        vi.doMock("../../providers/runtime.js", () => ({
-            detectProviderForModel: vi.fn().mockReturnValue("openai"),
-            createProviderFactory: vi.fn().mockReturnValue({ factory: {} }),
-            createProviderFactoryAsync: vi.fn().mockResolvedValue({ factory: {} }),
-            resolveModelRuntime: vi.fn().mockReturnValue({ model: {}, providerOptions: undefined }),
-        }));
-        vi.doMock("../prompts.js", () => ({
-            buildDebatePlanPrompt: vi.fn().mockReturnValue({ system: "sys", prompt: "prompt" }),
-        }));
-        vi.doMock("../llm.js", () => ({
-            // biome-ignore lint/correctness/useYield: mock generator intentionally throws without yielding
-            tracedGenerate: vi.fn().mockImplementation(async function* () {
-                throw new Error("also fails");
-            }),
-        }));
-        const { planDebate } = await import("../debate-planner.js");
-        const spec = { problemStatement: "topic", constraints: [], successCriteria: [], scope: "", rawQA: [] };
-        const gen = planDebate(spec, "gpt-4o", {});
-        let result = await gen.next();
-        while (!result.done) {
-            result = await gen.next();
-        }
-        const plan = result.value;
-        expect(plan.outputShape.kind).toBe("decision");
-        expect(plan.outputShape.sections.length).toBeGreaterThanOrEqual(3);
-        expect(plan.outputShape.sections.map((s) => s.key)).toContain("recommendation");
-    });
-});
-//# sourceMappingURL=evaluator-metrics.test.js.map

package/dist/src/council/__tests__/oauth-reachable.test.d.ts

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

package/dist/src/council/__tests__/oauth-reachable.test.js

@@ -1,31 +0,0 @@
-import { beforeAll, describe, expect, it, vi } from "vitest";
-// F15 regression: council participant resolution must treat OAuth-authed
-// providers (no API key) as reachable. getConfiguredProviders() is the
-// authoritative cred check; the old loadKeyForProvider-only path threw for
-// OAuth-only providers → 0 participants → council bailed "No reachable
-// provider" even though the model (e.g. grok via xAI OAuth) answers fine.
-// xai is configured via OAuth only (present in getConfiguredProviders, but
-// loadKeyForProvider would have thrown — no API key).
-vi.mock("../../providers/keychain.js", () => ({
-    getConfiguredProviders: vi.fn(async () => ["xai"]),
-}));
-// Hermetic settings: no explicit role models, nothing disabled.
-vi.mock("../../utils/settings.js", () => ({
-    getRoleModels: () => ({}),
-    getRoleModel: () => undefined,
-    isProviderDisabled: () => false,
-}));
-import { loadCatalog } from "../../models/registry.js";
-import { resolveParticipants } from "../leader.js";
-describe("F15 — council reachability counts OAuth-only providers", () => {
-    beforeAll(async () => {
-        await loadCatalog();
-    });
-    it("resolves >=2 participants when the session provider is OAuth-only (xai, no API key)", async () => {
-        const participants = await resolveParticipants("grok-build-0.1", false);
-        // Pre-fix this returned [] (loadKeyForProvider('xai') threw) → council bailed.
-        expect(participants.length).toBeGreaterThanOrEqual(2);
-        expect(participants.every((p) => p.model.startsWith("grok"))).toBe(true);
-    });
-});
-//# sourceMappingURL=oauth-reachable.test.js.map

package/dist/src/council/__tests__/parse-outcome-fallback.test.d.ts

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

package/dist/src/council/__tests__/parse-outcome-fallback.test.js

@@ -1,114 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-// Build a minimal mock CouncilLLM that returns a fixed synthesisText
-function makeMockLLM(synthesisText) {
-    return {
-        async generate() {
-            return synthesisText;
-        },
-        async research() {
-            return "";
-        },
-        async debate() {
-            return { text: "", toolCalls: [] };
-        },
-    };
-}
-async function runPlanningWith(synthesisText, debatePlan) {
-    const { runPlanning } = await import("../planner.js");
-    const spec = {
-        problemStatement: "test",
-        constraints: [],
-        successCriteria: [],
-        scope: "test",
-        rawQA: [],
-    };
-    const debateState = {
-        spec,
-        exchangeLogs: new Map(),
-        runningSummary: "",
-        roundCount: 1,
-        active: [],
-    };
-    const participants = [{ role: "primary", model: "m1", position: "pos1" }];
-    const gen = runPlanning(debateState, spec, participants, "m1", async () => false, makeMockLLM(synthesisText), debatePlan);
-    let result;
-    while (true) {
-        const step = await gen.next();
-        if (step.done) {
-            result = step.value;
-            break;
-        }
-    }
-    return result;
-}
-const sampleDebatePlan = {
-    intentSummary: "Evaluate options",
-    stances: [],
-    outputShape: {
-        kind: "evaluation",
-        sections: [
-            { key: "strengths", heading: "Strengths", prompt: "", shape: "list" },
-            { key: "summary_text", heading: "Summary", prompt: "", shape: "text" },
-        ],
-        guardrails: [],
-    },
-};
-describe("parseOutcome — raw log + shape-based fallback (CQ-20)", () => {
-    let errorSpy;
-    beforeEach(() => {
-        errorSpy = vi.spyOn(console, "error").mockImplementation(() => { });
-    });
-    afterEach(() => {
-        errorSpy.mockRestore();
-    });
-    it("Test 1: no JSON → returns null AND console.error called with raw text", async () => {
-        const rawText = "This is plain text with no JSON object inside at all.";
-        const result = await runPlanningWith(rawText);
-        expect(result?.outcome).toBeNull();
-        expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining("[Council] parseOutcome failed"), expect.stringContaining(rawText));
-    });
-    it("Test 2: malformed JSON → returns null AND logs raw text", async () => {
-        const malformed = '{"summary": "ok"'; // missing closing brace — no valid JSON match
-        const result = await runPlanningWith(malformed);
-        expect(result?.outcome).toBeNull();
-        expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining("[Council] parseOutcome failed"), expect.any(String));
-    });
-    it("Test 3: JSON parse fails + debatePlan sections → returns object with kind and summary", async () => {
-        const rawText = "This is a long enough line that exceeds twenty chars for summary extraction";
-        const result = await runPlanningWith(rawText, sampleDebatePlan);
-        expect(result?.outcome).not.toBeNull();
-        expect(result?.outcome.type).toBe("evaluation");
-        expect(result?.outcome.summary).toBe(rawText.trim());
-    });
-    it("Test 4: shape fallback populates sections with correct empty defaults", async () => {
-        const rawText = "Long enough summary text here for the fallback to work correctly";
-        const result = await runPlanningWith(rawText, sampleDebatePlan);
-        expect(result?.outcome?.sections).toBeDefined();
-        expect(result?.outcome?.sections?.strengths).toEqual([]);
-        expect(result?.outcome?.sections?.summary_text).toBe("");
-    });
-    it("Test 5: valid JSON path returns correct outcome — no regression", async () => {
-        const validJson = JSON.stringify({
-            type: "decision",
-            summary: "We should go with option A because it is simpler.",
-            agreed: ["Option A"],
-        });
-        const result = await runPlanningWith(validJson);
-        expect(result?.outcome).not.toBeNull();
-        expect(result?.outcome?.type).toBe("decision");
-        expect(result?.outcome?.summary).toBe("We should go with option A because it is simpler.");
-        expect(errorSpy).not.toHaveBeenCalled();
-    });
-    it("Test 6: shape fallback EXTRACTS section content from markdown headings (regex regression)", async () => {
-        // Pre-fix the heading regex used a literal "s+" instead of "\\s+" (and
-        // replaced spaces with "s+"), so it never matched a real "## Heading" line —
-        // every section came back empty even when the synthesis clearly contained them.
-        const md = "Here is the evaluation summary line that is plenty long enough.\n\n" +
-            "## Strengths\n- Fast startup\n- Low cost\n\n" +
-            "## Summary\nThe approach is solid overall.";
-        const result = await runPlanningWith(md, sampleDebatePlan);
-        expect(result?.outcome?.sections?.strengths).toEqual(["- Fast startup", "- Low cost"]);
-        expect(result?.outcome?.sections?.summary_text).toContain("The approach is solid overall.");
-    });
-});
-//# sourceMappingURL=parse-outcome-fallback.test.js.map

package/dist/src/council/__tests__/post-debate-recommendation.test.d.ts

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