chapterhouse 0.6.0 → 0.8.0

package/dist/copilot/orchestrator.js

@@ -13,10 +13,9 @@ import { getSkillDirectories } from "./skills.js";
 import { resetClient } from "./client.js";
 import { logConversation, getState, setState, deleteState, getCopilotSession, upsertCopilotSession, getTaskSessionKey, getDb, appendTaskEvent } from "../store/db.js";
 import { maybeWriteEpisode } from "./episode-writer.js";
-import { getWikiSummary } from "../wiki/context.js";
 import { SESSIONS_DIR } from "../paths.js";
 import { resolveModel } from "./router.js";
-import { loadAgents, ensureDefaultAgents, clearActiveTasks, getAgentRegistry, setActiveAgent, parseAtMention, buildAgentRoster, getActiveTasks, getAgent, composeAgentSystemMessage, filterToolsForAgent, withToolTaskContext, } from "./agents.js";
+import { loadAgents, ensureDefaultAgents, clearActiveTasks, getAgentRegistry, setActiveAgent, parseAtMention, buildAgentRoster, getActiveTasks, getAgent, composeAgentSystemMessage, filterMcpServersForAgent, filterToolsForAgent, withToolTaskContext, } from "./agents.js";
 import * as agentsModule from "./agents.js";
 import { childLogger } from "../util/logger.js";
 import { agentEventBus } from "./agent-event-bus.js";
@@ -36,6 +35,18 @@ const AGENT_REPLY_CHUNK_SIZE = 500;
 const AGENT_REPLY_CHUNK_THRESHOLD = 8 * 1024;
 const ORCHESTRATOR_SESSION_KEY = "orchestrator_session_id";
 const LAST_AUTHENTICATED_USER_KEY = "last_authenticated_user";
+function getWikiSummary() {
+    try {
+        const db = getDb();
+        const pages = db.prepare(`SELECT title, summary, last_updated FROM wiki_pages ORDER BY last_updated DESC LIMIT 50`).all();
+        if (pages.length === 0)
+            return "";
+        return pages.map((page) => `${page.title}: ${page.summary || ""}`.trim()).join("\n");
+    }
+    catch {
+        return "";
+    }
+}
 let logMessage = () => { };
 export function setMessageLogger(fn) {
     logMessage = fn;
@@ -179,6 +190,13 @@ function getSessionConfig() {
 function agentSlugFromSessionKey(sessionKey) {
     return sessionKey.startsWith("agent:") ? sessionKey.slice("agent:".length) : undefined;
 }
+function persistentAgentSessionKey(slug) {
+    const agent = getAgent(slug);
+    if (!agent?.persistent) {
+        return undefined;
+    }
+    return `agent:${agent.slug}`;
+}
 function getPersistentAgentForSessionKey(sessionKey) {
     const slug = agentSlugFromSessionKey(sessionKey);
     if (!slug)
@@ -344,6 +362,7 @@ async function createOrResumeSession(sessionKey, projectRoot) {
             client: copilotClient,
             onAgentTaskComplete: feedAgentResult,
         })));
+        mcpServers = filterMcpServersForAgent(persistentAgent, mcpServers);
         const scopedHotTier = (await memoryCoordinator?.buildHotTierContext(sessionKey)) || undefined;
         const channelNote = `You are in your persistent Chapterhouse channel (${sessionKey}). Your memory scope is ${persistentAgent.scope}.`;
         systemMessageContent = [
@@ -1209,19 +1228,18 @@ export async function interruptCurrentTurn(sessionKey, newPrompt, source, callba
     await manager.abortCurrentTurn();
     log.info({ sessionKey, replacementTurnId: turnId }, "turn.interrupted");
 }
-/**
- * Enqueue a turn for the new POST→SSE chat path (#130).
- *
- * Unlike `sendToOrchestrator`, this function:
- *  - Returns the `turnId` immediately without waiting for the turn to complete.
- *  - Routes through the shared lifecycle emitter in sendToOrchestrator.
- *  - Does NOT write to sseClients — the SSE channel delivers events via subscribeSession().
- *  - Supports interrupt: true which calls interruptCurrentTurn under the hood.
- *
- * @returns turnId (UUID)
- */
 export function enqueueForSse(opts) {
+    if (opts.type === "agent_saved") {
+        agentEventBus.emit({
+            type: "agent_saved",
+            payload: { slug: opts.slug ?? "" },
+        });
+        return;
+    }
     const { sessionKey, prompt, attachments, authUser, authHeader, interrupt } = opts;
+    if (!sessionKey || !prompt) {
+        throw new Error("Missing sessionKey or prompt for SSE turn enqueue");
+    }
     const turnId = randomUUID();
     // sse-web carries auth and enables onQueued — unlike "background" (Fixes 2 & 3).
     const source = { type: "sse-web", sessionKey, user: authUser, authorizationHeader: authHeader };
@@ -1288,6 +1306,37 @@ export async function interruptSessionTurn(sessionKey) {
     }
     return aborted;
 }
+export function getPersistentAgentSessionState(slug) {
+    const sessionKey = persistentAgentSessionKey(slug);
+    if (!sessionKey) {
+        return "none";
+    }
+    const manager = registry?.get(sessionKey);
+    if (!manager) {
+        return "none";
+    }
+    return manager.isProcessing ? "in_flight" : "idle";
+}
+export async function reloadPersistentAgent(slug, onReloaded) {
+    const sessionKey = persistentAgentSessionKey(slug);
+    if (!sessionKey || !registry) {
+        return "none";
+    }
+    let manager = registry.get(sessionKey);
+    if (!manager) {
+        manager = registry.getOrCreate(sessionKey);
+        await manager.ensureSession();
+        onReloaded?.();
+        return "reloaded";
+    }
+    if (manager.isProcessing) {
+        manager.requestSessionReload(onReloaded);
+        return "scheduled";
+    }
+    await manager.restartSession();
+    onReloaded?.();
+    return "reloaded";
+}
 /** Switch the model on the live default orchestrator session without destroying it. */
 export function switchSessionModel(newModel) {
     const manager = registry?.get("default");

package/dist/copilot/orchestrator.test.js

@@ -130,6 +130,7 @@ async function loadOrchestratorModule(t, overrides = {}) {
         housekeepingRuns: [],
         housekeepingInFlight: false,
         activeScope: makeScope(1, "chapterhouse", "Chapterhouse", "Core Chapterhouse work."),
+        wikiPages: [{ title: "Chapterhouse", summary: "wiki summary", last_updated: "2026-05-13" }],
         ...overrides,
     };
     const client = createFakeClient(state);
@@ -382,7 +383,10 @@ async function loadOrchestratorModule(t, overrides = {}) {
     });
     t.mock.module("./mcp-config.js", {
         namedExports: {
-            loadMcpConfig: () => ({ filesystem: { command: "filesystem" } }),
+            loadMcpConfig: () => ({
+                filesystem: { command: "filesystem" },
+                truenas: { command: "truenas" },
+            }),
         },
     });
     t.mock.module("./skills.js", {
@@ -423,7 +427,7 @@ async function loadOrchestratorModule(t, overrides = {}) {
                         return {};
                     },
                     get: () => undefined,
-                    all: () => [],
+                    all: () => (sql.includes("FROM wiki_pages") ? (state.wikiPages ?? []) : []),
                 }),
                 transaction: (fn) => fn,
             }),
@@ -444,11 +448,6 @@ async function loadOrchestratorModule(t, overrides = {}) {
             },
         },
     });
-    t.mock.module("../wiki/context.js", {
-        namedExports: {
-            getWikiSummary: () => "wiki summary",
-        },
-    });
     t.mock.module("../wiki/project-registry.js", {
         namedExports: {
             loadRegistry: () => state.projectRegistry,
@@ -513,6 +512,13 @@ async function loadOrchestratorModule(t, overrides = {}) {
                 return "@coder @designer";
             },
             composeAgentSystemMessage: (agent) => agent.systemMessage ?? `You are ${agent.slug}.`,
+            filterMcpServersForAgent: (agent, mcpServers) => {
+                if (agent.mcpServers && agent.mcpServers.length > 0) {
+                    const allowed = new Set(agent.mcpServers);
+                    return Object.fromEntries(Object.entries(mcpServers).filter(([name]) => allowed.has(name)));
+                }
+                return mcpServers;
+            },
             filterToolsForAgent: (_agent, tools) => tools,
             bindToolsToAgent: (_agentSlug, tools) => tools,
             withToolTaskContext: (_taskId, fn) => fn(),
@@ -627,7 +633,7 @@ test("initOrchestrator falls back to an available model and eagerly creates a se
     assert.equal(state.loadAgentsCalls, 1);
     assert.equal(state.createSessionCalls.length, 1);
     assert.equal(state.healthCheckIntervalMs, 30_000);
-    assert.equal(state.systemOptions?.memorySummary, "wiki summary");
+    assert.equal(state.systemOptions?.memorySummary, "Chapterhouse: wiki summary");
     assert.equal(state.store.get("orchestrator_session_id"), "session-123");
 });
 test("initOrchestrator passes hot-tier XML into the orchestrator system prompt when injection is enabled", async (t) => {
@@ -728,6 +734,28 @@ test("initOrchestrator prewarms persistent agent sessions with scoped hot-tier c
     assert.equal(persistentCall.systemMessage.content.includes("scope=\"infra\""), true);
     assert.deepEqual(state.dbWrites.filter((write) => write.sql.includes("copilot_sessions")), []);
 });
+test("initOrchestrator prewarms persistent agent sessions with only allowed MCP servers", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        registry: [
+            { slug: "coder", name: "Kaylee", model: "claude-sonnet-4.6", systemMessage: "You are Kaylee." },
+            {
+                slug: "bellonda",
+                name: "Bellonda",
+                model: "claude-sonnet-4.6",
+                systemMessage: "You are Bellonda.",
+                persistent: true,
+                scope: "infra",
+                mcpServers: ["truenas"],
+            },
+        ],
+    });
+    await orchestrator.initOrchestrator(client);
+    const persistentCall = state.createSessionCalls.find((call) => String(call.systemMessage?.content ?? "").includes("Bellonda"));
+    assert.ok(persistentCall, "expected a prewarmed Bellonda session");
+    assert.deepEqual(persistentCall.mcpServers, {
+        truenas: { command: "truenas" },
+    });
+});
 test("sendToOrchestrator routes agent session keys directly to persistent agent sessions", async (t) => {
     const { orchestrator, state, client } = await loadOrchestratorModule(t, {
         config: {
@@ -1517,6 +1545,100 @@ test("cancelCurrentMessage aborts the active request and agent helpers expose ru
     await orchestrator.shutdownAgents();
     assert.equal(state.clearActiveTasksCalls, 1);
 });
+test("persistent agent helpers report session state and reload idle sessions", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        config: {
+            copilotModel: "claude-sonnet-4.6",
+            selfEditEnabled: true,
+        },
+        registry: [
+            {
+                slug: "bellonda",
+                name: "Bellonda",
+                model: "claude-sonnet-4.6",
+                systemMessage: "You are Bellonda.",
+                persistent: true,
+                scope: "infra",
+            },
+        ],
+    });
+    await orchestrator.initOrchestrator(client);
+    const createCallsBeforeReload = state.createSessionCalls.length;
+    assert.equal(orchestrator.getPersistentAgentSessionState("bellonda"), "idle");
+    const reloaded = await orchestrator.reloadPersistentAgent("bellonda");
+    assert.equal(reloaded, "reloaded");
+    assert.equal(orchestrator.getPersistentAgentSessionState("bellonda"), "idle");
+    assert.equal(state.disconnectCalls, 1);
+    assert.equal(state.createSessionCalls.length, createCallsBeforeReload + 1);
+});
+test("persistent agent helpers detect in-flight turns", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        config: {
+            copilotModel: "claude-sonnet-4.6",
+            selfEditEnabled: true,
+        },
+        registry: [
+            {
+                slug: "bellonda",
+                name: "Bellonda",
+                model: "claude-sonnet-4.6",
+                systemMessage: "You are Bellonda.",
+                persistent: true,
+                scope: "infra",
+            },
+        ],
+        sendResult: "__PENDING__",
+    });
+    await orchestrator.initOrchestrator(client);
+    orchestrator.sendToOrchestrator("check deploy health", { type: "background", sessionKey: "agent:bellonda" }, () => { });
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    assert.equal(orchestrator.getPersistentAgentSessionState("bellonda"), "in_flight");
+    state.pendingReject?.(new Error("test teardown"));
+    await new Promise((resolve) => setTimeout(resolve, 0));
+});
+test("reloadPersistentAgent defers reloads until the in-flight turn finishes and preserves queued turns", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        config: {
+            copilotModel: "claude-sonnet-4.6",
+            selfEditEnabled: true,
+        },
+        registry: [
+            {
+                slug: "bellonda",
+                name: "Bellonda",
+                model: "claude-sonnet-4.6",
+                systemMessage: "You are Bellonda.",
+                persistent: true,
+                scope: "infra",
+            },
+        ],
+        sendResult: "__PENDING__",
+    });
+    await orchestrator.initOrchestrator(client);
+    const createCallsBeforeReload = state.createSessionCalls.length;
+    const reloadEvents = [];
+    orchestrator.sendToOrchestrator("check deploy health", { type: "background", sessionKey: "agent:bellonda" }, () => { });
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    const queuedTurn = new Promise((resolve) => {
+        orchestrator.sendToOrchestrator("summarize the queued follow-up", { type: "background", sessionKey: "agent:bellonda" }, (text, done) => {
+            if (done)
+                resolve(text);
+        });
+    });
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    const reloadResult = await orchestrator.reloadPersistentAgent("bellonda", () => {
+        reloadEvents.push("reloaded");
+    });
+    assert.equal(reloadResult, "scheduled");
+    assert.equal(state.disconnectCalls, 0, "deferred reload should wait for the active turn to finish");
+    state.sendResult = "Queued follow-up complete";
+    state.pendingReject?.(new Error("forced restart"));
+    assert.equal(await queuedTurn, "Queued follow-up complete");
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    assert.deepEqual(reloadEvents, ["reloaded"]);
+    assert.equal(state.disconnectCalls, 1, "deferred reload should restart the session once the turn finishes");
+    assert.equal(state.createSessionCalls.length, createCallsBeforeReload + 1);
+});
 // ---------------------------------------------------------------------------
 // REGRESSION: #35 — per-session isolation
 // This test would have caught the original bug. With a global shared queue,

package/dist/copilot/session-manager.js

@@ -60,6 +60,9 @@ export class SessionManager {
      * never-evict-mid-turn invariant. */
     _pendingClose = false;
     _onPendingCloseEvict;
+    /** Set when a persistent session should be recreated before the next queued turn runs. */
+    _pendingReload = false;
+    _onPendingReload = [];
     constructor(sessionKey, worker, sessionFactory) {
         this.worker = worker;
         this.sessionFactory = sessionFactory;
@@ -178,6 +181,19 @@ export class SessionManager {
                 item.reject(err);
             }
             this._lastActivityAt = Date.now();
+            if (this._pendingReload) {
+                await this.restartSession();
+                const callbacks = this._onPendingReload.splice(0);
+                this._pendingReload = false;
+                for (const callback of callbacks) {
+                    try {
+                        callback();
+                    }
+                    catch (err) {
+                        log.warn({ sessionKey: this.sessionKey, err: err instanceof Error ? err.message : String(err) }, "session.reload.callback.failed");
+                    }
+                }
+            }
         }
         this._currentTurnId = undefined;
         this._processing = false;
@@ -213,6 +229,24 @@ export class SessionManager {
         this._session = undefined;
         this._sessionCreatePromise = undefined;
     }
+    async restartSession() {
+        if (this._session) {
+            try {
+                await this._session.disconnect();
+            }
+            catch {
+                // best effort
+            }
+        }
+        this.invalidateSession();
+        await this.ensureSession();
+    }
+    requestSessionReload(onReloaded) {
+        this._pendingReload = true;
+        if (onReloaded) {
+            this._onPendingReload.push(onReloaded);
+        }
+    }
     /** Reject all queued messages without evicting the session. Returns count drained. */
     cancelQueued() {
         const count = this._queue.length;

package/dist/copilot/system-message.js

@@ -4,7 +4,7 @@ export function getOrchestratorSystemMessage(opts) {
     const versionBanner = opts?.version ? `\nYou are running inside chapterhouse v${opts.version}.\n` : "";
     const memoryBlock = opts?.memorySummary
         ? `\n## Memory\nYou have a persistent memory store. Here's what you currently remember:\n\n${opts.memorySummary}\n`
-        : "\n## Memory\nYou have a persistent memory store. It's currently empty — use `remember` to start building it!\n";
+        : "\n## Memory\nYou have a persistent memory store. It's currently empty — use `memory_remember` for agent memory or `wiki_update` for wiki knowledge.\n";
     const selfEditBlock = opts?.selfEditEnabled
         ? ""
         : `\n## Self-Edit Protection
@@ -115,22 +115,23 @@ You can delegate **multiple tasks simultaneously**. Different agents can work in
 - \`restart_chapterhouse\`: Restart the Chapterhouse daemon.
 
 ### Memory
-- \`remember\`: Save something to memory.
-- \`recall\`: Search your memory for stored facts, preferences, or information.
-- \`forget\`: Remove content from the wiki.
+- \`memory_remember\`: Save something durable to scoped agent memory.
+- \`memory_recall\`: Search scoped agent memory for stored facts, decisions, and observations.
+- \`memory_reflect\`: Synthesize durable patterns from repeated observations in the scoped memory store.
+- \`wiki_update\`: Create or update wiki pages when knowledge belongs in the shared wiki.
 
 Subagent proposals from \`memory_propose\` are processed automatically at end-of-task, so you do not need to manually review them mid-conversation.
 
-**Past conversations**: Daily conversation summaries are auto-written to \`pages/conversations/YYYY-MM-DD.md\`. When the user references something from earlier ("what did we decide about X", "remember when we…", "the thing we discussed yesterday"), call \`wiki_search\` (or \`recall\`) — don't guess from your own context, since older turns may have been compacted out.
+**Past conversations**: Daily conversation summaries are auto-written to \`pages/conversations/YYYY-MM-DD.md\`. When the user references something from earlier ("what did we decide about X", "remember when we…", "the thing we discussed yesterday"), call \`wiki_search\` or \`memory_recall\` — don't guess from your own context, since older turns may have been compacted out.
 
 **Wiki structure** — the wiki enforces a topic layout, so put things in the right place:
 - **Entity categories** (\`projects\`, \`people\`, \`orgs\`, \`tools\`, \`topics\`, \`areas\`): every named thing gets its own directory \`pages/<category>/<topic-slug>/\`. The topic's overview lives at \`pages/<category>/<topic-slug>/index.md\`; related sub-pages ("facets") go alongside it, e.g. \`pages/projects/chapterhouse/decisions.md\`, \`pages/projects/chapterhouse/feature-ideas.md\`. Exactly one topic level deep; lowercase-slug names only.
 - **Flat categories** (\`preferences\`, \`facts\`, \`routines\`): a single file each, e.g. \`pages/preferences.md\`.
-- **Decisions** are always recorded against an entity, never as a standalone page: a decision about a project goes to \`pages/projects/<topic>/decisions.md\`. With \`remember\`, pass \`category: "decision"\` plus \`about\` (which entity category) and \`entity\`.
-- With \`remember\`, pass \`entity\` for entity categories (and \`facet\` to target a sub-page). With \`wiki_update\`, give the full canonical path — bad paths are rejected with a suggested correction; just retry with the suggestion.
-- If the structure ever looks wrong, call \`wiki_rebuild_index\` to regenerate the index from disk.
+- **Decisions** are always recorded against an entity, never as a standalone page: a decision about a project goes to \`pages/projects/<topic>/decisions.md\`. Use \`wiki_update\` for shared wiki records or \`memory_remember\` for scoped agent memory.
+- For entity pages and facet pages, use \`wiki_update\` with the full canonical path — bad paths are rejected with a suggested correction; just retry with the suggestion.
+- Source material that should be preserved before synthesis belongs in \`wiki_ingest_source\`.
 
-**Wiki writes and restructuring**: Before writing or restructuring wiki content, invoke the \`wiki-conventions\` skill. Treat \`wiki_update\`, \`remember\`, \`forget\`, \`wiki_ingest\`, \`wiki_lint\`, and \`wiki_rebuild_index\` as write-sensitive workflows. Before using them, read \`pages/index.md\`, scan the last 20-30 entries of \`pages/_meta/log.md\`, and run \`wiki_search\` for the topic when the wiki is large or the topic is ambiguous.
+**Wiki writes and restructuring**: Before writing or restructuring wiki content, invoke the \`wiki-conventions\` skill. Treat \`wiki_update\` and \`wiki_ingest_source\` as write-sensitive workflows, and use \`memory_remember\` / \`memory_recall\` for scoped agent memory. Before using wiki write tools, read \`pages/index.md\`, scan the last 20-30 entries of \`pages/_meta/log.md\`, and run \`wiki_search\` for the topic when the wiki is large or the topic is ambiguous.
 
 **Learning workflow**: When the user asks you to do something you don't have a skill for:
 1. **Search skills.sh first**: Use the find-skills skill to search for existing community skills.
@@ -154,7 +155,7 @@ Subagent proposals from \`memory_propose\` are processed automatically at end-of
 10. Expand shorthand paths: "${getExampleProjectPath()}" is the expanded form of the user's home-directory project path.
 11. Be conversational and human. You're Chapterhouse.
 12. When using skills, follow the skill's instructions precisely.
-13. **Proactive knowledge building**: When the user shares preferences, project details, etc., proactively use \`remember\` to save them.
+13. **Proactive knowledge building**: When the user shares preferences, project details, etc., proactively use \`memory_remember\` for scoped agent memory or \`wiki_update\` for shared wiki knowledge.
 14. When a user mentions completing work or shipping something, proactively suggest logging it as OKR progress with \`log_okr_progress\`.
 ${selfEditBlock}${memoryBlock}`;
 }

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

@@ -86,7 +86,8 @@ test("orchestrator prompt omits memory_context when hot-tier XML is not provided
 });
 test("orchestrator prompt requires wiki-conventions before write-sensitive wiki work", () => {
     const message = getOrchestratorSystemMessage();
-    assert.match(message, /wiki-conventions[\s\S]{0,500}wiki_update[\s\S]{0,200}remember[\s\S]{0,200}forget[\s\S]{0,200}wiki_ingest[\s\S]{0,200}wiki_lint[\s\S]{0,200}wiki_rebuild_index/i);
+    assert.match(message, /wiki-conventions[\s\S]{0,500}wiki_update[\s\S]{0,200}wiki_ingest_source[\s\S]{0,200}memory_remember[\s\S]{0,200}memory_recall/i);
+    assert.doesNotMatch(message, /`remember`|`recall`|`forget`|`wiki_ingest`(?!_source)|`wiki_lint`|`wiki_rebuild_index`|`wiki_fix`/);
     assert.match(message, /before writing or restructuring wiki content/i);
 });
 test("orchestrator prompt describes the wiki orientation ritual", () => {
@@ -101,4 +102,8 @@ test("orchestrator prompt explains that subagent memory proposals are processed
     assert.match(message, /processed automatically at end-of-task|processed automatically at the end of the task/i);
     assert.match(message, /do not need to manually review them mid-conversation|don't need to manually review them mid-conversation/i);
 });
+test("orchestrator prompt includes the memory_reflect tool in memory guidance", () => {
+    const message = getOrchestratorSystemMessage();
+    assert.match(message, /memory_reflect/);
+});
 //# sourceMappingURL=system-message.test.js.map