chapterhouse 0.4.2 → 0.5.0

package/dist/copilot/orchestrator.test.js

@@ -29,6 +29,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) {
@@ -102,7 +105,7 @@ 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",
         taskEvents: new Map(),
@@ -150,11 +153,35 @@ async function loadOrchestratorModule(t, overrides = {}) {
     t.mock.module("../memory/hot-tier.js", {
         namedExports: {
             renderHotTierForActiveScope: () => state.hotTierXml ?? "",
+            getHotTierEntries: (scopeId) => ({
+                scope: scopeId !== undefined
+                    ? 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", {
@@ -249,8 +276,14 @@ async function loadOrchestratorModule(t, overrides = {}) {
     });
     t.mock.module("../store/db.js", {
         namedExports: {
-            logConversation: (role, content, source) => {
-                state.dbLogs.push({ role, content, source });
+            logConversation: (role, content, source, sessionKey, metadata) => {
+                state.dbLogs.push({
+                    role,
+                    content,
+                    source,
+                    ...(sessionKey && sessionKey !== "default" ? { sessionKey } : {}),
+                    ...metadata,
+                });
             },
             getState: (key) => state.store.get(key),
             setState: (key, value) => {
@@ -336,10 +369,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++;
@@ -348,6 +378,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 });
@@ -360,6 +391,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: () => { },
@@ -510,6 +545,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: {
@@ -559,9 +731,11 @@ test("sendToOrchestrator logs both sides, remembers web auth context, and record
         { direction: "in", source: "web", text: "Summarize the deployment" },
         { direction: "out", source: "web", text: "All green" },
     ]);
+    const loggedTurnId = state.dbLogs[0]?.turnId;
+    assert.equal(typeof loggedTurnId, "string");
     assert.deepEqual(state.dbLogs, [
-        { role: "user", content: "Summarize the deployment", source: "web" },
-        { role: "assistant", content: "All green", source: "web" },
+        { role: "user", content: "Summarize the deployment", source: "web", turnId: loggedTurnId },
+        { role: "assistant", content: "All green", source: "web", turnId: loggedTurnId },
     ]);
     assert.equal(state.episodeWrites, 1);
 });
@@ -999,13 +1173,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 injects a background completion turn and proactively notifies listeners", 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);
@@ -1013,28 +1188,69 @@ test("feedAgentResult injects a background completion turn and proactively notif
     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:\n\nFixed the flaky test",
+            prompt: "[Agent task completed] @coder finished task task-9. Their reply has been shown to the user. Acknowledge briefly.",
         }]);
+    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, 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");
+    assert.equal(started[0]?.prompt, "");
     assert.deepEqual(state.dbLogs, [
         {
             role: "agent_completion",
-            content: "[Agent task completed] @coder finished task task-9:\n\nFixed the flaky test",
+            content: agentReply,
             source: "background",
+            sessionKey: "chat:bg-lifecycle",
+            agentSlug: "coder",
+            agentDisplayName: "Kaylee",
+            turnId: started[0]?.turnId,
         },
         {
             role: "assistant",
             content: "Agent complete",
             source: "background",
+            sessionKey: "chat:bg-lifecycle",
+            turnId: started[1]?.turnId,
         },
     ]);
-    const started = events.filter((event) => event.type === "turn:started");
-    const completed = events.filter((event) => event.type === "turn:complete");
-    assert.equal(started.length, 1, "background turn should emit one turn:started event");
-    assert.equal(completed.length, 1, "background turn should emit one turn:complete event");
-    assert.equal(started[0]?.turnId, completed[0]?.turnId, "background lifecycle events must share the same turnId");
+    assert.equal(deltas[0]?.turnId, started[0]?.turnId);
+    assert.deepEqual(deltas[0]?.part, { type: "text", text: agentReply });
+    assert.equal(completed[0]?.turnId, started[0]?.turnId);
+    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, {
+        config: { copilotModel: "claude-sonnet-4.6", selfEditEnabled: true },
+        sendResult: "Acknowledged",
+        taskSessionKeys: new Map([["task-empty", "chat:bg-empty"]]),
+    });
+    await orchestrator.initOrchestrator(client);
+    const events = captureSessionEvents(t, "chat:bg-empty");
+    const notified = new Promise((resolve) => {
+        orchestrator.setProactiveNotify(resolve);
+    });
+    orchestrator.feedAgentResult("task-empty", "coder", "");
+    assert.equal(await notified, "Acknowledged");
+    const agentStarted = events.find((event) => event.type === "turn:started" && event.agentSlug === "coder");
+    assert.ok(agentStarted, "agent reply should emit a started event");
+    const deltas = events
+        .filter((event) => event.type === "turn:delta")
+        .filter((event) => event.turnId === agentStarted.turnId);
+    assert.equal(deltas.length, 1);
+    assert.deepEqual(deltas[0]?.part, { type: "text", text: "" });
 });
 test("enqueueForSse emits exactly one turn lifecycle pair for sse-web turns", async (t) => {
     const { orchestrator, client } = await loadOrchestratorModule(t, {
@@ -1227,11 +1443,11 @@ test("feedAgentResult routes to a non-default session when the task's session_ke
     // A second createSession call proves the orchestrator opened a fresh non-default session
     // rather than reusing the already-open default session.
     assert.equal(state.createSessionCalls.length, sessionsAfterInit + 1, "feedAgentResult should spin up a non-default session, not recycle the default one");
-    // The prompt must reference the task and agent
+    // The prompt must reference the task and agent but not include the full reply body.
     const prompt = state.sessionPrompts.at(-1);
     assert.ok(prompt?.prompt.includes("chat-task-1"), "prompt should reference the task id");
     assert.ok(prompt?.prompt.includes("coder"), "prompt should reference the agent slug");
-    assert.ok(prompt?.prompt.includes("Feature done"), "prompt should include the result text");
+    assert.equal(prompt?.prompt.includes("Feature done"), false, "prompt should not include the result text");
 });
 test("ensureOrchestratorSession cleans up in-flight promise on session creation failure", async (t) => {
     const { orchestrator, state, 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/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