chapterhouse 0.5.0 → 0.5.1

package/dist/api/server.js

@@ -32,6 +32,7 @@ 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");
 void searchIndex; // re-exported by index-manager; reference here documents the dep
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -81,6 +82,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" }),
@@ -892,6 +899,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);

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/copilot/orchestrator.js

@@ -359,6 +359,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 +457,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 +518,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 +554,7 @@ async function createOrResumeSession(sessionKey, projectRoot) {
                 configDir: SESSIONS_DIR,
                 streaming: true,
                 systemMessage: { content: systemMessageContent },
+                hooks: memoryHooks,
                 tools,
                 mcpServers,
                 skillDirectories,
@@ -568,6 +581,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/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

@@ -29,7 +29,7 @@ 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");
 /** Escape a string for safe inclusion as a single-line YAML scalar value. */
 function yamlEscape(value) {
@@ -66,19 +66,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 +138,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"]),
@@ -967,6 +984,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({

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/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");

package/dist/memory/eot.js

@@ -1,4 +1,5 @@
 import { config } from "../config.js";
+import { getAgent, loadAgents } from "../copilot/agents.js";
 import { runOneShotPrompt } from "../copilot/oneshot.js";
 import { childLogger } from "../util/logger.js";
 import { recordDecision } from "./decisions.js";
@@ -6,6 +7,7 @@ import { upsertEntity } from "./entities.js";
 import { listPendingMemoryProposalsForTask, resolveInboxItem } from "./inbox.js";
 import { recordObservation } from "./observations.js";
 import { recordActionItem } from "./action-items.js";
+import { getActiveScope } from "./active-scope.js";
 import { getScope } from "./scopes.js";
 const log = childLogger("memory.eot");
 function isEndOfTaskHookEnabled() {
@@ -119,7 +121,75 @@ function parseReviewerResponse(raw) {
             : [],
     };
 }
-function rememberAcceptedMemory(kind, scopeSlug, payload, source, confidence) {
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function isIsoTimestamp(value) {
+    return !Number.isNaN(Date.parse(value));
+}
+function validateActionItemPayload(payload) {
+    const actionItem = payload;
+    if (!isNonEmptyString(actionItem.title)) {
+        throw new Error("Action item proposal payload requires a non-empty title.");
+    }
+    if (actionItem.detail !== undefined && typeof actionItem.detail !== "string") {
+        throw new Error("Action item proposal payload detail must be a string.");
+    }
+    if (actionItem.due_at !== undefined && (typeof actionItem.due_at !== "string" || !isIsoTimestamp(actionItem.due_at))) {
+        throw new Error("Action item proposal payload due_at must be an ISO timestamp.");
+    }
+    if (actionItem.entity_id !== undefined && (!Number.isInteger(actionItem.entity_id) || actionItem.entity_id <= 0)) {
+        throw new Error("Action item proposal payload entity_id must be a positive integer.");
+    }
+    if (actionItem.entity_id !== undefined && actionItem.entity_name !== undefined) {
+        throw new Error("Action item proposal payload must provide either entity_id or entity_name/entity_kind, not both.");
+    }
+    const hasEntityName = actionItem.entity_name !== undefined;
+    const hasEntityKind = actionItem.entity_kind !== undefined;
+    if (hasEntityName !== hasEntityKind) {
+        throw new Error("Action item proposal payload entity_name and entity_kind must be provided together.");
+    }
+    if (hasEntityName && !isNonEmptyString(actionItem.entity_name)) {
+        throw new Error("Action item proposal payload entity_name must be non-empty when provided.");
+    }
+    if (hasEntityKind && !isNonEmptyString(actionItem.entity_kind)) {
+        throw new Error("Action item proposal payload entity_kind must be non-empty when provided.");
+    }
+    return {
+        title: actionItem.title.trim(),
+        detail: actionItem.detail,
+        due_at: actionItem.due_at,
+        source: actionItem.source,
+        entity_id: actionItem.entity_id,
+        entity_name: actionItem.entity_name?.trim(),
+        entity_kind: actionItem.entity_kind?.trim(),
+    };
+}
+function getBoundScopeSlug(sourceAgent) {
+    const agent = getAgent(sourceAgent);
+    return agent?.scope ?? loadAgents().find((entry) => entry.slug === sourceAgent)?.scope;
+}
+function resolveAcceptedProposalScopeSlug(envelope, proposal) {
+    if (isNonEmptyString(envelope.scope_slug)) {
+        return envelope.scope_slug.trim();
+    }
+    const boundScope = getBoundScopeSlug(proposal.sourceAgent);
+    if (boundScope) {
+        return boundScope;
+    }
+    const activeScope = getActiveScope();
+    if (activeScope) {
+        return activeScope.slug;
+    }
+    if (proposal.scopeId) {
+        const queuedScope = getScope(proposal.scopeId);
+        if (queuedScope) {
+            return queuedScope.slug;
+        }
+    }
+    throw new Error("No memory scope could be resolved for this proposal.");
+}
+function rememberAcceptedMemory(kind, scopeSlug, payload, source, confidence, sourceAgent) {
     const scope = getScope(scopeSlug);
     if (!scope) {
         throw new Error(`Unknown memory scope '${scopeSlug}'.`);
@@ -146,14 +216,22 @@ function rememberAcceptedMemory(kind, scopeSlug, payload, source, confidence) {
         return;
     }
     if (kind === "action_item") {
-        const actionItem = payload;
+        const actionItem = validateActionItemPayload(payload);
+        const entity = actionItem.entity_name && actionItem.entity_kind
+            ? upsertEntity({
+                scope_id: scope.id,
+                kind: actionItem.entity_kind,
+                name: actionItem.entity_name,
+                confidence,
+            })
+            : undefined;
         recordActionItem({
             scope_id: scope.id,
-            entity_id: actionItem.entity_id,
+            entity_id: entity?.id ?? actionItem.entity_id,
             title: actionItem.title,
             detail: actionItem.detail,
             due_at: actionItem.due_at,
-            source: actionItem.source ?? source,
+            source: sourceAgent ? `subagent_proposal:${sourceAgent}` : actionItem.source ?? source,
         });
         return;
     }
@@ -209,11 +287,21 @@ export async function runEndOfTaskMemoryHook(input) {
         }
         reviewedProposalIds.add(proposal.id);
         if (decision.decision === "accept") {
-            summary.accepted++;
-            if (autoAcceptEnabled) {
+            if (!autoAcceptEnabled) {
+                summary.accepted++;
+            }
+            else {
                 const envelope = parseEnvelope(proposal.payload);
-                rememberAcceptedMemory(envelope.kind, envelope.scope_slug ?? getScope(proposal.scopeId).slug, envelope.payload, `agent:${proposal.sourceAgent}`, envelope.confidence);
-                resolveInboxItem(proposal.id, "accepted", decision.reason);
+                try {
+                    rememberAcceptedMemory(envelope.kind, resolveAcceptedProposalScopeSlug(envelope, proposal), envelope.payload, `agent:${proposal.sourceAgent}`, envelope.confidence, proposal.sourceAgent);
+                    resolveInboxItem(proposal.id, "accepted", decision.reason);
+                    summary.accepted++;
+                }
+                catch (err) {
+                    const reason = err instanceof Error ? err.message : String(err);
+                    resolveInboxItem(proposal.id, "rejected", reason);
+                    summary.rejected++;
+                }
             }
             continue;
         }

package/dist/memory/eot.test.js

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { mkdirSync, rmSync } from "node:fs";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import test from "node:test";
 const repoRoot = process.cwd();
@@ -15,7 +15,8 @@ async function loadModules(cacheBust = `${Date.now()}-${Math.random()}`) {
     const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
     const memoryModule = await import(new URL(`./index.js?case=${cacheBust}`, import.meta.url).href);
     const eotModule = await import(new URL(`./eot.js?case=${cacheBust}`, import.meta.url).href);
-    return { dbModule, memoryModule, eotModule };
+    const agentsModule = await import(new URL(`../copilot/agents.js?case=${cacheBust}`, import.meta.url).href);
+    return { dbModule, memoryModule, eotModule, agentsModule };
 }
 function getFunction(module, name) {
     const value = module[name];
@@ -171,7 +172,6 @@ test("runEndOfTaskMemoryHook accepts action_item proposals into mem_action_items
         payload: {
             title: "Migrate feature ideas",
             detail: "Move feature-ideas.md into mem_action_items.",
-            source: "subagent_proposal",
         },
         confidence: 0.9,
     }));
@@ -189,11 +189,192 @@ test("runEndOfTaskMemoryHook accepts action_item proposals into mem_action_items
         }),
     });
     const actionItems = listActionItems({ scope_id: chapterhouse.id });
-    assert.equal(actionItems.some((item) => item.title === "Migrate feature ideas"
-        && item.detail === "Move feature-ideas.md into mem_action_items."), true);
+    const actionItem = actionItems.find((item) => item.title === "Migrate feature ideas");
+    assert.ok(actionItem);
+    assert.equal(actionItem.detail, "Move feature-ideas.md into mem_action_items.");
+    assert.equal(actionItem.status, "open");
+    assert.equal(actionItem.source, "subagent_proposal:coder");
     const inbox = db.prepare(`SELECT status FROM mem_inbox WHERE id = ?`).get(Number(inserted.lastInsertRowid));
     assert.equal(inbox.status, "accepted");
 });
+test("runEndOfTaskMemoryHook rejects invalid action_item proposals with a clear reason", async () => {
+    const { dbModule, memoryModule, eotModule } = await loadModules("action-item-invalid");
+    const db = dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const createScope = getFunction(memoryModule, "createScope");
+    const listActionItems = getFunction(memoryModule, "listActionItems");
+    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse);
+    const inserted = db.prepare(`
+    INSERT INTO mem_inbox (scope_id, kind, payload, source_agent, source_task_id, status)
+    VALUES (?, 'memory_proposal', ?, 'coder', 'task-eot-action-item-invalid', 'pending')
+  `).run(chapterhouse.id, JSON.stringify({
+        kind: "action_item",
+        payload: {
+            detail: "A title is required before this can become an action item.",
+        },
+        confidence: 0.9,
+    }));
+    await runEndOfTaskMemoryHook({
+        taskId: "task-eot-action-item-invalid",
+        finalResult: "Completed and proposed a malformed follow-up.",
+        copilotClient: {},
+        callLLM: async () => JSON.stringify({
+            decisions: [{
+                    proposal_id: Number(inserted.lastInsertRowid),
+                    decision: "accept",
+                    reason: "Concrete follow-up.",
+                }],
+            implicit_memories: [],
+        }),
+    });
+    assert.deepEqual(listActionItems({ scope_id: chapterhouse.id }), []);
+    const inbox = db.prepare(`
+    SELECT status, resolution_reason, resolved_at
+    FROM mem_inbox
+    WHERE id = ?
+  `).get(Number(inserted.lastInsertRowid));
+    assert.equal(inbox.status, "rejected");
+    assert.match(inbox.resolution_reason ?? "", /title/i);
+    assert.ok(inbox.resolved_at);
+});
+test("runEndOfTaskMemoryHook rejects action_item proposals with ambiguous entity references", async () => {
+    const { dbModule, memoryModule, eotModule } = await loadModules("action-item-ambiguous-entity");
+    const db = dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const createScope = getFunction(memoryModule, "createScope");
+    const listActionItems = getFunction(memoryModule, "listActionItems");
+    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse);
+    const inserted = db.prepare(`
+    INSERT INTO mem_inbox (scope_id, kind, payload, source_agent, source_task_id, status)
+    VALUES (?, 'memory_proposal', ?, 'coder', 'task-eot-action-item-ambiguous-entity', 'pending')
+  `).run(chapterhouse.id, JSON.stringify({
+        kind: "action_item",
+        payload: {
+            title: "Resolve ambiguous entity link",
+            entity_id: 1,
+            entity_name: "Bellonda",
+            entity_kind: "agent",
+        },
+        confidence: 0.9,
+    }));
+    await runEndOfTaskMemoryHook({
+        taskId: "task-eot-action-item-ambiguous-entity",
+        finalResult: "Completed and proposed an ambiguous follow-up.",
+        copilotClient: {},
+        callLLM: async () => JSON.stringify({
+            decisions: [{
+                    proposal_id: Number(inserted.lastInsertRowid),
+                    decision: "accept",
+                    reason: "Concrete follow-up.",
+                }],
+            implicit_memories: [],
+        }),
+    });
+    assert.deepEqual(listActionItems({ scope_id: chapterhouse.id }), []);
+    const inbox = db.prepare(`
+    SELECT status, resolution_reason
+    FROM mem_inbox
+    WHERE id = ?
+  `).get(Number(inserted.lastInsertRowid));
+    assert.equal(inbox.status, "rejected");
+    assert.match(inbox.resolution_reason ?? "", /entity_id.*entity_name|entity_name.*entity_id/i);
+});
+test("runEndOfTaskMemoryHook falls back to the source agent bound scope for action_item proposals without scope_slug", 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, "bellonda.agent.md"), [
+        "---",
+        "name: Bellonda",
+        "description: Mentat of the infrastructure domain",
+        "model: claude-sonnet-4.6",
+        "persistent: true",
+        "scope: infra",
+        "---",
+        "",
+        "You are Bellonda.",
+    ].join("\n"));
+    const { dbModule, memoryModule, eotModule, agentsModule } = await loadModules("action-item-bound-scope");
+    agentsModule.loadAgents();
+    const db = dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const createScope = getFunction(memoryModule, "createScope");
+    const listActionItems = getFunction(memoryModule, "listActionItems");
+    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
+    const chapterhouse = getScope("chapterhouse");
+    const infra = createScope({
+        slug: "infra",
+        title: "Infra",
+        description: "Infra test scope",
+        keywords: ["infra"],
+    });
+    assert.ok(chapterhouse);
+    const inserted = db.prepare(`
+    INSERT INTO mem_inbox (scope_id, kind, payload, source_agent, source_task_id, status)
+    VALUES (?, 'memory_proposal', ?, 'bellonda', 'task-eot-action-item-bound-scope', 'pending')
+  `).run(chapterhouse.id, JSON.stringify({
+        kind: "action_item",
+        payload: {
+            title: "Review NAS disk alerts",
+        },
+        confidence: 0.9,
+    }));
+    await runEndOfTaskMemoryHook({
+        taskId: "task-eot-action-item-bound-scope",
+        finalResult: "Bellonda proposed an infra follow-up.",
+        copilotClient: {},
+        callLLM: async () => JSON.stringify({
+            decisions: [{
+                    proposal_id: Number(inserted.lastInsertRowid),
+                    decision: "accept",
+                    reason: "Concrete infra follow-up.",
+                }],
+            implicit_memories: [],
+        }),
+    });
+    assert.equal(listActionItems({ scope_id: infra.id }).some((item) => item.title === "Review NAS disk alerts"), true);
+    assert.equal(listActionItems({ scope_id: chapterhouse.id }).some((item) => item.title === "Review NAS disk alerts"), false);
+});
+test("runEndOfTaskMemoryHook still accepts observation, decision, and entity proposals", async () => {
+    const { dbModule, memoryModule, eotModule } = await loadModules("existing-proposal-kinds");
+    const db = dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const listObservations = getFunction(memoryModule, "listObservations");
+    const listDecisions = getFunction(memoryModule, "listDecisions");
+    const listEntities = getFunction(memoryModule, "listEntities");
+    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse);
+    const proposals = [
+        { kind: "observation", payload: { content: "Existing observation proposals still persist." } },
+        { kind: "decision", payload: { title: "Keep auto-accept", rationale: "It is required for EOT memory promotion." } },
+        { kind: "entity", payload: { name: "Bellonda", entity_kind: "agent", summary: "Infrastructure mentat." } },
+    ].map((envelope) => db.prepare(`
+    INSERT INTO mem_inbox (scope_id, kind, payload, source_agent, source_task_id, status)
+    VALUES (?, 'memory_proposal', ?, 'coder', 'task-eot-existing-kinds', 'pending')
+  `).run(chapterhouse.id, JSON.stringify(envelope)));
+    await runEndOfTaskMemoryHook({
+        taskId: "task-eot-existing-kinds",
+        finalResult: "Completed with several proposal kinds.",
+        copilotClient: {},
+        callLLM: async () => JSON.stringify({
+            decisions: proposals.map((proposal) => ({
+                proposal_id: Number(proposal.lastInsertRowid),
+                decision: "accept",
+                reason: "Valid durable memory.",
+            })),
+            implicit_memories: [],
+        }),
+    });
+    assert.equal(listObservations({ scope_id: chapterhouse.id }).some((row) => row.content === "Existing observation proposals still persist."), true);
+    assert.equal(listDecisions({ scope_id: chapterhouse.id }).some((row) => row.title === "Keep auto-accept" && row.rationale === "It is required for EOT memory promotion."), true);
+    assert.equal(listEntities({ scope_id: chapterhouse.id, kind: "agent" }).some((row) => row.name === "Bellonda"), true);
+});
 test("runEndOfTaskMemoryHook accepts entity proposals with entity_kind into mem_entities", async () => {
     const { dbModule, memoryModule, eotModule } = await loadModules("entity-accept");
     const db = dbModule.getDb();

package/dist/memory/hot-tier.test.js

@@ -108,12 +108,17 @@ test("active-scope hot-tier queries do not leak rows from other scopes", async (
     const { dbModule, memoryModule, hotTierModule } = await loadModules();
     dbModule.getDb();
     const getScope = getFunction(memoryModule, "getScope");
+    const createScope = getFunction(memoryModule, "createScope");
     const setActiveScope = getFunction(memoryModule, "setActiveScope");
     const recordObservation = getFunction(memoryModule, "recordObservation");
     const chapterhouse = getScope("chapterhouse");
-    const team = getScope("team");
+    const team = createScope({
+        slug: "team",
+        title: "Team",
+        description: "Team test scope",
+        keywords: ["team"],
+    });
     assert.ok(chapterhouse);
-    assert.ok(team);
     recordObservation({
         scope_id: chapterhouse.id,
         content: "Chapterhouse hot entry",
@@ -135,11 +140,16 @@ test("renderHotTierXML includes open active-scope action items in a bounded acti
     const { dbModule, memoryModule, hotTierModule } = await loadModules();
     dbModule.getDb();
     const getScope = getFunction(memoryModule, "getScope");
+    const createScope = getFunction(memoryModule, "createScope");
     const recordActionItem = getFunction(memoryModule, "recordActionItem");
     const chapterhouse = getScope("chapterhouse");
-    const team = getScope("team");
+    const team = createScope({
+        slug: "team",
+        title: "Team",
+        description: "Team test scope",
+        keywords: ["team"],
+    });
     assert.ok(chapterhouse);
-    assert.ok(team);
     const urgent = recordActionItem({
         scope_id: chapterhouse.id,
         title: "Migrate <feature ideas>",

package/dist/memory/housekeeping.test.js

@@ -24,6 +24,15 @@ function getFunction(module, name) {
     assert.equal(typeof value, "function", `expected ${name} to be exported`);
     return value;
 }
+function createTestScope(memoryModule, slug) {
+    const createScope = getFunction(memoryModule, "createScope");
+    return createScope({
+        slug,
+        title: slug.split("-").map((part) => part[0]?.toUpperCase() + part.slice(1)).join(" "),
+        description: `${slug} test scope`,
+        keywords: [slug],
+    });
+}
 test.beforeEach(async () => {
     const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
     dbModule.closeDb();
@@ -42,8 +51,8 @@ test("dedupObservationsPass supersedes similar observations in scope determinist
     const getScope = getFunction(memoryModule, "getScope");
     const recordObservation = getFunction(memoryModule, "recordObservation");
     const chapterhouse = getScope("chapterhouse");
-    const team = getScope("team");
-    assert.ok(chapterhouse && team);
+    const team = createTestScope(memoryModule, "team");
+    assert.ok(chapterhouse);
     const first = recordObservation({
         scope_id: team.id,
         content: "The worker event stream uses server sent events for live task output.",
@@ -88,9 +97,8 @@ test("dedupDecisionsPass supersedes similar active decisions within scope and ke
     const getScope = getFunction(memoryModule, "getScope");
     const upsertEntity = getFunction(memoryModule, "upsertEntity");
     const recordDecision = getFunction(memoryModule, "recordDecision");
-    const team = getScope("team");
-    const infra = getScope("infra");
-    assert.ok(team && infra);
+    const team = createTestScope(memoryModule, "team");
+    const infra = createTestScope(memoryModule, "infra");
     const api = upsertEntity({ scope_id: team.id, kind: "component", name: "api" });
     const web = upsertEntity({ scope_id: team.id, kind: "component", name: "web" });
     const oldDecision = recordDecision({
@@ -139,8 +147,8 @@ test("orphanCleanupPass clears missing observation entity references without tou
     const upsertEntity = getFunction(memoryModule, "upsertEntity");
     const recordObservation = getFunction(memoryModule, "recordObservation");
     const chapterhouse = getScope("chapterhouse");
-    const team = getScope("team");
-    assert.ok(chapterhouse && team);
+    const team = createTestScope(memoryModule, "team");
+    assert.ok(chapterhouse);
     const entity = upsertEntity({ scope_id: chapterhouse.id, kind: "tool", name: "sqlite" });
     const valid = recordObservation({ scope_id: chapterhouse.id, entity_id: entity.id, content: "Valid entity reference", source: "test" });
     const orphan = recordObservation({ scope_id: chapterhouse.id, content: "Will become orphaned", source: "test" });
@@ -164,8 +172,8 @@ test("decayPass archives old low-confidence observations only in scope and compa
     const getScope = getFunction(memoryModule, "getScope");
     const recordObservation = getFunction(memoryModule, "recordObservation");
     const chapterhouse = getScope("chapterhouse");
-    const team = getScope("team");
-    assert.ok(chapterhouse && team);
+    const team = createTestScope(memoryModule, "team");
+    assert.ok(chapterhouse);
     const archiveMe = recordObservation({ scope_id: chapterhouse.id, content: "Old low confidence", source: "test", confidence: 0.2 });
     const highConfidence = recordObservation({ scope_id: chapterhouse.id, content: "Old high confidence", source: "test", confidence: 0.9 });
     const fresh = recordObservation({ scope_id: chapterhouse.id, content: "Fresh low confidence", source: "test", confidence: 0.2 });
@@ -201,8 +209,8 @@ test("runHousekeeping defaults to the active scope and can target all active sco
     const setActiveScope = getFunction(memoryModule, "setActiveScope");
     const recordObservation = getFunction(memoryModule, "recordObservation");
     const chapterhouse = getScope("chapterhouse");
-    const team = getScope("team");
-    assert.ok(chapterhouse && team);
+    const team = createTestScope(memoryModule, "team");
+    assert.ok(chapterhouse);
     const chapterhouseOld = recordObservation({ scope_id: chapterhouse.id, content: "Chapterhouse old low", source: "test", confidence: 0.1 });
     const teamOld = recordObservation({ scope_id: team.id, content: "Team old low", source: "test", confidence: 0.1 });
     db.prepare(`UPDATE mem_observations SET created_at = datetime('now', '-31 days') WHERE id IN (?, ?)`).run(chapterhouseOld.id, teamOld.id);
@@ -225,8 +233,7 @@ test("tieringPass promotes and demotes rows from lifecycle signals and is idempo
     const upsertEntity = getFunction(memoryModule, "upsertEntity");
     const recordObservation = getFunction(memoryModule, "recordObservation");
     const recordDecision = getFunction(memoryModule, "recordDecision");
-    const team = getScope("team");
-    assert.ok(team);
+    const team = createTestScope(memoryModule, "team");
     const entity = upsertEntity({ scope_id: team.id, kind: "component", name: "memory", tier: "warm" });
     const referencedObservation = recordObservation({
         scope_id: team.id,

package/dist/memory/scopes.test.js

@@ -68,13 +68,6 @@ test("getDb seeds canonical memory scopes on first run", async () => {
       ORDER BY slug
     `).all();
         assert.deepEqual(rows, [
-            {
-                slug: "brian",
-                title: "Brian",
-                description: "Brian's preferences, context, working style",
-                keywords: JSON.stringify(["brian"]),
-                active: 1,
-            },
             {
                 slug: "chapterhouse",
                 title: "Chapterhouse",
@@ -89,20 +82,6 @@ test("getDb seeds canonical memory scopes on first run", async () => {
                 keywords: JSON.stringify(["everywhere", "general"]),
                 active: 1,
             },
-            {
-                slug: "infra",
-                title: "Infra",
-                description: "Infrastructure, hosting, deployment, CI/CD",
-                keywords: JSON.stringify(["infra"]),
-                active: 1,
-            },
-            {
-                slug: "team",
-                title: "Team",
-                description: "Team processes, rituals, OKRs",
-                keywords: JSON.stringify(["team"]),
-                active: 1,
-            },
         ]);
     }
     finally {
@@ -123,11 +102,8 @@ test("memory schema initialization is idempotent", async () => {
       ORDER BY slug
     `).all();
         assert.deepEqual(counts, [
-            { slug: "brian", count: 1 },
             { slug: "chapterhouse", count: 1 },
             { slug: "global", count: 1 },
-            { slug: "infra", count: 1 },
-            { slug: "team", count: 1 },
         ]);
         reopened.dbModule.closeDb();
     }

package/dist/store/db.js

@@ -216,24 +216,6 @@ const MEMORY_SCOPE_SEEDS = [
         description: "Chapterhouse codebase, conventions, decisions, gotchas",
         keywords: ["chapterhouse", "this repo", "this project", "the daemon"],
     },
-    {
-        slug: "infra",
-        title: "Infra",
-        description: "Infrastructure, hosting, deployment, CI/CD",
-        keywords: ["infra"],
-    },
-    {
-        slug: "team",
-        title: "Team",
-        description: "Team processes, rituals, OKRs",
-        keywords: ["team"],
-    },
-    {
-        slug: "brian",
-        title: "Brian",
-        description: "Brian's preferences, context, working style",
-        keywords: ["brian"],
-    },
 ];
 const CHAPTERHOUSE_WIKI_INDEX_SOURCE = "wiki:pages/projects/chapterhouse/index.md";
 const CHAPTERHOUSE_WIKI_HOT_TIER_REASON = "P6 PR1 wiki migration hot-tier candidate";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chapterhouse",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "Chapterhouse — a team-level AI assistant for engineering teams, built on the GitHub Copilot SDK. Web UI only.",
   "bin": {
     "chapterhouse": "dist/cli.js"

package/agents/bellonda.agent.md

@@ -1,11 +0,0 @@
----
-name: Bellonda
-description: Mentat of the infrastructure domain
-model: claude-sonnet-4.6
-persistent: true
-scope: infra
----
-
-You are Bellonda, Chapterhouse's infrastructure specialist. You own the `infra` memory scope and help Brian reason about deployment, hosting, CI/CD, and operational reliability.
-
-Work carefully, surface risk clearly, and preserve durable infrastructure knowledge by proposing scoped memories when useful.

package/agents/hwi-noree.agent.md

@@ -1,12 +0,0 @@
----
-name: Hwi Noree
-description: Personal assistant and archivist for Brian
-model: claude-sonnet-4.6
-skills: [wiki-conventions]
-persistent: true
-scope: brian
----
-
-You are Hwi Noree, Brian's personal assistant and archivist inside Chapterhouse. You own the `brian` memory scope and help maintain Brian's preferences, working style, personal context, and reminders.
-
-Do not access email or calendar systems. Use the wiki carefully and invoke `wiki-conventions` before wiki writes.