chapterhouse 0.4.2 → 0.5.0

package/agents/bellonda.agent.md

@@ -0,0 +1,11 @@
+---
+name: Bellonda
+description: Mentat of the infrastructure domain
+model: claude-sonnet-4.6
+persistent: true
+scope: infra
+---
+
+You are Bellonda, Chapterhouse's infrastructure specialist. You own the `infra` memory scope and help Brian reason about deployment, hosting, CI/CD, and operational reliability.
+
+Work carefully, surface risk clearly, and preserve durable infrastructure knowledge by proposing scoped memories when useful.

package/agents/hwi-noree.agent.md

@@ -0,0 +1,12 @@
+---
+name: Hwi Noree
+description: Personal assistant and archivist for Brian
+model: claude-sonnet-4.6
+skills: [wiki-conventions]
+persistent: true
+scope: brian
+---
+
+You are Hwi Noree, Brian's personal assistant and archivist inside Chapterhouse. You own the `brian` memory scope and help maintain Brian's preferences, working style, personal context, and reminders.
+
+Do not access email or calendar systems. Use the wiki carefully and invoke `wiki-conventions` before wiki writes.

package/dist/api/server.js

@@ -5,9 +5,9 @@ import { existsSync } from "fs";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 import { z } from "zod";
-import { sendToOrchestrator, interruptCurrentTurn, enqueueForSse, getAgentInfo, cancelCurrentMessage, getLastRouteResult, getCurrentSessionKey } from "../copilot/orchestrator.js";
+import { sendToOrchestrator, interruptCurrentTurn, enqueueForSse, getAgentInfo, cancelCurrentMessage, interruptSessionTurn, getLastRouteResult, getCurrentSessionKey } from "../copilot/orchestrator.js";
 import { agentEventBus } from "../copilot/agent-event-bus.js";
-import { getAgentRegistry } from "../copilot/agents.js";
+import { ensureDefaultAgents, getAgentRegistry, loadAgents } from "../copilot/agents.js";
 import { config, persistModel } from "../config.js";
 import { getRouterConfig, updateRouterConfig } from "../copilot/router.js";
 import { searchIndex, parseIndex } from "../wiki/index-manager.js";
@@ -313,6 +313,33 @@ app.get("/health", handleHealth);
 app.get("/api/agents", (_req, res) => {
     res.json(getAgentInfo());
 });
+app.get("/api/channels", (_req, res) => {
+    let agents = getAgentRegistry();
+    if (agents.length === 0) {
+        ensureDefaultAgents();
+        agents = loadAgents();
+    }
+    const persistentAgentChannels = agents
+        .filter((agent) => agent.persistent)
+        .map((agent) => ({
+        key: `agent:${agent.slug}`,
+        label: `# ${agent.slug}`,
+        slug: agent.slug,
+        name: agent.name,
+        description: agent.description,
+        ...(agent.scope ? { scope: agent.scope } : {}),
+    }))
+        .sort((a, b) => a.label.localeCompare(b.label));
+    res.json([
+        {
+            key: "default",
+            label: "# chapterhouse",
+            name: "Chapterhouse",
+            description: "Orchestrator",
+        },
+        ...persistentAgentChannels,
+    ]);
+});
 // List all workers: reads from SQLite agent_tasks (last 24 hours) so completed
 // dispatched subagents remain visible after they finish, not just in-flight ones.
 app.get("/api/workers", (_req, res) => {
@@ -614,6 +641,16 @@ app.post("/api/cancel", async (_req, res) => {
     }
     res.json({ status: "ok", cancelled });
 });
+// Cancel the active turn for one session key without touching other channels.
+app.post("/api/session/:sessionKey/interrupt", async (req, res) => {
+    const sessionKey = Array.isArray(req.params.sessionKey)
+        ? req.params.sessionKey[0]
+        : req.params.sessionKey;
+    if (!sessionKey)
+        throw new BadRequestError("Missing sessionKey");
+    const cancelled = await interruptSessionTurn(sessionKey);
+    res.json({ status: "ok", cancelled });
+});
 // Interrupt the active turn on a specific session and start a replacement turn.
 // POST /api/sessions/:sessionKey/interrupt
 // Body: { prompt, connectionId, attachments? }

package/dist/api/server.test.js

@@ -207,6 +207,26 @@ test("server routes expose bootstrap and public config without auth", async () =
         });
     });
 });
+test("server channels route returns chapterhouse plus persistent agents in channel order", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader }) => {
+        const response = await fetch(`${baseUrl}/api/channels`, {
+            headers: { authorization: authHeader },
+        });
+        assert.equal(response.status, 200);
+        const channels = await response.json();
+        assert.deepEqual(channels.map((channel) => channel.key), [
+            "default",
+            "agent:bellonda",
+            "agent:hwi-noree",
+        ]);
+        assert.deepEqual(channels.map((channel) => channel.label), [
+            "# chapterhouse",
+            "# bellonda",
+            "# hwi-noree",
+        ]);
+        assert.equal(channels.find((channel) => channel.key === "agent:bellonda")?.scope, "infra");
+    });
+});
 test("server runs in standalone mode without auth", async () => {
     await withStartedServer(async ({ baseUrl }) => {
         const bootstrap = await fetch(`${baseUrl}/api/bootstrap`);

package/dist/api/turn-sse.integration.test.js

@@ -358,4 +358,16 @@ test("turn-sse: turnId returned by POST matches turnId in all SSE events for tha
         }
     }, { CHAPTERHOUSE_CHAT_SSE: "1" }, 15_000);
 });
+test("turn-sse: POST /api/session/:sessionKey/interrupt returns per-session cancel status", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader }) => {
+        const res = await fetch(`${baseUrl}/api/session/test-session-interrupt/interrupt`, {
+            method: "POST",
+            headers: { Authorization: authHeader },
+        });
+        const bodyText = await res.text();
+        assert.equal(res.status, 200, `POST /interrupt returned ${res.status}: ${bodyText}`);
+        const body = JSON.parse(bodyText);
+        assert.deepEqual(body, { status: "ok", cancelled: false });
+    }, { CHAPTERHOUSE_CHAT_SSE: "1" }, 15_000);
+});
 //# sourceMappingURL=turn-sse.integration.test.js.map

package/dist/copilot/agents.js

@@ -23,6 +23,12 @@ const agentFrontmatterSchema = z.object({
     tools: z.array(z.string()).optional(),
     mcpServers: z.array(z.string()).optional(),
     allowed_paths: z.array(z.string()).optional(),
+    persistent: z.union([z.boolean(), z.string()]).optional().transform((value) => {
+        if (typeof value === "string")
+            return value.toLowerCase() === "true";
+        return value;
+    }),
+    scope: z.string().optional(),
 });
 // ---------------------------------------------------------------------------
 // Agent Registry
@@ -77,6 +83,8 @@ export function parseAgentMd(content, slug) {
         name: fm.name,
         description: fm.description,
         model: fm.model,
+        persistent: fm.persistent,
+        scope: fm.scope,
         skills: fm.skills,
         tools: fm.tools,
         mcpServers: fm.mcpServers,
@@ -227,7 +235,7 @@ function getAgentBasePrompt() {
 You are an agent within Chapterhouse, a team-level AI assistant for engineering teams. You run on the user's local machine.
 
 ### Agent Memory
-Chapterhouse agent memory follows a three-tier memory model: **read** with \`memory_recall\`, **propose** with \`memory_propose\`, and **write** with orchestrator-only tools. Do not call \`memory_remember\` directly; when you discover something memory-worthy, use \`memory_propose\` instead. Proposals are processed automatically at end-of-task, so do not wait for confirmation. Examples: a durable fact is an \`observation\`, a settled implementation choice is a \`decision\`, and a named system/tool/person can be proposed as an \`entity\`.
+Chapterhouse agent memory follows a three-tier memory model: **read** with \`memory_recall\` and \`memory_list_action_items\`, **propose** with \`memory_propose\`, and **write** with orchestrator-only tools. Do not call \`memory_remember\` directly; when you discover something memory-worthy, use \`memory_propose\` instead. Proposals are processed automatically at end-of-task, so do not wait for confirmation. Examples: a durable fact is an \`observation\`, a settled implementation choice is a \`decision\`, a named system/tool/person can be proposed as an \`entity\`, and a reminder/follow-up can be proposed as an \`action_item\`.
 
 ### Shared Wiki
 All agents share a wiki knowledge base for persistent memory. Use \`wiki_read\` and \`wiki_search\` to find existing knowledge, and \`wiki_update\` to save important findings.
@@ -275,7 +283,7 @@ export function buildAgentRoster() {
 const WIKI_TOOL_NAMES = new Set([
     "wiki_search", "wiki_read", "wiki_update", "remember", "recall", "forget",
     "wiki_ingest", "wiki_lint", "wiki_rebuild_index",
-    "memory_recall", "memory_propose",
+    "memory_recall", "memory_propose", "memory_list_action_items",
 ]);
 // Management tools that only @chapterhouse should have
 const MANAGEMENT_TOOL_NAMES = new Set([
@@ -285,6 +293,7 @@ const MANAGEMENT_TOOL_NAMES = new Set([
     "restart_chapterhouse", "list_skills", "learn_skill", "uninstall_skill",
     "list_machine_sessions", "attach_machine_session",
     "memory_remember", "memory_set_scope", "memory_housekeep", "memory_promote", "memory_demote",
+    "memory_add_action_item", "memory_complete_action_item", "memory_drop_action_item", "memory_snooze_action_item",
 ]);
 export function getCurrentToolAgentSlug() {
     return toolAgentContext.getStore();
@@ -292,10 +301,13 @@ export function getCurrentToolAgentSlug() {
 export function getCurrentToolTaskId() {
     return toolTaskContext.getStore();
 }
+export function withToolTaskContext(taskId, fn) {
+    return toolTaskContext.run(taskId, fn);
+}
 export function bindToolsToAgent(agentSlug, allTools, taskId) {
     return allTools.map((tool) => ({
         ...tool,
-        handler: (args, invocation) => toolAgentContext.run(agentSlug, () => toolTaskContext.run(taskId, () => tool.handler(args, invocation))),
+        handler: (args, invocation) => toolAgentContext.run(agentSlug, () => toolTaskContext.run(taskId ?? getCurrentToolTaskId(), () => tool.handler(args, invocation))),
     }));
 }
 /** Filter tools based on agent config. */
@@ -303,7 +315,7 @@ export function filterToolsForAgent(agent, allTools) {
     if (agent.tools && agent.tools.length > 0) {
         // Agent specifies an explicit allowlist — give those + wiki tools
         const allowed = new Set([...agent.tools, ...WIKI_TOOL_NAMES]);
-        return allTools.filter((t) => allowed.has(t.name));
+        return allTools.filter((t) => allowed.has(t.name) && !(agent.persistent && MANAGEMENT_TOOL_NAMES.has(t.name)));
     }
     // Default: all tools except management (only @chapterhouse gets those)
     if (agent.slug === "chapterhouse") {

package/dist/copilot/agents.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { composeAgentSystemMessage, } from "./agents.js";
+import { composeAgentSystemMessage, filterToolsForAgent, bindToolsToAgent, getCurrentToolTaskId, parseAgentMd, withToolTaskContext, } from "./agents.js";
 function makeAgent(slug) {
     return {
         slug,
@@ -60,4 +60,46 @@ test("composeAgentSystemMessage teaches subagents the three-tier memory model an
     assert.match(message, /memory_propose/i);
     assert.match(message, /do not call `memory_remember` directly|should not call `memory_remember` directly/i);
 });
+test("parseAgentMd detects persistent agent scope from charter frontmatter", () => {
+    const agent = parseAgentMd([
+        "---",
+        "name: Bellonda",
+        "description: Mentat of the infrastructure domain",
+        "model: claude-sonnet-4.6",
+        "persistent: true",
+        "scope: infra",
+        "---",
+        "",
+        "You are Bellonda.",
+    ].join("\n"), "bellonda");
+    assert.ok(agent, "agent charter should parse");
+    assert.equal(agent.persistent, true);
+    assert.equal(agent.scope, "infra");
+});
+test("persistent agents cannot receive scope-changing management tools", () => {
+    const agent = {
+        ...makeAgent("bellonda"),
+        persistent: true,
+        scope: "infra",
+    };
+    const tools = [
+        { name: "memory_recall" },
+        { name: "memory_propose" },
+        { name: "memory_set_scope" },
+        { name: "delegate_to_agent" },
+        { name: "bash" },
+    ];
+    const filtered = filterToolsForAgent(agent, tools);
+    const names = filtered.map((tool) => tool.name);
+    assert.deepEqual(names.sort(), ["bash", "memory_propose", "memory_recall"].sort());
+});
+test("bindToolsToAgent uses the per-turn task context when no fixed task id is provided", async () => {
+    const tools = bindToolsToAgent("bellonda", [{
+            name: "probe_task_context",
+            handler: async () => getCurrentToolTaskId(),
+        }]);
+    assert.equal(await tools[0].handler({}, {}), undefined);
+    const taskId = await withToolTaskContext("delegated-persistent-001", () => tools[0].handler({}, {}));
+    assert.equal(taskId, "delegated-persistent-001");
+});
 //# sourceMappingURL=agents.test.js.map

package/dist/copilot/orchestrator.js

@@ -4,7 +4,9 @@ import { approveAll } from "@github/copilot-sdk";
 import { createTools } from "./tools.js";
 import { getOrchestratorSystemMessage } from "./system-message.js";
 import { renderHotTierForActiveScope } from "../memory/hot-tier.js";
-import { getActiveScope } from "../memory/active-scope.js";
+import { getHotTierEntries, renderHotTierXML } from "../memory/hot-tier.js";
+import { getActiveScope, withActiveScope } from "../memory/active-scope.js";
+import { getScope } from "../memory/scopes.js";
 import { CheckpointTracker, isCheckpointInFlight, runCheckpointExtraction } from "../memory/checkpoint.js";
 import { isHousekeepingInFlight, runHousekeeping } from "../memory/housekeeping.js";
 import { runEndOfTaskMemoryHook } from "../memory/eot.js";
@@ -18,7 +20,7 @@ import { maybeWriteEpisode } from "./episode-writer.js";
 import { getWikiSummary } from "../wiki/context.js";
 import { SESSIONS_DIR } from "../paths.js";
 import { resolveModel } from "./router.js";
-import { loadAgents, ensureDefaultAgents, clearActiveTasks, getAgentRegistry, setActiveAgent, parseAtMention, buildAgentRoster, getActiveTasks, } from "./agents.js";
+import { loadAgents, ensureDefaultAgents, clearActiveTasks, getAgentRegistry, setActiveAgent, parseAtMention, buildAgentRoster, getActiveTasks, getAgent, composeAgentSystemMessage, filterToolsForAgent, withToolTaskContext, } from "./agents.js";
 import * as agentsModule from "./agents.js";
 import { childLogger } from "../util/logger.js";
 import { agentEventBus } from "./agent-event-bus.js";
@@ -34,6 +36,8 @@ const log = childLogger("orchestrator");
 const MAX_RETRIES = 3;
 const RECONNECT_DELAYS_MS = [1_000, 3_000, 10_000];
 const HEALTH_CHECK_INTERVAL_MS = 30_000;
+const AGENT_REPLY_CHUNK_SIZE = 500;
+const AGENT_REPLY_CHUNK_THRESHOLD = 8 * 1024;
 const ORCHESTRATOR_SESSION_KEY = "orchestrator_session_id";
 const LAST_AUTHENTICATED_USER_KEY = "last_authenticated_user";
 let logMessage = () => { };
@@ -136,7 +140,7 @@ function scheduleCheckpointExtraction(sessionKey, prompt, finalContent, source)
         log.error({ sessionKey }, "memory.checkpoint.error");
         return;
     }
-    const activeScope = getActiveScope();
+    const activeScope = getMemoryScopeForSession(sessionKey);
     void runCheckpointExtraction({
         sessionKey,
         turns: turns.slice(-config.memoryCheckpointTurns),
@@ -161,7 +165,7 @@ function scheduleHousekeeping(sessionKey, source) {
         return;
     }
     housekeepingTurnsBySession.set(sessionKey, 0);
-    const activeScope = getActiveScope();
+    const activeScope = getMemoryScopeForSession(sessionKey);
     if (!activeScope) {
         log.info({ sessionKey }, "memory.housekeeping.no_active_scope");
         return;
@@ -321,6 +325,30 @@ function getSessionConfig() {
     const skillDirectories = getSkillDirectories();
     return { tools, mcpServers, skillDirectories };
 }
+function agentSlugFromSessionKey(sessionKey) {
+    return sessionKey.startsWith("agent:") ? sessionKey.slice("agent:".length) : undefined;
+}
+function getPersistentAgentForSessionKey(sessionKey) {
+    const slug = agentSlugFromSessionKey(sessionKey);
+    if (!slug)
+        return undefined;
+    const agent = getAgent(slug);
+    return agent?.persistent ? agent : undefined;
+}
+function getMemoryScopeForSession(sessionKey) {
+    const persistentAgent = getPersistentAgentForSessionKey(sessionKey);
+    if (persistentAgent?.scope) {
+        return getScope(persistentAgent.scope) ?? null;
+    }
+    return getActiveScope();
+}
+function buildScopedHotTierContext(scope) {
+    if (!config.memoryInjectEnabled || !scope) {
+        return undefined;
+    }
+    const hotTierXml = renderHotTierXML(getHotTierEntries(scope.id));
+    return hotTierXml ? hotTierXml.trimEnd() : undefined;
+}
 function buildHotTierContext() {
     if (!config.memoryInjectEnabled) {
         return undefined;
@@ -380,13 +408,51 @@ export function feedAgentResult(taskId, agentSlug, result) {
             log.error({ err: error, taskId }, "memory.eot.error");
         });
     }
-    const prompt = `[Agent task completed] @${agentSlug} finished task ${taskId}:\n\n${result}`;
-    const sessionKey = getTaskSessionKey(taskId);
-    sendToOrchestrator(prompt, { type: "background", sessionKey }, (text, done) => {
-        if (done && proactiveNotifyFn) {
-            proactiveNotifyFn(text);
+    const sessionKey = getTaskSessionKey(taskId) || "default";
+    const agentTurnId = randomUUID();
+    const agentDisplayName = getAgentRegistry().find((agent) => agent.slug === agentSlug)?.name ?? agentSlug;
+    try {
+        emitTurnEvent(sessionKey, {
+            type: "turn:started",
+            turnId: agentTurnId,
+            sessionKey,
+            prompt: "",
+            agentSlug,
+            agentDisplayName,
+        });
+        const chunks = result.length <= AGENT_REPLY_CHUNK_THRESHOLD ? [result] : Array.from({ length: Math.ceil(result.length / AGENT_REPLY_CHUNK_SIZE) }, (_, index) => result.slice(index * AGENT_REPLY_CHUNK_SIZE, (index + 1) * AGENT_REPLY_CHUNK_SIZE));
+        for (const chunk of chunks) {
+            emitTurnEvent(sessionKey, {
+                type: "turn:delta",
+                turnId: agentTurnId,
+                sessionKey,
+                part: { type: "text", text: chunk },
+            });
         }
-    });
+        finalizeTurnEvent(sessionKey, { type: "turn:complete", turnId: agentTurnId, finalMessage: result });
+    }
+    catch (err) {
+        log.warn({ err: err instanceof Error ? err.message : err, taskId, agentSlug }, "Failed to emit synthetic agent reply turn");
+    }
+    try {
+        logConversation("agent_completion", result, "background", sessionKey, {
+            agentSlug,
+            agentDisplayName,
+            turnId: agentTurnId,
+        });
+    }
+    catch (err) {
+        log.warn({ err: err instanceof Error ? err.message : err, taskId, agentSlug }, "Failed to persist agent completion");
+    }
+    void (async () => {
+        await new Promise((resolve) => setImmediate(resolve));
+        const prompt = `[Agent task completed] @${agentSlug} finished task ${taskId}. Their reply has been shown to the user. Acknowledge briefly.`;
+        sendToOrchestrator(prompt, { type: "background", sessionKey }, (text, done) => {
+            if (done && proactiveNotifyFn) {
+                proactiveNotifyFn(text);
+            }
+        }, undefined, undefined, undefined, undefined, undefined, { suppressPromptLog: true });
+    })();
 }
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
@@ -431,25 +497,48 @@ function startHealthCheck() {
 /** Internal: create or resume a CopilotSession. Called by SessionManager.ensureSession(). */
 async function createOrResumeSession(sessionKey, projectRoot) {
     const client = await ensureClient();
-    const { tools, mcpServers, skillDirectories } = getSessionConfig();
+    const baseConfig = getSessionConfig();
+    let { tools, mcpServers, skillDirectories } = baseConfig;
     const isProjectSession = sessionKey.startsWith("project:");
+    const persistentAgent = getPersistentAgentForSessionKey(sessionKey);
+    const agentScope = persistentAgent?.scope ? getScope(persistentAgent.scope) ?? null : null;
     const infiniteSessions = {
         enabled: true,
         backgroundCompactionThreshold: 0.80,
         bufferExhaustionThreshold: 0.95,
     };
-    const memorySummary = getWikiSummary();
-    const systemMessageContent = getOrchestratorSystemMessage({
-        ...getSystemMessageOptions(memorySummary),
-        version: CHAPTERHOUSE_VERSION,
-    });
+    let model = config.copilotModel;
+    let systemMessageContent;
+    let sessionMode = isProjectSession ? "project" : "default";
+    if (persistentAgent) {
+        model = persistentAgent.model === "auto" ? config.copilotModel : persistentAgent.model;
+        tools = agentsModule.bindToolsToAgent(persistentAgent.slug, filterToolsForAgent(persistentAgent, createTools({
+            client: copilotClient,
+            onAgentTaskComplete: feedAgentResult,
+        })));
+        const scopedHotTier = buildScopedHotTierContext(agentScope);
+        const channelNote = `You are in your persistent Chapterhouse channel (${sessionKey}). Your memory scope is ${persistentAgent.scope}.`;
+        systemMessageContent = [
+            composeAgentSystemMessage(persistentAgent),
+            channelNote,
+            scopedHotTier,
+        ].filter(Boolean).join("\n\n");
+        sessionMode = "agent";
+    }
+    else {
+        const memorySummary = getWikiSummary();
+        systemMessageContent = getOrchestratorSystemMessage({
+            ...getSystemMessageOptions(memorySummary),
+            version: CHAPTERHOUSE_VERSION,
+        });
+    }
     const stored = getCopilotSession(sessionKey);
     const savedSessionId = stored?.copilotSessionId ?? (sessionKey === "default" ? getState(ORCHESTRATOR_SESSION_KEY) : undefined);
     if (savedSessionId) {
         try {
             log.info({ sessionKey, sessionId: savedSessionId.slice(0, 8) }, "Resuming session");
             const session = await client.resumeSession(savedSessionId, {
-                model: config.copilotModel,
+                model,
                 configDir: SESSIONS_DIR,
                 streaming: true,
                 systemMessage: { content: systemMessageContent },
@@ -461,10 +550,10 @@ async function createOrResumeSession(sessionKey, projectRoot) {
             });
             log.info({ sessionKey }, "Session resumed successfully");
             resetCheckpointSessionState(sessionKey);
-            upsertCopilotSession(sessionKey, isProjectSession ? "project" : "default", session.sessionId, projectRoot, config.copilotModel);
+            upsertCopilotSession(sessionKey, sessionMode, session.sessionId, projectRoot, model);
             const mgr = registry?.get(sessionKey);
             if (mgr)
-                mgr.currentModel = config.copilotModel;
+                mgr.currentModel = model;
             return session;
         }
         catch (err) {
@@ -475,7 +564,7 @@ async function createOrResumeSession(sessionKey, projectRoot) {
     }
     log.info({ sessionKey }, "Creating new session");
     const session = await client.createSession({
-        model: config.copilotModel,
+        model,
         configDir: SESSIONS_DIR,
         streaming: true,
         systemMessage: { content: systemMessageContent },
@@ -487,12 +576,12 @@ async function createOrResumeSession(sessionKey, projectRoot) {
     });
     log.info({ sessionKey, sessionId: session.sessionId.slice(0, 8) }, "Session created");
     resetCheckpointSessionState(sessionKey);
-    upsertCopilotSession(sessionKey, isProjectSession ? "project" : "default", session.sessionId, projectRoot, config.copilotModel);
+    upsertCopilotSession(sessionKey, sessionMode, session.sessionId, projectRoot, model);
     if (sessionKey === "default")
         setState(ORCHESTRATOR_SESSION_KEY, session.sessionId);
     const mgr = registry?.get(sessionKey);
     if (mgr)
-        mgr.currentModel = config.copilotModel;
+        mgr.currentModel = model;
     return session;
 }
 export async function initOrchestrator(client) {
@@ -528,6 +617,9 @@ export async function initOrchestrator(client) {
     try {
         const defaultManager = registry.getOrCreate("default");
         await defaultManager.ensureSession();
+        await Promise.allSettled(agents
+            .filter((agent) => agent.persistent && agent.scope)
+            .map((agent) => registry.getOrCreate(`agent:${agent.slug}`).ensureSession()));
     }
     catch (err) {
         log.error({ err: err instanceof Error ? err.message : err }, "Failed to create initial session (will retry on first message)");
@@ -567,7 +659,7 @@ async function executeOnSession(manager, item) {
     // Update last-seen globals (backwards compat — for callers that inspect after a turn ends)
     currentAuthenticatedUser = item.authUser;
     currentAuthorizationHeader = item.authHeader;
-    return turnContextStorage.run({
+    const runTurn = () => turnContextStorage.run({
         sessionKey,
         sourceChannel: item.sourceChannel,
         channelKey: item.channelKey,
@@ -967,6 +1059,14 @@ async function executeOnSession(manager, item) {
             unsubTurnReasoning();
         }
     });
+    const persistentAgent = getPersistentAgentForSessionKey(sessionKey);
+    const scopedRunTurn = () => item.taskId
+        ? withToolTaskContext(item.taskId, runTurn)
+        : runTurn();
+    if (persistentAgent?.scope) {
+        return withActiveScope(persistentAgent.scope, scopedRunTurn);
+    }
+    return scopedRunTurn();
 }
 /**
  * Process a single queued item: route model, handle @mentions, execute.
@@ -974,6 +1074,10 @@ async function executeOnSession(manager, item) {
  */
 async function processItem(item, manager) {
     const { sessionKey } = manager;
+    const persistentAgent = getPersistentAgentForSessionKey(sessionKey);
+    if (persistentAgent) {
+        return executeOnSession(manager, item);
+    }
     if (item.targetAgent && item.targetAgent !== "chapterhouse") {
         setActiveAgent(item.channelKey || "default", item.targetAgent);
         return executeOnSession(manager, item);
@@ -1004,6 +1108,24 @@ async function processItem(item, manager) {
     lastRouteResult = routeResult;
     return executeOnSession(manager, item);
 }
+export async function sendToAgentSession(slug, prompt, taskId) {
+    const agent = getAgent(slug);
+    if (!agent?.persistent) {
+        throw new Error(`Agent '${slug}' is not a persistent agent.`);
+    }
+    const sessionKey = `agent:${agent.slug}`;
+    return await new Promise((resolve) => {
+        sendToOrchestrator(prompt, {
+            type: "sse-web",
+            sessionKey,
+            user: getCurrentAuthenticatedUser(),
+            authorizationHeader: getCurrentAuthorizationHeader(),
+        }, (text, done) => {
+            if (done)
+                resolve(text);
+        }, undefined, undefined, undefined, undefined, undefined, { logSource: "delegated", taskId, viaLabel: "@chapterhouse" });
+    });
+}
 function getActiveProjectRules(prompt, projectPath) {
     const registry = loadRegistry();
     const project = resolveProject(prompt, { projectPath }, registry);
@@ -1034,13 +1156,14 @@ function isRecoverableError(err) {
         return false;
     return /disconnect|connection|EPIPE|ECONNRESET|ECONNREFUSED|socket|closed|ENOENT|spawn|not found|expired|stale/i.test(msg);
 }
-export async function sendToOrchestrator(prompt, source, callback, attachments, onActivity, onQueued, onAdvance, externalTurnId) {
+export async function sendToOrchestrator(prompt, source, callback, attachments, onActivity, onQueued, onAdvance, externalTurnId, options) {
     updateUserContext(source);
     updateRequestContext(source);
     // Use the externally-supplied turnId if provided (POST→SSE path needs the ID
     // returned to the client to match every emitted event — Fix 1 root cause).
     const turnId = externalTurnId ?? randomUUID();
     const sourceLabel = source.type === "background" ? "background" : "web";
+    const logSource = options?.logSource ?? sourceLabel;
     logMessage("in", sourceLabel, prompt);
     let sessionKey;
     if ((source.type === "background" || source.type === "sse-web") && source.sessionKey) {
@@ -1050,12 +1173,13 @@ export async function sendToOrchestrator(prompt, source, callback, attachments,
         sessionKey = "default";
     }
     const channelKey = source.type === "web" ? source.connectionId : "default";
-    const mention = parseAtMention(prompt);
+    const isPersistentAgentSession = sessionKey.startsWith("agent:");
+    const mention = isPersistentAgentSession ? undefined : parseAtMention(prompt);
     const targetAgent = mention?.agentSlug;
     const routedPrompt = mention ? mention.message : prompt;
     const taggedPrompt = source.type === "background"
         ? routedPrompt
-        : `[via ${sourceLabel}] ${routedPrompt}`;
+        : `[via ${options?.viaLabel ?? sourceLabel}] ${routedPrompt}`;
     const logRole = source.type === "background" ? "agent_completion" : "user";
     const sourceChannel = source.type === "web" ? "web" : undefined;
     // Capture auth context at enqueue time — prevents cross-session contamination
@@ -1089,6 +1213,7 @@ export async function sendToOrchestrator(prompt, source, callback, attachments,
                         targetAgent,
                         channelKey,
                         sessionKey,
+                        taskId: options?.taskId,
                         authUser,
                         authHeader,
                         resolve,
@@ -1103,12 +1228,14 @@ export async function sendToOrchestrator(prompt, source, callback, attachments,
                     logMessage("out", sourceLabel, finalContent);
                 }
                 catch { /* best-effort */ }
-                try {
-                    logConversation(logRole, prompt, sourceLabel, sessionKey, turnId);
+                if (!options?.suppressPromptLog) {
+                    try {
+                        logConversation(logRole, prompt, logSource, sessionKey, { turnId });
+                    }
+                    catch { /* best-effort */ }
                 }
-                catch { /* best-effort */ }
                 try {
-                    logConversation("assistant", finalContent, sourceLabel, sessionKey, turnId);
+                    logConversation("assistant", finalContent, logSource, sessionKey, { turnId });
                 }
                 catch { /* best-effort */ }
                 scheduleCheckpointExtraction(sessionKey, prompt, finalContent, source);
@@ -1205,11 +1332,11 @@ export async function interruptCurrentTurn(sessionKey, newPrompt, source, callba
                 }
                 catch { /* best-effort */ }
                 try {
-                    logConversation("user", newPrompt, sourceLabel, sessionKey, turnId);
+                    logConversation("user", newPrompt, sourceLabel, sessionKey, { turnId });
                 }
                 catch { /* best-effort */ }
                 try {
-                    logConversation("assistant", finalContent, sourceLabel, sessionKey, turnId);
+                    logConversation("assistant", finalContent, sourceLabel, sessionKey, { turnId });
                 }
                 catch { /* best-effort */ }
                 scheduleCheckpointExtraction(sessionKey, newPrompt, finalContent, source);
@@ -1312,6 +1439,20 @@ export async function cancelCurrentMessage() {
     }
     return aborted || drained > 0;
 }
+/** Cancel the active turn for a single session key. */
+export async function interruptSessionTurn(sessionKey) {
+    const manager = registry?.get(sessionKey);
+    if (!manager?.isProcessing)
+        return false;
+    const turnId = manager.currentTurnId;
+    const aborted = await manager.abortCurrentTurn();
+    if (aborted && turnId) {
+        emitTurnEvent(sessionKey, { type: "turn:interrupted", turnId, sessionKey });
+        persistTurnEvents(turnId, sessionKey);
+        scheduleClearTurnLog(turnId);
+    }
+    return aborted;
+}
 /** Switch the model on the live default orchestrator session without destroying it. */
 export function switchSessionModel(newModel) {
     const manager = registry?.get("default");