chapterhouse 0.6.0 → 0.8.0

package/dist/config.test.js

@@ -126,6 +126,26 @@ test("defaults memory checkpoint turns to 5 and parses integer overrides", async
     assert.equal(parsedThree.memoryCheckpointTurns, 3);
     assert.equal(parsedTen.memoryCheckpointTurns, 10);
 });
+test("parses PKB consolidation defaults and explicit hour overrides", async () => {
+    const configModule = await import("./config.js");
+    assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
+    const parsedDefault = configModule.parseRuntimeConfig({});
+    const parsedExplicit = configModule.parseRuntimeConfig({
+        CHAPTERHOUSE_PKB_CONSOLIDATION_ENABLED: "false",
+        CHAPTERHOUSE_PKB_CONSOLIDATION_HOUR: "5",
+    });
+    assert.equal(parsedDefault.pkbConsolidationEnabled, true);
+    assert.equal(parsedDefault.pkbConsolidationHour, 3);
+    assert.equal(parsedExplicit.pkbConsolidationEnabled, false);
+    assert.equal(parsedExplicit.pkbConsolidationHour, 5);
+});
+test("rejects invalid PKB consolidation hours outside 0-23", async () => {
+    const configModule = await import("./config.js");
+    assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");
+    assert.throws(() => configModule.parseRuntimeConfig({
+        CHAPTERHOUSE_PKB_CONSOLIDATION_HOUR: "24",
+    }), /CHAPTERHOUSE_PKB_CONSOLIDATION_HOUR must be an integer between 0 and 23/);
+});
 test("defaults memory injection on and still honors explicit CHAPTERHOUSE_MEMORY_INJECT overrides", async () => {
     const configModule = await import("./config.js");
     assert.equal(typeof configModule.parseRuntimeConfig, "function", "parseRuntimeConfig should be exported");

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`);
@@ -240,7 +299,7 @@ Chapterhouse agent memory follows a three-tier memory model: **read** with \`mem
 ### 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.
 
-Invoke \`wiki-conventions\` before wiki writes or restructuring work. Treat \`wiki_update\`, \`remember\`, \`forget\`, \`wiki_ingest\`, \`wiki_lint\`, and \`wiki_rebuild_index\` as write-sensitive workflows. Before using them, read \`pages/index.md\`, scan the last 20-30 entries of \`pages/_meta/log.md\`, and run \`wiki_search\` for the topic when the wiki is large or the topic is ambiguous.
+Invoke \`wiki-conventions\` before wiki writes or restructuring work. Treat \`wiki_update\` and \`wiki_ingest_source\` as write-sensitive workflows, and use \`memory_propose\` for agent-memory handoff. Before using wiki write tools, read \`pages/index.md\`, scan the last 20-30 entries of \`pages/_meta/log.md\`, and run \`wiki_search\` for the topic when the wiki is large or the topic is ambiguous.
 
 ### Communication
 - You receive tasks from @chapterhouse (the orchestrator) or directly from the user
@@ -281,8 +340,7 @@ export function buildAgentRoster() {
 }
 // The wiki tools that every agent gets regardless of tool config
 const WIKI_TOOL_NAMES = new Set([
-    "wiki_search", "wiki_read", "wiki_update", "remember", "recall", "forget",
-    "wiki_ingest", "wiki_lint", "wiki_rebuild_index",
+    "wiki_search", "wiki_read", "wiki_update", "wiki_append_timeline", "wiki_ingest_source",
     "memory_recall", "memory_propose", "memory_list_action_items",
 ]);
 // Management tools that only @chapterhouse should have
@@ -292,7 +350,7 @@ const MANAGEMENT_TOOL_NAMES = new Set([
     "switch_model", "toggle_auto", "list_models",
     "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_remember", "memory_set_scope", "memory_housekeep", "memory_reflect", "memory_promote", "memory_demote",
     "memory_add_action_item", "memory_complete_action_item", "memory_drop_action_item", "memory_snooze_action_item",
 ]);
 export function getCurrentToolAgentSlug() {
@@ -323,6 +381,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 +400,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,8 @@
 import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
 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,
@@ -48,7 +50,8 @@ test("composeAgentSystemMessage steers wiki-capable agents to wiki-conventions",
     for (const slug of ["coder", "general-purpose"]) {
         const message = composeAgentSystemMessage(makeAgent(slug));
         assert.match(message, /invoke `wiki-conventions` before wiki writes/i);
-        assert.match(message, /wiki_update[\s\S]{0,80}remember[\s\S]{0,80}forget[\s\S]{0,80}wiki_ingest[\s\S]{0,80}wiki_lint[\s\S]{0,80}wiki_rebuild_index/i);
+        assert.match(message, /wiki_update[\s\S]{0,120}wiki_ingest_source[\s\S]{0,120}memory_propose/i);
+        assert.doesNotMatch(message, /`remember`|`forget`|`wiki_ingest`(?!_source)|`wiki_lint`|`wiki_rebuild_index`/);
         assert.match(message, /read `pages\/index\.md`/i);
         assert.match(message, /scan the last 20-30 entries of `pages\/_meta\/log\.md`/i);
     }
@@ -76,6 +79,30 @@ 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("korg charter is persistent and standardizes on the Summary heading", () => {
+    const charter = readFileSync(join(process.cwd(), "agents", "korg.agent.md"), "utf8");
+    const agent = parseAgentMd(charter, "korg");
+    assert.ok(agent, "korg charter should parse");
+    assert.equal(agent.persistent, true);
+    assert.match(charter, /## Summary/);
+    assert.doesNotMatch(charter, /## Compiled Truth/);
+});
 test("persistent agents cannot receive scope-changing management tools", () => {
     const agent = {
         ...makeAgent("bellonda"),
@@ -102,4 +129,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