chapterhouse 0.4.3 → 0.5.1

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) => {
@@ -29,6 +36,9 @@ function createFakeClient(state) {
             if (state.sendErrorMessage) {
                 throw new Error(state.sendErrorMessage);
             }
+            for (const delta of state.sendDeltas ?? []) {
+                this.emit("assistant.message_delta", { deltaContent: delta });
+            }
             return { data: { content: state.sendResult } };
         }
         async setModel(model) {
@@ -54,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),
             };
@@ -102,9 +112,10 @@ async function loadOrchestratorModule(t, overrides = {}) {
             { taskId: "task-2", agentSlug: "designer", status: "done", description: "Ignore me" },
         ],
         registry: [
-            { slug: "coder", name: "Kaylee", model: "claude-sonnet-4.6" },
+            { slug: "coder", name: "Kaylee", model: "claude-sonnet-4.6", systemMessage: "You are Kaylee." },
         ],
         sendResult: "Finished successfully",
+        promptMemoryContexts: [],
         taskEvents: new Map(),
         projectRegistry: {},
         resolveProjectArgs: [],
@@ -150,11 +161,37 @@ async function loadOrchestratorModule(t, overrides = {}) {
     t.mock.module("../memory/hot-tier.js", {
         namedExports: {
             renderHotTierForActiveScope: () => state.hotTierXml ?? "",
+            getHotTierEntries: (scopeId) => ({
+                scope: scopeId !== undefined
+                    ? scopeId === state.activeScope?.id
+                        ? state.activeScope
+                        : makeScope(scopeId, "infra", "Infra", "Infrastructure work.")
+                    : state.activeScope ?? null,
+                entities: [],
+                observations: [],
+                decisions: [],
+                actionItems: [],
+            }),
+            renderHotTierXML: (entries) => entries.scope ? state.hotTierByScope?.get(entries.scope.slug) ?? "" : "",
         },
     });
     t.mock.module("../memory/active-scope.js", {
         namedExports: {
             getActiveScope: () => state.activeScope ?? null,
+            withActiveScope: async (_slug, fn) => fn(),
+        },
+    });
+    t.mock.module("../memory/scopes.js", {
+        namedExports: {
+            getScope: (slugOrId) => {
+                if (slugOrId === "infra" || slugOrId === 3) {
+                    return makeScope(3, "infra", "Infra", "Infrastructure work.");
+                }
+                if (slugOrId === "brian" || slugOrId === 5) {
+                    return makeScope(5, "brian", "Brian", "Brian's personal context.");
+                }
+                return state.activeScope ?? null;
+            },
         },
     });
     t.mock.module("../memory/checkpoint.js", {
@@ -342,10 +379,7 @@ async function loadOrchestratorModule(t, overrides = {}) {
         namedExports: {
             loadAgents: () => {
                 state.loadAgentsCalls++;
-                return [
-                    { slug: "coder", name: "Kaylee", model: "claude-sonnet-4.6" },
-                    { slug: "designer", name: "Wash", model: "claude-opus-4.6" },
-                ];
+                return state.registry;
             },
             ensureDefaultAgents: () => {
                 state.ensureDefaultAgentsCalls++;
@@ -354,6 +388,7 @@ async function loadOrchestratorModule(t, overrides = {}) {
                 state.clearActiveTasksCalls++;
             },
             getAgentRegistry: () => state.registry,
+            getAgent: (slug) => state.registry.find((agent) => agent.slug === slug),
             getActiveAgent: () => undefined,
             setActiveAgent: (channelKey, agentSlug) => {
                 state.setActiveAgentCalls.push({ channelKey, agentSlug });
@@ -366,6 +401,10 @@ async function loadOrchestratorModule(t, overrides = {}) {
                 state.buildAgentRosterArgs.push(projectRoot);
                 return "@coder @designer";
             },
+            composeAgentSystemMessage: (agent) => agent.systemMessage ?? `You are ${agent.slug}.`,
+            filterToolsForAgent: (_agent, tools) => tools,
+            bindToolsToAgent: (_agentSlug, tools) => tools,
+            withToolTaskContext: (_taskId, fn) => fn(),
             getActiveTasks: () => state.activeTasks,
             completeTask: () => { },
             failTask: () => { },
@@ -497,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: "",
@@ -516,6 +592,143 @@ test("initOrchestrator omits hot-tier XML when memory injection is disabled", as
     await orchestrator.initOrchestrator(client);
     assert.equal(state.systemOptions?.hotTierXml, undefined);
 });
+test("initOrchestrator prewarms persistent agent sessions with scoped hot-tier context", 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",
+            },
+        ],
+        hotTierByScope: new Map([
+            ["infra", "<memory_context scope=\"infra\"><observation>terraform drift</observation></memory_context>"],
+        ]),
+    });
+    await orchestrator.initOrchestrator(client);
+    assert.equal(state.createSessionCalls.length, 2);
+    const persistentCall = state.createSessionCalls.find((call) => String(call.systemMessage?.content ?? "").includes("Bellonda"));
+    assert.ok(persistentCall, "expected a prewarmed Bellonda session");
+    assert.equal(persistentCall.systemMessage.content.includes("Bellonda"), true);
+    assert.equal(persistentCall.systemMessage.content.includes("scope=\"infra\""), true);
+    assert.deepEqual(state.dbWrites.filter((write) => write.sql.includes("copilot_sessions")), []);
+});
+test("sendToOrchestrator routes agent session keys directly to persistent agent sessions", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        config: {
+            copilotModel: "claude-sonnet-4.6",
+            selfEditEnabled: true,
+            memoryInjectEnabled: true,
+        },
+        registry: [
+            {
+                slug: "bellonda",
+                name: "Bellonda",
+                model: "claude-sonnet-4.6",
+                systemMessage: "You are Bellonda.",
+                persistent: true,
+                scope: "infra",
+            },
+        ],
+        sendResult: "Infra answer",
+        hotTierByScope: new Map([
+            ["infra", "<memory_context scope=\"infra\"><observation>vpc state</observation></memory_context>"],
+        ]),
+    });
+    await orchestrator.initOrchestrator(client);
+    state.sessionPrompts.length = 0;
+    state.routerArgs.length = 0;
+    const final = await new Promise((resolve) => {
+        orchestrator.sendToOrchestrator("What changed in prod?", { type: "sse-web", sessionKey: "agent:bellonda" }, (text, done) => {
+            if (done)
+                resolve(text);
+        });
+    });
+    assert.equal(final, "Infra answer");
+    assert.deepEqual(state.routerArgs, [], "direct persistent-agent chat must not use orchestrator model routing");
+    assert.deepEqual(state.sessionPrompts, [{ prompt: "[via web] What changed in prod?" }]);
+    assert.deepEqual(state.dbLogs.map((entry) => ({
+        role: entry.role,
+        content: entry.content,
+        source: entry.source,
+        sessionKey: entry.sessionKey,
+    })), [
+        { role: "user", content: "What changed in prod?", source: "web", sessionKey: "agent:bellonda" },
+        { role: "assistant", content: "Infra answer", source: "web", sessionKey: "agent:bellonda" },
+    ]);
+});
+test("sendToAgentSession annotates delegated turns as via chapterhouse", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        config: {
+            copilotModel: "claude-sonnet-4.6",
+            selfEditEnabled: true,
+            memoryInjectEnabled: true,
+        },
+        registry: [
+            {
+                slug: "bellonda",
+                name: "Bellonda",
+                model: "claude-sonnet-4.6",
+                systemMessage: "You are Bellonda.",
+                persistent: true,
+                scope: "infra",
+            },
+        ],
+        sendResult: "Delegated infra answer",
+    });
+    await orchestrator.initOrchestrator(client);
+    state.sessionPrompts.length = 0;
+    const final = await orchestrator.sendToAgentSession("bellonda", "Check deploy health", "task-bellonda-1");
+    assert.equal(final, "Delegated infra answer");
+    assert.deepEqual(state.sessionPrompts, [{ prompt: "[via @chapterhouse] Check deploy health" }]);
+    assert.deepEqual(state.dbLogs.map((entry) => ({
+        role: entry.role,
+        content: entry.content,
+        source: entry.source,
+        sessionKey: entry.sessionKey,
+    })), [
+        { role: "user", content: "Check deploy health", source: "delegated", sessionKey: "agent:bellonda" },
+        { role: "assistant", content: "Delegated infra answer", source: "delegated", sessionKey: "agent:bellonda" },
+    ]);
+});
+test("sendToOrchestrator preserves literal mentions inside persistent agent sessions", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        registry: [
+            {
+                slug: "bellonda",
+                name: "Bellonda",
+                model: "claude-sonnet-4.6",
+                systemMessage: "You are Bellonda.",
+                persistent: true,
+                scope: "infra",
+            },
+            {
+                slug: "hwi-noree",
+                name: "Hwi Noree",
+                model: "claude-sonnet-4.6",
+                systemMessage: "You are Hwi Noree.",
+                persistent: true,
+                scope: "brian",
+            },
+        ],
+        parseMentionResult: { agentSlug: "hwi-noree", message: "please archive this" },
+    });
+    await orchestrator.initOrchestrator(client);
+    state.sessionPrompts.length = 0;
+    state.setActiveAgentCalls.length = 0;
+    await new Promise((resolve) => {
+        orchestrator.sendToOrchestrator("@hwi-noree please archive this", { type: "sse-web", sessionKey: "agent:bellonda" }, (text, done) => {
+            if (done)
+                resolve(text);
+        });
+    });
+    assert.deepEqual(state.sessionPrompts, [{ prompt: "[via web] @hwi-noree please archive this" }]);
+    assert.deepEqual(state.setActiveAgentCalls, []);
+});
 test("sendToOrchestrator logs both sides, remembers web auth context, and records routing state", async (t) => {
     const { orchestrator, state, client } = await loadOrchestratorModule(t, {
         config: {
@@ -1007,13 +1220,14 @@ test("@mentions route through the orchestrator session without invoking the mode
     assert.deepEqual(state.routerArgs, []);
     assert.deepEqual(state.sessionPrompts, [{ prompt: "[via web] polish the landing page" }]);
 });
-test("feedAgentResult emits an attributed agent reply turn and sends only a short orchestrator prompt", async (t) => {
+test("feedAgentResult emits an attributed short agent reply before starting the orchestrator acknowledgement", async (t) => {
     const { orchestrator, state, client } = await loadOrchestratorModule(t, {
         config: {
             copilotModel: "claude-sonnet-4.6",
             selfEditEnabled: true,
         },
         sendResult: "Agent complete",
+        sendDeltas: ["Agent complete"],
         taskSessionKeys: new Map([["task-9", "chat:bg-lifecycle"]]),
     });
     await orchestrator.initOrchestrator(client);
@@ -1021,17 +1235,20 @@ test("feedAgentResult emits an attributed agent reply turn and sends only a shor
     const notified = new Promise((resolve) => {
         orchestrator.setProactiveNotify(resolve);
     });
-    orchestrator.feedAgentResult("task-9", "coder", "Fixed the flaky test");
+    const agentReply = "Fixed the flaky test. ".repeat(40);
+    orchestrator.feedAgentResult("task-9", "coder", agentReply);
+    assert.deepEqual(events.map((event) => event.type), ["turn:started", "turn:delta", "turn:complete"], "short agent replies should fully emit before the orchestrator acknowledgement starts");
+    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("Fixed the flaky test"), false, "orchestrator notification must not include the full agent reply body");
+    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");
     const deltas = events.filter((event) => event.type === "turn:delta");
     const completed = events.filter((event) => event.type === "turn:complete");
     assert.equal(started.length, 2, "agent reply plus orchestrator acknowledgement should each emit turn:started");
-    assert.equal(deltas.length, 1, "agent reply should stream as one or more deltas");
+    assert.equal(deltas.length, 2, "agent reply plus orchestrator acknowledgement should each emit one delta");
     assert.equal(completed.length, 2, "agent reply plus orchestrator acknowledgement should each emit turn:complete");
     assert.equal(started[0]?.agentSlug, "coder");
     assert.equal(started[0]?.agentDisplayName, "Kaylee");
@@ -1039,7 +1256,7 @@ test("feedAgentResult emits an attributed agent reply turn and sends only a shor
     assert.deepEqual(state.dbLogs, [
         {
             role: "agent_completion",
-            content: "Fixed the flaky test",
+            content: agentReply,
             source: "background",
             sessionKey: "chat:bg-lifecycle",
             agentSlug: "coder",
@@ -1055,10 +1272,11 @@ test("feedAgentResult emits an attributed agent reply turn and sends only a shor
         },
     ]);
     assert.equal(deltas[0]?.turnId, started[0]?.turnId);
-    assert.deepEqual(deltas[0]?.part, { type: "text", text: "Fixed the flaky test" });
+    assert.deepEqual(deltas[0]?.part, { type: "text", text: agentReply });
     assert.equal(completed[0]?.turnId, started[0]?.turnId);
-    assert.equal(completed[0]?.finalMessage, "Fixed the flaky test");
+    assert.equal(completed[0]?.finalMessage, agentReply);
     assert.notEqual(started[0]?.turnId, started[1]?.turnId, "agent reply and orchestrator acknowledgement need distinct turns");
+    assert.deepEqual(events.map((event) => event.type), ["turn:started", "turn:delta", "turn:complete", "turn:started", "turn:delta", "turn:complete"]);
 });
 test("feedAgentResult emits a delta even when the agent result is empty", async (t) => {
     const { orchestrator, client } = await loadOrchestratorModule(t, {

package/dist/copilot/session-manager.js

@@ -76,6 +76,9 @@ export class SessionManager {
     get canEvict() {
         return !this._processing && this._queue.length === 0;
     }
+    get isPersistent() {
+        return this.sessionKey.startsWith("agent:");
+    }
     get lastActivityAt() {
         return this._lastActivityAt;
     }
@@ -273,7 +276,7 @@ export class SessionRegistry {
         const existing = this.managers.get(sessionKey);
         if (existing)
             return existing;
-        if (this.managers.size >= this.options.maxActive) {
+        if (this.nonPersistentSize() >= this.options.maxActive) {
             this.evictLRU();
         }
         const manager = this.createManager(sessionKey);
@@ -330,6 +333,9 @@ export class SessionRegistry {
     runTtlEviction() {
         const now = Date.now();
         for (const [sessionKey, manager] of [...this.managers.entries()]) {
+            if (manager.isPersistent) {
+                continue;
+            }
             if (manager.canEvict && now - manager.lastActivityAt > this.options.idleTtlMs) {
                 const idleMs = now - manager.lastActivityAt;
                 this.managers.delete(sessionKey);
@@ -340,7 +346,7 @@ export class SessionRegistry {
     }
     evictLRU() {
         const evictable = [...this.managers.entries()]
-            .filter(([, m]) => m.canEvict)
+            .filter(([, m]) => m.canEvict && !m.isPersistent)
             .sort(([, a], [, b]) => a.lastActivityAt - b.lastActivityAt);
         if (evictable.length === 0) {
             log.warn({ size: this.managers.size, max: this.options.maxActive }, "At max active sessions and no idle sessions available for LRU eviction");
@@ -351,6 +357,9 @@ export class SessionRegistry {
         void manager.evict("lru-bumped");
         log.info({ sessionKey, reason: "lru-bumped" }, "session.evicted");
     }
+    nonPersistentSize() {
+        return [...this.managers.values()].filter((manager) => !manager.isPersistent).length;
+    }
     /** Shut down all sessions. Stops the eviction timer and disconnects every session. */
     async shutdown() {
         this.stopEvictionTimer();

package/dist/copilot/session-manager.test.js

@@ -312,6 +312,31 @@ test("SessionRegistry: TTL eviction removes sessions idle beyond the TTL", async
     assert.ok(disconnectLog.includes("idle-session"), "idle session must be evicted after TTL");
     assert.ok(!registry.get("idle-session"), "idle session must be removed");
 });
+test("SessionRegistry: TTL eviction does not remove persistent agent sessions", async () => {
+    const SHORT_TTL = 40;
+    const { registry, disconnectLog } = makeRegistry({ idleTtlMs: SHORT_TTL });
+    const manager = registry.getOrCreate("agent:bellonda");
+    await manager.ensureSession();
+    registry.startEvictionTimer();
+    await new Promise((r) => setTimeout(r, SHORT_TTL * 5));
+    registry.stopEvictionTimer();
+    assert.ok(registry.get("agent:bellonda"), "persistent agent session must stay registered after TTL");
+    assert.equal(disconnectLog.includes("agent:bellonda"), false, "persistent agent session must not disconnect on TTL");
+});
+test("SessionRegistry: LRU eviction skips persistent agent sessions", async () => {
+    const { registry, disconnectLog } = makeRegistry({ maxActive: 1, idleTtlMs: 60_000 });
+    const persistent = registry.getOrCreate("agent:bellonda");
+    await persistent.ensureSession();
+    await new Promise((r) => setTimeout(r, 2));
+    const regular = registry.getOrCreate("regular-session");
+    await regular.ensureSession();
+    registry.getOrCreate("new-session");
+    await new Promise((r) => setTimeout(r, 5));
+    assert.ok(registry.get("agent:bellonda"), "persistent agent session must not be LRU-evicted");
+    assert.ok(!registry.get("regular-session"), "oldest non-persistent idle session should be evicted");
+    assert.equal(disconnectLog.includes("agent:bellonda"), false);
+    assert.equal(disconnectLog.includes("regular-session"), true);
+});
 test("SessionRegistry: shutdown disconnects all sessions", async () => {
     const { registry, disconnectLog } = makeRegistry();
     for (const sk of ["a", "b", "c"]) {

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.agent.test.js

@@ -64,6 +64,7 @@ function expectedDelegatedPrompt(task, warningLines = []) {
 }
 async function loadToolsModule(t, options) {
     const sentPrompts = [];
+    const persistentSends = [];
     const taskId = options?.taskId ?? `delegated-task-${Date.now()}-${Math.random()}`;
     const fakeSession = {
         on: () => () => { },
@@ -86,15 +87,29 @@ async function loadToolsModule(t, options) {
             invalidateOrchestratorSession: () => { },
             resetCheckpointSessionState: () => { },
             switchSessionModel: async () => { },
+            sendToAgentSession: async (slug, prompt, delegatedTaskId) => {
+                persistentSends.push({ slug, prompt, taskId: delegatedTaskId });
+                return `persistent handled: ${prompt}`;
+            },
         },
     });
     t.mock.module("./agents.js", {
         namedExports: {
-            getAgentRegistry: () => [{ slug: "coder", name: "Coder", model: "claude-sonnet-4.6" }],
+            getAgentRegistry: () => [
+                { slug: "coder", name: "Coder", model: "claude-sonnet-4.6" },
+                { slug: "bellonda", name: "Bellonda", model: "claude-sonnet-4.6", persistent: true, scope: "infra" },
+            ],
             getAgent: (name) => name === "coder"
                 ? { slug: "coder", name: "Coder", model: "claude-sonnet-4.6" }
-                : undefined,
-            createEphemeralAgentSession: async () => fakeSession,
+                : name === "bellonda"
+                    ? { slug: "bellonda", name: "Bellonda", model: "claude-sonnet-4.6", persistent: true, scope: "infra" }
+                    : undefined,
+            createEphemeralAgentSession: async () => {
+                if (options?.persistentAgent) {
+                    throw new Error("persistent agent should not use ephemeral session");
+                }
+                return fakeSession;
+            },
             getAgentSessionStatus: () => ({ tasks: [] }),
             getActiveTasks: () => [],
             getTask: () => undefined,
@@ -115,7 +130,7 @@ async function loadToolsModule(t, options) {
         },
     });
     const module = await import(new URL(`./tools.js?case=${Date.now()}-${Math.random()}`, import.meta.url).href);
-    return { module, sentPrompts, taskId };
+    return { module, sentPrompts, taskId, persistentSends };
 }
 test.beforeEach(() => {
     process.env.CHAPTERHOUSE_HOME = mkdtempSync(join(tmpdir(), "chapterhouse-tools-agent-"));
@@ -235,4 +250,37 @@ test("delegate_to_agent does not inject orchestrator memory_context into subagen
     assert.deepEqual(sentPrompts, [expectedDelegatedPrompt(task)]);
     assert.equal(sentPrompts.some((prompt) => prompt.includes("<memory_context>")), false);
 });
+test("delegate_to_agent sends persistent agents through their backend session and returns result to orchestrator", async (t) => {
+    const { module, sentPrompts, persistentSends, taskId } = await loadToolsModule(t, {
+        taskId: "delegated-persistent-001",
+        persistentAgent: true,
+    });
+    const completions = [];
+    const tools = module.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: (completedTaskId, agentSlug, result) => {
+            completions.push({ taskId: completedTaskId, agentSlug, result });
+        },
+    });
+    const tool = tools.find((entry) => entry.name === "delegate_to_agent");
+    assert.ok(tool, "delegate_to_agent tool should be registered");
+    const response = await tool.handler({
+        agent_name: "bellonda",
+        summary: "Inspect infra drift",
+        task: "Run terraform plan for the VPC.",
+    }, {});
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    assert.match(String(response), /Task delegated to @bellonda/);
+    assert.deepEqual(sentPrompts, [], "persistent delegation must not create/use an ephemeral session");
+    assert.deepEqual(persistentSends, [{
+            slug: "bellonda",
+            prompt: "Run terraform plan for the VPC.",
+            taskId,
+        }]);
+    assert.deepEqual(completions, [{
+            taskId,
+            agentSlug: "bellonda",
+            result: "persistent handled: Run terraform plan for the VPC.",
+        }]);
+});
 //# sourceMappingURL=tools.agent.test.js.map