chapterhouse 0.1.1

package/dist/copilot/orchestrator.test.js

@@ -0,0 +1,523 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+function createFakeClient(state) {
+    class FakeSession {
+        sessionId = "session-123";
+        listeners = new Map();
+        on(eventName, handler) {
+            const handlers = this.listeners.get(eventName) || [];
+            handlers.push(handler);
+            this.listeners.set(eventName, handlers);
+            return () => {
+                const next = (this.listeners.get(eventName) || []).filter((candidate) => candidate !== handler);
+                this.listeners.set(eventName, next);
+            };
+        }
+        async sendAndWait(request, _timeoutMs) {
+            state.sessionPrompts.push(request);
+            if (state.sendResult === "__PENDING__") {
+                return await new Promise((_resolve, reject) => {
+                    state.pendingReject = reject;
+                });
+            }
+            return { data: { content: state.sendResult } };
+        }
+        async setModel(model) {
+            state.setModelCalls.push(model);
+        }
+        async abort() {
+            state.abortCalls++;
+            state.pendingReject?.(new Error("Aborted"));
+        }
+        async disconnect() {
+            state.disconnectCalls++;
+        }
+    }
+    return {
+        getState() {
+            return "connected";
+        },
+        async listModels() {
+            return [{ id: "fallback-model" }, { id: "claude-sonnet-4.6" }];
+        },
+        async createSession(options) {
+            state.createSessionCalls.push(options);
+            if (state.createSessionError) {
+                throw new Error(state.createSessionError);
+            }
+            return new FakeSession();
+        },
+        async resumeSession(savedId, options) {
+            state.resumeSessionCalls.push({ savedId, options });
+            throw new Error("resume failed");
+        },
+    };
+}
+async function loadOrchestratorModule(t, overrides = {}) {
+    const state = {
+        store: new Map(),
+        config: {
+            copilotModel: "missing-model",
+            selfEditEnabled: true,
+            squadEnabled: false,
+        },
+        routeResults: [],
+        routerArgs: [],
+        createSessionCalls: [],
+        resumeSessionCalls: [],
+        sessionPrompts: [],
+        setModelCalls: [],
+        abortCalls: 0,
+        disconnectCalls: 0,
+        conversationLogs: [],
+        dbLogs: [],
+        episodeWrites: 0,
+        ensureDefaultAgentsCalls: 0,
+        loadAgentsCalls: 0,
+        setActiveAgentCalls: [],
+        setChannelProjectCalls: [],
+        channelProjects: new Map(),
+        parseMentionArgs: [],
+        buildAgentRosterArgs: [],
+        clearActiveTasksCalls: 0,
+        activeTasks: [
+            { taskId: "task-1", agentSlug: "coder", status: "running", description: "Fix flaky tests" },
+            { taskId: "task-2", agentSlug: "designer", status: "done", description: "Ignore me" },
+        ],
+        registry: [
+            { slug: "coder", name: "Kaylee", model: "claude-sonnet-4.6" },
+        ],
+        sendResult: "Finished successfully",
+        ...overrides,
+    };
+    const client = createFakeClient(state);
+    t.mock.module("@github/copilot-sdk", {
+        namedExports: { approveAll: "approve-all" },
+    });
+    t.mock.module("./tools.js", {
+        namedExports: {
+            createTools: (deps) => {
+                state.toolDeps = deps;
+                return [{ name: "fake_tool", handler: async () => "ok" }];
+            },
+        },
+    });
+    t.mock.module("./system-message.js", {
+        namedExports: {
+            getOrchestratorSystemMessage: (options) => {
+                state.systemOptions = options;
+                return "SYSTEM";
+            },
+        },
+    });
+    t.mock.module("../config.js", {
+        namedExports: {
+            config: state.config,
+            DEFAULT_MODEL: "fallback-model",
+        },
+    });
+    t.mock.module("./mcp-config.js", {
+        namedExports: {
+            loadMcpConfig: () => ({ filesystem: { command: "filesystem" } }),
+        },
+    });
+    t.mock.module("./skills.js", {
+        namedExports: {
+            getSkillDirectories: () => ["/skills/team"],
+        },
+    });
+    t.mock.module("./client.js", {
+        namedExports: {
+            resetClient: async () => client,
+        },
+    });
+    t.mock.module("../squad/context.js", {
+        namedExports: {
+            setChannelProject: (channelKey, projectRoot) => {
+                state.setChannelProjectCalls.push({ channelKey, projectRoot });
+                state.channelProjects.set(channelKey, projectRoot);
+            },
+            getChannelProject: (channelKey) => state.channelProjects.get(channelKey),
+            normalizeProjectPath: (projectPath) => `normalized:${projectPath}`,
+        },
+    });
+    t.mock.module("../squad/charter.js", {
+        namedExports: {
+            buildSquadSystemPrefix: async (_projectRoot) => "# Squad context\n",
+            getSquadCoordinatorSystemMessage: async (_projectRoot) => "# Squad Coordinator\nYou are the Squad coordinator.\n",
+        },
+    });
+    t.mock.module("../store/db.js", {
+        namedExports: {
+            logConversation: (role, content, source) => {
+                state.dbLogs.push({ role, content, source });
+            },
+            getState: (key) => state.store.get(key),
+            setState: (key, value) => {
+                state.store.set(key, value);
+            },
+            deleteState: (key) => {
+                state.store.delete(key);
+            },
+            getCopilotSession: (_sessionKey) => undefined,
+            upsertCopilotSession: (_sessionKey, _mode, _copilotSessionId, _projectRoot, _model) => { },
+            getTaskSessionKey: (taskId) => state.taskSessionKeys?.get(taskId) ?? "default",
+        },
+    });
+    t.mock.module("./episode-writer.js", {
+        namedExports: {
+            maybeWriteEpisode: async () => {
+                state.episodeWrites++;
+            },
+        },
+    });
+    t.mock.module("../wiki/context.js", {
+        namedExports: {
+            getWikiSummary: () => "wiki summary",
+        },
+    });
+    t.mock.module("../paths.js", {
+        namedExports: {
+            SESSIONS_DIR: "/sessions",
+        },
+    });
+    t.mock.module("./router.js", {
+        namedExports: {
+            resolveModel: async (prompt, currentModel, recentTiers) => {
+                state.routerArgs.push([prompt, currentModel, [...recentTiers]]);
+                return state.routeResults.shift() || {
+                    model: currentModel,
+                    tier: null,
+                    switched: false,
+                    routerMode: "manual",
+                };
+            },
+        },
+    });
+    t.mock.module("./agents.js", {
+        namedExports: {
+            loadAgents: () => {
+                state.loadAgentsCalls++;
+                return [
+                    { slug: "coder", name: "Kaylee", model: "claude-sonnet-4.6" },
+                    { slug: "designer", name: "Wash", model: "claude-opus-4.6" },
+                ];
+            },
+            ensureDefaultAgents: () => {
+                state.ensureDefaultAgentsCalls++;
+            },
+            clearActiveTasks: async () => {
+                state.clearActiveTasksCalls++;
+            },
+            getAgentRegistry: () => state.registry,
+            getActiveAgent: () => undefined,
+            setActiveAgent: (channelKey, agentSlug) => {
+                state.setActiveAgentCalls.push({ channelKey, agentSlug });
+            },
+            parseAtMention: (text, projectRoot) => {
+                state.parseMentionArgs.push({ text, projectRoot });
+                return state.parseMentionResult;
+            },
+            buildAgentRoster: (projectRoot) => {
+                state.buildAgentRosterArgs.push(projectRoot);
+                return "@coder @designer";
+            },
+            getActiveTasks: () => state.activeTasks,
+            completeTask: () => { },
+            failTask: () => { },
+        },
+    });
+    t.mock.method(global, "setInterval", (_callback, delayMs) => {
+        state.healthCheckIntervalMs = delayMs;
+        return { ref() { }, unref() { } };
+    });
+    const orchestrator = await import(new URL(`./orchestrator.js?case=${Date.now()}-${Math.random()}`, import.meta.url).href);
+    return { orchestrator, state, client };
+}
+test("initOrchestrator falls back to an available model and eagerly creates a session", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t);
+    await orchestrator.initOrchestrator(client);
+    assert.equal(state.config.copilotModel, "fallback-model");
+    assert.equal(state.ensureDefaultAgentsCalls, 1);
+    assert.equal(state.loadAgentsCalls, 1);
+    assert.equal(state.createSessionCalls.length, 1);
+    assert.equal(state.healthCheckIntervalMs, 30_000);
+    assert.equal(state.systemOptions?.memorySummary, "wiki summary");
+    assert.equal(state.store.get("orchestrator_session_id"), "session-123");
+});
+test("sendToOrchestrator logs both sides, remembers web auth context, and records routing state", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        config: {
+            copilotModel: "claude-sonnet-4.6",
+            selfEditEnabled: true,
+            squadEnabled: false,
+        },
+        routeResults: [
+            {
+                model: "claude-sonnet-4.6",
+                tier: "standard",
+                switched: false,
+                routerMode: "auto",
+            },
+        ],
+        sendResult: "All green",
+    });
+    await orchestrator.initOrchestrator(client);
+    orchestrator.setMessageLogger((direction, source, text) => {
+        state.conversationLogs.push({ direction, source, text });
+    });
+    const user = {
+        id: "u-1",
+        name: "Ada Lovelace",
+        email: "ada@example.com",
+        role: "engineer",
+    };
+    const final = await new Promise((resolve) => {
+        orchestrator.sendToOrchestrator("Summarize the deployment", { type: "web", connectionId: "conn-1", user, authorizationHeader: "  Bearer token-123  " }, (text, done) => {
+            if (done) {
+                resolve(text);
+            }
+        });
+    });
+    assert.equal(final, "All green");
+    assert.deepEqual(state.sessionPrompts, [{ prompt: "[via web] Summarize the deployment" }]);
+    assert.deepEqual(state.routerArgs, [["[via web] Summarize the deployment", "claude-sonnet-4.6", []]]);
+    assert.deepEqual(orchestrator.getCurrentAuthenticatedUser(), user);
+    assert.equal(orchestrator.getCurrentAuthorizationHeader(), "Bearer token-123");
+    assert.deepEqual(orchestrator.getLastAuthenticatedUser(), user);
+    assert.deepEqual(orchestrator.getLastRouteResult(), {
+        model: "claude-sonnet-4.6",
+        tier: "standard",
+        switched: false,
+        routerMode: "auto",
+    });
+    assert.deepEqual(state.conversationLogs, [
+        { direction: "in", source: "web", text: "Summarize the deployment" },
+        { direction: "out", source: "web", text: "All green" },
+    ]);
+    assert.deepEqual(state.dbLogs, [
+        { role: "user", content: "Summarize the deployment", source: "web" },
+        { role: "assistant", content: "All green", source: "web" },
+    ]);
+    assert.equal(state.episodeWrites, 1);
+});
+test("@mentions route through the orchestrator session without invoking the model router", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        config: {
+            copilotModel: "claude-sonnet-4.6",
+            selfEditEnabled: true,
+            squadEnabled: false,
+        },
+        parseMentionResult: { agentSlug: "designer", message: "polish the landing page" },
+        sendResult: "Delegated",
+    });
+    await orchestrator.initOrchestrator(client);
+    const final = await new Promise((resolve) => {
+        orchestrator.sendToOrchestrator("@designer polish the landing page", { type: "web", connectionId: "conn-2" }, (text, done) => {
+            if (done) {
+                resolve(text);
+            }
+        });
+    });
+    assert.equal(final, "Delegated");
+    assert.deepEqual(state.setActiveAgentCalls, [{ channelKey: "conn-2", agentSlug: "designer" }]);
+    assert.deepEqual(state.routerArgs, []);
+    assert.deepEqual(state.sessionPrompts, [{ prompt: "[via web] polish the landing page" }]);
+});
+test("web projectPath activates squad context, rebuilds the orchestrator roster, and routes mentions per connection", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        config: {
+            copilotModel: "claude-sonnet-4.6",
+            selfEditEnabled: true,
+            squadEnabled: true,
+        },
+        parseMentionResult: { agentSlug: "ripley", message: "audit the squad routing" },
+        sendResult: "Squad handled it",
+    });
+    await orchestrator.initOrchestrator(client);
+    const final = await new Promise((resolve) => {
+        orchestrator.sendToOrchestrator("@ripley audit the squad routing", { type: "web", connectionId: "conn-squad", projectPath: "~/workspace/mock-squad" }, (text, done) => {
+            if (done) {
+                resolve(text);
+            }
+        });
+    });
+    assert.equal(final, "Squad handled it");
+    assert.deepEqual(state.setChannelProjectCalls, [{
+            channelKey: "conn-squad",
+            projectRoot: "normalized:~/workspace/mock-squad",
+        }]);
+    assert.deepEqual(state.parseMentionArgs.at(-1), {
+        text: "@ripley audit the squad routing",
+        projectRoot: "normalized:~/workspace/mock-squad",
+    });
+    assert.deepEqual(state.setActiveAgentCalls, [{ channelKey: "conn-squad", agentSlug: "ripley" }]);
+    assert.deepEqual(state.sessionPrompts.at(-1), [{ prompt: "[via web] audit the squad routing" }][0]);
+    // Project sessions use getSquadCoordinatorSystemMessage (not buildAgentRoster) — only the default
+    // session init triggers a buildAgentRoster call.
+    assert.deepEqual(state.buildAgentRosterArgs, [undefined]);
+    assert.equal(state.createSessionCalls.length, 2);
+    assert.equal(typeof orchestrator.getCurrentChannelKey, "function");
+    assert.equal(orchestrator.getCurrentChannelKey(), undefined);
+});
+test("feedAgentResult injects a background completion turn and proactively notifies listeners", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        config: {
+            copilotModel: "claude-sonnet-4.6",
+            selfEditEnabled: true,
+            squadEnabled: false,
+        },
+        sendResult: "Agent complete",
+    });
+    await orchestrator.initOrchestrator(client);
+    const notified = new Promise((resolve) => {
+        orchestrator.setProactiveNotify(resolve);
+    });
+    orchestrator.feedAgentResult("task-9", "coder", "Fixed the flaky test");
+    assert.equal(await notified, "Agent complete");
+    assert.deepEqual(state.sessionPrompts, [{
+            prompt: "[Agent task completed] @coder finished task task-9:\n\nFixed the flaky test",
+        }]);
+    assert.deepEqual(state.dbLogs, [
+        {
+            role: "system",
+            content: "[Agent task completed] @coder finished task task-9:\n\nFixed the flaky test",
+            source: "background",
+        },
+        {
+            role: "assistant",
+            content: "Agent complete",
+            source: "background",
+        },
+    ]);
+});
+test("cancelCurrentMessage aborts the active request and agent helpers expose running work", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        config: {
+            copilotModel: "claude-sonnet-4.6",
+            selfEditEnabled: true,
+            squadEnabled: false,
+        },
+        sendResult: "__PENDING__",
+    });
+    await orchestrator.initOrchestrator(client);
+    orchestrator.sendToOrchestrator("first request", { type: "background" }, () => { });
+    orchestrator.sendToOrchestrator("second request", { type: "background" }, () => { });
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    assert.equal(await orchestrator.cancelCurrentMessage(), true);
+    assert.equal(state.abortCalls, 1);
+    assert.deepEqual(orchestrator.getAgentInfo(), [
+        {
+            slug: "coder",
+            name: "Kaylee",
+            model: "claude-sonnet-4.6",
+            taskId: "task-1",
+            description: "Fix flaky tests",
+        },
+    ]);
+    await orchestrator.shutdownAgents();
+    assert.equal(state.clearActiveTasksCalls, 1);
+});
+test("feedAgentResult routes to project session when task session_key is a project key", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        config: {
+            copilotModel: "claude-sonnet-4.6",
+            selfEditEnabled: true,
+            squadEnabled: false,
+        },
+        sendResult: "Routed correctly",
+        taskSessionKeys: new Map([["proj-task-1", "project:/repo/squad"]]),
+    });
+    await orchestrator.initOrchestrator(client);
+    // initOrchestrator creates the default session — record that baseline
+    const sessionsAfterInit = state.createSessionCalls.length;
+    const notified = new Promise((resolve) => {
+        orchestrator.setProactiveNotify(resolve);
+    });
+    // Task belongs to the project session; feedAgentResult must open that session
+    orchestrator.feedAgentResult("proj-task-1", "coder", "Squad feature done");
+    assert.equal(await notified, "Routed correctly");
+    // A second createSession call proves the orchestrator opened a fresh project session
+    // rather than reusing the already-open default session.
+    assert.equal(state.createSessionCalls.length, sessionsAfterInit + 1, "feedAgentResult should spin up a project session, not recycle the default one");
+    // The prompt must reference the task and agent
+    const prompt = state.sessionPrompts.at(-1);
+    assert.ok(prompt?.prompt.includes("proj-task-1"), "prompt should reference the task id");
+    assert.ok(prompt?.prompt.includes("coder"), "prompt should reference the agent slug");
+    assert.ok(prompt?.prompt.includes("Squad feature done"), "prompt should include the result text");
+});
+// ---------------------------------------------------------------------------
+// Sprint 3, Item 5 — orchestrator lifecycle: project-session cancel/shutdown
+// ---------------------------------------------------------------------------
+test("cancelCurrentMessage targets the active project session, not the default session", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        config: {
+            copilotModel: "claude-sonnet-4.6",
+            selfEditEnabled: false,
+            // squadEnabled true so sendToOrchestrator derives a "project:…" session key
+            squadEnabled: true,
+        },
+        sendResult: "__PENDING__",
+    });
+    await orchestrator.initOrchestrator(client);
+    // Default session was created during init
+    const sessionsAfterInit = state.createSessionCalls.length;
+    // Send to a project path — this should open a separate project session
+    orchestrator.sendToOrchestrator("scaffold the new API", { type: "web", connectionId: "conn-project", projectPath: "/repo/squad-proj" }, () => { });
+    // Yield to the event loop so the project session is created and the
+    // sendAndWait promise is parked in PENDING state.
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    assert.equal(state.createSessionCalls.length, sessionsAfterInit + 1, "a distinct project session must be created, separate from the default session");
+    // Cancel should abort the active project session, not the default one
+    const cancelled = await orchestrator.cancelCurrentMessage();
+    assert.equal(cancelled, true, "cancelCurrentMessage should return true when an active request was aborted");
+    assert.equal(state.abortCalls, 1, "exactly one abort — on the in-flight project session");
+});
+test("shutdownAgents disconnects all sessions, clears maps, and clears active tasks", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        config: { copilotModel: "claude-sonnet-4.6", selfEditEnabled: false, squadEnabled: true },
+        sendResult: "ok",
+    });
+    // Init default session
+    await orchestrator.initOrchestrator(client);
+    const sessionsAfterInit = state.createSessionCalls.length;
+    // Trigger a project session by sending a message with a projectPath
+    orchestrator.sendToOrchestrator("hello from project", { type: "web", connectionId: "conn-1", projectPath: "/fake/project" }, (_text, _done) => { });
+    // Yield so the async session-creation IIFE runs
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    assert.ok(state.createSessionCalls.length > sessionsAfterInit, "a project session should have been created");
+    // Shutdown — both sessions should be disconnected
+    await orchestrator.shutdownAgents();
+    assert.equal(state.disconnectCalls, 2, "disconnect must be called once per session (default + project)");
+    assert.equal(state.clearActiveTasksCalls, 1, "clearActiveTasks must be called exactly once");
+    // Re-init after shutdown must create a fresh session (proves sessionMap was cleared)
+    await orchestrator.initOrchestrator(client);
+    assert.ok(state.createSessionCalls.length > sessionsAfterInit + 1, "re-init after shutdown must create a new session (not reuse stale sessionMap entry)");
+});
+test("ensureOrchestratorSession cleans up in-flight promise on session creation failure", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        config: { copilotModel: "claude-sonnet-4.6", selfEditEnabled: false, squadEnabled: false },
+        // Non-recoverable error so the retry loop exits immediately
+        createSessionError: "fatal: SDK host permanently unavailable",
+        sendResult: "unreachable",
+    });
+    // initOrchestrator catches the creation failure silently
+    await orchestrator.initOrchestrator(client);
+    // First message — session creation will fail
+    const received = [];
+    orchestrator.sendToOrchestrator("hello", { type: "background" }, (text, done) => {
+        received.push({ text, done });
+    });
+    // Yield long enough for the async IIFE inside sendToOrchestrator to settle
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    assert.ok(received.length > 0, "callback must be invoked after creation failure");
+    assert.ok(received[0].text.startsWith("Error:"), `callback should deliver an Error message; got: "${received[0].text}"`);
+    assert.equal(received[0].done, true, "done flag must be true on error delivery");
+    // The in-flight promise must be cleaned up (sessionCreatePromises.delete ran in finally).
+    // A second call must attempt a fresh createSession — proving the promise map was cleared.
+    const countAfterFirst = state.createSessionCalls.length;
+    orchestrator.sendToOrchestrator("retry", { type: "background" }, () => { });
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    assert.ok(state.createSessionCalls.length > countAfterFirst, "a second message must trigger a new createSession attempt, proving sessionCreatePromises was cleaned up");
+});
+//# sourceMappingURL=orchestrator.test.js.map

package/dist/copilot/router.js

@@ -0,0 +1,142 @@
+import { getState, setState } from "../store/db.js";
+import { classifyWithLLM } from "./classifier.js";
+// ---------------------------------------------------------------------------
+// Default configuration
+// ---------------------------------------------------------------------------
+const DEFAULT_CONFIG = {
+    enabled: false,
+    tierModels: {
+        fast: "gpt-4.1",
+        standard: "claude-sonnet-4.6",
+        premium: "claude-opus-4.6",
+    },
+    overrides: [
+        {
+            name: "design",
+            keywords: [
+                "design", "ui", "ux", "css", "layout", "styling", "visual",
+                "mockup", "wireframe", "frontend design", "tailwind", "responsive",
+            ],
+            model: "claude-opus-4.6",
+        },
+    ],
+    cooldownMessages: 2,
+};
+// ---------------------------------------------------------------------------
+// Module-level state
+// ---------------------------------------------------------------------------
+let messagesSinceSwitch = Infinity;
+// Short replies that should inherit the previous turn's tier
+const FOLLOW_UP_PATTERNS = [
+    "yes", "no", "do it", "go ahead", "sure", "sounds good", "looks good",
+    "perfect", "+1", "please", "yep", "yup", "nope", "nah", "ok", "okay",
+    "got it", "cool", "nice", "great", "alright", "right",
+];
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** Strip channel prefixes and trim whitespace. */
+function sanitize(prompt) {
+    return prompt.replace(/^\[via [a-z]+\]\s*/i, "").trim();
+}
+/** Word-boundary match that avoids partial-word hits (e.g. "ui" ≠ "fruit"). */
+function wordMatch(text, keyword) {
+    const escaped = keyword.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`\\b${escaped}\\b`, "i").test(text);
+}
+// ---------------------------------------------------------------------------
+// Config management
+// ---------------------------------------------------------------------------
+export function getRouterConfig() {
+    const stored = getState("router_config");
+    if (stored) {
+        try {
+            return { ...DEFAULT_CONFIG, ...JSON.parse(stored) };
+        }
+        catch {
+            return { ...DEFAULT_CONFIG };
+        }
+    }
+    return { ...DEFAULT_CONFIG };
+}
+export function updateRouterConfig(partial) {
+    const current = getRouterConfig();
+    const merged = {
+        ...current,
+        ...partial,
+        tierModels: {
+            ...current.tierModels,
+            ...(partial.tierModels ?? {}),
+        },
+        overrides: partial.overrides ?? current.overrides,
+    };
+    setState("router_config", JSON.stringify(merged));
+    return merged;
+}
+// ---------------------------------------------------------------------------
+// Classification
+// ---------------------------------------------------------------------------
+/**
+ * Classify a message using GPT-4.1. Falls back to "standard" if the LLM
+ * is unavailable. Background tasks and follow-ups are handled deterministically.
+ */
+async function classifyMessage(prompt, recentTiers, client) {
+    const text = sanitize(prompt);
+    const lower = text.toLowerCase();
+    // Background tasks → always standard
+    if (lower.startsWith("[background task completed]"))
+        return "standard";
+    // Short follow-ups inherit the previous tier
+    if (text.length < 20 && recentTiers.length > 0) {
+        const isFollowUp = FOLLOW_UP_PATTERNS.some((p) => lower === p || lower === p + ".");
+        if (isFollowUp)
+            return recentTiers[recentTiers.length - 1];
+    }
+    // LLM classification
+    if (client) {
+        const tier = await classifyWithLLM(client, text);
+        if (tier) {
+            console.log(`[chapterhouse] Classifier: ${tier}`);
+            return tier;
+        }
+    }
+    // Fallback — standard is always safe
+    console.log(`[chapterhouse] Classifier (fallback): standard`);
+    return "standard";
+}
+// ---------------------------------------------------------------------------
+// Main entry point
+// ---------------------------------------------------------------------------
+export async function resolveModel(prompt, currentModel, recentTiers, client) {
+    const config = getRouterConfig();
+    // Router disabled → manual mode
+    if (!config.enabled) {
+        messagesSinceSwitch = Infinity;
+        return { model: currentModel, tier: null, switched: false, routerMode: "manual" };
+    }
+    const text = sanitize(prompt);
+    // 1. Check overrides first — they bypass cooldown
+    for (const rule of config.overrides) {
+        if (rule.keywords.some((kw) => wordMatch(text, kw))) {
+            const switched = rule.model !== currentModel;
+            if (switched)
+                messagesSinceSwitch = 0;
+            return { model: rule.model, tier: null, overrideName: rule.name, switched, routerMode: "auto" };
+        }
+    }
+    // 2. Classify the message
+    const tier = await classifyMessage(prompt, recentTiers, client);
+    const targetModel = config.tierModels[tier];
+    const wouldSwitch = targetModel !== currentModel;
+    // 3. Cooldown — prevent rapid switching
+    if (wouldSwitch && messagesSinceSwitch < config.cooldownMessages) {
+        messagesSinceSwitch++;
+        return { model: currentModel, tier, switched: false, routerMode: "auto" };
+    }
+    if (wouldSwitch)
+        messagesSinceSwitch = 0;
+    else
+        messagesSinceSwitch++;
+    return { model: targetModel, tier, switched: wouldSwitch, routerMode: "auto" };
+}
+//# sourceMappingURL=router.js.map