chapterhouse 0.5.2 → 0.6.0

package/dist/copilot/orchestrator.js

@@ -3,13 +3,9 @@ import { randomUUID } from "node:crypto";
 import { approveAll } from "@github/copilot-sdk";
 import { createTools } from "./tools.js";
 import { getOrchestratorSystemMessage } from "./system-message.js";
-import { renderHotTierForActiveScope } from "../memory/hot-tier.js";
-import { getHotTierEntries, renderHotTierXML } from "../memory/hot-tier.js";
 import { getActiveScope, withActiveScope } from "../memory/active-scope.js";
 import { getScope } from "../memory/scopes.js";
-import { CheckpointTracker, isCheckpointInFlight, runCheckpointExtraction } from "../memory/checkpoint.js";
-import { isHousekeepingInFlight, runHousekeeping } from "../memory/housekeeping.js";
-import { runEndOfTaskMemoryHook } from "../memory/eot.js";
+import { MemoryCoordinator } from "./memory-coordinator.js";
 import { CHAPTERHOUSE_VERSION } from "../version.js";
 import { config, DEFAULT_MODEL } from "../config.js";
 import { loadMcpConfig } from "./mcp-config.js";
@@ -77,157 +73,15 @@ let currentUserContext;
 let currentAuthenticatedUser;
 let currentAuthorizationHeader;
 let lastRouteResult;
-const checkpointTrackers = new Map();
-const checkpointTurnsBySession = new Map();
-const housekeepingTurnsBySession = new Map();
-const MAX_CHECKPOINT_CHARS_PER_SIDE = 4_000;
+let memoryCoordinator;
 export function getLastRouteResult() {
     return lastRouteResult;
 }
-function truncateCheckpointText(value) {
-    const trimmed = value.trim();
-    if (trimmed.length <= MAX_CHECKPOINT_CHARS_PER_SIDE) {
-        return trimmed;
-    }
-    return `${trimmed.slice(0, MAX_CHECKPOINT_CHARS_PER_SIDE)}…`;
-}
-function getCheckpointTracker(sessionKey) {
-    let tracker = checkpointTrackers.get(sessionKey);
-    if (!tracker) {
-        tracker = new CheckpointTracker();
-        checkpointTrackers.set(sessionKey, tracker);
-    }
-    return tracker;
-}
 export function resetCheckpointSessionState(sessionKey) {
-    getCheckpointTracker(sessionKey).reset();
-    checkpointTurnsBySession.delete(sessionKey);
-    housekeepingTurnsBySession.delete(sessionKey);
-}
-function appendCheckpointTurn(sessionKey, turn) {
-    const turns = checkpointTurnsBySession.get(sessionKey) ?? [];
-    turns.push(turn);
-    const overflow = turns.length - config.memoryCheckpointTurns;
-    if (overflow > 0) {
-        turns.splice(0, overflow);
-    }
-    checkpointTurnsBySession.set(sessionKey, turns);
-    return turns;
-}
-function scheduleCheckpointExtraction(sessionKey, prompt, finalContent, source) {
-    if (source.type === "background") {
-        return;
-    }
-    const tracker = getCheckpointTracker(sessionKey);
-    const turns = appendCheckpointTurn(sessionKey, {
-        user: truncateCheckpointText(prompt),
-        assistant: truncateCheckpointText(finalContent),
-    });
-    if (!config.memoryCheckpointEnabled) {
-        log.info({ sessionKey }, "memory.checkpoint.disabled");
-        return;
-    }
-    tracker.tickOrchestratorTurn();
-    if (!tracker.shouldFire()) {
-        return;
-    }
-    tracker.markFired();
-    if (isCheckpointInFlight(sessionKey)) {
-        log.info({ sessionKey }, "memory.checkpoint.in_flight_skip");
-        return;
-    }
-    if (!copilotClient) {
-        log.error({ sessionKey }, "memory.checkpoint.error");
-        return;
-    }
-    const activeScope = getMemoryScopeForSession(sessionKey);
-    void runCheckpointExtraction({
-        sessionKey,
-        turns: turns.slice(-config.memoryCheckpointTurns),
-        activeScope,
-        copilotClient,
-        trigger: "cadence",
-    }).catch((error) => {
-        log.error({ err: error, sessionKey }, "memory.checkpoint.error");
-    });
-}
-function scheduleHousekeeping(sessionKey, source) {
-    if (source.type === "background") {
-        return;
-    }
-    if (!config.memoryHousekeepingEnabled) {
-        log.info({ sessionKey }, "memory.housekeeping.disabled");
-        return;
-    }
-    const turns = (housekeepingTurnsBySession.get(sessionKey) ?? 0) + 1;
-    if (turns < config.memoryHousekeepingTurns) {
-        housekeepingTurnsBySession.set(sessionKey, turns);
-        return;
-    }
-    housekeepingTurnsBySession.set(sessionKey, 0);
-    const activeScope = getMemoryScopeForSession(sessionKey);
-    if (!activeScope) {
-        log.info({ sessionKey }, "memory.housekeeping.no_active_scope");
-        return;
-    }
-    const scopeIds = [activeScope.id];
-    if (isHousekeepingInFlight(scopeIds)) {
-        log.info({ sessionKey, scope_ids: scopeIds }, "memory.housekeeping.in_flight_skip");
-        return;
-    }
-    void runHousekeeping({ scopeIds }).catch((error) => {
-        log.error({ err: error, sessionKey, scope_ids: scopeIds }, "memory.housekeeping.error");
-    });
+    memoryCoordinator?.reset(sessionKey);
 }
 export function maybeScheduleScopeChangeCheckpoint(sessionKey, previousScope, nextScope) {
-    if (!previousScope) {
-        return;
-    }
-    if (!config.memoryCheckpointOnScopeChange) {
-        log.info({ sessionKey, scope: previousScope.slug }, "memory.checkpoint.scope_change_disabled");
-        return;
-    }
-    const tracker = getCheckpointTracker(sessionKey);
-    const turnsSinceLast = tracker.turnsSinceLastFire();
-    if (turnsSinceLast < config.memoryCheckpointMinTurnsForScopeFire) {
-        log.info({
-            sessionKey,
-            scope: previousScope.slug,
-            turns_since_last: turnsSinceLast,
-            min_required: config.memoryCheckpointMinTurnsForScopeFire,
-        }, "memory.checkpoint.scope_change_skip");
-        return;
-    }
-    if (isCheckpointInFlight(sessionKey)) {
-        log.info({ sessionKey, trigger: "scope_change" }, "memory.checkpoint.in_flight_skip");
-        return;
-    }
-    if (!copilotClient) {
-        log.error({ sessionKey }, "memory.checkpoint.error");
-        return;
-    }
-    const turns = checkpointTurnsBySession.get(sessionKey) ?? [];
-    if (turns.length === 0) {
-        log.info({
-            sessionKey,
-            scope: previousScope.slug,
-            turns_since_last: turnsSinceLast,
-            min_required: config.memoryCheckpointMinTurnsForScopeFire,
-        }, "memory.checkpoint.scope_change_skip");
-        return;
-    }
-    tracker.markScopeChangeFire();
-    void runCheckpointExtraction({
-        sessionKey,
-        turns: turns.slice(-config.memoryCheckpointTurns),
-        activeScope: previousScope,
-        copilotClient,
-        trigger: "scope_change",
-        scopeChangeContext: {
-            from: previousScope.slug,
-            to: nextScope?.slug ?? "no active scope",
-        },
-    }).catch((error) => {
+    void memoryCoordinator?.onScopeChange(sessionKey, previousScope?.slug ?? "", nextScope?.slug ?? "").catch((error) => {
         log.error({ err: error, sessionKey }, "memory.checkpoint.error");
     });
 }
@@ -339,39 +193,11 @@ function getMemoryScopeForSession(sessionKey) {
     }
     return getActiveScope();
 }
-function buildScopedHotTierContext(scope) {
-    if (!config.memoryInjectEnabled || !scope) {
-        return undefined;
-    }
-    const hotTierXml = renderHotTierXML(getHotTierEntries(scope.id));
-    return hotTierXml ? hotTierXml.trimEnd() : undefined;
-}
-function buildHotTierContext() {
-    if (!config.memoryInjectEnabled) {
-        return undefined;
-    }
-    const hotTierXml = renderHotTierForActiveScope();
-    if (!hotTierXml) {
-        return undefined;
-    }
-    return hotTierXml.trimEnd();
-}
-function buildPerTurnMemoryHooks(sessionKey) {
-    if (!config.memoryInjectEnabled) {
-        return undefined;
-    }
-    return {
-        onUserPromptSubmitted: () => {
-            const hotTierXml = buildScopedHotTierContext(getMemoryScopeForSession(sessionKey));
-            return hotTierXml ? { additionalContext: hotTierXml } : undefined;
-        },
-    };
-}
-function getSystemMessageOptions(memorySummary) {
+function getSystemMessageOptions(memorySummary, hotTierXml) {
     return {
         selfEditEnabled: config.selfEditEnabled,
         memorySummary: memorySummary || undefined,
-        hotTierXml: buildHotTierContext(),
+        hotTierXml,
         agentRoster: buildAgentRoster(),
         userContext: currentUserContext,
     };
@@ -407,15 +233,9 @@ function updateRequestContext(source) {
     }
 }
 export function feedAgentResult(taskId, agentSlug, result) {
-    if (copilotClient) {
-        void runEndOfTaskMemoryHook({
-            taskId,
-            finalResult: result,
-            copilotClient,
-        }).catch((error) => {
-            log.error({ err: error, taskId }, "memory.eot.error");
-        });
-    }
+    void memoryCoordinator?.onAgentTaskComplete(taskId, result).catch((error) => {
+        log.error({ err: error, taskId }, "memory.eot.error");
+    });
     const sessionKey = getTaskSessionKey(taskId) || "default";
     const agentTurnId = randomUUID();
     const agentDisplayName = getAgentRegistry().find((agent) => agent.slug === agentSlug)?.name ?? agentSlug;
@@ -509,13 +329,12 @@ async function createOrResumeSession(sessionKey, projectRoot) {
     let { tools, mcpServers, skillDirectories } = baseConfig;
     const isProjectSession = sessionKey.startsWith("project:");
     const persistentAgent = getPersistentAgentForSessionKey(sessionKey);
-    const agentScope = persistentAgent?.scope ? getScope(persistentAgent.scope) ?? null : null;
     const infiniteSessions = {
         enabled: true,
         backgroundCompactionThreshold: 0.80,
         bufferExhaustionThreshold: 0.95,
     };
-    const memoryHooks = buildPerTurnMemoryHooks(sessionKey);
+    const memoryHooks = memoryCoordinator?.buildPerTurnHooks(sessionKey);
     let model = config.copilotModel;
     let systemMessageContent;
     let sessionMode = isProjectSession ? "project" : "default";
@@ -525,7 +344,7 @@ async function createOrResumeSession(sessionKey, projectRoot) {
             client: copilotClient,
             onAgentTaskComplete: feedAgentResult,
         })));
-        const scopedHotTier = buildScopedHotTierContext(agentScope);
+        const scopedHotTier = (await memoryCoordinator?.buildHotTierContext(sessionKey)) || undefined;
         const channelNote = `You are in your persistent Chapterhouse channel (${sessionKey}). Your memory scope is ${persistentAgent.scope}.`;
         systemMessageContent = [
             composeAgentSystemMessage(persistentAgent),
@@ -536,8 +355,9 @@ async function createOrResumeSession(sessionKey, projectRoot) {
     }
     else {
         const memorySummary = getWikiSummary();
+        const hotTierXml = (await memoryCoordinator?.buildHotTierContext(sessionKey)) || undefined;
         systemMessageContent = getOrchestratorSystemMessage({
-            ...getSystemMessageOptions(memorySummary),
+            ...getSystemMessageOptions(memorySummary, hotTierXml),
             version: CHAPTERHOUSE_VERSION,
         });
     }
@@ -559,7 +379,7 @@ async function createOrResumeSession(sessionKey, projectRoot) {
                 infiniteSessions,
             });
             log.info({ sessionKey }, "Session resumed successfully");
-            resetCheckpointSessionState(sessionKey);
+            memoryCoordinator?.reset(sessionKey);
             upsertCopilotSession(sessionKey, sessionMode, session.sessionId, projectRoot, model);
             const mgr = registry?.get(sessionKey);
             if (mgr)
@@ -586,7 +406,7 @@ async function createOrResumeSession(sessionKey, projectRoot) {
         infiniteSessions,
     });
     log.info({ sessionKey, sessionId: session.sessionId.slice(0, 8) }, "Session created");
-    resetCheckpointSessionState(sessionKey);
+    memoryCoordinator?.reset(sessionKey);
     upsertCopilotSession(sessionKey, sessionMode, session.sessionId, projectRoot, model);
     if (sessionKey === "default")
         setState(ORCHESTRATOR_SESSION_KEY, session.sessionId);
@@ -597,6 +417,12 @@ async function createOrResumeSession(sessionKey, projectRoot) {
 }
 export async function initOrchestrator(client) {
     copilotClient = client;
+    memoryCoordinator?.shutdown();
+    memoryCoordinator = new MemoryCoordinator({
+        getCopilotClient: () => copilotClient,
+        config,
+        resolveScopeForSession: getMemoryScopeForSession,
+    });
     // Initialize per-task ring buffer — subscribes to agentEventBus for session:tool_call events.
     initTaskEventLog();
     // (Re-)create the registry — supports multiple initOrchestrator calls in tests
@@ -893,12 +719,8 @@ async function executeOnSession(manager, item) {
                 spawnArgsMap.delete(taskId);
                 activeSubagentTaskIds.delete(taskId);
                 db.prepare(`UPDATE agent_tasks SET status = 'completed', result = ?, completed_at = CURRENT_TIMESTAMP WHERE task_id = ?`).run(finalResult?.slice(0, 10000) ?? null, taskId);
-                if (copilotClient && finalResult) {
-                    void runEndOfTaskMemoryHook({
-                        taskId,
-                        finalResult,
-                        copilotClient,
-                    }).catch((error) => {
+                if (finalResult) {
+                    void memoryCoordinator?.onAgentTaskComplete(taskId, finalResult).catch((error) => {
                         log.error({ err: error, taskId }, "memory.eot.error");
                     });
                 }
@@ -1249,8 +1071,9 @@ export async function sendToOrchestrator(prompt, source, callback, attachments,
                     logConversation("assistant", finalContent, logSource, sessionKey, { turnId });
                 }
                 catch { /* best-effort */ }
-                scheduleCheckpointExtraction(sessionKey, prompt, finalContent, source);
-                scheduleHousekeeping(sessionKey, source);
+                void memoryCoordinator?.onTurnComplete(sessionKey, prompt, finalContent, source.type).catch((error) => {
+                    log.error({ err: error, sessionKey }, "memory.turn_complete.error");
+                });
                 if (copilotClient) {
                     maybeWriteEpisode(copilotClient).catch((err) => {
                         log.error({ err: err instanceof Error ? err.message : err }, "Episode write failed (non-fatal)");
@@ -1350,8 +1173,9 @@ export async function interruptCurrentTurn(sessionKey, newPrompt, source, callba
                     logConversation("assistant", finalContent, sourceLabel, sessionKey, { turnId });
                 }
                 catch { /* best-effort */ }
-                scheduleCheckpointExtraction(sessionKey, newPrompt, finalContent, source);
-                scheduleHousekeeping(sessionKey, source);
+                void memoryCoordinator?.onTurnComplete(sessionKey, newPrompt, finalContent, source.type).catch((error) => {
+                    log.error({ err: error, sessionKey }, "memory.turn_complete.error");
+                });
                 if (copilotClient) {
                     maybeWriteEpisode(copilotClient).catch((err) => {
                         log.error({ err: err instanceof Error ? err.message : err }, "Episode write failed (non-fatal)");
@@ -1491,15 +1315,13 @@ export function getAgentInfo() {
 }
 /** Clean up on shutdown/restart. */
 export async function shutdownAgents() {
+    memoryCoordinator?.shutdown();
+    memoryCoordinator = undefined;
     if (!registry) {
-        checkpointTrackers.clear();
-        checkpointTurnsBySession.clear();
         await clearActiveTasks();
         return;
     }
     await registry.shutdown();
-    checkpointTrackers.clear();
-    checkpointTurnsBySession.clear();
     await clearActiveTasks();
 }
 //# sourceMappingURL=orchestrator.js.map

package/dist/copilot/orchestrator.test.js

@@ -158,6 +158,117 @@ async function loadOrchestratorModule(t, overrides = {}) {
             DEFAULT_MODEL: "fallback-model",
         },
     });
+    t.mock.module("./memory-coordinator.js", {
+        namedExports: {
+            MemoryCoordinator: class {
+                checkpointTrackers = new Map();
+                checkpointTurnsBySession = new Map();
+                housekeepingTurnsBySession = new Map();
+                constructor(_options) { }
+                getCheckpointTracker(sessionKey) {
+                    let tracker = this.checkpointTrackers.get(sessionKey);
+                    if (!tracker) {
+                        tracker = { turns: 0 };
+                        this.checkpointTrackers.set(sessionKey, tracker);
+                    }
+                    return tracker;
+                }
+                async onTurnComplete(sessionKey, prompt, response, source) {
+                    if (source === "background") {
+                        return;
+                    }
+                    const tracker = this.getCheckpointTracker(sessionKey);
+                    state.checkpointTickCalls++;
+                    tracker.turns++;
+                    const turns = this.checkpointTurnsBySession.get(sessionKey) ?? [];
+                    turns.push({ user: prompt.trim(), assistant: response.trim() });
+                    this.checkpointTurnsBySession.set(sessionKey, turns);
+                    if (state.config.memoryCheckpointEnabled !== false && tracker.turns >= state.checkpointShouldFireAfter && !state.checkpointInFlight) {
+                        state.checkpointMarkFiredCalls++;
+                        tracker.turns = 0;
+                        state.checkpointRuns.push({
+                            sessionKey,
+                            turns: turns.slice(-5),
+                            activeScope: state.activeScope ?? null,
+                            trigger: "cadence",
+                        });
+                    }
+                    if (state.config.memoryHousekeepingEnabled === false) {
+                        return;
+                    }
+                    const count = (this.housekeepingTurnsBySession.get(sessionKey) ?? 0) + 1;
+                    const cadence = state.config.memoryHousekeepingTurns ?? 50;
+                    if (count < cadence) {
+                        this.housekeepingTurnsBySession.set(sessionKey, count);
+                        return;
+                    }
+                    this.housekeepingTurnsBySession.set(sessionKey, 0);
+                    if (!state.activeScope || state.housekeepingInFlight) {
+                        return;
+                    }
+                    state.housekeepingRuns.push({ scopeIds: [state.activeScope.id] });
+                }
+                async onScopeChange(sessionKey, prev, next) {
+                    if (!prev || state.config.memoryCheckpointOnScopeChange === false || state.checkpointInFlight) {
+                        return;
+                    }
+                    const tracker = this.getCheckpointTracker(sessionKey);
+                    if (tracker.turns < (state.config.memoryCheckpointMinTurnsForScopeFire ?? 2)) {
+                        return;
+                    }
+                    const turns = this.checkpointTurnsBySession.get(sessionKey) ?? [];
+                    if (turns.length === 0) {
+                        return;
+                    }
+                    state.checkpointMarkScopeChangeFireCalls++;
+                    tracker.turns = 0;
+                    state.checkpointRuns.push({
+                        sessionKey,
+                        turns: turns.slice(-5),
+                        activeScope: { slug: prev },
+                        trigger: "scope_change",
+                        scopeChangeContext: { from: prev, to: next || "no active scope" },
+                    });
+                }
+                async buildHotTierContext(sessionKey) {
+                    if (state.config.memoryInjectEnabled === false) {
+                        return "";
+                    }
+                    if (sessionKey.startsWith("agent:")) {
+                        const agent = state.registry.find((entry) => `agent:${entry.slug}` === sessionKey);
+                        if (agent?.scope) {
+                            return (state.hotTierByScope?.get(agent.scope) ?? "").trimEnd();
+                        }
+                    }
+                    const xml = state.hotTierXml ?? state.hotTierByScope?.get(state.activeScope?.slug ?? "") ?? "";
+                    return xml.trimEnd();
+                }
+                buildPerTurnHooks(sessionKey) {
+                    if (state.config.memoryInjectEnabled === false) {
+                        return undefined;
+                    }
+                    return {
+                        onUserPromptSubmitted: async () => {
+                            const additionalContext = await this.buildHotTierContext(sessionKey);
+                            return additionalContext ? { additionalContext } : undefined;
+                        },
+                    };
+                }
+                async onAgentTaskComplete(_taskId, _result) { }
+                reset(sessionKey) {
+                    state.checkpointResetCalls++;
+                    this.getCheckpointTracker(sessionKey).turns = 0;
+                    this.checkpointTurnsBySession.delete(sessionKey);
+                    this.housekeepingTurnsBySession.delete(sessionKey);
+                }
+                shutdown() {
+                    this.checkpointTrackers.clear();
+                    this.checkpointTurnsBySession.clear();
+                    this.housekeepingTurnsBySession.clear();
+                }
+            },
+        },
+    });
     t.mock.module("../memory/hot-tier.js", {
         namedExports: {
             renderHotTierForActiveScope: () => state.hotTierXml ?? "",

package/dist/copilot/pr-title.js

@@ -0,0 +1,92 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PR_TYPES_CONFIG_PATH = join(__dirname, "..", "..", ".pr-types.json");
+function loadPrTitleTypes() {
+    const parsed = JSON.parse(readFileSync(PR_TYPES_CONFIG_PATH, "utf-8"));
+    if (!Array.isArray(parsed) || parsed.some((value) => typeof value !== "string" || value.trim().length === 0)) {
+        throw new Error(`Invalid PR title types config at ${PR_TYPES_CONFIG_PATH}`);
+    }
+    return parsed;
+}
+const VALID_PR_TITLE_TYPES = loadPrTitleTypes();
+const PR_TITLE_PATTERN = new RegExp(`^(?<type>${VALID_PR_TITLE_TYPES.join("|")})(?:\\((?<scope>[^()\\r\\n]+)\\))?: (?<description>.+)$`);
+function examplesBlock() {
+    return [
+        "Examples:",
+        "  Valid: feat: add user search",
+        "  Valid: fix(auth): handle token expiry",
+        "  Valid: test: memory tiering edge cases",
+        "  Invalid: adding new thing",
+        "  Invalid: WIP",
+        "  Invalid: HOTFIX",
+    ].join("\n");
+}
+function allowedTypesLine() {
+    return `Allowed types: ${VALID_PR_TITLE_TYPES.join(", ")}.`;
+}
+function isAllCapsDescription(description) {
+    const lettersOnly = description.replace(/[^A-Za-z]/g, "");
+    return lettersOnly.length > 0 && lettersOnly === lettersOnly.toUpperCase();
+}
+export function explainPrTitleValidation(title) {
+    const normalizedTitle = title.trim();
+    if (!normalizedTitle) {
+        return {
+            valid: false,
+            message: [
+                "PR title is required.",
+                "Use conventional commit format: type(optional-scope): description",
+                allowedTypesLine(),
+                examplesBlock(),
+            ].join("\n"),
+        };
+    }
+    const match = PR_TITLE_PATTERN.exec(normalizedTitle);
+    if (!match?.groups) {
+        return {
+            valid: false,
+            message: [
+                `PR title \"${normalizedTitle}\" must match conventional commit format: type(optional-scope): description`,
+                allowedTypesLine(),
+                examplesBlock(),
+            ].join("\n"),
+        };
+    }
+    const description = match.groups.description.trim();
+    if (!description) {
+        return {
+            valid: false,
+            message: [
+                "PR title description must be non-empty.",
+                examplesBlock(),
+            ].join("\n"),
+        };
+    }
+    if (isAllCapsDescription(description)) {
+        return {
+            valid: false,
+            message: [
+                `PR title description must not be ALL CAPS: \"${description}\".`,
+                "Use a short, sentence-style description after the conventional type prefix.",
+                examplesBlock(),
+            ].join("\n"),
+        };
+    }
+    return {
+        valid: true,
+        message: `PR title is valid: ${normalizedTitle}`,
+    };
+}
+export function isValidPrTitle(title) {
+    return explainPrTitleValidation(title).valid;
+}
+export function assertValidPrTitle(title) {
+    const result = explainPrTitleValidation(title);
+    if (!result.valid) {
+        throw new Error(result.message);
+    }
+}
+export { VALID_PR_TITLE_TYPES };
+//# sourceMappingURL=pr-title.js.map

package/dist/copilot/pr-title.test.js

@@ -0,0 +1,54 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import { explainPrTitleValidation, isValidPrTitle } from "./pr-title.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PR_TYPES_CONFIG_PATH = join(__dirname, "..", "..", ".pr-types.json");
+test("accepts conventional PR titles with and without scopes", () => {
+    assert.equal(isValidPrTitle("feat: add user search"), true);
+    assert.equal(isValidPrTitle("fix(auth): handle token expiry"), true);
+    assert.equal(isValidPrTitle("test: memory tiering edge cases"), true);
+    assert.equal(isValidPrTitle("release: v1.2.3"), true);
+});
+test("rejects blank or malformed PR titles with clear guidance", () => {
+    const blank = explainPrTitleValidation("   ");
+    assert.equal(blank.valid, false);
+    assert.match(blank.message, /PR title is required/i);
+    assert.match(blank.message, /feat: add user search/);
+    const malformed = explainPrTitleValidation("adding new thing");
+    assert.equal(malformed.valid, false);
+    assert.match(malformed.message, /must match conventional commit format/i);
+    assert.match(malformed.message, /type\(optional-scope\): description/i);
+});
+test("rejects all-caps descriptions even when the prefix is valid", () => {
+    const result = explainPrTitleValidation("fix: HOTFIX");
+    assert.equal(result.valid, false);
+    assert.match(result.message, /description must not be all caps/i);
+});
+test("rejects unsupported types", () => {
+    const result = explainPrTitleValidation("hotfix: patch prod issue");
+    assert.equal(result.valid, false);
+    assert.match(result.message, /allowed types/i);
+    assert.match(result.message, /feat, fix, docs, style, refactor, perf, test, chore, build, ci, revert, release/);
+});
+test("loads PR title types from the shared config file", () => {
+    const raw = readFileSync(PR_TYPES_CONFIG_PATH, "utf-8");
+    const types = JSON.parse(raw);
+    assert.deepEqual(types, [
+        "feat",
+        "fix",
+        "docs",
+        "style",
+        "refactor",
+        "perf",
+        "test",
+        "chore",
+        "build",
+        "ci",
+        "revert",
+        "release",
+    ]);
+});
+//# sourceMappingURL=pr-title.test.js.map

package/dist/copilot/router.test.js

@@ -29,6 +29,7 @@ async function loadRouterModule(t, options = {}) {
     return { router, state };
 }
 test("router config defaults personal-mode auto-routing to standard-cost routes before opt-in", async (t) => {
+    // Security/Billing: personal mode must not silently spend premium quota until the user explicitly opts in.
     const { router } = await loadRouterModule(t, { mode: "personal" });
     assert.deepEqual(router.getRouterConfig(), {
         enabled: true,
@@ -55,6 +56,7 @@ test("router config keeps auto-routing off by default in team mode", async (t) =
     assert.equal(router.getRouterConfig().enabled, false);
 });
 test("saving router config in personal mode opts into premium defaults and deep-merges tier model updates", async (t) => {
+    // Security/Billing: persisted router_config is the explicit consent boundary for premium model usage.
     const { router, state } = await loadRouterModule(t, { mode: "personal" });
     const saved = router.updateRouterConfig({ enabled: true });
     assert.equal(saved.enabled, true);
@@ -84,6 +86,7 @@ test("resolveModel stays in manual mode when the router is disabled", async (t)
     });
 });
 test("resolveModel applies safe design overrides before personal-mode opt-in and ignores partial-word matches", async (t) => {
+    // Security/Billing: premium-looking prompts like design work must still stay on standard-cost models until opt-in is stored.
     const { router } = await loadRouterModule(t, {
         classify: async () => "fast",
     });
@@ -96,7 +99,34 @@ test("resolveModel applies safe design overrides before personal-mode opt-in and
     assert.equal(noOverride.model, "gpt-4.1");
     assert.equal(noOverride.tier, "fast");
 });
+test("stored router opt-in re-enables premium design overrides in personal mode", async (t) => {
+    // Security/Billing: once the user explicitly opts in, premium routing should activate so future regressions do not strand consented users on downgraded routing.
+    const { router } = await loadRouterModule(t, {
+        mode: "personal",
+        storedConfig: JSON.stringify({
+            enabled: true,
+            tierModels: {
+                fast: "gpt-4.1",
+                standard: "claude-sonnet-4.6",
+                premium: "claude-opus-4.6",
+            },
+            overrides: [
+                {
+                    name: "design",
+                    keywords: ["design", "ui"],
+                    model: "claude-opus-4.6",
+                },
+            ],
+            cooldownMessages: 2,
+        }),
+    });
+    const result = await router.resolveModel("Need a UI refresh", "claude-sonnet-4.6", [], {});
+    assert.equal(result.overrideName, "design");
+    assert.equal(result.model, "claude-opus-4.6");
+    assert.equal(result.switched, true);
+});
 test("short follow-ups inherit the previous tier without forcing premium before opt-in", async (t) => {
+    // Security/Billing: follow-up replies must not become a backdoor that silently upgrades personal-mode users to premium routing.
     const { router } = await loadRouterModule(t);
     const result = await router.resolveModel("yes", "claude-sonnet-4.6", ["premium"]);
     assert.deepEqual(result, {