chapterhouse 0.5.2 → 0.7.0

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 ?? "",
@@ -271,7 +382,10 @@ async function loadOrchestratorModule(t, overrides = {}) {
     });
     t.mock.module("./mcp-config.js", {
         namedExports: {
-            loadMcpConfig: () => ({ filesystem: { command: "filesystem" } }),
+            loadMcpConfig: () => ({
+                filesystem: { command: "filesystem" },
+                truenas: { command: "truenas" },
+            }),
         },
     });
     t.mock.module("./skills.js", {
@@ -402,6 +516,13 @@ async function loadOrchestratorModule(t, overrides = {}) {
                 return "@coder @designer";
             },
             composeAgentSystemMessage: (agent) => agent.systemMessage ?? `You are ${agent.slug}.`,
+            filterMcpServersForAgent: (agent, mcpServers) => {
+                if (agent.mcpServers && agent.mcpServers.length > 0) {
+                    const allowed = new Set(agent.mcpServers);
+                    return Object.fromEntries(Object.entries(mcpServers).filter(([name]) => allowed.has(name)));
+                }
+                return mcpServers;
+            },
             filterToolsForAgent: (_agent, tools) => tools,
             bindToolsToAgent: (_agentSlug, tools) => tools,
             withToolTaskContext: (_taskId, fn) => fn(),
@@ -617,6 +738,28 @@ test("initOrchestrator prewarms persistent agent sessions with scoped hot-tier c
     assert.equal(persistentCall.systemMessage.content.includes("scope=\"infra\""), true);
     assert.deepEqual(state.dbWrites.filter((write) => write.sql.includes("copilot_sessions")), []);
 });
+test("initOrchestrator prewarms persistent agent sessions with only allowed MCP servers", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        registry: [
+            { slug: "coder", name: "Kaylee", model: "claude-sonnet-4.6", systemMessage: "You are Kaylee." },
+            {
+                slug: "bellonda",
+                name: "Bellonda",
+                model: "claude-sonnet-4.6",
+                systemMessage: "You are Bellonda.",
+                persistent: true,
+                scope: "infra",
+                mcpServers: ["truenas"],
+            },
+        ],
+    });
+    await orchestrator.initOrchestrator(client);
+    const persistentCall = state.createSessionCalls.find((call) => String(call.systemMessage?.content ?? "").includes("Bellonda"));
+    assert.ok(persistentCall, "expected a prewarmed Bellonda session");
+    assert.deepEqual(persistentCall.mcpServers, {
+        truenas: { command: "truenas" },
+    });
+});
 test("sendToOrchestrator routes agent session keys directly to persistent agent sessions", async (t) => {
     const { orchestrator, state, client } = await loadOrchestratorModule(t, {
         config: {
@@ -1406,6 +1549,100 @@ test("cancelCurrentMessage aborts the active request and agent helpers expose ru
     await orchestrator.shutdownAgents();
     assert.equal(state.clearActiveTasksCalls, 1);
 });
+test("persistent agent helpers report session state and reload idle sessions", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        config: {
+            copilotModel: "claude-sonnet-4.6",
+            selfEditEnabled: true,
+        },
+        registry: [
+            {
+                slug: "bellonda",
+                name: "Bellonda",
+                model: "claude-sonnet-4.6",
+                systemMessage: "You are Bellonda.",
+                persistent: true,
+                scope: "infra",
+            },
+        ],
+    });
+    await orchestrator.initOrchestrator(client);
+    const createCallsBeforeReload = state.createSessionCalls.length;
+    assert.equal(orchestrator.getPersistentAgentSessionState("bellonda"), "idle");
+    const reloaded = await orchestrator.reloadPersistentAgent("bellonda");
+    assert.equal(reloaded, "reloaded");
+    assert.equal(orchestrator.getPersistentAgentSessionState("bellonda"), "idle");
+    assert.equal(state.disconnectCalls, 1);
+    assert.equal(state.createSessionCalls.length, createCallsBeforeReload + 1);
+});
+test("persistent agent helpers detect in-flight turns", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        config: {
+            copilotModel: "claude-sonnet-4.6",
+            selfEditEnabled: true,
+        },
+        registry: [
+            {
+                slug: "bellonda",
+                name: "Bellonda",
+                model: "claude-sonnet-4.6",
+                systemMessage: "You are Bellonda.",
+                persistent: true,
+                scope: "infra",
+            },
+        ],
+        sendResult: "__PENDING__",
+    });
+    await orchestrator.initOrchestrator(client);
+    orchestrator.sendToOrchestrator("check deploy health", { type: "background", sessionKey: "agent:bellonda" }, () => { });
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    assert.equal(orchestrator.getPersistentAgentSessionState("bellonda"), "in_flight");
+    state.pendingReject?.(new Error("test teardown"));
+    await new Promise((resolve) => setTimeout(resolve, 0));
+});
+test("reloadPersistentAgent defers reloads until the in-flight turn finishes and preserves queued turns", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        config: {
+            copilotModel: "claude-sonnet-4.6",
+            selfEditEnabled: true,
+        },
+        registry: [
+            {
+                slug: "bellonda",
+                name: "Bellonda",
+                model: "claude-sonnet-4.6",
+                systemMessage: "You are Bellonda.",
+                persistent: true,
+                scope: "infra",
+            },
+        ],
+        sendResult: "__PENDING__",
+    });
+    await orchestrator.initOrchestrator(client);
+    const createCallsBeforeReload = state.createSessionCalls.length;
+    const reloadEvents = [];
+    orchestrator.sendToOrchestrator("check deploy health", { type: "background", sessionKey: "agent:bellonda" }, () => { });
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    const queuedTurn = new Promise((resolve) => {
+        orchestrator.sendToOrchestrator("summarize the queued follow-up", { type: "background", sessionKey: "agent:bellonda" }, (text, done) => {
+            if (done)
+                resolve(text);
+        });
+    });
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    const reloadResult = await orchestrator.reloadPersistentAgent("bellonda", () => {
+        reloadEvents.push("reloaded");
+    });
+    assert.equal(reloadResult, "scheduled");
+    assert.equal(state.disconnectCalls, 0, "deferred reload should wait for the active turn to finish");
+    state.sendResult = "Queued follow-up complete";
+    state.pendingReject?.(new Error("forced restart"));
+    assert.equal(await queuedTurn, "Queued follow-up complete");
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    assert.deepEqual(reloadEvents, ["reloaded"]);
+    assert.equal(state.disconnectCalls, 1, "deferred reload should restart the session once the turn finishes");
+    assert.equal(state.createSessionCalls.length, createCallsBeforeReload + 1);
+});
 // ---------------------------------------------------------------------------
 // REGRESSION: #35 — per-session isolation
 // This test would have caught the original bug. With a global shared queue,

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, {

package/dist/copilot/session-manager.js

@@ -60,6 +60,9 @@ export class SessionManager {
      * never-evict-mid-turn invariant. */
     _pendingClose = false;
     _onPendingCloseEvict;
+    /** Set when a persistent session should be recreated before the next queued turn runs. */
+    _pendingReload = false;
+    _onPendingReload = [];
     constructor(sessionKey, worker, sessionFactory) {
         this.worker = worker;
         this.sessionFactory = sessionFactory;
@@ -178,6 +181,19 @@ export class SessionManager {
                 item.reject(err);
             }
             this._lastActivityAt = Date.now();
+            if (this._pendingReload) {
+                await this.restartSession();
+                const callbacks = this._onPendingReload.splice(0);
+                this._pendingReload = false;
+                for (const callback of callbacks) {
+                    try {
+                        callback();
+                    }
+                    catch (err) {
+                        log.warn({ sessionKey: this.sessionKey, err: err instanceof Error ? err.message : String(err) }, "session.reload.callback.failed");
+                    }
+                }
+            }
         }
         this._currentTurnId = undefined;
         this._processing = false;
@@ -213,6 +229,24 @@ export class SessionManager {
         this._session = undefined;
         this._sessionCreatePromise = undefined;
     }
+    async restartSession() {
+        if (this._session) {
+            try {
+                await this._session.disconnect();
+            }
+            catch {
+                // best effort
+            }
+        }
+        this.invalidateSession();
+        await this.ensureSession();
+    }
+    requestSessionReload(onReloaded) {
+        this._pendingReload = true;
+        if (onReloaded) {
+            this._onPendingReload.push(onReloaded);
+        }
+    }
     /** Reject all queued messages without evicting the session. Returns count drained. */
     cancelQueued() {
         const count = this._queue.length;

package/dist/copilot/threat-model.js

@@ -0,0 +1,50 @@
+const THREAT_MODEL_PATTERNS = [
+    /(^|[\/._-])auth([\/._-]|$)/i,
+    /credential/i,
+    /(auth|access|bearer|refresh|session|payment|api)[-_.]?token|token[-_.]?(auth|key|secret|refresh|access|session|payment)/i,
+    /billing/i,
+    /subscription/i,
+    /api[-_]?key/i,
+    /(^|[\/._-])tiers?([\/._-]|$)/i,
+];
+function normalizeChangedFiles(changedFiles) {
+    return changedFiles.map((file) => file.trim()).filter(Boolean);
+}
+export function findThreatModelMatches(changedFiles) {
+    return normalizeChangedFiles(changedFiles).filter((file) => THREAT_MODEL_PATTERNS.some((pattern) => pattern.test(file)));
+}
+export function hasThreatModelSection(prBody) {
+    const stripped = (prBody ?? "").replace(/<!--[\s\S]*?-->/g, "");
+    return /^##+\s+Threat Model\b/im.test(stripped);
+}
+export function evaluateThreatModelCheck(input) {
+    const matchedFiles = findThreatModelMatches(input.changedFiles);
+    if (matchedFiles.length === 0) {
+        return {
+            required: false,
+            valid: true,
+            matchedFiles: [],
+            message: "✅ No auth/credentials/billing file changes detected — a threat model section is not required.",
+        };
+    }
+    if (hasThreatModelSection(input.prBody)) {
+        return {
+            required: true,
+            valid: true,
+            matchedFiles,
+            message: "✅ Threat model section present for auth/credentials/billing changes.",
+        };
+    }
+    return {
+        required: true,
+        valid: false,
+        matchedFiles,
+        message: [
+            "⚠️ This PR modifies auth/credentials/billing files. Add a '## Threat Model' section to the PR description explaining the security implications.",
+            "",
+            "Matched files:",
+            ...matchedFiles.map((file) => `- ${file}`),
+        ].join("\n"),
+    };
+}
+//# sourceMappingURL=threat-model.js.map