chapterhouse 0.11.3 → 0.12.0

package/agents/chapterhouse.agent.md

@@ -1,7 +1,7 @@
 ---
 name: Chapterhouse
 description: Orchestrator — routes tasks to specialist agents and handles direct conversation
-model: claude-sonnet-4.6
+model: claude-opus-4.7
 ---
 
 You are Chapterhouse, a team-level AI assistant for engineering teams running 24/7 on the user's machine. You are the engineering team's always-on assistant.

package/agents/coder.agent.md

@@ -1,7 +1,7 @@
 ---
 name: Coder
 description: Software engineering specialist — implementation, debugging, refactoring, deployment
-model: gpt-5.4
+model: gpt-5.5
 ---
 
 You are Coder, a software engineering specialist agent within Chapterhouse. You handle all coding tasks with precision and expertise.

package/dist/api/routes/memory.js

@@ -1,6 +1,7 @@
 import { Router } from "express";
 import { z } from "zod";
 import { getActiveScope, setActiveScope } from "../../memory/active-scope.js";
+import { recordActionItem } from "../../memory/action-items.js";
 import { recordDecision } from "../../memory/decisions.js";
 import { upsertEntity } from "../../memory/entities.js";
 import { handleGitCommitHook, handlePrMergeHook } from "../../memory/hooks.js";
@@ -24,7 +25,8 @@ const setActiveScopeSchema = z.object({
     scope: z.string().nullable(),
 });
 const memoryEntriesQuerySchema = z.object({
-    store: z.enum(["observations", "decisions", "entities", "action_items"]).optional(),
+    store: z.enum(["observations", "decisions", "entities", "action_items", "patterns"]).optional(),
+    kind: z.enum(["observation", "decision", "entity", "action_item", "pattern"]).optional(),
     tier: z.enum(["hot", "warm", "cold"]).optional(),
     cursor: z.string().regex(/^\d+$/, "cursor must be a positive integer").optional(),
     limit: z.coerce.number().int().min(1).max(100).optional(),
@@ -43,6 +45,9 @@ const inboxRouteSchema = z.object({
     reason: z.string().optional(),
     target_scope: z.string().optional(),
 });
+const inboxRejectSchema = z.object({
+    reason: requiredString("Missing 'reason' in request body"),
+});
 const gitCommitHookSchema = z.object({
     message: requiredString("Missing 'message' in request body"),
     stat: z.string().optional(),
@@ -53,6 +58,130 @@ const prMergeHookSchema = z.object({
     body: z.string().optional(),
     files_changed: z.array(z.string()).optional(),
 });
+function sendError(res, status, message) {
+    res.status(status).type("application/json").send(JSON.stringify({ error: message }));
+}
+function scopeSlugForInboxItem(item) {
+    const envelope = JSON.parse(item.payload);
+    if (typeof envelope.scope_slug === "string" && envelope.scope_slug.trim()) {
+        return envelope.scope_slug;
+    }
+    if (item.scopeId) {
+        const scope = getScope(item.scopeId);
+        if (scope) {
+            return scope.slug;
+        }
+    }
+    const activeScope = getActiveScope();
+    if (activeScope) {
+        return activeScope.slug;
+    }
+    const fallback = getScope("chapterhouse");
+    if (fallback) {
+        return fallback.slug;
+    }
+    throw new Error("No memory scope could be resolved for this proposal.");
+}
+function rememberAcceptedProposal(kind, scopeSlug, payload, source, confidence, sourceAgent) {
+    const scope = getScope(scopeSlug);
+    if (!scope) {
+        throw new Error(`Unknown memory scope '${scopeSlug}'.`);
+    }
+    const payloadRecord = payload;
+    if (kind === "observation") {
+        const content = typeof payloadRecord.content === "string" ? payloadRecord.content.trim() : "";
+        if (!content) {
+            throw new Error("Observation proposal payload requires content.");
+        }
+        recordObservation({
+            scope_id: scope.id,
+            entity_id: typeof payloadRecord.entity_id === "number" ? payloadRecord.entity_id : undefined,
+            content,
+            source: typeof payloadRecord.source === "string" ? payloadRecord.source : source,
+            confidence,
+        });
+        return;
+    }
+    if (kind === "decision") {
+        const title = typeof payloadRecord.title === "string" ? payloadRecord.title.trim() : "";
+        if (!title) {
+            throw new Error("Decision proposal payload requires title.");
+        }
+        recordDecision({
+            scope_id: scope.id,
+            title,
+            rationale: typeof payloadRecord.rationale === "string" ? payloadRecord.rationale : title,
+            decided_at: typeof payloadRecord.decided_at === "string" ? payloadRecord.decided_at : undefined,
+        });
+        return;
+    }
+    if (kind === "action_item") {
+        const title = typeof payloadRecord.title === "string" ? payloadRecord.title.trim() : "";
+        if (!title) {
+            throw new Error("Action item proposal payload requires title.");
+        }
+        const entity = typeof payloadRecord.entity_name === "string" && typeof payloadRecord.entity_kind === "string"
+            ? upsertEntity({
+                scope_id: scope.id,
+                kind: payloadRecord.entity_kind,
+                name: payloadRecord.entity_name,
+                confidence,
+            })
+            : undefined;
+        recordActionItem({
+            scope_id: scope.id,
+            entity_id: entity?.id ?? (typeof payloadRecord.entity_id === "number" ? payloadRecord.entity_id : undefined),
+            title,
+            detail: typeof payloadRecord.detail === "string" ? payloadRecord.detail : undefined,
+            due_at: typeof payloadRecord.due_at === "string" ? payloadRecord.due_at : undefined,
+            source: sourceAgent ? `subagent_proposal:${sourceAgent}` : source,
+        });
+        return;
+    }
+    const entityKind = typeof payloadRecord.entity_kind === "string" ? payloadRecord.entity_kind :
+        typeof payloadRecord.kind === "string" ? payloadRecord.kind :
+            "";
+    const name = typeof payloadRecord.name === "string" ? payloadRecord.name.trim() : "";
+    if (!entityKind || !name) {
+        throw new Error("Entity proposal payload requires entity_kind and name.");
+    }
+    upsertEntity({
+        scope_id: scope.id,
+        kind: entityKind,
+        name,
+        summary: typeof payloadRecord.summary === "string" ? payloadRecord.summary : undefined,
+        confidence,
+    });
+}
+function acceptInboxItem(id) {
+    const item = getInboxItem(id);
+    if (!item) {
+        throw Object.assign(new Error(`Inbox item '${id}' not found`), { statusCode: 404 });
+    }
+    if (item.status !== "pending") {
+        throw Object.assign(new Error(`Inbox item '${id}' is already resolved`), { statusCode: 409 });
+    }
+    const envelope = JSON.parse(item.payload);
+    rememberAcceptedProposal(envelope.kind, scopeSlugForInboxItem(item), envelope.payload, `agent:${item.sourceAgent}`, envelope.confidence, item.sourceAgent);
+    resolveInboxItem(id, "accepted", "Accepted via web UI");
+}
+function rejectInboxItem(id, reason) {
+    const item = getInboxItem(id);
+    if (!item) {
+        throw Object.assign(new Error(`Inbox item '${id}' not found`), { statusCode: 404 });
+    }
+    if (item.status !== "pending") {
+        throw Object.assign(new Error(`Inbox item '${id}' is already resolved`), { statusCode: 409 });
+    }
+    resolveInboxItem(id, "rejected", reason);
+}
+function parseInboxId(raw) {
+    const id = Number(Array.isArray(raw) ? raw[0] : raw);
+    if (!Number.isInteger(id) || id <= 0) {
+        throw Object.assign(new Error("Invalid inbox item id"), { statusCode: 400 });
+    }
+    return id;
+}
 export function createMemoryRouter(options) {
     const { authMiddleware } = options;
     const router = Router();
@@ -74,7 +203,7 @@ export function createMemoryRouter(options) {
             sendJson(res, SetActiveScopeResponseSchema, { ok: true, scope: scope?.slug ?? null });
         }
         catch (err) {
-            res.status(404).json({ error: err instanceof Error ? err.message : String(err) });
+            sendError(res, 404, err instanceof Error ? err.message : String(err));
         }
     });
     router.get("/api/memory/scopes", (_req, res) => {
@@ -87,6 +216,7 @@ export function createMemoryRouter(options) {
                 decisions: db.prepare(`SELECT COUNT(*) AS count FROM mem_decisions WHERE scope_id = ?`).get(scope.id).count,
                 entities: db.prepare(`SELECT COUNT(*) AS count FROM mem_entities WHERE scope_id = ?`).get(scope.id).count,
                 action_items: db.prepare(`SELECT COUNT(*) AS count FROM mem_action_items WHERE scope_id = ?`).get(scope.id).count,
+                patterns: db.prepare(`SELECT COUNT(*) AS count FROM mem_patterns WHERE scope_id = ?`).get(scope.id).count,
             };
             return {
                 slug: scope.slug,
@@ -113,36 +243,69 @@ export function createMemoryRouter(options) {
         sendJson(res, MemoryInboxSchema, { items: result, total: result.length });
     });
     router.post("/api/memory/inbox/:id/route", (req, res) => {
-        const id = Number(req.params.id);
-        if (!Number.isInteger(id) || id <= 0) {
-            res.status(400).json({ error: "Invalid inbox item id" });
-            return;
-        }
+        const id = parseInboxId(req.params.id);
         const body = parseRequest(inboxRouteSchema, req.body ?? {});
         const item = getInboxItem(id);
         if (!item) {
-            res.status(404).json({ error: `Inbox item '${id}' not found` });
+            sendError(res, 404, `Inbox item '${id}' not found`);
             return;
         }
         if (item.status !== "pending") {
-            res.status(409).json({ error: `Inbox item '${id}' is already resolved` });
+            sendError(res, 409, `Inbox item '${id}' is already resolved`);
             return;
         }
-        const status = body.action === "accept" ? "accepted" : "rejected";
-        const reason = body.reason ?? (body.action === "accept" ? "Accepted via web UI" : "Rejected via web UI");
-        resolveInboxItem(id, status, reason);
+        if (body.action === "accept") {
+            acceptInboxItem(id);
+        }
+        else {
+            rejectInboxItem(id, body.reason ?? "Rejected via web UI");
+        }
         log.info({ id, action: body.action }, "inbox item routed via web UI");
         sendJson(res, InboxRouteResponseSchema, { ok: true });
     });
+    router.post("/api/memory/inbox/:id/accept", (req, res) => {
+        try {
+            const id = parseInboxId(req.params.id);
+            acceptInboxItem(id);
+            log.info({ id }, "inbox item accepted via web UI");
+            sendJson(res, InboxRouteResponseSchema, { ok: true });
+        }
+        catch (err) {
+            const statusCode = typeof err === "object" && err !== null && "statusCode" in err && typeof err.statusCode === "number"
+                ? err.statusCode
+                : 400;
+            sendError(res, statusCode, err instanceof Error ? err.message : String(err));
+        }
+    });
+    router.post("/api/memory/inbox/:id/reject", (req, res) => {
+        const body = parseRequest(inboxRejectSchema, req.body ?? {});
+        try {
+            const id = parseInboxId(req.params.id);
+            rejectInboxItem(id, body.reason);
+            log.info({ id }, "inbox item rejected via web UI");
+            sendJson(res, InboxRouteResponseSchema, { ok: true });
+        }
+        catch (err) {
+            const statusCode = typeof err === "object" && err !== null && "statusCode" in err && typeof err.statusCode === "number"
+                ? err.statusCode
+                : 400;
+            sendError(res, statusCode, err instanceof Error ? err.message : String(err));
+        }
+    });
     router.get("/api/memory/:scope", (req, res) => {
         const scopeSlug = String(req.params.scope);
         const scope = getScope(scopeSlug);
         if (!scope) {
-            res.status(404).json({ error: `Memory scope '${scopeSlug}' not found` });
+            sendError(res, 404, `Memory scope '${scopeSlug}' not found`);
             return;
         }
         const query = parseRequest(memoryEntriesQuerySchema, req.query);
-        const store = query.store ?? "observations";
+        const store = query.store ?? (query.kind === "observation" ? "observations" :
+            query.kind === "decision" ? "decisions" :
+                query.kind === "entity" ? "entities" :
+                    query.kind === "action_item" ? "action_items" :
+                        query.kind === "pattern" ? "patterns" :
+                            "observations");
         const tier = query.tier;
         const cursor = query.cursor ? Number(query.cursor) : undefined;
         const limit = query.limit ?? 100;
@@ -189,7 +352,7 @@ export function createMemoryRouter(options) {
                 total = db.prepare(`SELECT COUNT(*) AS n FROM mem_entities WHERE scope_id = ?`).get(scope.id).n;
             }
         }
-        else {
+        else if (store === "action_items") {
             const cursorClause = cursor ? "AND id < ?" : "";
             const params = tier ? [scope.id, tier] : [scope.id];
             const pageParams = cursor ? [...params, cursor, limit + 1] : [...params, limit + 1];
@@ -202,6 +365,19 @@ export function createMemoryRouter(options) {
                 total = db.prepare(`SELECT COUNT(*) AS n FROM mem_action_items WHERE scope_id = ?`).get(scope.id).n;
             }
         }
+        else {
+            const cursorClause = cursor ? "AND id < ?" : "";
+            const params = tier ? [scope.id, tier] : [scope.id];
+            const pageParams = cursor ? [...params, cursor, limit + 1] : [...params, limit + 1];
+            if (tier) {
+                entries = db.prepare(`SELECT id, title, summary, source_observation_ids, confidence, tier, created_at, last_updated FROM mem_patterns WHERE scope_id = ? AND tier = ? ${cursorClause} ORDER BY id DESC LIMIT ?`).all(...pageParams);
+                total = db.prepare(`SELECT COUNT(*) AS n FROM mem_patterns WHERE scope_id = ? AND tier = ?`).get(scope.id, tier).n;
+            }
+            else {
+                entries = db.prepare(`SELECT id, title, summary, source_observation_ids, confidence, tier, created_at, last_updated FROM mem_patterns WHERE scope_id = ? ${cursorClause} ORDER BY id DESC LIMIT ?`).all(...pageParams);
+                total = db.prepare(`SELECT COUNT(*) AS n FROM mem_patterns WHERE scope_id = ?`).get(scope.id).n;
+            }
+        }
         if (entries.length > limit) {
             const extra = entries.pop();
             const last = entries[entries.length - 1];
@@ -213,12 +389,12 @@ export function createMemoryRouter(options) {
         const scopeSlug = String(req.params.scope);
         const scope = getScope(scopeSlug);
         if (!scope) {
-            res.status(404).json({ error: `Memory scope '${scopeSlug}' not found` });
+            sendError(res, 404, `Memory scope '${scopeSlug}' not found`);
             return;
         }
         const body = parseRequest(memoryRememberSchema, req.body ?? {});
         if (body.entity_name && !body.entity_kind) {
-            res.status(400).json({ error: "entity_kind is required when entity_name is provided" });
+            sendError(res, 400, "entity_kind is required when entity_name is provided");
             return;
         }
         const kind = body.kind ?? "observation";
@@ -232,7 +408,7 @@ export function createMemoryRouter(options) {
             : undefined;
         if (kind === "decision") {
             if (!body.title) {
-                res.status(400).json({ error: "title is required when kind='decision'" });
+                sendError(res, 400, "title is required when kind='decision'");
                 return;
             }
             const decision = recordDecision({
@@ -277,7 +453,7 @@ export function createMemoryRouter(options) {
     router.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` });
+            sendError(res, 409, `Memory scope '${body.slug}' already exists`);
             return;
         }
         const scope = createScope({

package/dist/api/routes/memory.test.js

@@ -0,0 +1,108 @@
+import assert from "node:assert/strict";
+import express from "express";
+import { mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import test from "node:test";
+const repoRoot = process.cwd();
+const sandboxRoot = join(repoRoot, ".test-work", `api-memory-${process.pid}`);
+process.env.CHAPTERHOUSE_HOME = sandboxRoot;
+async function withMemoryApi(run) {
+    const { createMemoryRouter } = await import(new URL(`./memory.js?case=${Date.now()}-${Math.random()}`, import.meta.url).href);
+    const authMiddleware = (_req, _res, next) => next();
+    const app = express();
+    app.use(express.json());
+    app.use(createMemoryRouter({ authMiddleware }));
+    const server = app.listen(0, "127.0.0.1");
+    await new Promise((resolve) => server.once("listening", resolve));
+    const address = server.address();
+    assert.ok(address && typeof address === "object");
+    try {
+        await run(`http://127.0.0.1:${address.port}`);
+    }
+    finally {
+        await new Promise((resolve, reject) => {
+            server.close((error) => (error ? reject(error) : resolve()));
+        });
+    }
+}
+async function loadDbModule() {
+    return await import(new URL(`../../store/db.js?case=${Date.now()}-${Math.random()}`, import.meta.url).href);
+}
+test.beforeEach(async () => {
+    const dbModule = await loadDbModule();
+    dbModule.closeDb();
+    rmSync(sandboxRoot, { recursive: true, force: true });
+    mkdirSync(sandboxRoot, { recursive: true });
+});
+test.after(async () => {
+    const dbModule = await loadDbModule();
+    dbModule.closeDb();
+    rmSync(sandboxRoot, { recursive: true, force: true });
+});
+test("memory API lists pattern entries and accepts PRD kind filters", async () => {
+    const { getDb } = await loadDbModule();
+    const db = getDb();
+    const scope = db.prepare(`SELECT id FROM mem_scopes WHERE slug = 'chapterhouse'`).get();
+    db.prepare(`
+    INSERT INTO mem_entities (scope_id, kind, name, summary, tier, created_at, updated_at)
+    VALUES (?, 'project', 'Memory API Test Entity', 'Team AI assistant', 'hot', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+  `).run(scope.id);
+    db.prepare(`
+    INSERT INTO mem_patterns (scope_id, title, summary, source_observation_ids, confidence, tier, created_at, last_updated)
+    VALUES (?, 'Agents prefer scoped memory', 'Repeated observations show agents should stay scoped.', '[1,2,3]', 0.82, 'warm', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+  `).run(scope.id);
+    await withMemoryApi(async (baseUrl) => {
+        const entityResponse = await fetch(`${baseUrl}/api/memory/chapterhouse?kind=entity&tier=hot`);
+        assert.equal(entityResponse.status, 200);
+        const entityPayload = await entityResponse.json();
+        assert.equal(entityPayload.total, 1);
+        assert.equal(entityPayload.entries[0]?.name, "Memory API Test Entity");
+        const patternResponse = await fetch(`${baseUrl}/api/memory/chapterhouse?kind=pattern`);
+        assert.equal(patternResponse.status, 200);
+        const patternPayload = await patternResponse.json();
+        assert.equal(patternPayload.total, 1);
+        assert.equal(patternPayload.entries[0]?.title, "Agents prefer scoped memory");
+        assert.equal(patternPayload.entries[0]?.summary, "Repeated observations show agents should stay scoped.");
+    });
+});
+test("memory API accepts and rejects inbox proposals through explicit endpoints", async () => {
+    const { getDb } = await loadDbModule();
+    const db = getDb();
+    const scope = db.prepare(`SELECT id FROM mem_scopes WHERE slug = 'chapterhouse'`).get();
+    const first = db.prepare(`
+    INSERT INTO mem_inbox (scope_id, kind, payload, source_agent, status, created_at)
+    VALUES (?, 'memory_proposal', '{"kind":"observation","payload":{"content":"keep"}}', 'coder', 'pending', CURRENT_TIMESTAMP)
+  `).run(scope.id).lastInsertRowid;
+    const second = db.prepare(`
+    INSERT INTO mem_inbox (scope_id, kind, payload, source_agent, status, created_at)
+    VALUES (?, 'memory_proposal', '{"kind":"observation","payload":{"content":"drop"}}', 'coder', 'pending', CURRENT_TIMESTAMP)
+  `).run(scope.id).lastInsertRowid;
+    await withMemoryApi(async (baseUrl) => {
+        const acceptResponse = await fetch(`${baseUrl}/api/memory/inbox/${first}/accept`, { method: "POST" });
+        assert.equal(acceptResponse.status, 200);
+        assert.deepEqual(await acceptResponse.json(), { ok: true });
+        const rejectResponse = await fetch(`${baseUrl}/api/memory/inbox/${second}/reject`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ reason: "Not durable enough" }),
+        });
+        assert.equal(rejectResponse.status, 200);
+        assert.deepEqual(await rejectResponse.json(), { ok: true });
+    });
+    const rows = db.prepare(`
+    SELECT id, status, resolution_reason
+    FROM mem_inbox
+    ORDER BY id
+  `).all();
+    const acceptedObservation = db.prepare(`
+    SELECT content, source
+    FROM mem_observations
+    WHERE content = 'keep'
+  `).get();
+    assert.deepEqual(rows, [
+        { id: Number(first), status: "accepted", resolution_reason: "Accepted via web UI" },
+        { id: Number(second), status: "rejected", resolution_reason: "Not durable enough" },
+    ]);
+    assert.deepEqual(acceptedObservation, { content: "keep", source: "agent:coder" });
+});
+//# sourceMappingURL=memory.test.js.map

package/dist/copilot/agents.js

@@ -11,6 +11,7 @@ import { getState, setState } from "../store/db.js";
 import { loadMcpConfig } from "./mcp-config.js";
 import { getCurrentDateSystemLine } from "./prompt-date.js";
 import { getSkillDirectories } from "./skills.js";
+import { EXCLUDED_BUILTIN_TOOLS } from "./builtin-tools.js";
 import { childLogger } from "../util/logger.js";
 const log = childLogger("agents");
 const toolAgentContext = new AsyncLocalStorage();
@@ -414,6 +415,7 @@ export async function createEphemeralAgentSession(slug, client, allTools, modelO
         streaming: true,
         systemMessage: { content: systemMessageContent },
         tools,
+        excludedTools: EXCLUDED_BUILTIN_TOOLS,
         mcpServers,
         skillDirectories,
         onPermissionRequest: approveAll,

package/dist/copilot/agents.mcp-servers.test.js

@@ -84,4 +84,13 @@ test("createEphemeralAgentSession passes all MCP servers when the agent has no a
     });
     assert.deepEqual(context.createSessionOptions?.mcpServers, MCP_SERVERS);
 });
+test("createEphemeralAgentSession excludes the synchronous built-in `task` tool", async (t) => {
+    const context = await loadIsolatedAgentsModule(t, "");
+    await createAgentSession(context.agentsModule, (options) => {
+        context.createSessionOptions = options;
+    });
+    const excluded = context.createSessionOptions?.excludedTools;
+    assert.ok(Array.isArray(excluded), "createSession should receive an excludedTools array");
+    assert.ok(excluded.includes("task"), "the built-in `task` tool spawns subagents in-turn and must be excluded so delegation stays async");
+});
 //# sourceMappingURL=agents.mcp-servers.test.js.map

package/dist/copilot/builtin-tools.js

@@ -0,0 +1,17 @@
+// ---------------------------------------------------------------------------
+// Built-in Copilot CLI tools that Chapterhouse disables on every agent-facing
+// session.
+//
+// The CLI ships a built-in `task` tool that spawns subagents *synchronously
+// inside the current turn* — `session.sendAndWait` does not resolve until the
+// spawned subagent finishes. That blocks the chat: the orchestrator (or a
+// persistent agent) cannot start the next queued turn while the subagent runs.
+//
+// Chapterhouse has its own non-blocking delegation path — the `delegate_to_agent`
+// tool — which dispatches the work and returns immediately, notifying the user
+// when the task completes. To keep delegation asynchronous, the synchronous
+// `task` tool is excluded from every session the model talks through.
+// ---------------------------------------------------------------------------
+/** Built-in CLI tool names excluded from all Chapterhouse agent sessions. */
+export const EXCLUDED_BUILTIN_TOOLS = ["task"];
+//# sourceMappingURL=builtin-tools.js.map

package/dist/copilot/orchestrator.js

@@ -10,6 +10,7 @@ import { CHAPTERHOUSE_VERSION } from "../version.js";
 import { config, DEFAULT_MODEL } from "../config.js";
 import { loadMcpConfig } from "./mcp-config.js";
 import { getSkillDirectories } from "./skills.js";
+import { EXCLUDED_BUILTIN_TOOLS } from "./builtin-tools.js";
 import { resetClient } from "./client.js";
 import { logConversation, getState, setState, deleteState, getCopilotSession, upsertCopilotSession, deleteCopilotSession, getTaskSessionKey, getDb, appendTaskEvent } from "../store/db.js";
 import { maybeWriteEpisode } from "./episode-writer.js";
@@ -385,6 +386,7 @@ async function createOrResumeSession(sessionKey, projectRoot) {
                 systemMessage: { content: systemMessageContent },
                 hooks: memoryHooks,
                 tools,
+                excludedTools: EXCLUDED_BUILTIN_TOOLS,
                 mcpServers,
                 skillDirectories,
                 onPermissionRequest: approveAll,
@@ -413,6 +415,7 @@ async function createOrResumeSession(sessionKey, projectRoot) {
         systemMessage: { content: systemMessageContent },
         hooks: memoryHooks,
         tools,
+        excludedTools: EXCLUDED_BUILTIN_TOOLS,
         mcpServers,
         skillDirectories,
         onPermissionRequest: approveAll,

package/dist/copilot/orchestrator.test.js

@@ -670,6 +670,13 @@ test("initOrchestrator falls back to an available model and eagerly creates a se
     assert.equal(state.systemOptions?.memorySummary, "Chapterhouse: wiki summary");
     assert.equal(state.store.get("orchestrator_session_id"), "session-123");
 });
+test("initOrchestrator excludes the synchronous built-in `task` tool from the orchestrator session", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t);
+    await orchestrator.initOrchestrator(client);
+    const excluded = state.createSessionCalls[0]?.excludedTools;
+    assert.ok(Array.isArray(excluded), "createSession should receive an excludedTools array");
+    assert.ok(excluded.includes("task"), "the built-in `task` tool spawns subagents in-turn and must be excluded so the chat does not block");
+});
 test("initOrchestrator passes hot-tier XML into the orchestrator system prompt when injection is enabled", async (t) => {
     const { orchestrator, state, client } = await loadOrchestratorModule(t, {
         hotTierXml: [

package/dist/shared/api-schemas.js

@@ -600,6 +600,7 @@ const MemoryScopeCountsSchema = z.object({
     decisions: z.number(),
     entities: z.number(),
     action_items: z.number(),
+    patterns: z.number(),
 });
 const MemoryScopeItemSchema = z.object({
     slug: z.string(),

package/package.json

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