chapterhouse 0.3.23 → 0.3.25

package/dist/copilot/tools.js

@@ -1,11 +1,12 @@
 import { z } from "zod";
 import { approveAll, defineTool } from "@github/copilot-sdk";
-import { getDb } from "../store/db.js";
+import { getDb, appendTaskOutputDeltaEvent, appendTaskStatusEvent, updateTaskResult } from "../store/db.js";
 import { readdirSync, readFileSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
 import { listSkills, createSkill, removeSkill } from "./skills.js";
 import { config, persistModel } from "../config.js";
+import { agentEventBus } from "./agent-event-bus.js";
 import { getCurrentSourceChannel, getCurrentActivityCallback, getCurrentActiveProjectRules, getCurrentAuthenticatedUser, getLastAuthenticatedUser, getCurrentAuthorizationHeader, getCurrentSessionKey, switchSessionModel, } from "./orchestrator.js";
 import { getRouterConfig, updateRouterConfig } from "./router.js";
 import { ensureWikiStructure, readPage, writePage, deletePage, writeRawSource, assertPagePath } from "../wiki/fs.js";
@@ -137,6 +138,34 @@ export function createTools(deps) {
                 // `executeOnSession` finishes.
                 const parentActivity = getCurrentActivityCallback();
                 const childUnsubs = [];
+                const emitTaskLogEvent = (taskEvent) => {
+                    void agentEventBus.emit({
+                        type: "session:tool_call",
+                        sessionId: task.taskId,
+                        payload: {
+                            toolName: "",
+                            toolArgs: {},
+                            _kind: taskEvent.kind,
+                            _seq: taskEvent.seq,
+                            _ts: taskEvent.ts,
+                            _summary: taskEvent.summary,
+                            _text: taskEvent.text,
+                            _status: taskEvent.status,
+                        },
+                        timestamp: new Date(taskEvent.ts),
+                    });
+                };
+                let workerOutput = "";
+                childUnsubs.push(session.on("assistant.message_delta", (event) => {
+                    const delta = typeof event.data.deltaContent === "string" ? event.data.deltaContent : "";
+                    if (!delta)
+                        return;
+                    workerOutput += delta;
+                    const taskEvent = appendTaskOutputDeltaEvent(task.taskId, delta);
+                    if (!taskEvent)
+                        return;
+                    emitTaskLogEvent(taskEvent);
+                }));
                 if (parentActivity) {
                     childUnsubs.push(session.on("assistant.reasoning_delta", (event) => {
                         parentActivity({
@@ -179,15 +208,21 @@ export function createTools(deps) {
                 (async () => {
                     try {
                         const result = await session.sendAndWait({ prompt: taskPrompt }, timeoutMs);
-                        const output = result?.data?.content || "No response";
+                        const output = workerOutput || result?.data?.content || "No response";
                         completeTask(task.taskId, output);
-                        db.prepare(`UPDATE agent_tasks SET status = 'completed', result = ?, completed_at = CURRENT_TIMESTAMP WHERE task_id = ?`).run(output.slice(0, 10000), task.taskId);
+                        updateTaskResult(task.taskId, "completed", output);
+                        const statusEvent = appendTaskStatusEvent(task.taskId, "completed");
+                        if (statusEvent)
+                            emitTaskLogEvent(statusEvent);
                         deps.onAgentTaskComplete(task.taskId, delegatedSlug, output);
                     }
                     catch (err) {
                         const msg = err instanceof Error ? err.message : String(err);
                         failTask(task.taskId, msg);
-                        db.prepare(`UPDATE agent_tasks SET status = 'error', result = ?, completed_at = CURRENT_TIMESTAMP WHERE task_id = ?`).run(msg, task.taskId);
+                        updateTaskResult(task.taskId, "error", msg);
+                        const statusEvent = appendTaskStatusEvent(task.taskId, "error", msg);
+                        if (statusEvent)
+                            emitTaskLogEvent(statusEvent);
                         deps.onAgentTaskComplete(task.taskId, delegatedSlug, `Error: ${msg}`);
                     }
                     finally {

package/dist/store/db.js

@@ -44,6 +44,14 @@ export function getDb() {
         started_at DATETIME DEFAULT CURRENT_TIMESTAMP,
         completed_at DATETIME
       )
+    `);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS projects (
+        slug TEXT PRIMARY KEY,
+        cwd TEXT NOT NULL,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
     `);
         db.exec(`
       CREATE TABLE IF NOT EXISTS max_state (
@@ -118,19 +126,45 @@ export function getDb() {
         if (!taskCols.some((c) => c.name === "prompt")) {
             db.exec(`ALTER TABLE agent_tasks ADD COLUMN prompt TEXT`);
         }
-        // agent_task_events: append-only per-task tool-call activity log for /workers streaming
+        // agent_task_events: append-only per-task activity log for /workers streaming
         db.exec(`
       CREATE TABLE IF NOT EXISTS agent_task_events (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
         task_id TEXT NOT NULL REFERENCES agent_tasks(task_id) ON DELETE CASCADE,
         seq INTEGER NOT NULL,
         ts INTEGER NOT NULL,
-        kind TEXT NOT NULL CHECK(kind IN ('tool_start', 'tool_complete')),
+        kind TEXT NOT NULL CHECK(kind IN ('tool_start', 'tool_complete', 'output_delta', 'task_status')),
         tool_name TEXT,
-        summary TEXT
+        summary TEXT,
+        text TEXT,
+        status TEXT
       )
     `);
         db.exec(`CREATE INDEX IF NOT EXISTS idx_agent_task_events_task_id ON agent_task_events(task_id, seq)`);
+        // Migrate existing agent_task_events tables that lack text/status columns
+        const taskEventCols = db.prepare(`PRAGMA table_info(agent_task_events)`).all();
+        if (!taskEventCols.some((c) => c.name === "text") || !taskEventCols.some((c) => c.name === "status")) {
+            db.exec(`ALTER TABLE agent_task_events RENAME TO agent_task_events_old`);
+            db.exec(`
+        CREATE TABLE agent_task_events (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          task_id TEXT NOT NULL REFERENCES agent_tasks(task_id) ON DELETE CASCADE,
+          seq INTEGER NOT NULL,
+          ts INTEGER NOT NULL,
+          kind TEXT NOT NULL CHECK(kind IN ('tool_start', 'tool_complete', 'output_delta', 'task_status')),
+          tool_name TEXT,
+          summary TEXT,
+          text TEXT,
+          status TEXT
+        )
+      `);
+            db.exec(`
+        INSERT INTO agent_task_events (id, task_id, seq, ts, kind, tool_name, summary)
+        SELECT id, task_id, seq, ts, kind, tool_name, summary FROM agent_task_events_old
+      `);
+            db.exec(`DROP TABLE agent_task_events_old`);
+            db.exec(`CREATE INDEX IF NOT EXISTS idx_agent_task_events_task_id ON agent_task_events(task_id, seq)`);
+        }
         // Migrate: add event_seq column to agent_tasks for monotonic event numbering
         const taskColsNow = db.prepare(`PRAGMA table_info(agent_tasks)`).all();
         if (!taskColsNow.some((c) => c.name === 'event_seq')) {
@@ -334,7 +368,7 @@ export function getSessionMessages(sessionKey, limit) {
  * Uses a transaction so seq is monotonically incremented.
  * Non-fatal: silently ignores DB errors (task may not exist yet due to race).
  */
-export function appendTaskEvent(taskId, kind, toolName, summary) {
+export function appendTaskEvent(taskId, kind, toolName, summary, text = null, status = null) {
     const db = getDb();
     try {
         return db.transaction(() => {
@@ -344,20 +378,30 @@ export function appendTaskEvent(taskId, kind, toolName, summary) {
                 return undefined;
             const seq = row.event_seq;
             const ts = Date.now();
-            const info = db.prepare(`INSERT INTO agent_task_events (task_id, seq, ts, kind, tool_name, summary) VALUES (?, ?, ?, ?, ?, ?)`).run(taskId, seq, ts, kind, toolName, summary);
-            return { id: Number(info.lastInsertRowid), taskId, seq, ts, kind, toolName, summary };
+            const info = db.prepare(`INSERT INTO agent_task_events (task_id, seq, ts, kind, tool_name, summary, text, status) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(taskId, seq, ts, kind, toolName, summary, text, status);
+            return { id: Number(info.lastInsertRowid), taskId, seq, ts, kind, toolName, summary, text, status };
         })();
     }
     catch {
         return undefined;
     }
 }
+export function appendTaskOutputDeltaEvent(taskId, text) {
+    return appendTaskEvent(taskId, "output_delta", null, null, text, null);
+}
+export function appendTaskStatusEvent(taskId, status, summary = null) {
+    return appendTaskEvent(taskId, "task_status", null, summary, null, status);
+}
+export function updateTaskResult(taskId, status, result) {
+    const db = getDb();
+    db.prepare(`UPDATE agent_tasks SET status = ?, result = ?, completed_at = CURRENT_TIMESTAMP WHERE task_id = ?`).run(status, result ? result.slice(0, 10000) : null, taskId);
+}
 /**
  * Return all events for a task ordered by seq ascending.
  */
 export function getTaskEvents(taskId, afterSeq = 0) {
     const db = getDb();
-    const rows = db.prepare(`SELECT id, task_id, seq, ts, kind, tool_name, summary
+    const rows = db.prepare(`SELECT id, task_id, seq, ts, kind, tool_name, summary, text, status
      FROM agent_task_events WHERE task_id = ? AND seq > ? ORDER BY seq ASC`).all(taskId, afterSeq);
     return rows.map((r) => ({
         id: r.id,
@@ -367,6 +411,8 @@ export function getTaskEvents(taskId, afterSeq = 0) {
         kind: r.kind,
         toolName: r.tool_name,
         summary: r.summary,
+        text: r.text,
+        status: r.status,
     }));
 }
 export function closeDb() {

package/dist/store/db.test.js

@@ -32,6 +32,7 @@ test("getDb initializes schema, state helpers, and conversation formatting", asy
             "worker_sessions",
             "agent_sessions",
             "agent_tasks",
+            "projects",
             "max_state",
             "conversation_log",
             "memories",
@@ -265,6 +266,62 @@ test("#86: agent_task_events table exists in schema after getDb()", async () =>
         dbModule.closeDb();
     }
 });
+test("#158: appendTaskOutputDeltaEvent writes output_delta event with text", async () => {
+    const dbModule = await loadDbModule();
+    try {
+        const db = dbModule.getDb();
+        db.prepare("INSERT INTO agent_tasks (task_id, agent_slug, description, status) VALUES (?, ?, ?, ?)").run("task-delta-001", "coder", "delta test", "running");
+        const ev = dbModule.appendTaskOutputDeltaEvent("task-delta-001", "Hello world");
+        assert.ok(ev, "appendTaskOutputDeltaEvent must return the event");
+        assert.equal(ev.kind, "output_delta");
+        assert.equal(ev.text, "Hello world");
+        assert.equal(ev.toolName, null);
+        assert.equal(ev.status, null);
+        assert.equal(ev.seq, 1);
+        const events = dbModule.getTaskEvents("task-delta-001");
+        assert.equal(events.length, 1);
+        assert.equal(events[0].text, "Hello world");
+        assert.equal(events[0].kind, "output_delta");
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
+test("#158: appendTaskStatusEvent writes task_status event with status field", async () => {
+    const dbModule = await loadDbModule();
+    try {
+        const db = dbModule.getDb();
+        db.prepare("INSERT INTO agent_tasks (task_id, agent_slug, description, status) VALUES (?, ?, ?, ?)").run("task-status-001", "coder", "status test", "running");
+        const ev = dbModule.appendTaskStatusEvent("task-status-001", "completed", "All done");
+        assert.ok(ev, "appendTaskStatusEvent must return the event");
+        assert.equal(ev.kind, "task_status");
+        assert.equal(ev.status, "completed");
+        assert.equal(ev.summary, "All done");
+        assert.equal(ev.text, null);
+        assert.equal(ev.toolName, null);
+        const events = dbModule.getTaskEvents("task-status-001");
+        assert.equal(events.length, 1);
+        assert.equal(events[0].status, "completed");
+        assert.equal(events[0].kind, "task_status");
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
+test("#158: updateTaskResult updates agent_tasks status and result", async () => {
+    const dbModule = await loadDbModule();
+    try {
+        const db = dbModule.getDb();
+        db.prepare("INSERT INTO agent_tasks (task_id, agent_slug, description, status) VALUES (?, ?, ?, ?)").run("task-result-001", "coder", "result test", "running");
+        dbModule.updateTaskResult("task-result-001", "completed", "output text");
+        const row = db.prepare("SELECT status, result FROM agent_tasks WHERE task_id = ?").get("task-result-001");
+        assert.equal(row.status, "completed");
+        assert.equal(row.result, "output text");
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
 // ---------------------------------------------------------------------------
 // normalizeSqliteTsToIso — unit tests
 // ---------------------------------------------------------------------------

package/dist/wiki/project-registry.js

@@ -1,47 +1,91 @@
 import { isAbsolute } from "node:path";
-import { readPage, writePage } from "./fs.js";
-const PROJECTS_INDEX_PATH = "pages/projects/index.md";
+import { getDb } from "../store/db.js";
+import { childLogger } from "../util/logger.js";
+import { deletePage, pageExists, readPage } from "./fs.js";
+const log = childLogger("project-registry");
+const LEGACY_PROJECTS_INDEX_PATH = "pages/projects/index.md";
 const REGISTRY_HEADING = "## Project Registry";
 const OPENING_FENCE = "```yaml";
 const CLOSING_FENCE = "```";
 const SLUG_RE = /^[a-z0-9][a-z0-9-]*$/;
 export function loadRegistry() {
-    const content = readPage(PROJECTS_INDEX_PATH);
-    if (!content)
-        return {};
-    const section = parseRegistrySection(content);
-    if (!section)
-        return {};
-    return parseRegistryBlock(section.blockLines);
+    ensureRegistryMigrated();
+    const rows = getDb()
+        .prepare("SELECT slug, cwd FROM projects ORDER BY slug")
+        .all();
+    return Object.fromEntries(rows.map(({ slug, cwd }) => [slug, cwd]));
 }
 export function saveRegistry(registry) {
     validateRegistry(registry);
-    const renderedSection = renderRegistrySection(registry);
-    const current = readPage(PROJECTS_INDEX_PATH);
-    if (!current) {
-        writePage(PROJECTS_INDEX_PATH, `${renderedSection}\n`);
+    ensureRegistryMigrated();
+    const entries = Object.entries(registry).sort(([left], [right]) => left.localeCompare(right));
+    const db = getDb();
+    const save = db.transaction(() => {
+        db.prepare("DELETE FROM projects").run();
+        const insert = db.prepare(`
+      INSERT INTO projects (slug, cwd, created_at, updated_at)
+      VALUES (?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+    `);
+        for (const [slug, cwd] of entries) {
+            insert.run(slug, cwd);
+        }
+    });
+    save();
+    removeLegacyRegistryFile("Removed legacy wiki registry after SQLite save");
+}
+export function assertValidProjectSlug(slug) {
+    if (!SLUG_RE.test(slug)) {
+        throw new Error(`Project registry has invalid project slug '${slug}'. Expected a lowercase slug.`);
+    }
+}
+function ensureRegistryMigrated() {
+    const db = getDb();
+    let migratedRegistry;
+    const migrate = db.transaction(() => {
+        const row = db.prepare("SELECT COUNT(*) AS count FROM projects").get();
+        if (row.count > 0 || !pageExists(LEGACY_PROJECTS_INDEX_PATH)) {
+            return;
+        }
+        const legacyContent = readPage(LEGACY_PROJECTS_INDEX_PATH);
+        if (!legacyContent) {
+            return;
+        }
+        const registry = parseLegacyRegistry(legacyContent);
+        if (!registry) {
+            log.warn({ path: LEGACY_PROJECTS_INDEX_PATH }, "Legacy projects page had no registry section; skipping SQLite migration");
+            return;
+        }
+        const insert = db.prepare(`
+      INSERT INTO projects (slug, cwd, created_at, updated_at)
+      VALUES (?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+    `);
+        for (const [slug, cwd] of Object.entries(registry).sort(([left], [right]) => left.localeCompare(right))) {
+            insert.run(slug, cwd);
+        }
+        migratedRegistry = registry;
+    });
+    migrate.immediate();
+    if (!migratedRegistry) {
         return;
     }
-    const section = parseRegistrySection(current);
-    if (!section) {
-        const trimmed = stripTrailingBlankLines(normalizeLineEndings(current));
-        const prefix = trimmed ? `${trimmed}\n\n` : "";
-        writePage(PROJECTS_INDEX_PATH, `${prefix}${renderedSection}\n`);
+    removeLegacyRegistryFile("Migrated project registry from wiki to SQLite", Object.keys(migratedRegistry).length);
+}
+function removeLegacyRegistryFile(message, count) {
+    if (!deletePage(LEGACY_PROJECTS_INDEX_PATH)) {
         return;
     }
-    const before = stripTrailingBlankLines(section.before.join("\n"));
-    const after = stripTrailingBlankLines(stripLeadingBlankLines(section.after).join("\n"));
-    const pieces = [];
-    if (before) {
-        pieces.push(before);
-        pieces.push("");
+    if (typeof count === "number") {
+        log.info({ count, path: LEGACY_PROJECTS_INDEX_PATH }, message);
+        return;
     }
-    pieces.push(renderedSection);
-    if (after) {
-        pieces.push("");
-        pieces.push(after);
+    log.info({ path: LEGACY_PROJECTS_INDEX_PATH }, message);
+}
+function parseLegacyRegistry(content) {
+    const section = parseRegistrySection(content);
+    if (!section) {
+        return undefined;
     }
-    writePage(PROJECTS_INDEX_PATH, `${pieces.join("\n")}\n`);
+    return parseRegistryBlock(section.blockLines);
 }
 function parseRegistrySection(content) {
     const normalized = normalizeLineEndings(content);
@@ -81,11 +125,7 @@ function parseRegistrySection(content) {
             throw new Error("Project registry is malformed: unexpected content after the fenced block.");
         }
     }
-    return {
-        before: lines.slice(0, headingIndex),
-        blockLines,
-        after: lines.slice(sectionEnd),
-    };
+    return { blockLines };
 }
 function parseRegistryBlock(lines) {
     const registry = {};
@@ -114,28 +154,11 @@ function validateRegistry(registry) {
         validatePath(path);
     }
 }
-export function assertValidProjectSlug(slug) {
-    if (!SLUG_RE.test(slug)) {
-        throw new Error(`Project registry has invalid project slug '${slug}'. Expected a lowercase slug.`);
-    }
-}
 function validatePath(path) {
     if (!path || !isAbsolute(path)) {
         throw new Error(`Project registry path '${path}' must be an absolute path.`);
     }
 }
-function renderRegistrySection(registry) {
-    const lines = [
-        REGISTRY_HEADING,
-        "",
-        OPENING_FENCE,
-        ...Object.keys(registry)
-            .sort()
-            .map((slug) => `${slug}: ${registry[slug]}`),
-        CLOSING_FENCE,
-    ];
-    return lines.join("\n");
-}
 function findNextHeading(lines, startIndex) {
     for (let index = startIndex; index < lines.length; index += 1) {
         if (/^##\s+/.test(lines[index])) {
@@ -147,14 +170,4 @@ function findNextHeading(lines, startIndex) {
 function normalizeLineEndings(content) {
     return content.replace(/\r\n/g, "\n");
 }
-function stripTrailingBlankLines(content) {
-    return content.replace(/\n+$/g, "");
-}
-function stripLeadingBlankLines(lines) {
-    let start = 0;
-    while (start < lines.length && lines[start].trim() === "") {
-        start += 1;
-    }
-    return lines.slice(start);
-}
 //# sourceMappingURL=project-registry.js.map

package/dist/wiki/project-registry.test.js

@@ -6,67 +6,115 @@ const repoRoot = process.cwd();
 const sandboxRoot = join(repoRoot, ".test-work", `wiki-project-registry-${process.pid}`);
 process.env.CHAPTERHOUSE_HOME = sandboxRoot;
 async function loadModules() {
-    const nonce = `${Date.now()}-${Math.random()}`;
-    const projectRegistry = await import(new URL(`./project-registry.js?case=${nonce}`, import.meta.url).href);
-    const wikiFs = await import(new URL(`./fs.js?case=${nonce}`, import.meta.url).href);
-    return { projectRegistry, wikiFs };
+    const projectRegistry = await import(new URL("./project-registry.js", import.meta.url).href);
+    const wikiFs = await import(new URL("./fs.js", import.meta.url).href);
+    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
+    return { projectRegistry, wikiFs, dbModule };
 }
 function resetSandbox() {
     mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
     rmSync(sandboxRoot, { recursive: true, force: true });
 }
-test.beforeEach(() => {
+test.beforeEach(async () => {
+    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
+    dbModule.closeDb();
     resetSandbox();
 });
-test.after(() => {
+test.after(async () => {
+    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
+    dbModule.closeDb();
     rmSync(sandboxRoot, { recursive: true, force: true });
 });
-test("loadRegistry returns an empty object when pages/projects/index.md is absent", async () => {
-    const { projectRegistry } = await loadModules();
-    assert.deepEqual(projectRegistry.loadRegistry(), {});
+test("loadRegistry returns an empty object when the projects table is empty", async () => {
+    const { projectRegistry, dbModule } = await loadModules();
+    try {
+        assert.deepEqual(projectRegistry.loadRegistry(), {});
+    }
+    finally {
+        dbModule.closeDb();
+    }
 });
-test("loadRegistry returns an empty object when the projects page has no registry section", async () => {
-    const { projectRegistry, wikiFs } = await loadModules();
-    wikiFs.writePage("pages/projects/index.md", "---\ntitle: Projects\nsummary: Project pages live here.\nupdated: 2026-05-12\n---\n\n# Projects\n\nTracked project pages.\n");
-    assert.deepEqual(projectRegistry.loadRegistry(), {});
+test("saveRegistry persists the registry in SQLite", async () => {
+    const { projectRegistry, dbModule, wikiFs } = await loadModules();
+    try {
+        projectRegistry.saveRegistry({
+            "docs-site": "/home/bjk/projects/docs-site",
+            chapterhouse: "/home/bjk/projects/chapterhouse",
+        });
+        assert.deepEqual(projectRegistry.loadRegistry(), {
+            chapterhouse: "/home/bjk/projects/chapterhouse",
+            "docs-site": "/home/bjk/projects/docs-site",
+        });
+        assert.equal(wikiFs.readPage("pages/projects/index.md"), undefined);
+        assert.deepEqual(dbModule.getDb().prepare("SELECT slug, cwd FROM projects ORDER BY slug").all(), [
+            { slug: "chapterhouse", cwd: "/home/bjk/projects/chapterhouse" },
+            { slug: "docs-site", cwd: "/home/bjk/projects/docs-site" },
+        ]);
+    }
+    finally {
+        dbModule.closeDb();
+    }
 });
-test("loadRegistry parses the fenced yaml registry block", async () => {
-    const { projectRegistry, wikiFs } = await loadModules();
-    wikiFs.writePage("pages/projects/index.md", "---\ntitle: Projects\nsummary: Canonical project registry.\nupdated: 2026-05-12\n---\n\n# Projects\n\n## Project Registry\n\n```yaml\nchapterhouse: /home/bjk/projects/chapterhouse\ndocs-site: /home/bjk/Documents/docs site\n```\n");
-    assert.deepEqual(projectRegistry.loadRegistry(), {
-        chapterhouse: "/home/bjk/projects/chapterhouse",
-        "docs-site": "/home/bjk/Documents/docs site",
-    });
+test("saveRegistry replaces prior SQLite-backed registry contents", async () => {
+    const { projectRegistry, dbModule } = await loadModules();
+    try {
+        projectRegistry.saveRegistry({
+            alpha: "/srv/alpha",
+            zeta: "/srv/zeta",
+        });
+        projectRegistry.saveRegistry({
+            beta: "/srv/beta",
+            alpha: "/srv/alpha",
+        });
+        assert.deepEqual(projectRegistry.loadRegistry(), {
+            alpha: "/srv/alpha",
+            beta: "/srv/beta",
+        });
+        assert.deepEqual(dbModule.getDb().prepare("SELECT slug, cwd FROM projects ORDER BY slug").all(), [
+            { slug: "alpha", cwd: "/srv/alpha" },
+            { slug: "beta", cwd: "/srv/beta" },
+        ]);
+    }
+    finally {
+        dbModule.closeDb();
+    }
 });
-test("loadRegistry rejects malformed registry content", async () => {
-    const { projectRegistry, wikiFs } = await loadModules();
-    wikiFs.writePage("pages/projects/index.md", "# Projects\n\n## Project Registry\n\n```yaml\nChapterHouse: /home/bjk/projects/chapterhouse\nrelative: ./docs-site\nbroken line\nchapterhouse: /home/bjk/projects/chapterhouse\n```\n");
-    assert.throws(() => projectRegistry.loadRegistry(), /invalid project slug|absolute path|malformed registry line|duplicate project slug/);
-});
-test("saveRegistry creates a new registry page with deterministic ordering", async () => {
-    const { projectRegistry, wikiFs } = await loadModules();
-    projectRegistry.saveRegistry({
-        "docs-site": "/home/bjk/projects/docs-site",
-        chapterhouse: "/home/bjk/projects/chapterhouse",
-    });
-    assert.equal(wikiFs.readPage("pages/projects/index.md"), "## Project Registry\n\n```yaml\nchapterhouse: /home/bjk/projects/chapterhouse\ndocs-site: /home/bjk/projects/docs-site\n```\n");
-});
-test("saveRegistry rewrites only the registry section and preserves surrounding content", async () => {
-    const { projectRegistry, wikiFs } = await loadModules();
-    wikiFs.writePage("pages/projects/index.md", "---\ntitle: Projects\nsummary: Canonical project registry.\nupdated: 2026-05-12\n---\n\n# Projects\n\nIntro paragraph.\n\n## Project Registry\n\n```yaml\nzeta: /srv/zeta\nalpha: /srv/alpha\n```\n\n## Notes\n\nKeep this section untouched.\n");
-    projectRegistry.saveRegistry({
-        beta: "/srv/beta",
-        alpha: "/srv/alpha",
-    });
-    assert.equal(wikiFs.readPage("pages/projects/index.md"), "---\ntitle: Projects\nsummary: Canonical project registry.\nupdated: 2026-05-12\n---\n\n# Projects\n\nIntro paragraph.\n\n## Project Registry\n\n```yaml\nalpha: /srv/alpha\nbeta: /srv/beta\n```\n\n## Notes\n\nKeep this section untouched.\n");
-    assert.deepEqual(projectRegistry.loadRegistry(), {
-        alpha: "/srv/alpha",
-        beta: "/srv/beta",
-    });
+test("loadRegistry migrates the legacy wiki registry into SQLite and removes the file", async () => {
+    const { projectRegistry, wikiFs, dbModule } = await loadModules();
+    try {
+        wikiFs.writePage("pages/projects/index.md", "---\n"
+            + "title: Projects\n"
+            + "summary: Canonical project registry.\n"
+            + "updated: 2026-05-12\n"
+            + "---\n\n"
+            + "# Projects\n\n"
+            + "## Project Registry\n\n"
+            + "```yaml\n"
+            + "chapterhouse: /home/bjk/projects/chapterhouse\n"
+            + "docs-site: /home/bjk/Documents/docs site\n"
+            + "```\n");
+        assert.deepEqual(projectRegistry.loadRegistry(), {
+            chapterhouse: "/home/bjk/projects/chapterhouse",
+            "docs-site": "/home/bjk/Documents/docs site",
+        });
+        assert.equal(wikiFs.pageExists("pages/projects/index.md"), false);
+        assert.deepEqual(dbModule.getDb().prepare("SELECT slug, cwd FROM projects ORDER BY slug").all(), [
+            { slug: "chapterhouse", cwd: "/home/bjk/projects/chapterhouse" },
+            { slug: "docs-site", cwd: "/home/bjk/Documents/docs site" },
+        ]);
+    }
+    finally {
+        dbModule.closeDb();
+    }
 });
 test("saveRegistry rejects invalid slugs and non-absolute paths", async () => {
-    const { projectRegistry } = await loadModules();
-    assert.throws(() => projectRegistry.saveRegistry({ ChapterHouse: "/home/bjk/projects/chapterhouse" }), /invalid project slug/);
-    assert.throws(() => projectRegistry.saveRegistry({ chapterhouse: "./relative" }), /absolute path/);
+    const { projectRegistry, dbModule } = await loadModules();
+    try {
+        assert.throws(() => projectRegistry.saveRegistry({ ChapterHouse: "/home/bjk/projects/chapterhouse" }), /invalid project slug/);
+        assert.throws(() => projectRegistry.saveRegistry({ chapterhouse: "./relative" }), /absolute path/);
+    }
+    finally {
+        dbModule.closeDb();
+    }
 });
 //# sourceMappingURL=project-registry.test.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chapterhouse",
-  "version": "0.3.23",
+  "version": "0.3.25",
   "description": "Chapterhouse — a team-level AI assistant for engineering teams, built on the GitHub Copilot SDK. Web UI only.",
   "bin": {
     "chapterhouse": "dist/cli.js"