chapterhouse 0.6.0 → 0.7.0

package/dist/copilot/agent-event-bus.js

@@ -11,6 +11,7 @@
  *   session:tool_call  — tool invoked           payload: { toolName, toolArgs, resultType?, _kind?, _seq?, _ts?, _summary? }
  *   session:destroyed  — subagent finished      payload: { agentName, reason: "complete" | "error" | "abort" }
  *   session:error      — subagent failed        payload: { agentName, error }
+ *   agent_saved        — custom agent saved     payload: { slug }
  *
  * @module copilot/agent-event-bus
  */

package/dist/copilot/agents.js

@@ -3,6 +3,7 @@ import { readdirSync, readFileSync, mkdirSync, writeFileSync, existsSync, rmSync
 import { createHash } from "crypto";
 import { join, dirname, sep } from "path";
 import { fileURLToPath } from "url";
+import { load as yamlLoad, dump as yamlDump } from "js-yaml";
 import { z } from "zod";
 import { approveAll } from "@github/copilot-sdk";
 import { AGENTS_DIR, SESSIONS_DIR } from "../paths.js";
@@ -34,48 +35,42 @@ const agentFrontmatterSchema = z.object({
 // Agent Registry
 // ---------------------------------------------------------------------------
 let agentRegistry = [];
+const defaultAgentSaveRuntimeHooks = {
+    getPersistentSessionState: () => "none",
+    reloadPersistentSession: async () => "none",
+    emitAgentReloadEvent: () => { },
+};
+let agentSaveRuntimeHooks = { ...defaultAgentSaveRuntimeHooks };
 /** Bundled agents shipped with the package */
 const BUNDLED_AGENTS_DIR = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "agents");
-const RESERVED_SLUGS = new Set(["chapterhouse", "designer", "coder", "general-purpose"]);
-const SLUG_REGEX = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+export const RESERVED_SLUGS = new Set(["chapterhouse", "designer", "coder", "general-purpose"]);
+export const SLUG_REGEX = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+const BUILTIN_AGENT_SLUGS = new Set(RESERVED_SLUGS);
+if (existsSync(BUNDLED_AGENTS_DIR)) {
+    for (const file of readdirSync(BUNDLED_AGENTS_DIR)) {
+        if (file.endsWith(".agent.md")) {
+            BUILTIN_AGENT_SLUGS.add(file.replace(/\.agent\.md$/, ""));
+        }
+    }
+}
+export function isBuiltinAgent(slug) {
+    return BUILTIN_AGENT_SLUGS.has(slug);
+}
 /** Parse YAML frontmatter and markdown body from an .agent.md file. */
-export function parseAgentMd(content, slug) {
+export function parseAgentMdOrThrow(content, slug) {
     const fmMatch = content.match(/^---\n([\s\S]*?)\n---\s*([\s\S]*)$/);
-    if (!fmMatch)
-        return null;
+    if (!fmMatch) {
+        throw new Error("Missing YAML frontmatter");
+    }
     const frontmatterRaw = fmMatch[1];
     const body = fmMatch[2].trim();
-    // Simple YAML parser for flat + array values
-    const parsed = {};
-    for (const line of frontmatterRaw.split("\n")) {
-        const idx = line.indexOf(": ");
-        if (idx <= 0)
-            continue;
-        const key = line.slice(0, idx).trim();
-        let value = line.slice(idx + 2).trim();
-        // Handle YAML quoted strings
-        if (typeof value === "string" && value.startsWith('"') && value.endsWith('"')) {
-            value = value.slice(1, -1);
-        }
-        parsed[key] = value;
+    const loaded = yamlLoad(frontmatterRaw);
+    if (loaded !== undefined && (loaded === null || typeof loaded !== "object" || Array.isArray(loaded))) {
+        throw new Error("Agent frontmatter must be a YAML object");
     }
-    // Parse arrays from YAML inline syntax: [a, b, c]
-    for (const key of ["skills", "tools", "mcpServers", "allowed_paths"]) {
-        const raw = parsed[key];
-        if (typeof raw === "string") {
-            const arrMatch = raw.match(/^\[(.*)\]$/);
-            if (arrMatch) {
-                parsed[key] = arrMatch[1]
-                    .split(",")
-                    .map((s) => s.trim().replace(/^['"]|['"]$/g, ""))
-                    .filter(Boolean);
-            }
-        }
-    }
-    const result = agentFrontmatterSchema.safeParse(parsed);
+    const result = agentFrontmatterSchema.safeParse(loaded ?? {});
     if (!result.success) {
-        log.warn({ slug, errors: result.error.format() }, "Invalid frontmatter in agent file");
-        return null;
+        throw new Error(z.prettifyError(result.error));
     }
     const fm = result.data;
     return {
@@ -92,6 +87,29 @@ export function parseAgentMd(content, slug) {
         systemMessage: body,
     };
 }
+export function parseAgentMd(content, slug) {
+    try {
+        return parseAgentMdOrThrow(content, slug);
+    }
+    catch (err) {
+        log.warn({ slug, err: err instanceof Error ? err.message : err }, "Invalid agent file");
+        return null;
+    }
+}
+export function serializeAgentMd(agent) {
+    const frontmatter = {
+        name: agent.name,
+        description: agent.description,
+        model: agent.model,
+        ...(agent.persistent !== undefined ? { persistent: agent.persistent } : {}),
+        ...(agent.scope !== undefined ? { scope: agent.scope } : {}),
+        ...(agent.skills !== undefined ? { skills: agent.skills } : {}),
+        ...(agent.tools !== undefined ? { tools: agent.tools } : {}),
+        ...(agent.mcpServers !== undefined ? { mcpServers: agent.mcpServers } : {}),
+        ...(agent.allowedPaths !== undefined ? { allowed_paths: agent.allowedPaths } : {}),
+    };
+    return `---\n${yamlDump(frontmatter, { lineWidth: -1 })}---\n\n${agent.systemMessage}`;
+}
 /** Scan ~/.chapterhouse/agents/ for .agent.md files and load configs. */
 export function loadAgents() {
     if (!existsSync(AGENTS_DIR)) {
@@ -132,6 +150,49 @@ export function getAgent(nameOrSlug) {
 export function getAgentRegistry() {
     return [...agentRegistry];
 }
+export function setAgentSaveRuntimeHooks(hooks) {
+    agentSaveRuntimeHooks = {
+        ...agentSaveRuntimeHooks,
+        ...hooks,
+    };
+}
+export function resetAgentSaveRuntimeHooks() {
+    agentSaveRuntimeHooks = { ...defaultAgentSaveRuntimeHooks };
+}
+export async function notifyAgentSaved(slug, savedConfig) {
+    const config = savedConfig ?? parseAgentMdOrThrow(readFileSync(join(AGENTS_DIR, `${slug}.agent.md`), "utf-8"), slug);
+    const existingIndex = agentRegistry.findIndex((entry) => entry.slug === slug);
+    if (existingIndex >= 0) {
+        agentRegistry[existingIndex] = config;
+    }
+    else {
+        agentRegistry.push(config);
+    }
+    void import("./orchestrator.js").then(({ enqueueForSse }) => {
+        enqueueForSse({ type: "agent_saved", slug });
+    }).catch((err) => {
+        log.warn({ slug, err: err instanceof Error ? err.message : err }, "Failed to emit agent_saved SSE event");
+    });
+    const emitReloaded = () => {
+        agentSaveRuntimeHooks.emitAgentReloadEvent({
+            type: "agent_reloaded",
+            slug,
+            reason: "session_restart",
+        });
+    };
+    const result = await agentSaveRuntimeHooks.reloadPersistentSession(slug, emitReloaded);
+    if (result === "scheduled") {
+        agentSaveRuntimeHooks.emitAgentReloadEvent({
+            type: "agent_reload_pending",
+            slug,
+            reason: "in_flight",
+        });
+        return;
+    }
+    if (result === "reloaded") {
+        emitReloaded();
+    }
+}
 /** Copy bundled agents to ~/.chapterhouse/agents/, updating stale copies when the bundled version changes.
  *  Respects user customizations: if the user edited the deployed file after our last sync, we skip it. */
 export function ensureDefaultAgents() {
@@ -186,16 +247,14 @@ export function createAgentFile(slug, name, description, model, systemPrompt, sk
     if (existsSync(filePath)) {
         return `Agent '${slug}' already exists. Edit it directly or remove it first.`;
     }
-    // YAML value escaping for safe frontmatter
-    const escapedName = name.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
-    const escapedDesc = description.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
-    let frontmatter = `---\nname: "${escapedName}"\ndescription: "${escapedDesc}"\nmodel: ${model}`;
-    if (skills?.length)
-        frontmatter += `\nskills:\n${skills.map((s) => `  - ${s}`).join("\n")}`;
-    if (tools?.length)
-        frontmatter += `\ntools:\n${tools.map((t) => `  - ${t}`).join("\n")}`;
-    frontmatter += "\n---\n\n";
-    writeFileSync(filePath, frontmatter + systemPrompt + "\n");
+    writeFileSync(filePath, serializeAgentMd({
+        name,
+        description,
+        model,
+        skills,
+        tools,
+        systemMessage: `${systemPrompt}\n`,
+    }));
     return null;
 }
 /** Remove an agent .md file. Returns error string or null on success. */
@@ -203,7 +262,7 @@ export function removeAgentFile(slug) {
     if (!SLUG_REGEX.test(slug)) {
         return `Invalid slug '${slug}'.`;
     }
-    if (RESERVED_SLUGS.has(slug)) {
+    if (isBuiltinAgent(slug)) {
         return `Cannot remove built-in agent '${slug}'. You can edit its file instead.`;
     }
     const filePath = join(AGENTS_DIR, `${slug}.agent.md`);
@@ -323,6 +382,14 @@ export function filterToolsForAgent(agent, allTools) {
     }
     return allTools.filter((t) => !MANAGEMENT_TOOL_NAMES.has(t.name));
 }
+/** Filter MCP servers based on agent config. */
+export function filterMcpServersForAgent(agent, allMcpServers) {
+    if (agent.mcpServers && agent.mcpServers.length > 0) {
+        const allowed = new Set(agent.mcpServers);
+        return Object.fromEntries(Object.entries(allMcpServers).filter(([name]) => allowed.has(name)));
+    }
+    return allMcpServers;
+}
 /** Create an ephemeral session for an agent. Always creates a fresh session — caller is responsible for destroying it. */
 export async function createEphemeralAgentSession(slug, client, allTools, modelOverride, systemMessagePrefix, taskId) {
     const agent = getAgent(slug);
@@ -334,7 +401,8 @@ export async function createEphemeralAgentSession(slug, client, allTools, modelO
         ? modelOverride
         : (agent.model === "auto" ? "claude-sonnet-4.6" : agent.model);
     const tools = bindToolsToAgent(agent.slug, filterToolsForAgent(agent, allTools), taskId);
-    const mcpServers = loadMcpConfig();
+    const allMcpServers = loadMcpConfig();
+    const mcpServers = filterMcpServersForAgent(agent, allMcpServers);
     const skillDirectories = getSkillDirectories();
     const baseSystemMessage = composeAgentSystemMessage(agent);
     const systemMessageContent = systemMessagePrefix

package/dist/copilot/agents.mcp-servers.test.js

@@ -0,0 +1,87 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+const MCP_SERVERS = {
+    filesystem: { command: "filesystem" },
+    truenas: { command: "truenas" },
+};
+async function loadIsolatedAgentsModule(t, agentFrontmatter) {
+    const root = mkdtempSync(join(tmpdir(), "chapterhouse-agents-mcp-"));
+    const agentsDir = join(root, "agents");
+    const sessionsDir = join(root, "sessions");
+    mkdirSync(agentsDir, { recursive: true });
+    mkdirSync(sessionsDir, { recursive: true });
+    writeFileSync(join(agentsDir, "mcp-test-agent.agent.md"), [
+        "---",
+        "name: MCP Test Agent",
+        "description: Agent used to verify MCP session config",
+        "model: claude-sonnet-4.6",
+        agentFrontmatter,
+        "---",
+        "",
+        "You are an MCP test agent.",
+    ].filter(Boolean).join("\n"));
+    t.after(() => rmSync(root, { recursive: true, force: true }));
+    t.mock.module("../paths.js", {
+        namedExports: {
+            AGENTS_DIR: agentsDir,
+            SESSIONS_DIR: sessionsDir,
+        },
+    });
+    t.mock.module("./mcp-config.js", {
+        namedExports: {
+            loadMcpConfig: () => MCP_SERVERS,
+        },
+    });
+    t.mock.module("./skills.js", {
+        namedExports: {
+            getSkillDirectories: () => [],
+        },
+    });
+    t.mock.module("../store/db.js", {
+        namedExports: {
+            getState: () => undefined,
+            setState: () => undefined,
+        },
+    });
+    let createSessionOptions;
+    const agentsModule = await import(new URL(`./agents.js?case=${Date.now()}-${Math.random()}`, import.meta.url).href);
+    agentsModule.loadAgents();
+    return {
+        agentsModule,
+        get createSessionOptions() {
+            return createSessionOptions;
+        },
+        set createSessionOptions(value) {
+            createSessionOptions = value;
+        },
+    };
+}
+async function createAgentSession(agentsModule, setCreateSessionOptions) {
+    const client = {
+        createSession: async (options) => {
+            setCreateSessionOptions(options);
+            return {};
+        },
+    };
+    await agentsModule.createEphemeralAgentSession("mcp-test-agent", client, []);
+}
+test("createEphemeralAgentSession only passes MCP servers listed by the agent allowlist", async (t) => {
+    const context = await loadIsolatedAgentsModule(t, "mcpServers: [truenas]");
+    await createAgentSession(context.agentsModule, (options) => {
+        context.createSessionOptions = options;
+    });
+    assert.deepEqual(context.createSessionOptions?.mcpServers, {
+        truenas: { command: "truenas" },
+    });
+});
+test("createEphemeralAgentSession passes all MCP servers when the agent has no allowlist", async (t) => {
+    const context = await loadIsolatedAgentsModule(t, "");
+    await createAgentSession(context.agentsModule, (options) => {
+        context.createSessionOptions = options;
+    });
+    assert.deepEqual(context.createSessionOptions?.mcpServers, MCP_SERVERS);
+});
+//# sourceMappingURL=agents.mcp-servers.test.js.map

package/dist/copilot/agents.parse.test.js

@@ -0,0 +1,69 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { parseAgentMd } from "./agents.js";
+test("parseAgentMd parses block-style YAML arrays", () => {
+    const agent = parseAgentMd([
+        "---",
+        "name: Designer",
+        "description: Handles UI flows",
+        "model: claude-sonnet-4.6",
+        "skills:",
+        "  - frontend-design",
+        "  - ux-copy",
+        "tools:",
+        "  - read",
+        "  - write",
+        "---",
+        "",
+        "You are Designer.",
+    ].join("\n"), "designer");
+    assert.ok(agent, "agent charter should still parse");
+    assert.deepEqual(agent.skills, ["frontend-design", "ux-copy"]);
+    assert.deepEqual(agent.tools, ["read", "write"]);
+});
+test("parseAgentMd still parses inline YAML arrays", () => {
+    const agent = parseAgentMd([
+        "---",
+        "name: Designer",
+        "description: Handles UI flows",
+        "model: claude-sonnet-4.6",
+        "skills: [frontend-design, ux-copy]",
+        "tools: [read, write]",
+        "---",
+        "",
+        "You are Designer.",
+    ].join("\n"), "designer");
+    assert.ok(agent, "agent charter should parse");
+    assert.deepEqual(agent.skills, ["frontend-design", "ux-copy"]);
+    assert.deepEqual(agent.tools, ["read", "write"]);
+});
+test("parseAgentMd tolerates missing optional fields", () => {
+    const agent = parseAgentMd([
+        "---",
+        "name: Designer",
+        "description: Handles UI flows",
+        "model: claude-sonnet-4.6",
+        "---",
+        "",
+        "You are Designer.",
+    ].join("\n"), "designer");
+    assert.ok(agent, "agent charter should parse");
+    assert.equal(agent.skills, undefined);
+    assert.equal(agent.tools, undefined);
+    assert.equal(agent.mcpServers, undefined);
+    assert.equal(agent.allowedPaths, undefined);
+});
+test("parseAgentMd returns null for invalid YAML frontmatter", () => {
+    const agent = parseAgentMd([
+        "---",
+        "name: Designer",
+        "description: Handles UI flows",
+        "model: claude-sonnet-4.6",
+        "skills: [frontend-design",
+        "---",
+        "",
+        "You are Designer.",
+    ].join("\n"), "designer");
+    assert.equal(agent, null);
+});
+//# sourceMappingURL=agents.parse.test.js.map

package/dist/copilot/agents.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { composeAgentSystemMessage, filterToolsForAgent, bindToolsToAgent, getCurrentToolTaskId, parseAgentMd, withToolTaskContext, } from "./agents.js";
+import { composeAgentSystemMessage, filterToolsForAgent, bindToolsToAgent, getCurrentToolTaskId, getAgentRegistry, parseAgentMd, withToolTaskContext, } from "./agents.js";
 function makeAgent(slug) {
     return {
         slug,
@@ -76,6 +76,22 @@ test("parseAgentMd detects persistent agent scope from charter frontmatter", ()
     assert.equal(agent.persistent, true);
     assert.equal(agent.scope, "infra");
 });
+test("parseAgentMd preserves block-style skills arrays from charter frontmatter", () => {
+    const agent = parseAgentMd([
+        "---",
+        "name: Designer",
+        "description: UI/UX design specialist",
+        "model: claude-opus-4.6",
+        "skills:",
+        "  - frontend-design",
+        "  - accessibility-review",
+        "---",
+        "",
+        "You are the Designer.",
+    ].join("\n"), "designer");
+    assert.ok(agent, "agent charter should parse");
+    assert.deepEqual(agent.skills, ["frontend-design", "accessibility-review"]);
+});
 test("persistent agents cannot receive scope-changing management tools", () => {
     const agent = {
         ...makeAgent("bellonda"),
@@ -102,4 +118,112 @@ test("bindToolsToAgent uses the per-turn task context when no fixed task id is p
     const taskId = await withToolTaskContext("delegated-persistent-001", () => tools[0].handler({}, {}));
     assert.equal(taskId, "delegated-persistent-001");
 });
+test("notifyAgentSaved uses the provided charter instead of rereading from CHAPTERHOUSE_HOME", async () => {
+    const slug = "notify-agent-saved-inline-charter";
+    const agents = await import("./agents.js");
+    const config = {
+        ...makeAgent(slug),
+        persistent: true,
+        scope: "infra",
+    };
+    agents.setAgentSaveRuntimeHooks({
+        reloadPersistentSession: async () => "none",
+    });
+    try {
+        await agents.notifyAgentSaved(slug, config);
+    }
+    finally {
+        agents.resetAgentSaveRuntimeHooks();
+    }
+    const saved = getAgentRegistry().find((entry) => entry.slug === slug);
+    assert.deepEqual(saved, config);
+});
+test("notifyAgentSaved reloads idle persistent sessions and emits a restart event", async () => {
+    const events = [];
+    const reloads = [];
+    const agents = await import("./agents.js");
+    const config = {
+        ...makeAgent("bellonda"),
+        persistent: true,
+        scope: "infra",
+    };
+    agents.setAgentSaveRuntimeHooks({
+        reloadPersistentSession: async (slug) => {
+            reloads.push(slug);
+            return "reloaded";
+        },
+        emitAgentReloadEvent: (event) => {
+            events.push(event);
+        },
+    });
+    try {
+        await agents.notifyAgentSaved("bellonda", config);
+    }
+    finally {
+        agents.resetAgentSaveRuntimeHooks();
+    }
+    assert.deepEqual(reloads, ["bellonda"]);
+    assert.deepEqual(events, [{ type: "agent_reloaded", slug: "bellonda", reason: "session_restart" }]);
+});
+test("notifyAgentSaved marks in-flight persistent sessions as pending and emits restart after the deferred reload", async () => {
+    const events = [];
+    const reloads = [];
+    const agents = await import("./agents.js");
+    const config = {
+        ...makeAgent("bellonda"),
+        persistent: true,
+        scope: "infra",
+    };
+    let finishReload;
+    agents.setAgentSaveRuntimeHooks({
+        reloadPersistentSession: async (slug, onReloaded) => {
+            reloads.push(slug);
+            finishReload = onReloaded;
+            return "scheduled";
+        },
+        emitAgentReloadEvent: (event) => {
+            events.push(event);
+        },
+    });
+    try {
+        await agents.notifyAgentSaved("bellonda", config);
+        assert.deepEqual(events, [{ type: "agent_reload_pending", slug: "bellonda", reason: "in_flight" }]);
+        finishReload?.();
+    }
+    finally {
+        agents.resetAgentSaveRuntimeHooks();
+    }
+    assert.deepEqual(reloads, ["bellonda"]);
+    assert.deepEqual(events, [
+        { type: "agent_reload_pending", slug: "bellonda", reason: "in_flight" },
+        { type: "agent_reloaded", slug: "bellonda", reason: "session_restart" },
+    ]);
+});
+test("notifyAgentSaved leaves agents without open persistent sessions alone", async () => {
+    const events = [];
+    const reloads = [];
+    const agents = await import("./agents.js");
+    const config = {
+        ...makeAgent("bellonda"),
+        persistent: true,
+        scope: "infra",
+    };
+    agents.setAgentSaveRuntimeHooks({
+        reloadPersistentSession: async (slug) => {
+            reloads.push(slug);
+            return "none";
+        },
+        emitAgentReloadEvent: (event) => {
+            events.push(event);
+        },
+    });
+    try {
+        await agents.notifyAgentSaved("bellonda", config);
+    }
+    finally {
+        agents.resetAgentSaveRuntimeHooks();
+    }
+    assert.deepEqual(reloads, ["bellonda"]);
+    assert.deepEqual(events, []);
+});
 //# sourceMappingURL=agents.test.js.map

package/dist/copilot/orchestrator.js

@@ -16,7 +16,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, getAgent, composeAgentSystemMessage, filterToolsForAgent, withToolTaskContext, } from "./agents.js";
+import { loadAgents, ensureDefaultAgents, clearActiveTasks, getAgentRegistry, setActiveAgent, parseAtMention, buildAgentRoster, getActiveTasks, getAgent, composeAgentSystemMessage, filterMcpServersForAgent, filterToolsForAgent, withToolTaskContext, } from "./agents.js";
 import * as agentsModule from "./agents.js";
 import { childLogger } from "../util/logger.js";
 import { agentEventBus } from "./agent-event-bus.js";
@@ -179,6 +179,13 @@ function getSessionConfig() {
 function agentSlugFromSessionKey(sessionKey) {
     return sessionKey.startsWith("agent:") ? sessionKey.slice("agent:".length) : undefined;
 }
+function persistentAgentSessionKey(slug) {
+    const agent = getAgent(slug);
+    if (!agent?.persistent) {
+        return undefined;
+    }
+    return `agent:${agent.slug}`;
+}
 function getPersistentAgentForSessionKey(sessionKey) {
     const slug = agentSlugFromSessionKey(sessionKey);
     if (!slug)
@@ -344,6 +351,7 @@ async function createOrResumeSession(sessionKey, projectRoot) {
             client: copilotClient,
             onAgentTaskComplete: feedAgentResult,
         })));
+        mcpServers = filterMcpServersForAgent(persistentAgent, mcpServers);
         const scopedHotTier = (await memoryCoordinator?.buildHotTierContext(sessionKey)) || undefined;
         const channelNote = `You are in your persistent Chapterhouse channel (${sessionKey}). Your memory scope is ${persistentAgent.scope}.`;
         systemMessageContent = [
@@ -1209,19 +1217,18 @@ export async function interruptCurrentTurn(sessionKey, newPrompt, source, callba
     await manager.abortCurrentTurn();
     log.info({ sessionKey, replacementTurnId: turnId }, "turn.interrupted");
 }
-/**
- * Enqueue a turn for the new POST→SSE chat path (#130).
- *
- * Unlike `sendToOrchestrator`, this function:
- *  - Returns the `turnId` immediately without waiting for the turn to complete.
- *  - Routes through the shared lifecycle emitter in sendToOrchestrator.
- *  - Does NOT write to sseClients — the SSE channel delivers events via subscribeSession().
- *  - Supports interrupt: true which calls interruptCurrentTurn under the hood.
- *
- * @returns turnId (UUID)
- */
 export function enqueueForSse(opts) {
+    if (opts.type === "agent_saved") {
+        agentEventBus.emit({
+            type: "agent_saved",
+            payload: { slug: opts.slug ?? "" },
+        });
+        return;
+    }
     const { sessionKey, prompt, attachments, authUser, authHeader, interrupt } = opts;
+    if (!sessionKey || !prompt) {
+        throw new Error("Missing sessionKey or prompt for SSE turn enqueue");
+    }
     const turnId = randomUUID();
     // sse-web carries auth and enables onQueued — unlike "background" (Fixes 2 & 3).
     const source = { type: "sse-web", sessionKey, user: authUser, authorizationHeader: authHeader };
@@ -1288,6 +1295,37 @@ export async function interruptSessionTurn(sessionKey) {
     }
     return aborted;
 }
+export function getPersistentAgentSessionState(slug) {
+    const sessionKey = persistentAgentSessionKey(slug);
+    if (!sessionKey) {
+        return "none";
+    }
+    const manager = registry?.get(sessionKey);
+    if (!manager) {
+        return "none";
+    }
+    return manager.isProcessing ? "in_flight" : "idle";
+}
+export async function reloadPersistentAgent(slug, onReloaded) {
+    const sessionKey = persistentAgentSessionKey(slug);
+    if (!sessionKey || !registry) {
+        return "none";
+    }
+    let manager = registry.get(sessionKey);
+    if (!manager) {
+        manager = registry.getOrCreate(sessionKey);
+        await manager.ensureSession();
+        onReloaded?.();
+        return "reloaded";
+    }
+    if (manager.isProcessing) {
+        manager.requestSessionReload(onReloaded);
+        return "scheduled";
+    }
+    await manager.restartSession();
+    onReloaded?.();
+    return "reloaded";
+}
 /** Switch the model on the live default orchestrator session without destroying it. */
 export function switchSessionModel(newModel) {
     const manager = registry?.get("default");