chapterhouse 0.4.3 → 0.5.1

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";
@@ -32,6 +32,7 @@ import { assertAuthenticationConfigured, createHealthPayload, createPublicConfig
 import { BadRequestError, ForbiddenError, InternalServerError, NotFoundError, apiNotFoundHandler, asBadRequest, createApiErrorHandler, parseRequest, } from "./errors.js";
 import { childLogger } from "../util/logger.js";
 import { getActiveScope } from "../memory/active-scope.js";
+import { createScope, getScope } from "../memory/scopes.js";
 const log = childLogger("server");
 void searchIndex; // re-exported by index-manager; reference here documents the dep
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -81,6 +82,12 @@ const projectCreateSchema = z.object({
     cwd: requiredString("Missing 'cwd' in request body")
         .refine((value) => value.startsWith("/"), "Project cwd must be an absolute path"),
 }).strict();
+const scopeCreateSchema = z.object({
+    slug: requiredString("Missing 'slug' in request body")
+        .regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "Scope slug must be unique kebab-case"),
+    title: requiredString("Missing 'title' in request body"),
+    description: z.string().optional(),
+}).strict();
 const projectHardRulesSchema = z.object({
     hardRules: z.object({
         auto_pr: z.boolean({ error: "hardRules.auto_pr must be a boolean" }),
@@ -313,6 +320,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 +648,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? }
@@ -855,6 +899,25 @@ app.get("/api/memory/active-scope", (_req, res) => {
         title: activeScope.title,
     });
 });
+app.post("/api/scopes", (req, res) => {
+    const body = parseRequest(scopeCreateSchema, req.body ?? {});
+    if (getScope(body.slug)) {
+        res.status(409).json({ error: `Memory scope '${body.slug}' already exists` });
+        return;
+    }
+    const scope = createScope({
+        slug: body.slug,
+        title: body.title,
+        description: body.description ?? "",
+        keywords: [body.slug],
+    });
+    res.status(201).json({
+        slug: scope.slug,
+        title: scope.title,
+        description: scope.description,
+        active: scope.active,
+    });
+});
 app.post("/api/auto", (req, res) => {
     const body = parseRequest(autoRequestSchema, req.body ?? {});
     const updated = updateRouterConfig(body);

package/dist/api/server.test.js

@@ -207,6 +207,21 @@ 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",
+        ]);
+        assert.deepEqual(channels.map((channel) => channel.label), [
+            "# chapterhouse",
+        ]);
+    });
+});
 test("server runs in standalone mode without auth", async () => {
     await withStartedServer(async ({ baseUrl }) => {
         const bootstrap = await fetch(`${baseUrl}/api/bootstrap`);
@@ -247,6 +262,54 @@ test("server exposes the active memory scope API and requires auth", async () =>
         });
     });
 });
+test("server creates memory scopes with duplicate and slug validation", async () => {
+    await withStartedServer(async ({ baseUrl, authHeader }) => {
+        const unauthorized = await fetch(`${baseUrl}/api/scopes`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ slug: "docs-site", title: "Docs Site" }),
+        });
+        assert.equal(unauthorized.status, 401);
+        const created = await fetch(`${baseUrl}/api/scopes`, {
+            method: "POST",
+            headers: {
+                authorization: authHeader,
+                "content-type": "application/json",
+            },
+            body: JSON.stringify({
+                slug: "docs-site",
+                title: "Docs Site",
+                description: "Documentation publishing and content workflows",
+            }),
+        });
+        assert.equal(created.status, 201);
+        assert.deepEqual(await created.json(), {
+            slug: "docs-site",
+            title: "Docs Site",
+            description: "Documentation publishing and content workflows",
+            active: true,
+        });
+        const duplicate = await fetch(`${baseUrl}/api/scopes`, {
+            method: "POST",
+            headers: {
+                authorization: authHeader,
+                "content-type": "application/json",
+            },
+            body: JSON.stringify({ slug: "docs-site", title: "Docs Site Again" }),
+        });
+        assert.equal(duplicate.status, 409);
+        assert.deepEqual(await duplicate.json(), { error: "Memory scope 'docs-site' already exists" });
+        const invalid = await fetch(`${baseUrl}/api/scopes`, {
+            method: "POST",
+            headers: {
+                authorization: authHeader,
+                "content-type": "application/json",
+            },
+            body: JSON.stringify({ slug: "Docs Site", title: "Docs Site" }),
+        });
+        assert.equal(invalid.status, 400);
+    });
+});
 test("server bootstrap rejects non-loopback origins", async () => {
     await withStartedServer(async ({ baseUrl }) => {
         const response = 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,
@@ -293,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. */
@@ -304,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;
@@ -331,6 +359,17 @@ function buildHotTierContext() {
     }
     return hotTierXml.trimEnd();
 }
+function buildPerTurnMemoryHooks(sessionKey) {
+    if (!config.memoryInjectEnabled) {
+        return undefined;
+    }
+    return {
+        onUserPromptSubmitted: () => {
+            const hotTierXml = buildScopedHotTierContext(getMemoryScopeForSession(sessionKey));
+            return hotTierXml ? { additionalContext: hotTierXml } : undefined;
+        },
+    };
+}
 function getSystemMessageOptions(memorySummary) {
     return {
         selfEditEnabled: config.selfEditEnabled,
@@ -392,8 +431,7 @@ export function feedAgentResult(taskId, agentSlug, result) {
             agentSlug,
             agentDisplayName,
         });
-        const chunkSize = 500;
-        const chunks = result.length === 0 ? [""] : Array.from({ length: Math.ceil(result.length / chunkSize) }, (_, index) => result.slice(index * chunkSize, (index + 1) * chunkSize));
+        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",
@@ -417,12 +455,15 @@ export function feedAgentResult(taskId, agentSlug, result) {
     catch (err) {
         log.warn({ err: err instanceof Error ? err.message : err, taskId, agentSlug }, "Failed to persist agent completion");
     }
-    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 });
+    void (async () => {
+        await new Promise((resolve) => setImmediate(resolve));
+        const prompt = `[Agent task completed] @${agentSlug} finished task ${taskId}. The user has already seen this reply in the agent's own bubble. Acknowledge briefly without restating content.`;
+        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));
@@ -467,28 +508,53 @@ 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,
-    });
+    const memoryHooks = buildPerTurnMemoryHooks(sessionKey);
+    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 },
+                hooks: memoryHooks,
                 tools,
                 mcpServers,
                 skillDirectories,
@@ -497,10 +563,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) {
@@ -511,10 +577,11 @@ 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 },
+        hooks: memoryHooks,
         tools,
         mcpServers,
         skillDirectories,
@@ -523,12 +590,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) {
@@ -564,6 +631,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)");
@@ -603,7 +673,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,
@@ -1003,6 +1073,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.
@@ -1010,6 +1088,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);
@@ -1040,6 +1122,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);
@@ -1077,6 +1177,7 @@ export async function sendToOrchestrator(prompt, source, callback, attachments,
     // 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) {
@@ -1086,12 +1187,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
@@ -1125,6 +1227,7 @@ export async function sendToOrchestrator(prompt, source, callback, attachments,
                         targetAgent,
                         channelKey,
                         sessionKey,
+                        taskId: options?.taskId,
                         authUser,
                         authHeader,
                         resolve,
@@ -1141,12 +1244,12 @@ export async function sendToOrchestrator(prompt, source, callback, attachments,
                 catch { /* best-effort */ }
                 if (!options?.suppressPromptLog) {
                     try {
-                        logConversation(logRole, prompt, sourceLabel, sessionKey, { turnId });
+                        logConversation(logRole, prompt, logSource, sessionKey, { turnId });
                     }
                     catch { /* best-effort */ }
                 }
                 try {
-                    logConversation("assistant", finalContent, sourceLabel, sessionKey, { turnId });
+                    logConversation("assistant", finalContent, logSource, sessionKey, { turnId });
                 }
                 catch { /* best-effort */ }
                 scheduleCheckpointExtraction(sessionKey, prompt, finalContent, source);
@@ -1350,6 +1453,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");