chapterhouse 0.4.3 → 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", {
@@ -342,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++;
@@ -354,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 });
@@ -366,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: () => { },
@@ -516,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: {
@@ -1007,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 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 +1188,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.",
         }]);
-    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 +1209,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 +1225,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/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

package/dist/copilot/tools.js

@@ -7,7 +7,7 @@ import { homedir } from "os";
 import { listSkills, createSkill, removeSkill } from "./skills.js";
 import { config, persistModel } from "../config.js";
 import { agentEventBus } from "./agent-event-bus.js";
-import { getCurrentSourceChannel, getCurrentActivityCallback, getCurrentActiveProjectRules, getCurrentAuthenticatedUser, getLastAuthenticatedUser, getCurrentAuthorizationHeader, getCurrentSessionKey, invalidateOrchestratorSession, maybeScheduleScopeChangeCheckpoint, resetCheckpointSessionState, switchSessionModel, } from "./orchestrator.js";
+import { getCurrentSourceChannel, getCurrentActivityCallback, getCurrentActiveProjectRules, getCurrentAuthenticatedUser, getLastAuthenticatedUser, getCurrentAuthorizationHeader, getCurrentSessionKey, sendToAgentSession, invalidateOrchestratorSession, maybeScheduleScopeChangeCheckpoint, resetCheckpointSessionState, switchSessionModel, } from "./orchestrator.js";
 import { getRouterConfig, updateRouterConfig } from "./router.js";
 import { ensureWikiStructure, readPage, writePage, deletePage, writeRawSource, assertPagePath } from "../wiki/fs.js";
 import { searchIndex, addToIndex, removeFromIndex, buildIndexEntryForPage } from "../wiki/index-manager.js";
@@ -65,6 +65,21 @@ function requireOrchestratorMemoryWrite() {
     }
     return null;
 }
+function resolveProposalScopeSlug(requestedScopeSlug) {
+    const agentSlug = agentsModule.getCurrentToolAgentSlug?.();
+    if (!agentSlug || agentSlug === "chapterhouse") {
+        return requestedScopeSlug;
+    }
+    const activeScope = getMemoryActiveScope();
+    if (activeScope) {
+        return activeScope.slug;
+    }
+    const agent = getAgent(agentSlug);
+    if (agent?.persistent && agent.scope) {
+        return agent.scope;
+    }
+    return requestedScopeSlug;
+}
 function resolveMemoryScopeForWrite(explicitScope, content) {
     const explicit = explicitScope ? getMemoryScope(explicitScope) : undefined;
     if (explicitScope && !explicit) {
@@ -210,15 +225,6 @@ export function createTools(deps) {
                 }
                 const delegatedSlug = agent.slug;
                 const taskId = createTaskId();
-                let session;
-                try {
-                    const allTools = createTools(deps);
-                    session = await createEphemeralAgentSession(agent.slug, deps.client, allTools, args.model_override, undefined, taskId);
-                }
-                catch (err) {
-                    const msg = err instanceof Error ? err.message : String(err);
-                    return `Failed to create session for @${delegatedSlug}: ${msg}`;
-                }
                 const task = registerTask(delegatedSlug, args.summary, getCurrentSourceChannel(), taskId);
                 const activeProjectRules = getCurrentActiveProjectRules();
                 const warningLines = activeProjectRules
@@ -232,6 +238,71 @@ export function createTools(deps) {
                 const db = getDb();
                 db.prepare(`INSERT INTO agent_tasks (task_id, agent_slug, description, prompt, status, origin_channel, session_key, source)
            VALUES (?, ?, ?, ?, 'running', ?, ?, 'adhoc')`).run(task.taskId, delegatedSlug, args.summary, args.task, task.originChannel || null, getCurrentSessionKey());
+                if (agent.persistent) {
+                    (async () => {
+                        try {
+                            const output = await sendToAgentSession(delegatedSlug, taskPrompt, task.taskId);
+                            completeTask(task.taskId, output);
+                            updateTaskResult(task.taskId, "completed", output);
+                            const statusEvent = appendTaskStatusEvent(task.taskId, "completed");
+                            if (statusEvent) {
+                                void agentEventBus.emit({
+                                    type: "session:tool_call",
+                                    sessionId: task.taskId,
+                                    payload: {
+                                        toolName: "",
+                                        toolArgs: {},
+                                        _kind: statusEvent.kind,
+                                        _seq: statusEvent.seq,
+                                        _ts: statusEvent.ts,
+                                        _summary: statusEvent.summary,
+                                        _text: statusEvent.text,
+                                        _status: statusEvent.status,
+                                    },
+                                    timestamp: new Date(statusEvent.ts),
+                                });
+                            }
+                            deps.onAgentTaskComplete(task.taskId, delegatedSlug, output);
+                        }
+                        catch (err) {
+                            const msg = err instanceof Error ? err.message : String(err);
+                            failTask(task.taskId, msg);
+                            updateTaskResult(task.taskId, "error", msg);
+                            const statusEvent = appendTaskStatusEvent(task.taskId, "error", msg);
+                            if (statusEvent) {
+                                void agentEventBus.emit({
+                                    type: "session:tool_call",
+                                    sessionId: task.taskId,
+                                    payload: {
+                                        toolName: "",
+                                        toolArgs: {},
+                                        _kind: statusEvent.kind,
+                                        _seq: statusEvent.seq,
+                                        _ts: statusEvent.ts,
+                                        _summary: statusEvent.summary,
+                                        _text: statusEvent.text,
+                                        _status: statusEvent.status,
+                                    },
+                                    timestamp: new Date(statusEvent.ts),
+                                });
+                            }
+                            deps.onAgentTaskComplete(task.taskId, delegatedSlug, `Error: ${msg}`);
+                        }
+                    })();
+                    const model = (args.model_override && args.model_override.length > 0)
+                        ? args.model_override
+                        : (agent.model === "auto" ? "claude-sonnet-4.6" : agent.model || "claude-sonnet-4.6");
+                    return `Task delegated to @${delegatedSlug} (${model}). Task ID: ${task.taskId}. I'll notify you when it's done.`;
+                }
+                let session;
+                try {
+                    const allTools = createTools(deps);
+                    session = await createEphemeralAgentSession(agent.slug, deps.client, allTools, args.model_override, undefined, taskId);
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    return `Failed to create session for @${delegatedSlug}: ${msg}`;
+                }
                 // Capture the parent's activity callback so the child session can stream
                 // its events back to the originating SSE connection. This survives past
                 // the parent assistant turn — the child runs long after the parent's
@@ -876,7 +947,7 @@ export function createTools(deps) {
                                 : actionItemProposalPayloadSchema.parse(parsedArgs.payload);
                     const proposal = queueMemoryProposal({
                         kind: parsedArgs.kind,
-                        scopeSlug: parsedArgs.scope_slug,
+                        scopeSlug: resolveProposalScopeSlug(parsedArgs.scope_slug),
                         payload,
                         confidence: parsedArgs.confidence ?? 0.5,
                         reason: parsedArgs.reason,

package/dist/copilot/tools.memory.test.js

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { mkdtempSync, rmSync } from "node:fs";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import test from "node:test";
@@ -46,6 +46,7 @@ test("memory_set_scope invalidates the orchestrator session after scheduling the
             invalidateOrchestratorSession: (sessionKey) => {
                 events.push(`invalidate:${sessionKey}`);
             },
+            sendToAgentSession: async () => "",
             switchSessionModel: async () => { },
         },
     });
@@ -194,6 +195,54 @@ test("memory_propose queues pending proposals, defaults scope from the active sc
     assert.equal(payload.reason, "The user explicitly asked for the new proposal path.");
     assert.equal(payload.payload.content, "Subagents can queue durable observations for orchestrator review.");
 });
+test("memory_propose from a persistent agent is bound to that agent's scope", async () => {
+    const home = process.env.CHAPTERHOUSE_HOME;
+    assert.ok(home, "test home should be set");
+    const chapterhouseHome = home.endsWith(".chapterhouse") ? home : join(home, ".chapterhouse");
+    const agentsDir = join(chapterhouseHome, "agents");
+    mkdirSync(agentsDir, { recursive: true });
+    writeFileSync(join(agentsDir, "bellonda.agent.md"), [
+        "---",
+        "name: Bellonda",
+        "description: Mentat of the infrastructure domain",
+        "model: claude-sonnet-4.6",
+        "persistent: true",
+        "scope: infra",
+        "---",
+        "",
+        "You are Bellonda.",
+    ].join("\n"));
+    const { toolsModule, agentsModule, dbModule } = await loadModules();
+    agentsModule.loadAgents();
+    const tools = toolsModule.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+    });
+    const bindToolsToAgent = agentsModule.bindToolsToAgent;
+    assert.equal(typeof bindToolsToAgent, "function", "bindToolsToAgent should be exported");
+    const chapterhouseTools = bindToolsToAgent("chapterhouse", tools);
+    const bellondaTools = bindToolsToAgent("bellonda", tools, "task-persistent-scope-001");
+    await findTool(chapterhouseTools, "memory_set_scope").handler({ slug: "chapterhouse" }, {});
+    const memoryModule = await import("../memory/index.js");
+    const proposed = await memoryModule.withActiveScope("infra", () => findTool(bellondaTools, "memory_propose").handler({
+        kind: "observation",
+        scope_slug: "chapterhouse",
+        payload: {
+            content: "Persistent agents should not be able to write proposals outside their bound scope.",
+        },
+    }, {}));
+    assert.equal(proposed.status, "queued");
+    const row = dbModule.getDb().prepare(`
+    SELECT source_agent, source_task_id, payload
+    FROM mem_inbox
+    WHERE id = ?
+  `).get(proposed.proposal_id);
+    assert.ok(row, "memory_propose should insert a mem_inbox row");
+    assert.equal(row.source_agent, "bellonda");
+    assert.equal(row.source_task_id, "task-persistent-scope-001");
+    const payload = JSON.parse(row.payload);
+    assert.equal(payload.scope_slug, "infra");
+});
 test("memory_propose accepts entity proposals with entity_kind and queues the full payload", async () => {
     const { toolsModule, agentsModule, dbModule } = await loadModules();
     const tools = toolsModule.createTools({