muonroi-cli 1.8.1 → 1.8.4

package/dist/src/router/decide.test.js

@@ -1,198 +0,0 @@
-import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
-import { getTestModels, getTestProviders } from "../__test-helpers__/catalog-fixtures.js";
-import { startStubEEServer } from "../__test-stubs__/ee-server.js";
-import { createEEClient } from "../ee/client.js";
-import { setDefaultEEClient } from "../ee/intercept.js";
-import { loadCatalog } from "../models/registry.js";
-import { decide } from "./decide.js";
-import { routerStore } from "./store.js";
-// Mock bridge to always return null so tests go through HTTP path
-vi.mock("../ee/bridge.js", () => ({
-    routeModel: vi.fn().mockResolvedValue(null),
-    classifyViaBrain: vi.fn().mockResolvedValue(null),
-    searchCollection: vi.fn().mockResolvedValue([]),
-    getEmbeddingRaw: vi.fn().mockResolvedValue(null),
-    routeTask: vi.fn().mockResolvedValue(null),
-}));
-vi.mock("../models/catalog-client.js", async (importOriginal) => {
-    const original = await importOriginal();
-    return {
-        ...original,
-        fetchCatalog: async () => {
-            const fs = await import("node:fs");
-            const path = await import("node:path");
-            const raw = fs.readFileSync(path.resolve(process.cwd(), "src/models/catalog.json"), "utf8");
-            const data = JSON.parse(raw);
-            return data.models;
-        },
-    };
-});
-let disabledProvidersList = ["siliconflow", "deepseek", "openai", "xai"];
-vi.mock("../utils/settings.js", async (importOriginal) => {
-    const original = await importOriginal();
-    return {
-        ...original,
-        isProviderDisabled: (provider) => {
-            const res = disabledProvidersList.includes(provider);
-            console.log(`[MOCK] isProviderDisabled("${provider}") => ${res}`);
-            return res;
-        },
-    };
-});
-let BASE_OPTS;
-describe("decide()", () => {
-    let stub;
-    beforeAll(async () => {
-        await loadCatalog();
-        const _models = getTestModels();
-        const _providers = getTestProviders();
-        BASE_OPTS = {
-            tenantId: "default",
-            cwd: "/tmp",
-            defaultModel: "deepseek-v4-flash", // stable, independent of getModelByTier order after Agy catalog updates
-            defaultProvider: "google",
-            threshold: 0.55,
-        };
-        stub = await startStubEEServer({
-            routeModel: (_req) => ({
-                model: "deepseek-ai/DeepSeek-V4-Flash",
-                tier: "balanced",
-                confidence: 0.7,
-                reason: "ee-warm",
-                source: "brain",
-                taskHash: "test-hash",
-            }),
-            coldRoute: (_req) => ({
-                model: "deepseek-v4-flash",
-                tier: "premium",
-                reason: "ee-cold",
-                taskHash: "test-hash",
-            }),
-        });
-        setDefaultEEClient(createEEClient({ baseUrl: `http://localhost:${stub.port}` }));
-    });
-    afterAll(async () => {
-        await stub.stop();
-    });
-    beforeEach(() => {
-        disabledProvidersList = ["siliconflow", "deepseek", "openai", "xai"];
-        routerStore.setState({
-            tier: "hot",
-            degraded: false,
-            lastDecision: null,
-            lastHealthCheckAtMs: 0,
-        });
-    });
-    it("falls through to warm when classifier abstains (stub classifier always abstains)", async () => {
-        const result = await decide("I need to analyze and restructure the payment processing module with proper error boundaries and retry logic across multiple services", BASE_OPTS);
-        expect(result.tier).toBe("warm");
-        // decide() picks from current catalog (Agy google models may be selected depending on tier calc)
-        expect(result.model).toMatch(/gemini-/);
-        expect(routerStore.getState().lastDecision).toEqual(result);
-    });
-    it("falls through to cold when warm returns null", async () => {
-        // Stub that returns null for warm but succeeds for cold.
-        // Use defaultModel as cold-route model to avoid cap-driven downgrade for unknown models.
-        const coldOnlyStub = await startStubEEServer({
-            routeModel: undefined, // 500 -> null
-            coldRoute: () => ({
-                model: BASE_OPTS.defaultModel,
-                tier: "cold",
-                reason: "ee-cold",
-                taskHash: "test-hash",
-            }),
-        });
-        setDefaultEEClient(createEEClient({ baseUrl: `http://localhost:${coldOnlyStub.port}` }));
-        const result = await decide("I need to analyze and restructure the payment processing module with proper error boundaries and retry logic across multiple services", BASE_OPTS);
-        expect(result.tier).toBe("cold");
-        // Note: with current Agy-updated catalog the fallback picks a google premium model (gemini-3.1-pro-high)
-        // instead of the BASE default in this ee-null path. Check tier + reason instead of exact id.
-        expect(result.model).toBe("gemini-3.1-pro-high");
-        // Restore
-        setDefaultEEClient(createEEClient({ baseUrl: `http://localhost:${stub.port}` }));
-        await coldOnlyStub.stop();
-    });
-    it("returns fallback when both warm and cold are unreachable", async () => {
-        // Stub with no handlers -> both return 500 -> null
-        const deadStub = await startStubEEServer({});
-        setDefaultEEClient(createEEClient({ baseUrl: `http://localhost:${deadStub.port}` }));
-        disabledProvidersList = [];
-        const result = await decide("I need to analyze and restructure the payment processing module with proper error boundaries and retry logic across multiple services", BASE_OPTS);
-        // Model id depends on current catalog getModelByTier / routing (Agy google models affect first premium etc.)
-        expect(typeof result.model).toBe("string");
-        expect(result.reason).toBe("fallback:ee-unreachable");
-        setDefaultEEClient(createEEClient({ baseUrl: `http://localhost:${stub.port}` }));
-        await deadStub.stop();
-    });
-    it("returns degraded tier in fallback when store.degraded is true", async () => {
-        const deadStub = await startStubEEServer({});
-        setDefaultEEClient(createEEClient({ baseUrl: `http://localhost:${deadStub.port}` }));
-        routerStore.setState({ degraded: true });
-        disabledProvidersList = [];
-        const result = await decide("I need to analyze and restructure the payment processing module with proper error boundaries and retry logic across multiple services", BASE_OPTS);
-        expect(result.tier).toBe("degraded");
-        expect(result.reason).toBe("fallback:ee-unreachable");
-        setDefaultEEClient(createEEClient({ baseUrl: `http://localhost:${stub.port}` }));
-        await deadStub.stop();
-    });
-});
-describe("provider constraint with PROVIDER_INHERIT", () => {
-    let stub;
-    beforeAll(async () => {
-        await loadCatalog();
-    });
-    afterAll(async () => {
-        await stub?.stop();
-        vi.restoreAllMocks();
-    });
-    beforeEach(() => {
-        routerStore.setState({
-            tier: "hot",
-            degraded: false,
-            lastDecision: null,
-            lastHealthCheckAtMs: 0,
-        });
-    });
-    it("constrains warm-path model when its provider is disabled", async () => {
-        stub = await startStubEEServer({
-            routeModel: () => ({
-                model: "claude-sonnet-4-6",
-                tier: "balanced",
-                confidence: 0.8,
-                reason: "ee-warm",
-                source: "brain",
-                taskHash: "test-hash",
-            }),
-        });
-        setDefaultEEClient(createEEClient({ baseUrl: `http://localhost:${stub.port}` }));
-        const settingsMod = await import("../utils/settings.js");
-        vi.spyOn(settingsMod, "isProviderDisabled").mockImplementation((p) => p === "anthropic");
-        const fallbackModel = getTestModels().fast;
-        const fallbackProvider = getTestProviders().default;
-        const result = await decide("I need to analyze and restructure the payment processing module with proper error boundaries and retry logic across multiple services", {
-            tenantId: "default",
-            cwd: "/tmp",
-            defaultModel: fallbackModel,
-            defaultProvider: fallbackProvider,
-            threshold: 0.55,
-        });
-        expect(result.model).not.toBe("claude-sonnet-4-6");
-        expect(result.reason).toContain("provider-constrained");
-    });
-});
-describe("routerStore", () => {
-    it("exposes subscribe/getState/setState and emits on changes", () => {
-        const changes = [];
-        const unsub = routerStore.subscribe((s) => changes.push({ ...s }));
-        routerStore.setState({ tier: "warm" });
-        expect(changes.length).toBe(1);
-        expect(changes[0].tier).toBe("warm");
-        routerStore.setState({ tier: "cold" });
-        expect(changes.length).toBe(2);
-        expect(changes[1].tier).toBe("cold");
-        unsub();
-        routerStore.setState({ tier: "hot" });
-        expect(changes.length).toBe(2); // No more notifications after unsub
-    });
-});
-//# sourceMappingURL=decide.test.js.map

package/dist/src/router/health.test.d.ts

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

package/dist/src/router/health.test.js

@@ -1,52 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { startStubEEServer } from "../__test-stubs__/ee-server.js";
-import { createEEClient } from "../ee/client.js";
-import { setDefaultEEClient } from "../ee/intercept.js";
-import { getHealthStatus, startHealthProbe, stopHealthProbe } from "./health.js";
-import { routerStore } from "./store.js";
-describe("health probe", () => {
-    let stub;
-    let healthy;
-    beforeEach(async () => {
-        healthy = true;
-        stub = await startStubEEServer({
-            health: () => healthy,
-        });
-        setDefaultEEClient(createEEClient({ baseUrl: `http://localhost:${stub.port}` }));
-        // Reset store state
-        routerStore.setState({ degraded: false, lastHealthCheckAtMs: 0 });
-    });
-    afterEach(async () => {
-        stopHealthProbe();
-        await stub.stop();
-    });
-    it("flips routerStore.degraded=true when probe returns unhealthy", async () => {
-        healthy = false;
-        await startHealthProbe();
-        expect(routerStore.getState().degraded).toBe(true);
-    });
-    it("flips routerStore.degraded=false when probe returns healthy after being unhealthy", async () => {
-        healthy = false;
-        await startHealthProbe();
-        expect(routerStore.getState().degraded).toBe(true);
-        stopHealthProbe();
-        healthy = true;
-        await startHealthProbe();
-        expect(routerStore.getState().degraded).toBe(false);
-    });
-    it("getHealthStatus reflects last probe result with timestamp", async () => {
-        const _before = Date.now();
-        await startHealthProbe();
-        const status = getHealthStatus();
-        expect(status.ok).toBe(true);
-        expect(status.staleMs).toBeLessThan(1000);
-    });
-    it("stopHealthProbe clears the interval", async () => {
-        const clearSpy = vi.spyOn(globalThis, "clearInterval");
-        await startHealthProbe();
-        stopHealthProbe();
-        expect(clearSpy).toHaveBeenCalled();
-        clearSpy.mockRestore();
-    });
-});
-//# sourceMappingURL=health.test.js.map

package/dist/src/router/provider-sentinel.test.d.ts

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

package/dist/src/router/provider-sentinel.test.js

@@ -1,20 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { isInheritProvider, PROVIDER_INHERIT } from "./provider-sentinel.js";
-describe("provider-sentinel", () => {
-    it("PROVIDER_INHERIT is the empty string (load-bearing contract with constrainToProvider)", () => {
-        expect(PROVIDER_INHERIT).toBe("");
-    });
-    it("isInheritProvider returns true for empty / nullish values", () => {
-        expect(isInheritProvider(PROVIDER_INHERIT)).toBe(true);
-        expect(isInheritProvider("")).toBe(true);
-        expect(isInheritProvider(undefined)).toBe(true);
-        expect(isInheritProvider(null)).toBe(true);
-    });
-    it("isInheritProvider returns false for any concrete provider id", () => {
-        expect(isInheritProvider("anthropic")).toBe(false);
-        expect(isInheritProvider("openai")).toBe(false);
-        expect(isInheritProvider("deepseek")).toBe(false);
-        expect(isInheritProvider("ollama")).toBe(false);
-    });
-});
-//# sourceMappingURL=provider-sentinel.test.js.map

package/dist/src/router/role-override.test.d.ts

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

package/dist/src/router/role-override.test.js

@@ -1,26 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { shouldUseRoleModel } from "./decide.js";
-/**
- * Regression for the "stale roleModel after provider switch" failure observed
- * live: user switched active provider to openai (gpt-5.4-mini) but their
- * user-settings.roleModels still pointed at deepseek-v4-flash. The council /
- * sprint role phases blindly honored the deepseek roleModel and failed
- * mid-task with 402 Insufficient Balance. A cross-provider role model must only
- * be honored when the user explicitly opted into multi-provider council.
- */
-describe("shouldUseRoleModel", () => {
-    it("honors a role model whose provider matches the active provider", () => {
-        expect(shouldUseRoleModel("openai", "openai", { providerDisabled: false, multiProviderPreferred: false })).toBe(true);
-    });
-    it("SKIPS a cross-provider role model when multi-provider is OFF (stale after switch)", () => {
-        // roleModel resolves to deepseek but the user is now on openai, multi off.
-        expect(shouldUseRoleModel("deepseek", "openai", { providerDisabled: false, multiProviderPreferred: false })).toBe(false);
-    });
-    it("honors a cross-provider role model when multi-provider is ON (explicit opt-in)", () => {
-        expect(shouldUseRoleModel("deepseek", "openai", { providerDisabled: false, multiProviderPreferred: true })).toBe(true);
-    });
-    it("SKIPS when the role model provider is disabled, even if it matches", () => {
-        expect(shouldUseRoleModel("anthropic", "anthropic", { providerDisabled: true, multiProviderPreferred: true })).toBe(false);
-    });
-});
-//# sourceMappingURL=role-override.test.js.map

package/dist/src/router/warm.test.d.ts

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

package/dist/src/router/warm.test.js

@@ -1,202 +0,0 @@
-import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
-import { startStubEEServer } from "../__test-stubs__/ee-server.js";
-import { createEEClient } from "../ee/client.js";
-import { setDefaultEEClient } from "../ee/intercept.js";
-import { getModelByTier, loadCatalog } from "../models/registry.js";
-import { callWarmRoute } from "./warm.js";
-// ─── Bridge cascade tests ────────────────────────────────────────────────────
-vi.mock("../ee/bridge.js", () => ({
-    routeModel: vi.fn(),
-}));
-import { routeModel as bridgeRouteModel } from "../ee/bridge.js";
-const mockBridgeRouteModel = vi.mocked(bridgeRouteModel);
-describe("callWarmRoute bridge cascade", () => {
-    let stub;
-    beforeAll(async () => {
-        stub = await startStubEEServer({
-            routeModel: (_req) => ({
-                model: "qwen2.5-coder",
-                tier: "balanced",
-                confidence: 0.7,
-                reason: "remote",
-                source: "brain",
-                taskHash: "http-hash",
-            }),
-        });
-    });
-    beforeEach(() => {
-        // Re-pin the global EE client before each test so the second describe
-        // block's beforeAll cannot leave a stale client pointing at a different port.
-        setDefaultEEClient(createEEClient({ baseUrl: `http://localhost:${stub.port}` }));
-    });
-    afterAll(async () => {
-        await stub.stop();
-    });
-    afterEach(() => {
-        mockBridgeRouteModel.mockReset();
-    });
-    it("returns bridge result without calling HTTP when bridge succeeds", async () => {
-        mockBridgeRouteModel.mockResolvedValue({
-            tier: "balanced",
-            model: "deepseek-v4-flash",
-            reasoningEffort: "medium",
-            confidence: 0.95,
-            source: "brain",
-            reason: "bridge-match",
-            taskHash: "bridge-hash",
-        });
-        const result = await callWarmRoute("write a function", {
-            tenantId: "default",
-            cwd: "/tmp",
-        });
-        expect(result).not.toBeNull();
-        expect(result.model).toBe("deepseek-v4-flash");
-        expect(result.reason).toMatch(/^warm:bridge:/);
-        expect(result.confidence).toBe(0.95);
-        expect(result.taskHash).toBe("bridge-hash");
-        expect(result.source).toBe("brain");
-        expect(result.reasoningEffort).toBe("medium");
-    });
-    it("falls through to HTTP when bridge returns null", async () => {
-        mockBridgeRouteModel.mockResolvedValue(null);
-        const result = await callWarmRoute("write a function", {
-            tenantId: "default",
-            cwd: "/tmp",
-        });
-        expect(result).not.toBeNull();
-        expect(result.model).toBe("qwen2.5-coder"); // HTTP stub model
-        expect(result.reason).toMatch(/^warm:/);
-        expect(result.reason).not.toMatch(/^warm:bridge:/);
-        expect(result.taskHash).toBe("http-hash");
-    });
-    it("derives the EE runtime from the session provider (not hardcoded 'claude')", async () => {
-        mockBridgeRouteModel.mockResolvedValue({
-            tier: "balanced",
-            model: "gpt-5.3-codex",
-            confidence: 0.9,
-            source: "brain",
-            reason: "x",
-            taskHash: null,
-        });
-        await callWarmRoute("t", { tenantId: "default", cwd: "/tmp", defaultProvider: "openai" });
-        expect(mockBridgeRouteModel.mock.calls.at(-1)?.[2]).toBe("codex");
-        await callWarmRoute("t", { tenantId: "default", cwd: "/tmp", defaultProvider: "google" });
-        expect(mockBridgeRouteModel.mock.calls.at(-1)?.[2]).toBe("gemini");
-        await callWarmRoute("t", { tenantId: "default", cwd: "/tmp", defaultProvider: "anthropic" });
-        expect(mockBridgeRouteModel.mock.calls.at(-1)?.[2]).toBe("claude");
-        // Providers without an EE runtime ladder pass "" so EE returns tier only.
-        await callWarmRoute("t", { tenantId: "default", cwd: "/tmp", defaultProvider: "deepseek" });
-        expect(mockBridgeRouteModel.mock.calls.at(-1)?.[2]).toBe("");
-    });
-    it("emits PROVIDER_INHERIT on the bridge path so constrainToProvider governs", async () => {
-        mockBridgeRouteModel.mockResolvedValue({
-            tier: "balanced",
-            model: "gpt-5.3-codex",
-            confidence: 0.9,
-            source: "brain",
-            reason: "x",
-            taskHash: null,
-        });
-        const result = await callWarmRoute("t", { tenantId: "default", cwd: "/tmp", defaultProvider: "openai" });
-        expect(result.provider).toBe(""); // PROVIDER_INHERIT
-    });
-    it("falls back to the catalog model when EE returns a null model (no EE runtime)", async () => {
-        await loadCatalog();
-        const fastDeepseek = getModelByTier("fast", "deepseek");
-        // Skip gracefully if the test catalog has no deepseek-fast entry.
-        if (!fastDeepseek)
-            return;
-        mockBridgeRouteModel.mockResolvedValue({
-            // EE returns the tier but a null model for a runtime it cannot resolve.
-            tier: "fast",
-            model: null,
-            confidence: 0.8,
-            source: "keyword",
-            reason: "fast complexity",
-            taskHash: null,
-        });
-        const result = await callWarmRoute("t", { tenantId: "default", cwd: "/tmp", defaultProvider: "deepseek" });
-        expect(result).not.toBeNull();
-        expect(result.model).toBe(fastDeepseek.id);
-        expect(result.provider).toBe(""); // still PROVIDER_INHERIT
-    });
-    it("maps bridge tier 'fast' to 'hot' and 'premium' to 'cold'", async () => {
-        mockBridgeRouteModel.mockResolvedValue({
-            tier: "fast",
-            model: "gpt-4o-mini",
-            confidence: 0.9,
-            source: "brain",
-            reason: "fast-task",
-            taskHash: null,
-        });
-        const fast = await callWarmRoute("quick task", { tenantId: "default", cwd: "/tmp" });
-        expect(fast.tier).toBe("hot");
-        mockBridgeRouteModel.mockResolvedValue({
-            tier: "premium",
-            model: "o1-pro",
-            confidence: 0.85,
-            source: "brain",
-            reason: "complex-task",
-            taskHash: null,
-        });
-        const premium = await callWarmRoute("complex analysis", { tenantId: "default", cwd: "/tmp" });
-        expect(premium.tier).toBe("cold");
-    });
-});
-describe("callWarmRoute", () => {
-    let stub;
-    beforeAll(async () => {
-        stub = await startStubEEServer({
-            routeModel: (_req) => ({
-                model: "qwen2.5-coder",
-                tier: "balanced",
-                confidence: 0.7,
-                reason: "remote",
-                source: "brain",
-                taskHash: "test-hash",
-            }),
-        });
-    });
-    beforeEach(() => {
-        setDefaultEEClient(createEEClient({ baseUrl: `http://localhost:${stub.port}` }));
-    });
-    afterAll(async () => {
-        await stub.stop();
-    });
-    it("returns RouteDecision when stub responds successfully", async () => {
-        const result = await callWarmRoute("write a function", {
-            tenantId: "default",
-            cwd: "/tmp",
-        });
-        expect(result).not.toBeNull();
-        expect(result.tier).toBe("warm");
-        expect(result.model).toBe("qwen2.5-coder");
-        expect(result.provider).toBe("");
-        expect(result.reason).toContain("warm:");
-        expect(result.confidence).toBe(0.7);
-    });
-    it("returns null when warm path times out (>250ms)", async () => {
-        // Create a slow stub
-        const slowStub = await startStubEEServer({
-            latencyMs: 500,
-            routeModel: () => ({
-                model: "qwen2.5-coder",
-                tier: "balanced",
-                confidence: 0.7,
-                reason: "remote",
-                source: "brain",
-                taskHash: "test-hash",
-            }),
-        });
-        setDefaultEEClient(createEEClient({ baseUrl: `http://localhost:${slowStub.port}` }));
-        const result = await callWarmRoute("write a function", {
-            tenantId: "default",
-            cwd: "/tmp",
-        });
-        expect(result).toBeNull();
-        // Restore original stub
-        setDefaultEEClient(createEEClient({ baseUrl: `http://localhost:${stub.port}` }));
-        await slowStub.stop();
-    });
-});
-//# sourceMappingURL=warm.test.js.map

package/dist/src/scaffold/__tests__/continuation-prompt.test.d.ts

@@ -1,4 +0,0 @@
-/**
- * Unit tests for buildIdealContinuationPrompt.
- */
-export {};

package/dist/src/scaffold/__tests__/continuation-prompt.test.js

@@ -1,79 +0,0 @@
-/**
- * Unit tests for buildIdealContinuationPrompt.
- */
-import { describe, expect, it } from "vitest";
-import { buildIdealContinuationPrompt } from "../continuation-prompt.js";
-describe("buildIdealContinuationPrompt", () => {
-    const base = {
-        originalPrompt: "todo app",
-        projectDir: "/home/user/projects/todo-app",
-        templateName: "Muonroi.BaseTemplate",
-    };
-    it("interpolates originalPrompt verbatim", () => {
-        const result = buildIdealContinuationPrompt(base);
-        expect(result).toContain('"todo app"');
-    });
-    it("includes the absolute projectDir path", () => {
-        const result = buildIdealContinuationPrompt(base);
-        expect(result).toContain("/home/user/projects/todo-app");
-    });
-    it("includes the templateName", () => {
-        const result = buildIdealContinuationPrompt(base);
-        expect(result).toContain("Muonroi.BaseTemplate");
-    });
-    it("includes the joined installedPackages list when provided", () => {
-        const result = buildIdealContinuationPrompt({
-            ...base,
-            installedPackages: ["Muonroi.Auth", "Muonroi.Audit"],
-        });
-        expect(result).toContain("with packages: Muonroi.Auth, Muonroi.Audit");
-    });
-    it("omits the packages clause when installedPackages is empty", () => {
-        const result = buildIdealContinuationPrompt({ ...base, installedPackages: [] });
-        expect(result).not.toContain("with packages:");
-    });
-    it("omits the packages clause when installedPackages is not provided", () => {
-        const result = buildIdealContinuationPrompt(base);
-        expect(result).not.toContain("with packages:");
-    });
-    it("mentions docs_search MCP tool and dotnet build", () => {
-        const result = buildIdealContinuationPrompt(base);
-        expect(result).toContain("docs_search");
-        expect(result).toContain("dotnet build");
-    });
-    it("instructs LLM to tolerate missing README/AGENTS files", () => {
-        const result = buildIdealContinuationPrompt(base);
-        expect(result.toLowerCase()).toContain("missing files are fine");
-    });
-    it("warns that template sample files are reference-only and should be deleted", () => {
-        const result = buildIdealContinuationPrompt(base);
-        expect(result).toContain("REFERENCE ONLY");
-        expect(result.toLowerCase()).toContain("delete all template sample");
-    });
-    it("instructs LLM to rename BaseTemplate/DocTemplate identifiers", () => {
-        const result = buildIdealContinuationPrompt(base);
-        expect(result).toContain("BaseTemplate");
-        expect(result).toContain("DocTemplate");
-        expect(result.toLowerCase()).toContain("rename");
-    });
-    it("calls out .NET conventions explicitly", () => {
-        const result = buildIdealContinuationPrompt(base);
-        expect(result).toContain("CancellationToken");
-        expect(result).toContain("Async");
-        expect(result).toContain("DTO");
-        expect(result.toLowerCase()).toContain("namespace must mirror");
-    });
-    it("instructs LLM to preserve SemanticProvider in client scaffolds", () => {
-        const result = buildIdealContinuationPrompt(base);
-        expect(result).toContain("SemanticProvider");
-        expect(result).toContain("VITE_API_BASE");
-        expect(result.toLowerCase()).toContain("never delete or overwrite");
-    });
-    it("requires three async view states + strict ts + build verification on client", () => {
-        const result = buildIdealContinuationPrompt(base);
-        expect(result.toLowerCase()).toContain("loading, empty, error");
-        expect(result).toContain('"strict": true');
-        expect(result).toContain("bunx tsc --noEmit");
-    });
-});
-//# sourceMappingURL=continuation-prompt.test.js.map

package/dist/src/scaffold/__tests__/continue-as-council.spec.d.ts

@@ -1,10 +0,0 @@
-/**
- * Unit tests for continueAsCouncil() — Task 5.5.
- *
- * All filesystem writes are injected via opts.fs so the real filesystem is
- * never touched. runCouncil is also injected so no real orchestrator runs.
- *
- * Key invariant checked by Test 2: the source file must contain no reference
- * to "runVerify" — guaranteeing it can never accidentally re-enter CB-3.
- */
-export {};