chapterhouse 0.13.1 → 0.14.1

package/dist/memory/tools/write.js

@@ -0,0 +1,116 @@
+// Write tools: cog_write, cog_edit, cog_append, cog_move. Each mutating tool
+// runs through withMemoryWrite (write-lock + auto-commit).
+// Ported from chgo's tools_write.go.
+import { defineTool } from "@github/copilot-sdk";
+import { z } from "zod";
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
+import { dirname } from "path";
+import { resolveMemoryPath } from "../path-guard.js";
+import { hasL0Header } from "../markdown.js";
+import { withMemoryWrite } from "./commit-wrapper.js";
+import { toolError } from "./shared.js";
+export function createWriteTools(manager) {
+    const root = manager.paths.memoryRoot;
+    return [
+        defineTool("cog_write", {
+            description: "Create or overwrite a memory file. A .md file must begin with an " +
+                "<!-- L0: summary --> line within the first few lines.",
+            parameters: z.object({
+                path: z.string().describe("File path relative to the memory root"),
+                content: z.string().describe("Full file content"),
+            }),
+            handler: async (args) => {
+                try {
+                    const abs = resolveMemoryPath(root, args.path);
+                    if (abs.endsWith(".md") && !hasL0Header(args.content)) {
+                        return "Error: a .md memory file must begin with an <!-- L0: summary --> line";
+                    }
+                    return await withMemoryWrite(manager, `memory: write ${args.path}`, () => {
+                        mkdirSync(dirname(abs), { recursive: true });
+                        writeFileSync(abs, args.content, "utf8");
+                        return `wrote ${args.path}`;
+                    });
+                }
+                catch (err) {
+                    return toolError(err);
+                }
+            },
+        }),
+        defineTool("cog_edit", {
+            description: "Replace an exact, unique string in a memory file (edit in place).",
+            parameters: z.object({
+                path: z.string().describe("File path"),
+                old: z.string().describe("Exact text to replace — must occur exactly once"),
+                new: z.string().describe("Replacement text"),
+            }),
+            handler: async (args) => {
+                try {
+                    const abs = resolveMemoryPath(root, args.path);
+                    const data = readFileSync(abs, "utf8");
+                    const occurrences = data.split(args.old).length - 1;
+                    if (occurrences === 0) {
+                        return `Error: old string not found in ${args.path}`;
+                    }
+                    if (occurrences > 1) {
+                        return `Error: old string is not unique in ${args.path} — include more context`;
+                    }
+                    return await withMemoryWrite(manager, `memory: edit ${args.path}`, () => {
+                        writeFileSync(abs, data.replace(args.old, args.new), "utf8");
+                        return `edited ${args.path}`;
+                    });
+                }
+                catch (err) {
+                    return toolError(err);
+                }
+            },
+        }),
+        defineTool("cog_append", {
+            description: "Append a block of text to a memory file (for append-only files like observations).",
+            parameters: z.object({
+                path: z.string().describe("File path"),
+                content: z.string().describe("Text to append"),
+            }),
+            handler: async (args) => {
+                try {
+                    const abs = resolveMemoryPath(root, args.path);
+                    const existing = readFileSync(abs, "utf8");
+                    let next = existing;
+                    if (next !== "" && !next.endsWith("\n"))
+                        next += "\n";
+                    next += args.content;
+                    if (!next.endsWith("\n"))
+                        next += "\n";
+                    return await withMemoryWrite(manager, `memory: append ${args.path}`, () => {
+                        writeFileSync(abs, next, "utf8");
+                        return `appended to ${args.path}`;
+                    });
+                }
+                catch (err) {
+                    return toolError(err);
+                }
+            },
+        }),
+        defineTool("cog_move", {
+            description: "Move or rename a memory file (used for glacier archival).",
+            parameters: z.object({
+                from: z.string().describe("Source path"),
+                to: z.string().describe("Destination path"),
+            }),
+            handler: async (args) => {
+                try {
+                    const from = resolveMemoryPath(root, args.from);
+                    const to = resolveMemoryPath(root, args.to);
+                    return await withMemoryWrite(manager, `memory: move ${args.from} -> ${args.to}`, () => {
+                        mkdirSync(dirname(to), { recursive: true });
+                        renameSync(from, to);
+                        return `moved ${args.from} -> ${args.to}`;
+                    });
+                }
+                catch (err) {
+                    return toolError(err);
+                }
+            },
+        }),
+    ];
+}
+//# sourceMappingURL=write.js.map

package/dist/memory/tools/write.test.js

@@ -0,0 +1,107 @@
+import assert from "node:assert/strict";
+import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import test from "node:test";
+import { gitAvailable, gitLog } from "../git.js";
+import { MemoryManager } from "../manager.js";
+import { createMemoryTools } from "./index.js";
+const sandbox = join(process.cwd(), ".test-work", `mem-tools-write-${process.pid}`);
+function findTool(tools, name) {
+    const found = tools.find((t) => t.name === name);
+    assert.ok(found, `tool ${name} not found`);
+    return found;
+}
+async function call(tool, args) {
+    const result = await tool.handler(args, {
+        sessionId: "t",
+        toolCallId: "t",
+        toolName: tool.name,
+        arguments: args,
+    });
+    return String(result);
+}
+async function setup() {
+    const mgr = new MemoryManager(sandbox);
+    await mgr.ensureReady();
+    return { tools: createMemoryTools(mgr), root: mgr.paths.memoryRoot };
+}
+test.beforeEach(() => {
+    rmSync(sandbox, { recursive: true, force: true });
+    mkdirSync(sandbox, { recursive: true });
+});
+test.after(() => rmSync(sandbox, { recursive: true, force: true }));
+test("cog_write rejects a .md file with no L0 header", async () => {
+    if (!gitAvailable())
+        return;
+    const { tools } = await setup();
+    const out = await call(findTool(tools, "cog_write"), {
+        path: "personal/note.md",
+        content: "# No L0 here\nbody",
+    });
+    assert.match(out, /<!-- L0: summary -->/);
+});
+test("cog_write accepts a .md file with an L0 header and commits it", async () => {
+    if (!gitAvailable())
+        return;
+    const { tools, root } = await setup();
+    const before = (await gitLog(root, 50)).trim().split("\n").length;
+    const out = await call(findTool(tools, "cog_write"), {
+        path: "personal/note.md",
+        content: "<!-- L0: a note -->\n# Note\nbody",
+    });
+    assert.match(out, /wrote personal\/note\.md/);
+    assert.ok(existsSync(join(root, "personal/note.md")));
+    const log = await gitLog(root, 50);
+    assert.ok(log.includes("memory: write personal/note.md"));
+    assert.equal(log.trim().split("\n").length, before + 1, "exactly one new commit");
+});
+test("cog_edit errors on missing and non-unique matches, succeeds when unique", async () => {
+    if (!gitAvailable())
+        return;
+    const { tools } = await setup();
+    await call(findTool(tools, "cog_write"), {
+        path: "personal/note.md",
+        content: "<!-- L0: a note -->\nalpha\nbeta\nalpha",
+    });
+    assert.match(await call(findTool(tools, "cog_edit"), { path: "personal/note.md", old: "zeta", new: "x" }), /not found/);
+    assert.match(await call(findTool(tools, "cog_edit"), { path: "personal/note.md", old: "alpha", new: "x" }), /not unique/);
+    assert.match(await call(findTool(tools, "cog_edit"), { path: "personal/note.md", old: "beta", new: "BETA" }), /edited/);
+});
+test("cog_append normalizes newlines", async () => {
+    if (!gitAvailable())
+        return;
+    const { tools, root } = await setup();
+    await call(findTool(tools, "cog_write"), {
+        path: "personal/observations.md",
+        content: "<!-- L0: obs -->\nfirst line",
+    });
+    await call(findTool(tools, "cog_append"), { path: "personal/observations.md", content: "second line" });
+    assert.equal(readFileSync(join(root, "personal/observations.md"), "utf8"), "<!-- L0: obs -->\nfirst line\nsecond line\n");
+});
+test("cog_move relocates a file", async () => {
+    if (!gitAvailable())
+        return;
+    const { tools, root } = await setup();
+    await call(findTool(tools, "cog_write"), {
+        path: "personal/old.md",
+        content: "<!-- L0: x -->\nbody",
+    });
+    const out = await call(findTool(tools, "cog_move"), {
+        from: "personal/old.md",
+        to: "glacier/personal/old.md",
+    });
+    assert.match(out, /moved/);
+    assert.ok(!existsSync(join(root, "personal/old.md")));
+    assert.ok(existsSync(join(root, "glacier/personal/old.md")));
+});
+test("cog_write rejects a path escaping the memory root", async () => {
+    if (!gitAvailable())
+        return;
+    const { tools } = await setup();
+    const out = await call(findTool(tools, "cog_write"), {
+        path: "../escape.md",
+        content: "<!-- L0: x -->\nbody",
+    });
+    assert.match(out, /escapes the memory root/);
+});
+//# sourceMappingURL=write.test.js.map

package/dist/memory/walk.js

@@ -0,0 +1,39 @@
+// Walks the markdown files of the memory tree (or one domain subtree),
+// skipping the .git directory. Ported from chgo's tools_read.go walkMemoryMarkdown.
+import { readdirSync } from "fs";
+import { join, relative, sep } from "path";
+import { resolveMemoryPath } from "./path-guard.js";
+/**
+ * Calls `fn(rel, abs)` for every `.md` file under the memory root, or under a
+ * domain subdirectory when `domain` is given. `rel` is slash-separated and
+ * relative to the memory root.
+ */
+export function walkMemoryMarkdown(memoryRoot, domain, fn) {
+    let base = memoryRoot;
+    if (domain && domain.trim() !== "") {
+        base = resolveMemoryPath(memoryRoot, domain);
+    }
+    const walk = (dir) => {
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return; // directory may not exist yet
+        }
+        for (const entry of entries) {
+            const full = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (entry.name === ".git")
+                    continue;
+                walk(full);
+            }
+            else if (entry.name.endsWith(".md")) {
+                const rel = relative(memoryRoot, full).split(sep).join("/");
+                fn(rel, full);
+            }
+        }
+    };
+    walk(base);
+}
+//# sourceMappingURL=walk.js.map

package/dist/store/repositories/sessions.js

@@ -229,6 +229,46 @@ export function getSessionMessages(sessionKey, limit, options = {}) {
         return message;
     });
 }
+/**
+ * Group conversation_log rows into sessions for the cog_sessions tool. Rows are
+ * grouped by (session_key, run_id); `agent_completion` rows map to role
+ * "assistant"; empty-content rows are skipped. When `since` (an ISO-8601
+ * string) is given, only later turns are kept. Sessions are sorted
+ * newest-first; `limit` (0 = no cap) bounds the count.
+ *
+ * Note: conversation_log is pruned to the last 1000 rows, so only recent
+ * history is visible — adequate for the reflect skill's cursor model.
+ */
+export function getConversationSessions(since, limit = 0) {
+    const db = getDb();
+    const rows = db.prepare(`SELECT role, content, ts, session_key, run_id, agent_slug FROM conversation_log
+     WHERE role IN ('user', 'assistant', 'agent_completion')
+     ORDER BY session_key, run_id, id ASC`).all();
+    const sinceIso = since ? normalizeSqliteTsToIso(since) : undefined;
+    const byKey = new Map();
+    for (const r of rows) {
+        if (!r.content || r.content.trim() === "")
+            continue;
+        const at = normalizeSqliteTsToIso(r.ts);
+        if (sinceIso && at <= sinceIso)
+            continue;
+        const key = `${r.session_key}|${r.run_id ?? ""}`;
+        let session = byKey.get(key);
+        if (!session) {
+            session = { sessionKey: r.session_key, runId: r.run_id, startedAt: at, turns: [] };
+            byKey.set(key, session);
+        }
+        session.turns.push({
+            role: r.role === "agent_completion" ? "assistant" : r.role,
+            content: r.content,
+            ts: at,
+            agentSlug: r.agent_slug,
+        });
+    }
+    const sessions = Array.from(byKey.values()).filter((s) => s.turns.length > 0);
+    sessions.sort((a, b) => (a.startedAt < b.startedAt ? 1 : a.startedAt > b.startedAt ? -1 : 0));
+    return limit > 0 ? sessions.slice(0, limit) : sessions;
+}
 /**
  * Append one event to agent_task_events and return the new event.
  * Uses a transaction so seq is monotonically incremented.

package/dist/wiki/consolidation.js

@@ -3,8 +3,6 @@ import { execFileSync } from "node:child_process";
 import { existsSync, mkdirSync, renameSync } from "node:fs";
 import { dirname, join, basename } from "node:path";
 import { config } from "../config.js";
-import { recordActionItem } from "../memory/action-items.js";
-import { getScope } from "../memory/scopes.js";
 import { getChapterhouseHome, resolveWikiRelativePath } from "../paths.js";
 import { childLogger } from "../util/logger.js";
 import { deletePage, listPages, readPage, writePage } from "./fs.js";
@@ -77,13 +75,14 @@ export async function runConsolidationWithDeps(db, partialDeps = {}) {
     await deps.commitWikiChanges(runAt);
     return result;
 }
-function createDefaultDeps(db) {
+function createDefaultDeps(_db) {
     return {
         now: () => new Date(),
         synthesizeTruth: synthesizeTruthWithCopilot,
         rebuildIndex: rebuildWikiIndex,
         commitWikiChanges: async (runAt) => commitWikiChanges(runAt),
-        createActionItem: ({ title, detail, source }) => createStaleSessionActionItem(db, { title, detail, source }),
+        // Wiki consolidation no longer records action items into agent memory.
+        createActionItem: () => false,
         truthRewriteBudget: config.pkbTruthRewriteBudget,
     };
 }
@@ -466,33 +465,6 @@ function notifyStaleSessions(db, deps, runAt) {
     }
     return created;
 }
-function createStaleSessionActionItem(db, input) {
-    const globalScope = getScope("global");
-    if (!globalScope) {
-        return false;
-    }
-    const existing = recordDuplicateActionItemCheck(db, globalScope.id, input.title);
-    if (existing) {
-        return false;
-    }
-    recordActionItem({
-        scope_id: globalScope.id,
-        title: input.title,
-        detail: input.detail,
-        source: input.source,
-        tier: "warm",
-    });
-    return true;
-}
-function recordDuplicateActionItemCheck(db, scopeId, title) {
-    const row = db.prepare(`
-    SELECT 1
-    FROM mem_action_items
-    WHERE scope_id = ? AND title = ? AND status IN ('open', 'snoozed')
-    LIMIT 1
-  `).get(scopeId, title);
-    return Boolean(row);
-}
 async function synthesizeTruthWithCopilot(input) {
     const token = config.copilotAuthToken;
     if (!token) {

package/dist/wiki/consolidation.test.js

@@ -118,25 +118,6 @@ test("runConsolidation removes orphaned wiki_links rows", async () => {
     assert.equal(result.linksRepaired, 1);
     assert.equal(orphanCount.c, 0);
 });
-test("runConsolidation creates an action item for research sessions inactive for 7+ days", async () => {
-    const { dbModule, wikiFs, consolidation, memory } = await loadModules();
-    const db = dbModule.getDb();
-    wikiFs.ensureWikiStructure();
-    const globalScope = memory.getScope("global");
-    assert.ok(globalScope);
-    db.prepare(`
-    INSERT INTO wiki_sources (id, source_type, origin, title, ingested_at, raw_path, parsed_content, pages_updated, status, session_id, session_name)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `).run("source-1", "url", "https://example.test/1", "Research note", "2026-05-01T10:00:00.000Z", "sources/source-1.md", "content", "[]", "active", "session-123", "Compiler research");
-    const result = await consolidation.runConsolidationWithDeps(db, {
-        now: () => new Date("2026-05-14T22:30:03.086Z"),
-        synthesizeTruth: async () => "unused",
-        commitWikiChanges: async () => false,
-    });
-    const actionItems = memory.listActionItems({ scope_id: globalScope.id, includeArchived: true });
-    assert.equal(result.staleSessionsNotified, 1);
-    assert.equal(actionItems.some((item) => item.title.includes("Research session 'Compiler research' has been inactive for 7+ days")), true);
-});
 test("runConsolidation caps truth rewrites before exceeding the LLM budget", async () => {
     const { dbModule, wikiFs, indexManager, consolidation } = await loadModules();
     const db = dbModule.getDb();

package/memory-assets/domain-skill.md

@@ -0,0 +1,38 @@
+---
+name: {{ID}}
+description: Use when the conversation involves {{LABEL}}. Triggers — {{TRIGGER_LINE}}. Do not use for topics belonging to other domains.
+---
+
+# {{LABEL}}
+
+Use this skill when the user discusses {{LABEL}} topics.
+
+## Memory Files
+
+Always read on activation:
+- `memory/{{PATH}}/hot-memory.md` (via `cog_read`)
+
+Then load additional files per the memory retrieval protocol based on the query:
+- Status/task query → `memory/{{PATH}}/action-items.md`
+- Entity/people query → `memory/{{PATH}}/entities.md`
+- Update/observation → the target file only
+- Complex query → hot-memory first, then drill into referenced files
+
+Available warm files: {{FILES}}
+
+To find files without opening them, run `cog_l0_scan` scoped to `{{PATH}}`.
+Historical data: `cog_read` on `memory/glacier/index.md`, filter by domain `{{ID}}`.
+
+## Routing
+
+When the user shares information or asks to save something, write with the
+`cog_*` tools:
+- Task/todo → `memory/{{PATH}}/action-items.md`
+- Person/entity → `memory/{{PATH}}/entities.md`
+- Update/log → `memory/{{PATH}}/observations.md`
+- Status/overview → `memory/{{PATH}}/hot-memory.md`
+
+## Activation
+
+Read the hot-memory file, classify the query, load the minimum files needed,
+and respond.

package/memory-assets/seed/cog-meta/improvements.md

@@ -0,0 +1,8 @@
+<!-- L0: Feature ideas, wishlists, and repair notes -->
+# Improvements
+
+<!-- Edit in place by section. -->
+
+## Ideas
+
+## Implemented

package/memory-assets/seed/cog-meta/patterns.md

@@ -0,0 +1,5 @@
+<!-- L0: Distilled interaction and workflow rules from experience -->
+# Learned Patterns
+
+<!-- Edit in place. Distill self-observations into actionable, timeless rules. -->
+<!-- HARD LIMIT: 70 lines / 5.5KB. Domain-specific patterns go in satellite files. -->

package/memory-assets/seed/cog-meta/reflect-cursor.md

@@ -0,0 +1,4 @@
+<!-- L0: Ingestion cursor for the reflect skill over session history -->
+# Reflect Cursor
+
+last_processed: never

package/memory-assets/seed/cog-meta/scenario-calibration.md

@@ -0,0 +1,14 @@
+<!-- L0: Prediction accuracy tracker for decision scenarios -->
+# Scenario Calibration
+
+<!-- Updated by the reflect skill when scenarios resolve. -->
+
+## Resolved Scenarios
+
+| Scenario | Created | Resolved | Predicted Branch | Actual Branch | Accuracy | Lesson |
+|----------|---------|----------|-----------------|---------------|----------|--------|
+
+## Metrics
+
+- Total resolved: 0
+- Accuracy rate: —

package/memory-assets/seed/cog-meta/self-observations.md

@@ -0,0 +1,4 @@
+<!-- L0: What worked and didn't in interactions — append-only -->
+# Self-Observations
+
+<!-- Append-only. Format: - YYYY-MM-DD [tag]: observation -->

package/memory-assets/seed/domains.yml

@@ -0,0 +1,19 @@
+# Chapterhouse Domain Manifest
+# Single source of truth for all memory domains.
+# Add domains with the setup skill, or edit this file directly — Chapterhouse
+# reconciles directories and skill files from it on every startup.
+
+domains:
+  - id: personal
+    path: personal
+    type: personal
+    label: "Family, health, calendar, day-to-day"
+    triggers: [family, health, kids, calendar, personal, home, car, finance]
+    files: [hot-memory, action-items, entities, observations, habits, health, calendar]
+
+  - id: cog-meta
+    path: cog-meta
+    type: system
+    label: "Memory self-knowledge, pipeline health, architecture"
+    triggers: [meta, evolve, pipeline, memory system, architecture]
+    files: [self-observations, patterns, improvements, scenario-calibration, reflect-cursor]

package/memory-assets/seed/glacier/index.md

@@ -0,0 +1,6 @@
+# Glacier Index
+<!-- Auto-generated by the housekeeping skill. Do not edit. -->
+<!-- Last updated: — -->
+
+| File | Domain | Type | Tags | Date Range | Entries | Summary |
+|------|--------|------|------|------------|---------|---------|

package/memory-assets/seed/hot-memory.md

@@ -0,0 +1,5 @@
+<!-- L0: Cross-domain strategic context — identity, active priorities -->
+# Hot Memory
+
+<!-- Rewrite freely. Keep under 50 lines. -->
+<!-- Use the setup skill to populate this with your domains and priorities. -->

package/memory-assets/seed/link-index.md

@@ -0,0 +1,6 @@
+# Memory Link Index
+<!-- Auto-generated by the housekeeping skill. Do not edit. -->
+<!-- Last updated: — -->
+
+| Target | Linked from |
+|--------|-------------|