chapterhouse 0.5.0 → 0.5.2

package/dist/api/server.js

@@ -9,6 +9,7 @@ import { sendToOrchestrator, interruptCurrentTurn, enqueueForSse, getAgentInfo,
 import { agentEventBus } from "../copilot/agent-event-bus.js";
 import { ensureDefaultAgents, getAgentRegistry, loadAgents } from "../copilot/agents.js";
 import { config, persistModel } from "../config.js";
+import { ModeContext } from "../mode-context.js";
 import { getRouterConfig, updateRouterConfig } from "../copilot/router.js";
 import { searchIndex, parseIndex } from "../wiki/index-manager.js";
 import { createAuthMiddleware, getBootstrapAuthResponse } from "./auth.js";
@@ -32,7 +33,9 @@ import { assertAuthenticationConfigured, createHealthPayload, createPublicConfig
 import { BadRequestError, ForbiddenError, InternalServerError, NotFoundError, apiNotFoundHandler, asBadRequest, createApiErrorHandler, parseRequest, } from "./errors.js";
 import { childLogger } from "../util/logger.js";
 import { getActiveScope } from "../memory/active-scope.js";
+import { createScope, getScope } from "../memory/scopes.js";
 const log = childLogger("server");
+const modeContext = new ModeContext(config);
 void searchIndex; // re-exported by index-manager; reference here documents the dep
 const __dirname = dirname(fileURLToPath(import.meta.url));
 // Built SPA bundle (web/dist/), shipped alongside dist/
@@ -81,6 +84,12 @@ const projectCreateSchema = z.object({
     cwd: requiredString("Missing 'cwd' in request body")
         .refine((value) => value.startsWith("/"), "Project cwd must be an absolute path"),
 }).strict();
+const scopeCreateSchema = z.object({
+    slug: requiredString("Missing 'slug' in request body")
+        .regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "Scope slug must be unique kebab-case"),
+    title: requiredString("Missing 'title' in request body"),
+    description: z.string().optional(),
+}).strict();
 const projectHardRulesSchema = z.object({
     hardRules: z.object({
         auto_pr: z.boolean({ error: "hardRules.auto_pr must be a boolean" }),
@@ -141,7 +150,7 @@ catch (err) {
     log.error({ err: err instanceof Error ? err.message : String(err) }, "Auth token error");
     process.exit(1);
 }
-if (config.standaloneMode) {
+if (modeContext.isPersonal() && config.standaloneMode) {
     log.warn("Running without authentication — team features disabled");
 }
 function isLoopbackHostname(hostname) {
@@ -255,7 +264,7 @@ function assertValidPagePath(path) {
     }
 }
 function getWikiPageScope(path) {
-    return teamWikiSync.isTeamPath(path) ? "team" : "personal";
+    return modeContext.canSyncTeamWiki() && teamWikiSync.isTeamPath(path) ? "team" : "personal";
 }
 function getEmptyWikiWelcomeContent(today = new Date()) {
     return `---
@@ -892,6 +901,25 @@ app.get("/api/memory/active-scope", (_req, res) => {
         title: activeScope.title,
     });
 });
+app.post("/api/scopes", (req, res) => {
+    const body = parseRequest(scopeCreateSchema, req.body ?? {});
+    if (getScope(body.slug)) {
+        res.status(409).json({ error: `Memory scope '${body.slug}' already exists` });
+        return;
+    }
+    const scope = createScope({
+        slug: body.slug,
+        title: body.title,
+        description: body.description ?? "",
+        keywords: [body.slug],
+    });
+    res.status(201).json({
+        slug: scope.slug,
+        title: scope.title,
+        description: scope.description,
+        active: scope.active,
+    });
+});
 app.post("/api/auto", (req, res) => {
     const body = parseRequest(autoRequestSchema, req.body ?? {});
     const updated = updateRouterConfig(body);
@@ -1001,7 +1029,7 @@ app.put("/api/projects/:slug/rules/soft", async (req, res) => {
 app.get("/api/wiki/pages", async (req, res) => {
     ensureWikiStructure();
     // Sync team wiki pages if connected, using the caller's auth token
-    if (teamWikiSync.isEnabled()) {
+    if (modeContext.canSyncTeamWiki() && teamWikiSync.isEnabled()) {
         const authorizationHeader = typeof req.headers.authorization === "string"
             ? req.headers.authorization
             : undefined;

package/dist/api/server.test.js

@@ -216,15 +216,10 @@ test("server channels route returns chapterhouse plus persistent agents in chann
         const channels = await response.json();
         assert.deepEqual(channels.map((channel) => channel.key), [
             "default",
-            "agent:bellonda",
-            "agent:hwi-noree",
         ]);
         assert.deepEqual(channels.map((channel) => channel.label), [
             "# chapterhouse",
-            "# bellonda",
-            "# hwi-noree",
         ]);
-        assert.equal(channels.find((channel) => channel.key === "agent:bellonda")?.scope, "infra");
     });
 });
 test("server runs in standalone mode without auth", async () => {
@@ -267,6 +262,54 @@ test("server exposes the active memory scope API and requires auth", async () =>
         });
     });
 });
+test("server creates memory scopes with duplicate and slug validation", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader }) => {
+        const unauthorized = await fetch(`${baseUrl}/api/scopes`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ slug: "docs-site", title: "Docs Site" }),
+        });
+        assert.equal(unauthorized.status, 401);
+        const created = await fetch(`${baseUrl}/api/scopes`, {
+            method: "POST",
+            headers: {
+                authorization: authHeader,
+                "content-type": "application/json",
+            },
+            body: JSON.stringify({
+                slug: "docs-site",
+                title: "Docs Site",
+                description: "Documentation publishing and content workflows",
+            }),
+        });
+        assert.equal(created.status, 201);
+        assert.deepEqual(await created.json(), {
+            slug: "docs-site",
+            title: "Docs Site",
+            description: "Documentation publishing and content workflows",
+            active: true,
+        });
+        const duplicate = await fetch(`${baseUrl}/api/scopes`, {
+            method: "POST",
+            headers: {
+                authorization: authHeader,
+                "content-type": "application/json",
+            },
+            body: JSON.stringify({ slug: "docs-site", title: "Docs Site Again" }),
+        });
+        assert.equal(duplicate.status, 409);
+        assert.deepEqual(await duplicate.json(), { error: "Memory scope 'docs-site' already exists" });
+        const invalid = await fetch(`${baseUrl}/api/scopes`, {
+            method: "POST",
+            headers: {
+                authorization: authHeader,
+                "content-type": "application/json",
+            },
+            body: JSON.stringify({ slug: "Docs Site", title: "Docs Site" }),
+        });
+        assert.equal(invalid.status, 400);
+    });
+});
 test("server bootstrap rejects non-loopback origins", async () => {
     await withStartedServer(async ({ baseUrl }) => {
         const response = await fetch(`${baseUrl}/api/bootstrap`, {

package/dist/cli.js

@@ -61,9 +61,11 @@ switch (command) {
         await import("./daemon.js");
         break;
     }
-    case "setup":
-        await import("./setup.js");
+    case "setup": {
+        const { runSetup } = await import("./setup.js");
+        await runSetup();
         break;
+    }
     case "update": {
         const updateFlags = args.slice(1);
         const checkOnly = updateFlags.includes("--check-only");

package/dist/config.js

@@ -2,6 +2,7 @@ import { config as loadEnv } from "dotenv";
 import { z } from "zod";
 import { existsSync, readFileSync, writeFileSync } from "fs";
 import { API_TOKEN_PATH, ENV_PATH, ensureChapterhouseHome } from "./paths.js";
+export { ModeContext } from "./mode-context.js";
 export const DISABLE_DOTENV_ENV_VAR = "CHAPTERHOUSE_DISABLE_DOTENV";
 const DEFAULT_WORKER_TIMEOUT_MS = 900_000;
 const BOOLEAN_ENV_PATTERN = /^(true|false)$/;
@@ -176,6 +177,43 @@ function parseEntityCategories(rawValue) {
         .filter(Boolean);
     return cats.length > 0 ? [...new Set(cats)] : [...DEFAULT_ENTITY_CATEGORIES];
 }
+function configuredKeys(entries) {
+    return entries
+        .filter(([, value]) => typeof value === "boolean" ? value : value.trim().length > 0)
+        .map(([key]) => key);
+}
+function buildModeCompatibilityWarnings(raw, mode) {
+    if (mode !== "personal") {
+        return [];
+    }
+    const warnings = [];
+    const adoKeys = configuredKeys([
+        ["ADO_ORG", raw.ADO_ORG?.trim() || ""],
+        ["ADO_PROJECT", raw.ADO_PROJECT?.trim() || ""],
+        ["ADO_PAT", raw.ADO_PAT?.trim() || ""],
+    ]);
+    if (adoKeys.length > 0 && adoKeys.length < 3) {
+        warnings.push(`Personal mode detected incomplete Azure DevOps settings (${adoKeys.join(", ")}); those team-only settings may be ignored.`);
+    }
+    const entraKeys = configuredKeys([
+        ["ENTRA_AUTH_ENABLED", raw.ENTRA_AUTH_ENABLED?.trim() === "true"],
+        ["ENTRA_TENANT_ID", raw.ENTRA_TENANT_ID?.trim() || ""],
+        ["ENTRA_CLIENT_ID", raw.ENTRA_CLIENT_ID?.trim() || ""],
+        ["ENTRA_REQUIRED_ROLE", raw.ENTRA_REQUIRED_ROLE?.trim() || ""],
+        ["ENTRA_TEAM_LEAD_ID", raw.ENTRA_TEAM_LEAD_ID?.trim() || ""],
+    ]);
+    if (entraKeys.length > 0) {
+        warnings.push(`Personal mode ignores Entra auth settings (${entraKeys.join(", ")}).`);
+    }
+    const teamsKeys = configuredKeys([
+        ["TEAMS_NOTIFICATIONS_ENABLED", raw.TEAMS_NOTIFICATIONS_ENABLED?.trim() === "true"],
+        ["TEAMS_WEBHOOK_URL", raw.TEAMS_WEBHOOK_URL?.trim() || ""],
+    ]);
+    if (teamsKeys.length > 0) {
+        warnings.push(`Personal mode ignores Teams notification settings (${teamsKeys.join(", ")}).`);
+    }
+    return warnings;
+}
 function resolveConfiguredApiToken(envToken, { apiTokenPath = API_TOKEN_PATH, exists = existsSync, readFile = readFileSync, } = {}) {
     const trimmedEnvToken = envToken?.trim();
     if (trimmedEnvToken) {
@@ -220,11 +258,33 @@ export function parseRuntimeConfig(env, options = {}) {
     const entraClientId = raw.ENTRA_CLIENT_ID?.trim() || "";
     const entraRequiredRole = raw.ENTRA_REQUIRED_ROLE?.trim() || "";
     const entraTeamLeadId = raw.ENTRA_TEAM_LEAD_ID?.trim() || "";
-    const entraAuthEnabled = parseBooleanEnv("ENTRA_AUTH_ENABLED", raw.ENTRA_AUTH_ENABLED, false);
+    const rawEntraAuthEnabled = parseBooleanEnv("ENTRA_AUTH_ENABLED", raw.ENTRA_AUTH_ENABLED, false);
+    if (parsedMode === "personal" && rawEntraAuthEnabled) {
+        throw new Error("Personal mode cannot be used with ENTRA_AUTH_ENABLED=true. Set CHAPTERHOUSE_MODE=team to use Entra auth, or unset ENTRA_AUTH_ENABLED to run in unauthenticated personal mode.");
+    }
+    const parsedTeamsWebhookUrl = parseOptionalUrl("TEAMS_WEBHOOK_URL", raw.TEAMS_WEBHOOK_URL);
+    const rawTeamsNotificationsEnabled = parseBooleanEnv("TEAMS_NOTIFICATIONS_ENABLED", raw.TEAMS_NOTIFICATIONS_ENABLED, false);
+    const modeCompatibilityWarnings = buildModeCompatibilityWarnings(raw, parsedMode);
+    const personalModeIgnoresEntra = parsedMode === "personal" && configuredKeys([
+        ["ENTRA_AUTH_ENABLED", rawEntraAuthEnabled],
+        ["ENTRA_TENANT_ID", entraTenantId],
+        ["ENTRA_CLIENT_ID", entraClientId],
+        ["ENTRA_REQUIRED_ROLE", entraRequiredRole],
+        ["ENTRA_TEAM_LEAD_ID", entraTeamLeadId],
+    ]).length > 0;
+    const personalModeIgnoresTeams = parsedMode === "personal" && configuredKeys([
+        ["TEAMS_NOTIFICATIONS_ENABLED", rawTeamsNotificationsEnabled],
+        ["TEAMS_WEBHOOK_URL", parsedTeamsWebhookUrl],
+    ]).length > 0;
+    const effectiveEntraAuthEnabled = personalModeIgnoresEntra ? false : rawEntraAuthEnabled;
+    const effectiveEntraTenantId = personalModeIgnoresEntra ? "" : entraTenantId;
+    const effectiveEntraClientId = personalModeIgnoresEntra ? "" : entraClientId;
+    const effectiveEntraRequiredRole = personalModeIgnoresEntra ? "" : entraRequiredRole;
+    const effectiveEntraTeamLeadId = personalModeIgnoresEntra ? "" : entraTeamLeadId;
+    const effectiveTeamsWebhookUrl = personalModeIgnoresTeams ? "" : parsedTeamsWebhookUrl;
+    const effectiveTeamsNotificationsEnabled = personalModeIgnoresTeams ? false : rawTeamsNotificationsEnabled;
     const apiToken = resolveConfiguredApiToken(raw.API_TOKEN, options);
-    const standaloneMode = !entraAuthEnabled && !apiToken;
-    const teamsWebhookUrl = parseOptionalUrl("TEAMS_WEBHOOK_URL", raw.TEAMS_WEBHOOK_URL);
-    const teamsNotificationsEnabled = parseBooleanEnv("TEAMS_NOTIFICATIONS_ENABLED", raw.TEAMS_NOTIFICATIONS_ENABLED, false);
+    const standaloneMode = !effectiveEntraAuthEnabled && !apiToken;
     const apiRateLimitWindowMs = parsePositiveIntegerEnv("API_RATE_LIMIT_WINDOW_MS", raw.API_RATE_LIMIT_WINDOW_MS, DEFAULT_API_RATE_LIMIT_WINDOW_MS);
     const apiRateLimitGeneralMax = parsePositiveIntegerEnv("API_RATE_LIMIT_GENERAL_MAX", raw.API_RATE_LIMIT_GENERAL_MAX, DEFAULT_API_RATE_LIMIT_GENERAL_MAX);
     const apiRateLimitAuthMax = parsePositiveIntegerEnv("API_RATE_LIMIT_AUTH_MAX", raw.API_RATE_LIMIT_AUTH_MAX, DEFAULT_API_RATE_LIMIT_AUTH_MAX);
@@ -238,10 +298,10 @@ export function parseRuntimeConfig(env, options = {}) {
     const memoryInboxRetentionDays = parsePositiveIntegerEnv("CHAPTERHOUSE_MEMORY_INBOX_RETENTION_DAYS", raw.CHAPTERHOUSE_MEMORY_INBOX_RETENTION_DAYS, 7);
     const memoryHotRecallBoost = parsePositiveNumberEnv("CHAPTERHOUSE_MEMORY_HOT_RECALL_BOOST", raw.CHAPTERHOUSE_MEMORY_HOT_RECALL_BOOST, 1.5);
     const memoryHotAgeDays = parsePositiveIntegerEnv("CHAPTERHOUSE_MEMORY_HOT_AGE_DAYS", raw.CHAPTERHOUSE_MEMORY_HOT_AGE_DAYS, 30);
-    if (entraAuthEnabled && (!entraTenantId || !entraClientId)) {
+    if (effectiveEntraAuthEnabled && (!effectiveEntraTenantId || !effectiveEntraClientId)) {
         throw new Error("ENTRA_AUTH_ENABLED=true requires ENTRA_TENANT_ID and ENTRA_CLIENT_ID");
     }
-    if (teamsNotificationsEnabled && !teamsWebhookUrl) {
+    if (effectiveTeamsNotificationsEnabled && !effectiveTeamsWebhookUrl) {
         throw new Error("TEAMS_NOTIFICATIONS_ENABLED=true requires TEAMS_WEBHOOK_URL");
     }
     return {
@@ -256,11 +316,11 @@ export function parseRuntimeConfig(env, options = {}) {
         adoProject: raw.ADO_PROJECT?.trim() || DEFAULT_ADO_PROJECT,
         adoPat: raw.ADO_PAT?.trim() || "",
         workerTimeoutMs: parsedWorkerTimeout,
-        entraTenantId,
-        entraClientId,
-        entraRequiredRole,
-        entraTeamLeadId,
-        entraAuthEnabled,
+        entraTenantId: effectiveEntraTenantId,
+        entraClientId: effectiveEntraClientId,
+        entraRequiredRole: effectiveEntraRequiredRole,
+        entraTeamLeadId: effectiveEntraTeamLeadId,
+        entraAuthEnabled: effectiveEntraAuthEnabled,
         standaloneMode,
         corsAllowedOrigins: parseCorsAllowedOrigins(raw.CORS_ALLOWED_ORIGINS),
         copilotModel: raw.COPILOT_MODEL || DEFAULT_MODEL,
@@ -271,8 +331,8 @@ export function parseRuntimeConfig(env, options = {}) {
         teamWikiCacheTtlMinutes: parsedTeamWikiCacheTtlMinutes,
         teamWikiPaths: parseTeamWikiPaths(raw.TEAM_WIKI_PATHS),
         wikiEntityCategories: parseEntityCategories(raw.WIKI_ENTITY_CATEGORIES),
-        teamsWebhookUrl,
-        teamsNotificationsEnabled,
+        teamsWebhookUrl: effectiveTeamsWebhookUrl,
+        teamsNotificationsEnabled: effectiveTeamsNotificationsEnabled,
         apiRateLimitWindowMs,
         apiRateLimitGeneralMax,
         apiRateLimitAuthMax,
@@ -295,6 +355,7 @@ export function parseRuntimeConfig(env, options = {}) {
         memoryTieringEnabled: parseZeroOneEnv("CHAPTERHOUSE_MEMORY_TIERING_ENABLED", raw.CHAPTERHOUSE_MEMORY_TIERING_ENABLED, true),
         memoryHotRecallBoost,
         memoryHotAgeDays,
+        modeCompatibilityWarnings,
     };
 }
 const runtimeConfig = parseRuntimeConfig(process.env);
@@ -352,6 +413,7 @@ export const config = {
     memoryTieringEnabled: runtimeConfig.memoryTieringEnabled,
     memoryHotRecallBoost: runtimeConfig.memoryHotRecallBoost,
     memoryHotAgeDays: runtimeConfig.memoryHotAgeDays,
+    modeCompatibilityWarnings: runtimeConfig.modeCompatibilityWarnings,
     copilotAuthToken: runtimeConfig.copilotAuthToken,
     get copilotModel() {
         return _copilotModel;

package/dist/config.test.js

@@ -14,6 +14,7 @@ test("parses Teams webhook settings", async () => {
     const configModule = await import("./config.js");
     assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
     const parsed = configModule.parseRuntimeConfig({
+        CHAPTERHOUSE_MODE: "team",
         TEAMS_WEBHOOK_URL: "https://teams.example.test/webhook",
         TEAMS_NOTIFICATIONS_ENABLED: "true",
     });
@@ -24,6 +25,7 @@ test("rejects Teams notifications without a webhook", async () => {
     const configModule = await import("./config.js");
     assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
     assert.throws(() => configModule.parseRuntimeConfig({
+        CHAPTERHOUSE_MODE: "team",
         TEAMS_NOTIFICATIONS_ENABLED: "true",
     }), /TEAMS_NOTIFICATIONS_ENABLED=true requires TEAMS_WEBHOOK_URL/);
 });
@@ -60,6 +62,7 @@ test("requires Entra tenant and client when auth is enabled", async () => {
     const configModule = await import("./config.js");
     assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
     assert.throws(() => configModule.parseRuntimeConfig({
+        CHAPTERHOUSE_MODE: "team",
         ENTRA_AUTH_ENABLED: "true",
         ENTRA_TENANT_ID: "tenant-id",
     }), /ENTRA_AUTH_ENABLED=true requires ENTRA_TENANT_ID and ENTRA_CLIENT_ID/);
@@ -268,4 +271,45 @@ test("rejects invalid SSE replay settings", async () => {
         CHAPTERHOUSE_SSE_BUFFER_CAPACITY: "0",
     }), /CHAPTERHOUSE_SSE_BUFFER_CAPACITY must be a positive integer/);
 });
+test("personal mode rejects explicit Entra auth enablement with a clear fix suggestion", async () => {
+    const configModule = await import("./config.js");
+    assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
+    assert.throws(() => configModule.parseRuntimeConfig({
+        CHAPTERHOUSE_MODE: "personal",
+        ENTRA_AUTH_ENABLED: "true",
+        ENTRA_TENANT_ID: "tenant-id",
+        ENTRA_CLIENT_ID: "client-id",
+    }), /Personal mode cannot be used with ENTRA_AUTH_ENABLED=true[\s\S]*CHAPTERHOUSE_MODE=team[\s\S]*unset ENTRA_AUTH_ENABLED/);
+});
+test("personal mode still warns about leftover Entra settings when auth is not explicitly enabled", async () => {
+    const configModule = await import("./config.js");
+    assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
+    const parsed = configModule.parseRuntimeConfig({
+        CHAPTERHOUSE_MODE: "personal",
+        ENTRA_TENANT_ID: "tenant-only",
+    });
+    assert.equal(parsed.chapterhouseMode, "personal");
+    assert.equal(parsed.entraAuthEnabled, false);
+    assert.match(parsed.modeCompatibilityWarnings.join("\n"), /Entra/i);
+});
+test("personal mode warns and disables incomplete Teams notification settings instead of throwing", async () => {
+    const configModule = await import("./config.js");
+    assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
+    const parsed = configModule.parseRuntimeConfig({
+        CHAPTERHOUSE_MODE: "personal",
+        TEAMS_NOTIFICATIONS_ENABLED: "true",
+    });
+    assert.equal(parsed.teamsNotificationsEnabled, false);
+    assert.match(parsed.modeCompatibilityWarnings.join("\n"), /Teams/i);
+});
+test("personal mode warns when Azure DevOps settings are only partially configured", async () => {
+    const configModule = await import("./config.js");
+    assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
+    const parsed = configModule.parseRuntimeConfig({
+        CHAPTERHOUSE_MODE: "personal",
+        ADO_PAT: "test-pat",
+    });
+    assert.equal(parsed.adoPat, "test-pat");
+    assert.match(parsed.modeCompatibilityWarnings.join("\n"), /Azure DevOps/i);
+});
 //# sourceMappingURL=config.test.js.map

package/dist/copilot/orchestrator.js

@@ -175,12 +175,9 @@ function scheduleHousekeeping(sessionKey, source) {
         log.info({ sessionKey, scope_ids: scopeIds }, "memory.housekeeping.in_flight_skip");
         return;
     }
-    try {
-        void runHousekeeping({ scopeIds });
-    }
-    catch (error) {
+    void runHousekeeping({ scopeIds }).catch((error) => {
         log.error({ err: error, sessionKey, scope_ids: scopeIds }, "memory.housekeeping.error");
-    }
+    });
 }
 export function maybeScheduleScopeChangeCheckpoint(sessionKey, previousScope, nextScope) {
     if (!previousScope) {
@@ -359,6 +356,17 @@ function buildHotTierContext() {
     }
     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) {
     return {
         selfEditEnabled: config.selfEditEnabled,
@@ -446,7 +454,7 @@ export function feedAgentResult(taskId, agentSlug, result) {
     }
     void (async () => {
         await new Promise((resolve) => setImmediate(resolve));
-        const prompt = `[Agent task completed] @${agentSlug} finished task ${taskId}. Their reply has been shown to the user. Acknowledge briefly.`;
+        const prompt = `[Agent task completed] @${agentSlug} finished task ${taskId}. The user has already seen this reply in the agent's own bubble. Acknowledge briefly without restating content.`;
         sendToOrchestrator(prompt, { type: "background", sessionKey }, (text, done) => {
             if (done && proactiveNotifyFn) {
                 proactiveNotifyFn(text);
@@ -507,6 +515,7 @@ async function createOrResumeSession(sessionKey, projectRoot) {
         backgroundCompactionThreshold: 0.80,
         bufferExhaustionThreshold: 0.95,
     };
+    const memoryHooks = buildPerTurnMemoryHooks(sessionKey);
     let model = config.copilotModel;
     let systemMessageContent;
     let sessionMode = isProjectSession ? "project" : "default";
@@ -542,6 +551,7 @@ async function createOrResumeSession(sessionKey, projectRoot) {
                 configDir: SESSIONS_DIR,
                 streaming: true,
                 systemMessage: { content: systemMessageContent },
+                hooks: memoryHooks,
                 tools,
                 mcpServers,
                 skillDirectories,
@@ -568,6 +578,7 @@ async function createOrResumeSession(sessionKey, projectRoot) {
         configDir: SESSIONS_DIR,
         streaming: true,
         systemMessage: { content: systemMessageContent },
+        hooks: memoryHooks,
         tools,
         mcpServers,
         skillDirectories,

package/dist/copilot/orchestrator.test.js

@@ -3,8 +3,12 @@ import test from "node:test";
 import { clearTurnLog, subscribeSession } from "./turn-event-log.js";
 function createFakeClient(state) {
     class FakeSession {
+        options;
         sessionId = "session-123";
         listeners = new Map();
+        constructor(options) {
+            this.options = options;
+        }
         on(eventName, handler) {
             const handlers = this.listeners.get(eventName) || [];
             handlers.push(handler);
@@ -20,6 +24,9 @@ function createFakeClient(state) {
             }
         }
         async sendAndWait(request, _timeoutMs) {
+            const hooks = this.options.hooks;
+            const hookResult = await hooks?.onUserPromptSubmitted?.({ prompt: request.prompt }, { sessionId: this.sessionId });
+            state.promptMemoryContexts.push(hookResult?.additionalContext);
             state.sessionPrompts.push(request);
             if (state.sendResult === "__PENDING__") {
                 return await new Promise((_resolve, reject) => {
@@ -57,7 +64,7 @@ function createFakeClient(state) {
             if (state.createSessionError) {
                 throw new Error(state.createSessionError);
             }
-            const session = new FakeSession();
+            const session = new FakeSession(options);
             state.lastSession = {
                 emit: (eventName, data) => session.emit(eventName, data),
             };
@@ -108,6 +115,7 @@ async function loadOrchestratorModule(t, overrides = {}) {
             { slug: "coder", name: "Kaylee", model: "claude-sonnet-4.6", systemMessage: "You are Kaylee." },
         ],
         sendResult: "Finished successfully",
+        promptMemoryContexts: [],
         taskEvents: new Map(),
         projectRegistry: {},
         resolveProjectArgs: [],
@@ -155,7 +163,9 @@ async function loadOrchestratorModule(t, overrides = {}) {
             renderHotTierForActiveScope: () => state.hotTierXml ?? "",
             getHotTierEntries: (scopeId) => ({
                 scope: scopeId !== undefined
-                    ? makeScope(scopeId, "infra", "Infra", "Infrastructure work.")
+                    ? scopeId === state.activeScope?.id
+                        ? state.activeScope
+                        : makeScope(scopeId, "infra", "Infra", "Infrastructure work.")
                     : state.activeScope ?? null,
                 entities: [],
                 observations: [],
@@ -526,6 +536,43 @@ test("initOrchestrator passes hot-tier XML into the orchestrator system prompt w
     assert.match(hotTierXml, /<decision id="decision-1">hi<\/decision>/);
     assert.doesNotMatch(hotTierXml, /<memory_context[^>]*>[\s\S]*<memory_context\b/);
 });
+test("orchestrator refreshes hot-tier memory context for each assistant turn", async (t) => {
+    const firstMemoryContext = [
+        "<memory_context scope=\"chapterhouse\" generated_at=\"2026-05-13T00:00:00.000Z\">",
+        "  <observation id=\"observation-1\">Initial hot memory</observation>",
+        "</memory_context>",
+    ].join("\n");
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        hotTierXml: firstMemoryContext,
+        hotTierByScope: new Map([["chapterhouse", firstMemoryContext]]),
+    });
+    await orchestrator.initOrchestrator(client);
+    await new Promise((resolve) => {
+        orchestrator.sendToOrchestrator("first turn", { type: "background" }, (text, done) => {
+            if (done)
+                resolve(text);
+        });
+    });
+    const secondMemoryContext = [
+        "<memory_context scope=\"chapterhouse\" generated_at=\"2026-05-13T00:01:00.000Z\">",
+        "  <observation id=\"observation-1\">Initial hot memory</observation>",
+        "  <observation id=\"observation-2\">Checkpoint wrote this between turns</observation>",
+        "</memory_context>",
+    ].join("\n");
+    state.hotTierXml = secondMemoryContext;
+    state.hotTierByScope?.set("chapterhouse", secondMemoryContext);
+    await new Promise((resolve) => {
+        orchestrator.sendToOrchestrator("second turn", { type: "background" }, (text, done) => {
+            if (done)
+                resolve(text);
+        });
+    });
+    assert.equal(state.createSessionCalls.length, 1, "same SDK session should handle both turns");
+    assert.equal(state.promptMemoryContexts.length, 2);
+    assert.match(state.promptMemoryContexts[0] ?? "", /Initial hot memory/);
+    assert.doesNotMatch(state.promptMemoryContexts[0] ?? "", /Checkpoint wrote this between turns/);
+    assert.match(state.promptMemoryContexts[1] ?? "", /Checkpoint wrote this between turns/);
+});
 test("initOrchestrator omits hot-tier XML when no active-scope memory is available", async (t) => {
     const { orchestrator, state, client } = await loadOrchestratorModule(t, {
         hotTierXml: "",
@@ -1194,7 +1241,7 @@ test("feedAgentResult emits an attributed short agent reply before starting the
     await new Promise((resolve) => setImmediate(resolve));
     assert.equal(await notified, "Agent complete");
     assert.deepEqual(state.sessionPrompts, [{
-            prompt: "[Agent task completed] @coder finished task task-9. Their reply has been shown to the user. Acknowledge briefly.",
+            prompt: "[Agent task completed] @coder finished task task-9. The user has already seen this reply in the agent's own bubble. Acknowledge briefly without restating content.",
         }]);
     assert.equal(state.sessionPrompts[0]?.prompt.includes(agentReply), false, "orchestrator notification must not include the full agent reply body");
     const started = events.filter((event) => event.type === "turn:started");

package/dist/copilot/router.js

@@ -1,16 +1,19 @@
 import { getState, setState } from "../store/db.js";
+import { config } from "../config.js";
 import { classifyWithLLM } from "./classifier.js";
 import { childLogger } from "../util/logger.js";
 const log = childLogger("router");
 // ---------------------------------------------------------------------------
 // Default configuration
 // ---------------------------------------------------------------------------
+const STANDARD_MODEL = "claude-sonnet-4.6";
+const PREMIUM_MODEL = "claude-opus-4.6";
 const DEFAULT_CONFIG = {
-    enabled: false,
+    enabled: config.chapterhouseMode === "personal",
     tierModels: {
         fast: "gpt-4.1",
-        standard: "claude-sonnet-4.6",
-        premium: "claude-opus-4.6",
+        standard: STANDARD_MODEL,
+        premium: PREMIUM_MODEL,
     },
     overrides: [
         {
@@ -19,11 +22,32 @@ const DEFAULT_CONFIG = {
                 "design", "ui", "ux", "css", "layout", "styling", "visual",
                 "mockup", "wireframe", "frontend design", "tailwind", "responsive",
             ],
-            model: "claude-opus-4.6",
+            model: PREMIUM_MODEL,
         },
     ],
     cooldownMessages: 2,
 };
+function cloneRouterConfig(routerConfig) {
+    return {
+        ...routerConfig,
+        tierModels: { ...routerConfig.tierModels },
+        overrides: routerConfig.overrides.map((rule) => ({
+            ...rule,
+            keywords: [...rule.keywords],
+        })),
+    };
+}
+function getDefaultRouterConfig(hasStoredConfig) {
+    const defaults = cloneRouterConfig(DEFAULT_CONFIG);
+    if (config.chapterhouseMode === "personal" && !hasStoredConfig) {
+        defaults.tierModels.premium = defaults.tierModels.standard;
+        defaults.overrides = defaults.overrides.map((rule) => ({
+            ...rule,
+            model: rule.model === PREMIUM_MODEL ? defaults.tierModels.standard : rule.model,
+        }));
+    }
+    return defaults;
+}
 // ---------------------------------------------------------------------------
 // Module-level state
 // ---------------------------------------------------------------------------
@@ -51,18 +75,29 @@ function wordMatch(text, keyword) {
 // ---------------------------------------------------------------------------
 export function getRouterConfig() {
     const stored = getState("router_config");
+    const defaults = getDefaultRouterConfig(stored !== undefined);
     if (stored) {
         try {
-            return { ...DEFAULT_CONFIG, ...JSON.parse(stored) };
+            const parsed = JSON.parse(stored);
+            return {
+                ...defaults,
+                ...parsed,
+                tierModels: {
+                    ...defaults.tierModels,
+                    ...(parsed.tierModels ?? {}),
+                },
+                overrides: parsed.overrides ?? defaults.overrides,
+            };
         }
         catch {
-            return { ...DEFAULT_CONFIG };
+            return defaults;
         }
     }
-    return { ...DEFAULT_CONFIG };
+    return defaults;
 }
 export function updateRouterConfig(partial) {
-    const current = getRouterConfig();
+    const hasStoredConfig = getState("router_config") !== undefined;
+    const current = hasStoredConfig ? getRouterConfig() : cloneRouterConfig(DEFAULT_CONFIG);
     const merged = {
         ...current,
         ...partial,