chapterhouse 0.5.0 → 0.5.2

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/system-message.js

@@ -39,7 +39,7 @@ ${hotTierBlock}
 You are a Node.js daemon process built with the Copilot SDK. Here's how you work:
 
 - **Web UI**: Your primary interface. The team talks to you in a browser tab at http://localhost:7788. Messages arrive tagged with \`[via web]\`. Markdown rendering and code blocks are fully supported, so feel free to be detailed when it helps — but stay focused.
-- **Background tasks**: Messages tagged \`[via background]\` are results from agent tasks you delegated. Summarize and relay these to the team.
+- **Background tasks**: Messages tagged \`[via background]\` are results from agent tasks you delegated or system follow-ups. Only summarize background content that has not already been rendered in a separate agent bubble.
 
 When no source tag is present, assume web.
 
@@ -68,7 +68,7 @@ The \`delegate_to_agent\` tool is **non-blocking**. It dispatches the task and r
 1. When you delegate a task, acknowledge it right away. Be natural and brief: "On it — I've asked @coder to handle that." or "Sending this to @designer."
 2. You do NOT wait for the agent to finish. The tool returns immediately.
 3. After delegating, do NOT poll \`get_agent_result\` in a loop. Wait silently for the \`[Agent task completed]\` message to arrive automatically.
-4. When that completion message arrives, call \`get_agent_result\` exactly once for that task, then summarize the result and relay it to the user in a clear, concise way.
+4. When that completion message arrives, call \`get_agent_result\` exactly once for that task, then follow the subagent completion rule below.
 
 You can delegate **multiple tasks simultaneously**. Different agents can work in parallel.
 
@@ -146,7 +146,7 @@ Subagent proposals from \`memory_propose\` are processed automatically at end-of
 2. **Skill-first mindset**: Search skills.sh for existing skills before building from scratch.
 3. For execution tasks, **always** delegate to a specialist agent. You cannot write code, run commands, or read files directly.
 4. **Announce your delegations**: Tell the user which agent you're sending work to and what the task is.
-5. When you receive background results, summarize the key points. Don't relay the entire output verbatim.
+5. **Subagent completion rule**: Subagent replies are already shown to the user in their own bubble. When you receive \`[Agent task completed]\`, your follow-up should be a brief acknowledgment unless you have non-obvious framing or next-step decisions to add. Do NOT restate, paraphrase, or summarize the agent's content. Do NOT re-list files changed, re-state merge SHAs, re-quote the agent's bullet points, or copy the agent's table verbatim.
 6. If asked about status, check agent status and give a consolidated update.
 7. You can delegate to multiple agents simultaneously — use this for parallel work.
 8. When a task is complete, relay the results clearly.

package/dist/copilot/system-message.test.js

@@ -43,6 +43,16 @@ test("orchestrator prompt tells Chapterhouse to wait for agent completion notifi
     assert.match(message, /wait silently for the `\[Agent task completed\]` message/i);
     assert.match(message, /call `get_agent_result` exactly once/i);
 });
+test("orchestrator prompt tells Chapterhouse not to restate already-rendered subagent replies", () => {
+    const message = getOrchestratorSystemMessage();
+    assert.match(message, /Subagent replies are already shown to the user in their own bubble/i);
+    assert.match(message, /brief acknowledgment/i);
+    assert.match(message, /Do NOT restate, paraphrase, or summarize the agent's content/i);
+    assert.match(message, /re-list files changed/i);
+    assert.match(message, /re-state merge SHAs/i);
+    assert.doesNotMatch(message, /When you receive background results, summarize the key points/i);
+    assert.doesNotMatch(message, /summarize the result and relay it to the user/i);
+});
 test("orchestrator prompt expands shorthand paths with the current home directory", () => {
     const message = getOrchestratorSystemMessage();
     assert.match(message, new RegExp(join(homedir(), "dev", "myapp").replace(/[.*+?^${}()|[\]\\]/g, "\\$&")));

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";
@@ -29,8 +30,9 @@ import { TeamsNotifier } from "../integrations/teams-notify.js";
 import { TeamPushClient } from "../integrations/team-push.js";
 import { OKRMapper, parseOKRPageContent } from "./okr-mapper.js";
 import { childLogger } from "../util/logger.js";
-import { getActiveScope as getMemoryActiveScope, 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";
+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.
@@ -66,19 +68,19 @@ function requireOrchestratorMemoryWrite() {
     return null;
 }
 function resolveProposalScopeSlug(requestedScopeSlug) {
-    const agentSlug = agentsModule.getCurrentToolAgentSlug?.();
-    if (!agentSlug || agentSlug === "chapterhouse") {
+    if (requestedScopeSlug) {
         return requestedScopeSlug;
     }
-    const activeScope = getMemoryActiveScope();
-    if (activeScope) {
-        return activeScope.slug;
+    const agentSlug = agentsModule.getCurrentToolAgentSlug?.();
+    if (!agentSlug || agentSlug === "chapterhouse") {
+        return getMemoryActiveScope()?.slug;
     }
     const agent = getAgent(agentSlug);
-    if (agent?.persistent && agent.scope) {
-        return agent.scope;
+    const boundScope = agent?.scope ?? loadAgents().find((entry) => entry.slug === agentSlug)?.scope;
+    if (boundScope && getMemoryScope(boundScope)) {
+        return boundScope;
     }
-    return requestedScopeSlug;
+    return getMemoryActiveScope()?.slug;
 }
 function resolveMemoryScopeForWrite(explicitScope, content) {
     const explicit = explicitScope ? getMemoryScope(explicitScope) : undefined;
@@ -138,11 +140,28 @@ const entityProposalPayloadSchema = z.object({
     summary: value.summary,
 }));
 const actionItemProposalPayloadSchema = z.object({
-    title: z.string(),
+    title: z.string().trim().min(1, "title is required for action_item proposals."),
     detail: z.string().optional(),
     due_at: z.string().optional(),
     source: z.string().optional(),
     entity_id: z.number().int().positive().optional(),
+    entity_name: z.string().trim().min(1, "entity_name must be non-empty when provided.").optional(),
+    entity_kind: z.string().trim().min(1, "entity_kind must be non-empty when provided.").optional(),
+}).superRefine((value, context) => {
+    if ((value.entity_name && !value.entity_kind) || (!value.entity_name && value.entity_kind)) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "entity_name and entity_kind must be provided together for action_item proposals.",
+            path: ["entity_name"],
+        });
+    }
+    if (value.entity_id !== undefined && value.entity_name) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "Provide either entity_id or entity_name/entity_kind for action_item proposals, not both.",
+            path: ["entity_id"],
+        });
+    }
 });
 const memoryProposeArgsSchema = z.object({
     kind: z.enum(["observation", "decision", "entity", "action_item"]),
@@ -519,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();
@@ -967,6 +986,54 @@ export function createTools(deps) {
                 }
             },
         }),
+        defineTool("memory_create_scope", {
+            description: "Create a new user-defined memory scope. Slugs must be unique kebab-case; baseline installs only include global and chapterhouse.",
+            parameters: z.object({
+                slug: z.string()
+                    .trim()
+                    .regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "slug must be unique kebab-case"),
+                title: z.string().trim().min(1, "title is required"),
+                description: z.string().optional(),
+            }),
+            handler: async (args) => {
+                const denied = requireOrchestratorMemoryWrite();
+                if (denied)
+                    return denied;
+                const parsed = z.object({
+                    slug: z.string()
+                        .trim()
+                        .regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "slug must be unique kebab-case"),
+                    title: z.string().trim().min(1, "title is required"),
+                    description: z.string().optional(),
+                }).safeParse(args);
+                if (!parsed.success) {
+                    return parsed.error.issues.map((issue) => issue.message).join("; ");
+                }
+                try {
+                    if (getMemoryScope(parsed.data.slug)) {
+                        return `Memory scope '${parsed.data.slug}' already exists.`;
+                    }
+                    const scope = createMemoryScope({
+                        slug: parsed.data.slug,
+                        title: parsed.data.title,
+                        description: parsed.data.description ?? "",
+                        keywords: [parsed.data.slug],
+                    });
+                    return {
+                        ok: true,
+                        scope: {
+                            slug: scope.slug,
+                            title: scope.title,
+                            description: scope.description,
+                            active: scope.active,
+                        },
+                    };
+                }
+                catch (err) {
+                    return err instanceof Error ? err.message : String(err);
+                }
+            },
+        }),
         defineTool("memory_add_action_item", {
             description: "Add a scoped memory action item/reminder. Orchestrator-only write tool for follow-ups and proactive reminders.",
             parameters: z.object({
@@ -1181,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/copilot/tools.memory.test.js

@@ -85,6 +85,7 @@ test("memory tools remember, recall, set scope, and enforce orchestrator-only wr
     const memoryRemember = findTool(tools, "memory_remember");
     const memoryRecall = findTool(tools, "memory_recall");
     const memorySetScope = findTool(tools, "memory_set_scope");
+    const memoryCreateScope = findTool(tools, "memory_create_scope");
     const bindToolsToAgent = agentsModule.bindToolsToAgent;
     assert.equal(typeof bindToolsToAgent, "function", "bindToolsToAgent should be exported");
     const chapterhouseTools = bindToolsToAgent("chapterhouse", tools);
@@ -121,6 +122,30 @@ test("memory tools remember, recall, set scope, and enforce orchestrator-only wr
     assert.equal((recalled.hits ?? []).some((hit) => hit.id === row.id), true);
     const scopeResult = await chapterhouseSetScope.handler({ slug: "chapterhouse" }, {});
     assert.equal(scopeResult.active_scope?.slug, "chapterhouse");
+    const createdScope = await memoryCreateScope.handler({
+        slug: "docs-site",
+        title: "Docs Site",
+        description: "Documentation publishing and content workflows",
+    }, {});
+    assert.deepEqual(createdScope, {
+        ok: true,
+        scope: {
+            slug: "docs-site",
+            title: "Docs Site",
+            description: "Documentation publishing and content workflows",
+            active: true,
+        },
+    });
+    const duplicateScope = await memoryCreateScope.handler({
+        slug: "docs-site",
+        title: "Docs Site Again",
+    }, {});
+    assert.match(String(duplicateScope), /already exists/i);
+    const invalidScope = await memoryCreateScope.handler({
+        slug: "Docs Site",
+        title: "Docs Site",
+    }, {});
+    assert.match(String(invalidScope), /kebab-case/i);
     const implicitScopeRemember = await chapterhouseRemember.handler({
         content: "Implicit active-scope writes should route to chapterhouse.",
         kind: "observation",
@@ -151,7 +176,7 @@ test("memory tools remember, recall, set scope, and enforce orchestrator-only wr
     }, {});
     assert.equal(typeof coderRecalled, "object");
     assert.equal((coderRecalled.hits ?? []).some((hit) => hit.id === row.id), true);
-    assert.ok(memoryRemember && memoryRecall && memorySetScope);
+    assert.ok(memoryRemember && memoryRecall && memorySetScope && memoryCreateScope);
 });
 test("memory_propose queues pending proposals, defaults scope from the active scope, and captures delegated task context", async () => {
     const { toolsModule, agentsModule, dbModule } = await loadModules();
@@ -195,11 +220,10 @@ test("memory_propose queues pending proposals, defaults scope from the active sc
     assert.equal(payload.reason, "The user explicitly asked for the new proposal path.");
     assert.equal(payload.payload.content, "Subagents can queue durable observations for orchestrator review.");
 });
-test("memory_propose from a persistent agent is bound to that agent's scope", async () => {
+test("memory_propose from a persistent agent honors an explicit scope_slug", async () => {
     const home = process.env.CHAPTERHOUSE_HOME;
     assert.ok(home, "test home should be set");
-    const chapterhouseHome = home.endsWith(".chapterhouse") ? home : join(home, ".chapterhouse");
-    const agentsDir = join(chapterhouseHome, "agents");
+    const { AGENTS_DIR: agentsDir } = await import("../paths.js");
     mkdirSync(agentsDir, { recursive: true });
     writeFileSync(join(agentsDir, "bellonda.agent.md"), [
         "---",
@@ -228,7 +252,7 @@ test("memory_propose from a persistent agent is bound to that agent's scope", as
         kind: "observation",
         scope_slug: "chapterhouse",
         payload: {
-            content: "Persistent agents should not be able to write proposals outside their bound scope.",
+            content: "Persistent agents can explicitly route proposals to another scope when needed.",
         },
     }, {}));
     assert.equal(proposed.status, "queued");
@@ -241,7 +265,51 @@ test("memory_propose from a persistent agent is bound to that agent's scope", as
     assert.equal(row.source_agent, "bellonda");
     assert.equal(row.source_task_id, "task-persistent-scope-001");
     const payload = JSON.parse(row.payload);
-    assert.equal(payload.scope_slug, "infra");
+    assert.equal(payload.scope_slug, "chapterhouse");
+});
+test("memory_propose ignores a missing subagent bound scope and falls back to the active scope", async () => {
+    const home = process.env.CHAPTERHOUSE_HOME;
+    assert.ok(home, "test home should be set");
+    const { AGENTS_DIR: agentsDir } = await import("../paths.js");
+    mkdirSync(agentsDir, { recursive: true });
+    writeFileSync(join(agentsDir, "hwi.agent.md"), [
+        "---",
+        "name: Hwi",
+        "description: Mentat of Brian's personal scope",
+        "model: claude-sonnet-4.6",
+        "persistent: true",
+        "scope: brian",
+        "---",
+        "",
+        "You are Hwi.",
+    ].join("\n"));
+    const { toolsModule, agentsModule, dbModule } = await loadModules();
+    agentsModule.loadAgents();
+    const tools = toolsModule.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+    });
+    const bindToolsToAgent = agentsModule.bindToolsToAgent;
+    assert.equal(typeof bindToolsToAgent, "function", "bindToolsToAgent should be exported");
+    const chapterhouseTools = bindToolsToAgent("chapterhouse", tools);
+    const hwiTools = bindToolsToAgent("hwi", tools, "task-hwi-action-item");
+    await findTool(chapterhouseTools, "memory_set_scope").handler({ slug: "chapterhouse" }, {});
+    const proposed = await findTool(hwiTools, "memory_propose").handler({
+        kind: "action_item",
+        payload: {
+            title: "Follow up with Brian",
+        },
+    }, {});
+    assert.equal(proposed.status, "queued");
+    const row = dbModule.getDb().prepare(`
+    SELECT source_agent, payload
+    FROM mem_inbox
+    WHERE id = ?
+  `).get(proposed.proposal_id);
+    assert.ok(row, "memory_propose should insert a mem_inbox row");
+    assert.equal(row.source_agent, "hwi");
+    const payload = JSON.parse(row.payload);
+    assert.equal(payload.scope_slug, "chapterhouse");
 });
 test("memory_propose accepts entity proposals with entity_kind and queues the full payload", async () => {
     const { toolsModule, agentsModule, dbModule } = await loadModules();
@@ -367,6 +435,26 @@ test("memory_propose accepts action_item proposals with a resolvable payload sha
     assert.equal(payload.payload.title, "Remind infra about high disk usage");
     assert.equal(payload.payload.detail, "Next time disk exceeds 85%, notify Bellonda.");
 });
+test("memory_propose rejects action_item proposals with blank titles before queuing", async () => {
+    const { toolsModule, dbModule } = await loadModules();
+    const tools = toolsModule.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+    });
+    const memoryPropose = findTool(tools, "memory_propose");
+    const result = await memoryPropose.handler({
+        kind: "action_item",
+        payload: {
+            title: "   ",
+        },
+    }, {});
+    assert.match(String(result), /title/i);
+    const queued = dbModule.getDb().prepare(`
+    SELECT COUNT(*) AS count
+    FROM mem_inbox
+  `).get();
+    assert.equal(queued.count, 0);
+});
 test("memory_propose rejects invalid proposal kinds", async () => {
     const { toolsModule } = await loadModules();
     const tools = toolsModule.createTools({

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;
         }

package/dist/memory/active-scope.test.js

@@ -38,11 +38,16 @@ test("active scope can be set, read, and cleared without changing scope activati
     const getActiveScope = getFunction(memoryModule, "getActiveScope");
     const setActiveScope = getFunction(memoryModule, "setActiveScope");
     const deactivateScope = getFunction(memoryModule, "deactivateScope");
+    const createScope = getFunction(memoryModule, "createScope");
     assert.equal(getActiveScope(), null);
     assert.equal(setActiveScope("chapterhouse")?.slug, "chapterhouse");
     assert.equal(getActiveScope()?.slug, "chapterhouse");
-    const team = getScope("team");
-    assert.ok(team);
+    const team = createScope({
+        slug: "team",
+        title: "Team",
+        description: "Team test scope",
+        keywords: ["team"],
+    });
     const deactivated = deactivateScope(team.id);
     assert.equal(deactivated.active, false);
     assert.equal(getActiveScope()?.slug, "chapterhouse");