chapterhouse 0.5.2 → 0.7.0

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/memory-coordinator.js

@@ -0,0 +1,234 @@
+import { getActiveScope } from "../memory/active-scope.js";
+import { CheckpointTracker, isCheckpointInFlight, runCheckpointExtraction } from "../memory/checkpoint.js";
+import { runEndOfTaskMemoryHook } from "../memory/eot.js";
+import { getHotTierEntries, renderHotTierForActiveScope, renderHotTierXML } from "../memory/hot-tier.js";
+import { isHousekeepingInFlight, runHousekeeping } from "../memory/housekeeping.js";
+import { getScope } from "../memory/scopes.js";
+import { config as defaultConfig } from "../config.js";
+import { childLogger } from "../util/logger.js";
+const log = childLogger("memory-coordinator");
+const MAX_CHECKPOINT_CHARS_PER_SIDE = 4_000;
+export class MemoryCoordinator {
+    checkpointTrackers = new Map();
+    checkpointTurnsBySession = new Map();
+    housekeepingTurnsBySession = new Map();
+    completedTaskIds = new Set();
+    getCopilotClient;
+    resolveScopeForSession;
+    config;
+    constructor(options) {
+        this.getCopilotClient = options.getCopilotClient;
+        this.resolveScopeForSession = options.resolveScopeForSession ?? (() => getActiveScope());
+        this.config = options.config ?? defaultConfig;
+    }
+    async onTurnComplete(sessionKey, prompt, response, source) {
+        const sourceType = this.normalizeSource(source);
+        if (sourceType === "background") {
+            return;
+        }
+        this.scheduleCheckpointExtraction(sessionKey, prompt, response);
+        this.scheduleHousekeeping(sessionKey);
+    }
+    async onScopeChange(sessionKey, prev, next) {
+        if (!prev) {
+            return;
+        }
+        const previousScope = getScope(prev) ?? null;
+        if (!previousScope) {
+            return;
+        }
+        if (!this.config.memoryCheckpointOnScopeChange) {
+            log.info({ sessionKey, scope: previousScope.slug }, "memory.checkpoint.scope_change_disabled");
+            return;
+        }
+        const tracker = this.getCheckpointTracker(sessionKey);
+        const turnsSinceLast = tracker.turnsSinceLastFire();
+        if (turnsSinceLast < this.config.memoryCheckpointMinTurnsForScopeFire) {
+            log.info({
+                sessionKey,
+                scope: previousScope.slug,
+                turns_since_last: turnsSinceLast,
+                min_required: this.config.memoryCheckpointMinTurnsForScopeFire,
+            }, "memory.checkpoint.scope_change_skip");
+            return;
+        }
+        if (isCheckpointInFlight(sessionKey)) {
+            log.info({ sessionKey, trigger: "scope_change" }, "memory.checkpoint.in_flight_skip");
+            return;
+        }
+        const copilotClient = this.getCopilotClient();
+        if (!copilotClient) {
+            log.error({ sessionKey }, "memory.checkpoint.error");
+            return;
+        }
+        const turns = this.checkpointTurnsBySession.get(sessionKey) ?? [];
+        if (turns.length === 0) {
+            log.info({
+                sessionKey,
+                scope: previousScope.slug,
+                turns_since_last: turnsSinceLast,
+                min_required: this.config.memoryCheckpointMinTurnsForScopeFire,
+            }, "memory.checkpoint.scope_change_skip");
+            return;
+        }
+        tracker.markScopeChangeFire();
+        const nextScope = next ? (getScope(next) ?? null) : null;
+        void runCheckpointExtraction({
+            sessionKey,
+            turns: turns.slice(-this.config.memoryCheckpointTurns),
+            activeScope: previousScope,
+            copilotClient,
+            trigger: "scope_change",
+            scopeChangeContext: {
+                from: previousScope.slug,
+                to: nextScope?.slug ?? "no active scope",
+            },
+        }).catch((error) => {
+            log.error({ err: error, sessionKey }, "memory.checkpoint.error");
+        });
+    }
+    async buildHotTierContext(sessionKey) {
+        if (!this.config.memoryInjectEnabled) {
+            return "";
+        }
+        const scope = this.resolveScopeForSession(sessionKey);
+        if (!scope) {
+            return "";
+        }
+        const activeScope = getActiveScope();
+        const hotTierXml = activeScope?.id === scope.id
+            ? renderHotTierForActiveScope()
+            : renderHotTierXML(getHotTierEntries(scope.id));
+        return hotTierXml ? hotTierXml.trimEnd() : "";
+    }
+    buildPerTurnHooks(sessionKey) {
+        if (!this.config.memoryInjectEnabled) {
+            return undefined;
+        }
+        const hooks = {
+            onUserPromptSubmitted: async () => {
+                const hotTierXml = await this.buildHotTierContext(sessionKey);
+                return hotTierXml ? { additionalContext: hotTierXml } : undefined;
+            },
+        };
+        return hooks;
+    }
+    async onAgentTaskComplete(taskId, result) {
+        if (this.completedTaskIds.has(taskId)) {
+            log.info({ taskId }, "memory.eot.duplicate_skip");
+            return;
+        }
+        this.completedTaskIds.add(taskId);
+        const copilotClient = this.getCopilotClient();
+        if (!copilotClient) {
+            return;
+        }
+        const finalResult = typeof result === "string" ? result : result == null ? "" : String(result);
+        await runEndOfTaskMemoryHook({
+            taskId,
+            finalResult,
+            copilotClient,
+        });
+    }
+    reset(sessionKey) {
+        this.getCheckpointTracker(sessionKey).reset();
+        this.checkpointTurnsBySession.delete(sessionKey);
+        this.housekeepingTurnsBySession.delete(sessionKey);
+        this.completedTaskIds.clear();
+    }
+    shutdown() {
+        this.checkpointTrackers.clear();
+        this.checkpointTurnsBySession.clear();
+        this.housekeepingTurnsBySession.clear();
+        this.completedTaskIds.clear();
+    }
+    normalizeSource(source) {
+        return source === "background" ? "background" : source === "sse-web" ? "sse-web" : "web";
+    }
+    truncateCheckpointText(value) {
+        const trimmed = value.trim();
+        if (trimmed.length <= MAX_CHECKPOINT_CHARS_PER_SIDE) {
+            return trimmed;
+        }
+        return `${trimmed.slice(0, MAX_CHECKPOINT_CHARS_PER_SIDE)}…`;
+    }
+    getCheckpointTracker(sessionKey) {
+        let tracker = this.checkpointTrackers.get(sessionKey);
+        if (!tracker) {
+            tracker = new CheckpointTracker();
+            this.checkpointTrackers.set(sessionKey, tracker);
+        }
+        return tracker;
+    }
+    appendCheckpointTurn(sessionKey, turn) {
+        const turns = this.checkpointTurnsBySession.get(sessionKey) ?? [];
+        turns.push(turn);
+        const overflow = turns.length - this.config.memoryCheckpointTurns;
+        if (overflow > 0) {
+            turns.splice(0, overflow);
+        }
+        this.checkpointTurnsBySession.set(sessionKey, turns);
+        return turns;
+    }
+    scheduleCheckpointExtraction(sessionKey, prompt, response) {
+        const tracker = this.getCheckpointTracker(sessionKey);
+        const turns = this.appendCheckpointTurn(sessionKey, {
+            user: this.truncateCheckpointText(prompt),
+            assistant: this.truncateCheckpointText(response),
+        });
+        if (!this.config.memoryCheckpointEnabled) {
+            log.info({ sessionKey }, "memory.checkpoint.disabled");
+            return;
+        }
+        tracker.tickOrchestratorTurn();
+        if (!tracker.shouldFire()) {
+            return;
+        }
+        tracker.markFired();
+        if (isCheckpointInFlight(sessionKey)) {
+            log.info({ sessionKey }, "memory.checkpoint.in_flight_skip");
+            return;
+        }
+        const copilotClient = this.getCopilotClient();
+        if (!copilotClient) {
+            log.error({ sessionKey }, "memory.checkpoint.error");
+            return;
+        }
+        const activeScope = this.resolveScopeForSession(sessionKey);
+        void runCheckpointExtraction({
+            sessionKey,
+            turns: turns.slice(-this.config.memoryCheckpointTurns),
+            activeScope,
+            copilotClient,
+            trigger: "cadence",
+        }).catch((error) => {
+            log.error({ err: error, sessionKey }, "memory.checkpoint.error");
+        });
+    }
+    scheduleHousekeeping(sessionKey) {
+        if (!this.config.memoryHousekeepingEnabled) {
+            log.info({ sessionKey }, "memory.housekeeping.disabled");
+            return;
+        }
+        const turns = (this.housekeepingTurnsBySession.get(sessionKey) ?? 0) + 1;
+        if (turns < this.config.memoryHousekeepingTurns) {
+            this.housekeepingTurnsBySession.set(sessionKey, turns);
+            return;
+        }
+        this.housekeepingTurnsBySession.set(sessionKey, 0);
+        const activeScope = this.resolveScopeForSession(sessionKey);
+        if (!activeScope) {
+            log.info({ sessionKey }, "memory.housekeeping.no_active_scope");
+            return;
+        }
+        const scopeIds = [activeScope.id];
+        if (isHousekeepingInFlight(scopeIds)) {
+            log.info({ sessionKey, scope_ids: scopeIds }, "memory.housekeeping.in_flight_skip");
+            return;
+        }
+        void runHousekeeping({ scopeIds }).catch((error) => {
+            log.error({ err: error, sessionKey, scope_ids: scopeIds }, "memory.housekeeping.error");
+        });
+    }
+}
+//# sourceMappingURL=memory-coordinator.js.map