chapterhouse 0.13.0 → 0.14.0

package/dist/copilot/agents.js

@@ -12,6 +12,7 @@ import { loadMcpConfig } from "./mcp-config.js";
 import { getCurrentDateSystemLine } from "./prompt-date.js";
 import { getSkillDirectories } from "./skills.js";
 import { EXCLUDED_BUILTIN_TOOLS } from "./builtin-tools.js";
+import { memorySystemInstructions } from "../memory/index.js";
 import { childLogger } from "../util/logger.js";
 const log = childLogger("agents");
 const toolAgentContext = new AsyncLocalStorage();
@@ -23,6 +24,7 @@ const agentFrontmatterSchema = z.object({
     model: z.string().min(1),
     skills: z.array(z.string()).optional(),
     tools: z.array(z.string()).optional(),
+    management_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) => {
@@ -83,6 +85,7 @@ export function parseAgentMdOrThrow(content, slug) {
         scope: fm.scope,
         skills: fm.skills,
         tools: fm.tools,
+        managementTools: fm.management_tools,
         mcpServers: fm.mcpServers,
         allowedPaths: fm.allowed_paths,
         systemMessage: body,
@@ -295,12 +298,12 @@ function getAgentBasePrompt() {
 You are an agent within Chapterhouse, a team-level AI assistant for engineering teams. You run on the user's local machine.
 
 ### Agent Memory
-Chapterhouse agent memory follows a three-tier memory model: **read** with \`memory_recall\` and \`memory_list_action_items\`, **propose** with \`memory_propose\`, and **write** with orchestrator-only tools. Do not call \`memory_remember\` directly; when you discover something memory-worthy, use \`memory_propose\` instead. Proposals are processed automatically at end-of-task, so do not wait for confirmation. Examples: a durable fact is an \`observation\`, a settled implementation choice is a \`decision\`, a named system/tool/person can be proposed as an \`entity\`, and a reminder/follow-up can be proposed as an \`action_item\`.
+Chapterhouse gives every agent a persistent, file-based memory tree under \`memory/\`, organized into domains. Read it with \`cog_read\`, \`cog_l0_scan\`, \`cog_l1_outline\`, \`cog_tree\`, and \`cog_search\`; write directly with \`cog_write\`, \`cog_edit\`, \`cog_append\`, and \`cog_move\` whenever you learn something worth remembering — don't wait for end of task. Every write auto-commits to git. The full memory operating instructions are included below.
 
 ### 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\` 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.
+Invoke \`wiki-conventions\` before wiki writes or restructuring work. Treat \`wiki_update\` and \`wiki_ingest_source\` as write-sensitive workflows. 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
@@ -319,11 +322,12 @@ export function composeAgentSystemMessage(agent, rosterInfo) {
     const agentPrompt = agent.systemMessage;
     const currentDateLine = getCurrentDateSystemLine();
     const currentDateBlock = currentDateLine ? `${currentDateLine}\n\n` : "";
+    const memoryBlock = memorySystemInstructions() ? `\n\n${memorySystemInstructions()}` : "";
     // For @chapterhouse, inject the agent roster
     if (agent.slug === "chapterhouse" && rosterInfo) {
-        return `${currentDateBlock}${agentPrompt.replace("{agent_roster}", rosterInfo)}`;
+        return `${currentDateBlock}${agentPrompt.replace("{agent_roster}", rosterInfo)}${memoryBlock}`;
     }
-    return `${currentDateBlock}${agentPrompt}\n\n${base}`;
+    return `${currentDateBlock}${agentPrompt}\n\n${base}${memoryBlock}`;
 }
 /** Build a roster description of all agents for @chapterhouse's system prompt. */
 export function buildAgentRoster() {
@@ -339,10 +343,13 @@ export function buildAgentRoster() {
         return "No agents registered.";
     return chLines.join("\n");
 }
-// The wiki tools that every agent gets regardless of tool config
-const WIKI_TOOL_NAMES = new Set([
+// Tools every agent gets regardless of tool config: the shared wiki and the
+// full file-based memory surface (all agents read and write memory directly).
+const ALWAYS_AVAILABLE_TOOL_NAMES = new Set([
     "wiki_search", "wiki_read", "wiki_update", "wiki_reindex", "wiki_append_timeline", "wiki_ingest_source",
-    "memory_recall", "memory_propose", "memory_list_action_items",
+    "cog_read", "cog_l0_scan", "cog_l1_outline", "cog_tree", "cog_search", "cog_stats",
+    "cog_write", "cog_edit", "cog_append", "cog_move",
+    "cog_git", "cog_domains", "cog_domain_create", "cog_sessions",
 ]);
 // Management tools that only @chapterhouse should have
 const MANAGEMENT_TOOL_NAMES = new Set([
@@ -351,8 +358,6 @@ 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_reflect", "memory_promote", "memory_demote",
-    "memory_add_action_item", "memory_complete_action_item", "memory_drop_action_item", "memory_snooze_action_item",
 ]);
 export function getCurrentToolAgentSlug() {
     return toolAgentContext.getStore();
@@ -373,14 +378,21 @@ export function bindToolsToAgent(agentSlug, allTools, taskId) {
 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) && !(agent.persistent && MANAGEMENT_TOOL_NAMES.has(t.name)));
+        const allowed = new Set([...agent.tools, ...ALWAYS_AVAILABLE_TOOL_NAMES]);
+        return allTools.filter((t) => allowed.has(t.name));
     }
-    // Default: all tools except management (only @chapterhouse gets those)
+    // Default: all tools except management (only @chapterhouse gets those by default)
     if (agent.slug === "chapterhouse") {
         return allTools;
     }
-    return allTools.filter((t) => !MANAGEMENT_TOOL_NAMES.has(t.name));
+    const baseTools = allTools.filter((t) => !MANAGEMENT_TOOL_NAMES.has(t.name));
+    // Agents can opt into specific management tools via management_tools: in their config
+    if (agent.managementTools && agent.managementTools.length > 0) {
+        const optedIn = new Set(agent.managementTools);
+        const extra = allTools.filter((t) => MANAGEMENT_TOOL_NAMES.has(t.name) && optedIn.has(t.name));
+        return [...baseTools, ...extra];
+    }
+    return baseTools;
 }
 /** Filter MCP servers based on agent config. */
 export function filterMcpServersForAgent(agent, allMcpServers) {

package/dist/copilot/agents.test.js

@@ -50,18 +50,17 @@ 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,120}wiki_ingest_source[\s\S]{0,120}memory_propose/i);
+        assert.match(message, /wiki_update[\s\S]{0,120}wiki_ingest_source/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);
     }
 });
-test("composeAgentSystemMessage teaches subagents the three-tier memory model and directs them to memory_propose", () => {
+test("composeAgentSystemMessage teaches subagents the file-based memory tools", () => {
     const message = composeAgentSystemMessage(makeAgent("coder"));
-    assert.match(message, /three-tier memory model|read, propose, write/i);
-    assert.match(message, /memory_recall/i);
-    assert.match(message, /memory_propose/i);
-    assert.match(message, /do not call `memory_remember` directly|should not call `memory_remember` directly/i);
+    assert.match(message, /cog_read/);
+    assert.match(message, /cog_write/);
+    assert.match(message, /write directly/i);
 });
 test("parseAgentMd detects persistent agent scope from charter frontmatter", () => {
     const agent = parseAgentMd([
@@ -103,22 +102,22 @@ test("korg charter is persistent and standardizes on the Summary heading", () =>
     assert.match(charter, /## Summary/);
     assert.doesNotMatch(charter, /## Compiled Truth/);
 });
-test("persistent agents cannot receive scope-changing management tools", () => {
+test("persistent agents cannot receive management tools", () => {
     const agent = {
         ...makeAgent("bellonda"),
         persistent: true,
         scope: "infra",
     };
     const tools = [
-        { name: "memory_recall" },
-        { name: "memory_propose" },
-        { name: "memory_set_scope" },
+        { name: "cog_read" },
+        { name: "cog_write" },
         { name: "delegate_to_agent" },
+        { name: "hire_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());
+    assert.deepEqual(names.sort(), ["bash", "cog_read", "cog_write"].sort());
 });
 test("bindToolsToAgent uses the per-turn task context when no fixed task id is provided", async () => {
     const tools = bindToolsToAgent("bellonda", [{

package/dist/copilot/memory-coordinator.js

@@ -1,234 +1,19 @@
-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;
+import { getMemoryManager } from "../memory/index.js";
+/**
+ * Wires the file-based memory subsystem into the agent runtime. Its only job is
+ * to inject the always-loaded hot-tier block into each turn via the
+ * onUserPromptSubmitted hook — all memory reads and writes are agent-driven via
+ * the cog_* tools.
+ */
 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 = {
+    /** Returns the per-turn hooks that inject the hot-tier memory block. */
+    buildPerTurnHooks() {
+        return {
             onUserPromptSubmitted: async () => {
-                const hotTierXml = await this.buildHotTierContext(sessionKey);
-                return hotTierXml ? { additionalContext: hotTierXml } : undefined;
+                const block = getMemoryManager().hotTier();
+                return block ? { additionalContext: block } : 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