chapterhouse 0.5.1 → 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";
@@ -34,6 +35,7 @@ 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/
@@ -148,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) {
@@ -262,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 `---
@@ -1027,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/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) {

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,

package/dist/copilot/router.test.js

@@ -13,6 +13,13 @@ async function loadRouterModule(t, options = {}) {
             },
         },
     });
+    t.mock.module("../config.js", {
+        namedExports: {
+            config: {
+                chapterhouseMode: options.mode ?? "personal",
+            },
+        },
+    });
     t.mock.module("./classifier.js", {
         namedExports: {
             classifyWithLLM: async (_client, prompt) => await (options.classify?.(prompt) ?? null),
@@ -21,16 +28,14 @@ async function loadRouterModule(t, options = {}) {
     const router = await import(new URL(`./router.js?case=${Date.now()}-${Math.random()}`, import.meta.url).href);
     return { router, state };
 }
-test("router config falls back safely and deep-merges tier model updates", async (t) => {
-    const { router, state } = await loadRouterModule(t, {
-        storedConfig: "{not-json}",
-    });
+test("router config defaults personal-mode auto-routing to standard-cost routes before opt-in", async (t) => {
+    const { router } = await loadRouterModule(t, { mode: "personal" });
     assert.deepEqual(router.getRouterConfig(), {
-        enabled: false,
+        enabled: true,
         tierModels: {
             fast: "gpt-4.1",
             standard: "claude-sonnet-4.6",
-            premium: "claude-opus-4.6",
+            premium: "claude-sonnet-4.6",
         },
         overrides: [
             {
@@ -39,19 +44,28 @@ test("router config falls back safely and deep-merges tier model updates", async
                     "design", "ui", "ux", "css", "layout", "styling", "visual",
                     "mockup", "wireframe", "frontend design", "tailwind", "responsive",
                 ],
-                model: "claude-opus-4.6",
+                model: "claude-sonnet-4.6",
             },
         ],
         cooldownMessages: 2,
     });
+});
+test("router config keeps auto-routing off by default in team mode", async (t) => {
+    const { router } = await loadRouterModule(t, { mode: "team" });
+    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) => {
+    const { router, state } = await loadRouterModule(t, { mode: "personal" });
+    const saved = router.updateRouterConfig({ enabled: true });
+    assert.equal(saved.enabled, true);
+    assert.equal(saved.tierModels.premium, "claude-opus-4.6");
+    assert.equal(saved.overrides[0]?.model, "claude-opus-4.6");
     const updated = router.updateRouterConfig({
-        enabled: true,
         tierModels: {
-            ...router.getRouterConfig().tierModels,
+            ...saved.tierModels,
             premium: "gpt-5.5",
         },
     });
-    assert.equal(updated.enabled, true);
     assert.deepEqual(updated.tierModels, {
         fast: "gpt-4.1",
         standard: "claude-sonnet-4.6",
@@ -60,7 +74,7 @@ test("router config falls back safely and deep-merges tier model updates", async
     assert.equal(JSON.parse(state.get("router_config") || "{}").tierModels.premium, "gpt-5.5");
 });
 test("resolveModel stays in manual mode when the router is disabled", async (t) => {
-    const { router } = await loadRouterModule(t);
+    const { router } = await loadRouterModule(t, { mode: "team" });
     const result = await router.resolveModel("Ship it", "claude-sonnet-4.6", []);
     assert.deepEqual(result, {
         model: "claude-sonnet-4.6",
@@ -69,28 +83,26 @@ test("resolveModel stays in manual mode when the router is disabled", async (t)
         routerMode: "manual",
     });
 });
-test("resolveModel applies overrides by whole word and ignores partial-word matches", async (t) => {
+test("resolveModel applies safe design overrides before personal-mode opt-in and ignores partial-word matches", async (t) => {
     const { router } = await loadRouterModule(t, {
         classify: async () => "fast",
     });
-    router.updateRouterConfig({ enabled: true });
     const override = await router.resolveModel("Need a UI refresh", "gpt-4.1", [], {});
     const noOverride = await router.resolveModel("Fruit salad", "gpt-4.1", [], {});
     assert.equal(override.overrideName, "design");
-    assert.equal(override.model, "claude-opus-4.6");
+    assert.equal(override.model, "claude-sonnet-4.6");
     assert.equal(override.switched, true);
     assert.equal(noOverride.overrideName, undefined);
     assert.equal(noOverride.model, "gpt-4.1");
     assert.equal(noOverride.tier, "fast");
 });
-test("short follow-ups inherit the previous tier", async (t) => {
+test("short follow-ups inherit the previous tier without forcing premium before opt-in", async (t) => {
     const { router } = await loadRouterModule(t);
-    router.updateRouterConfig({ enabled: true });
     const result = await router.resolveModel("yes", "claude-sonnet-4.6", ["premium"]);
     assert.deepEqual(result, {
-        model: "claude-opus-4.6",
+        model: "claude-sonnet-4.6",
         tier: "premium",
-        switched: true,
+        switched: false,
         routerMode: "auto",
     });
 });

package/dist/copilot/tools.js

@@ -6,6 +6,7 @@ import { join } from "path";
 import { homedir } from "os";
 import { listSkills, createSkill, removeSkill } from "./skills.js";
 import { config, persistModel } from "../config.js";
+import { ModeContext } from "../mode-context.js";
 import { agentEventBus } from "./agent-event-bus.js";
 import { getCurrentSourceChannel, getCurrentActivityCallback, getCurrentActiveProjectRules, getCurrentAuthenticatedUser, getLastAuthenticatedUser, getCurrentAuthorizationHeader, getCurrentSessionKey, sendToAgentSession, invalidateOrchestratorSession, maybeScheduleScopeChangeCheckpoint, resetCheckpointSessionState, switchSessionModel, } from "./orchestrator.js";
 import { getRouterConfig, updateRouterConfig } from "./router.js";
@@ -31,6 +32,7 @@ import { OKRMapper, parseOKRPageContent } from "./okr-mapper.js";
 import { childLogger } from "../util/logger.js";
 import { getActiveScope as getMemoryActiveScope, createScope as createMemoryScope, getScope as getMemoryScope, inferScopeFromText, completeActionItem, demoteToCold, demoteToWarm, dropActionItem, queueMemoryProposal, recall as recallMemory, listActionItems, recordDecision, recordActionItem, recordObservation, runHousekeeping, setActiveScope as setMemoryActiveScope, snoozeActionItem, promoteToHot, upsertEntity, } from "../memory/index.js";
 const log = childLogger("tools");
+const modeContext = new ModeContext(config);
 /** Escape a string for safe inclusion as a single-line YAML scalar value. */
 function yamlEscape(value) {
     // Always quote and escape backslashes, double quotes, and newlines.
@@ -536,7 +538,7 @@ export function createTools(deps) {
                 notes: z.string().optional().describe("Optional notes about the work"),
             }),
             handler: async (args) => {
-                if (config.chapterhouseMode !== "personal") {
+                if (!modeContext.canLogToAdo()) {
                     return "OKR progress logging is only available from personal Chapterhouse instances.";
                 }
                 const mapper = createOKRMapper();
@@ -1246,7 +1248,7 @@ export function createTools(deps) {
                     if (args.scope_slug && !requestedScope) {
                         return `Unknown memory scope '${args.scope_slug}'.`;
                     }
-                    const result = runHousekeeping({
+                    const result = await runHousekeeping({
                         scopeIds: requestedScope ? [requestedScope.id] : undefined,
                         allScopes: args.all_scopes,
                         passes: args.passes,

package/dist/daemon.js

@@ -4,6 +4,7 @@ import { stopEpisodeWriter } from "./copilot/episode-writer.js";
 import { startApiServer, broadcastToSSE } from "./api/server.js";
 import { getDb, closeDb, getState } from "./store/db.js";
 import { config } from "./config.js";
+import { ModeContext } from "./mode-context.js";
 import { spawn } from "child_process";
 import { readdirSync, statSync, rmSync } from "fs";
 import { join } from "path";
@@ -21,6 +22,7 @@ import { CHAPTERHOUSE_VERSION } from "./version.js";
 import { isWorkiqAutoInstallEnabled, ensureWorkiqMcpEntry } from "./copilot/workiq-installer.js";
 import { MemoryHousekeepingScheduler } from "./memory/housekeeping-scheduler.js";
 const log = logger.child({ module: "daemon" });
+const modeContext = new ModeContext(config);
 let memoryHousekeepingScheduler;
 const SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1000;
 /**
@@ -86,6 +88,9 @@ async function main() {
     if (config.selfEditEnabled) {
         log.warn("Self-edit mode enabled — Chapterhouse can modify his own source code");
     }
+    for (const warning of config.modeCompatibilityWarnings) {
+        log.warn({ mode: config.chapterhouseMode }, warning);
+    }
     // Set up message logging to daemon console
     setMessageLogger((direction, source, text) => {
         const arrow = direction === "in" ? "⟶" : "⟵";
@@ -100,7 +105,7 @@ async function main() {
     if (wikiIsNew) {
         log.info("Created wiki");
     }
-    if (config.chapterhouseMode === "team") {
+    if (modeContext.isTeam()) {
         const seed = seedTeamWiki();
         if (seed.created.length > 0) {
             log.info({ pages: seed.created }, "Seeded team wiki pages");
@@ -153,7 +158,7 @@ async function main() {
     await startApiServer();
     memoryHousekeepingScheduler = new MemoryHousekeepingScheduler();
     memoryHousekeepingScheduler.start();
-    if (config.chapterhouseMode === "personal" && (config.adoPat || config.teamChapterhouseUrl)) {
+    if (modeContext.canLogToAdo() && (config.adoPat || config.teamChapterhouseUrl)) {
         new StandupScheduler().schedule();
     }
     const url = `http://${getDisplayHost(config.apiHost)}:${config.apiPort}`;

package/dist/integrations/team-push.js

@@ -1,4 +1,5 @@
 import { config } from "../config.js";
+import { ModeContext } from "../mode-context.js";
 export class TeamPushClient {
     teamChapterhouseUrl;
     teamChapterhouseToken;
@@ -6,6 +7,7 @@ export class TeamPushClient {
     fetchImpl;
     getAuthorizationHeader;
     getCurrentUser;
+    modeContext;
     constructor(options = {}) {
         this.teamChapterhouseUrl = (options.teamChapterhouseUrl ?? config.teamChapterhouseUrl).trim().replace(/\/+$/, "");
         this.teamChapterhouseToken = (options.teamChapterhouseToken ?? config.teamChapterhouseToken).trim();
@@ -13,6 +15,11 @@ export class TeamPushClient {
         this.fetchImpl = options.fetchImpl ?? fetch;
         this.getAuthorizationHeader = options.getAuthorizationHeader;
         this.getCurrentUser = options.getCurrentUser;
+        this.modeContext = new ModeContext({
+            ...config,
+            teamChapterhouseUrl: this.teamChapterhouseUrl,
+            standaloneMode: this.standaloneMode,
+        });
     }
     async pushUpdate(payload) {
         if (!this.isEnabled()) {
@@ -129,7 +136,7 @@ export class TeamPushClient {
         throw new Error("Failed to push OKR update: no authenticated engineer identity is available");
     }
     isEnabled() {
-        return !this.standaloneMode && this.teamChapterhouseUrl.length > 0;
+        return this.modeContext.canSyncTeamWiki();
     }
 }
 function describeHttpFailure(status) {

package/dist/integrations/teams-notify.js

@@ -1,4 +1,5 @@
 import { config } from "../config.js";
+import { ModeContext } from "../mode-context.js";
 import { childLogger } from "../util/logger.js";
 const log = childLogger("teams-notify");
 export const TEAMS_MILESTONE_THRESHOLDS = [25, 50, 75, 100];
@@ -8,11 +9,17 @@ export class TeamsNotifier {
     enabled;
     fetchImpl;
     warn;
+    modeContext;
     constructor(options = {}) {
         this.webhookUrl = (options.webhookUrl ?? config.teamsWebhookUrl).trim();
         this.enabled = options.enabled ?? config.teamsNotificationsEnabled;
         this.fetchImpl = options.fetchImpl ?? fetch;
         this.warn = options.warn ?? ((message) => log.warn(message));
+        this.modeContext = new ModeContext({
+            ...config,
+            teamsWebhookUrl: this.webhookUrl,
+            teamsNotificationsEnabled: this.enabled,
+        });
     }
     async sendMessage(title, body, color = DEFAULT_COLOR) {
         return await this.postCard({
@@ -61,7 +68,7 @@ export class TeamsNotifier {
         });
     }
     async postCard(card) {
-        if (!this.enabled || this.webhookUrl.length === 0) {
+        if (!this.modeContext.canSyncToTeams()) {
             this.warn("[teams] Teams notifications are disabled or TEAMS_WEBHOOK_URL is empty.");
             return false;
         }