chapterhouse 0.1.1

package/dist/status.js

@@ -0,0 +1,25 @@
+let currentStatus = "idle";
+let statusMessage = "";
+const listeners = new Set();
+export function setBusy(reason, message) {
+    currentStatus = reason;
+    statusMessage = message;
+    for (const listener of listeners) {
+        listener(currentStatus, statusMessage);
+    }
+}
+export function setIdle() {
+    currentStatus = "idle";
+    statusMessage = "";
+    for (const listener of listeners) {
+        listener(currentStatus, statusMessage);
+    }
+}
+export function getStatus() {
+    return { status: currentStatus, message: statusMessage };
+}
+export function onStatusChange(fn) {
+    listeners.add(fn);
+    return () => listeners.delete(fn);
+}
+//# sourceMappingURL=status.js.map

package/dist/status.test.js

@@ -0,0 +1,22 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { getStatus, onStatusChange, setBusy, setIdle } from "./status.js";
+test("tracks dreaming status and notifies listeners", () => {
+    const seen = [];
+    const unsubscribe = onStatusChange((status, message) => {
+        seen.push({ status, message });
+    });
+    setBusy("dreaming", "Consolidating memories...");
+    assert.deepEqual(getStatus(), {
+        status: "dreaming",
+        message: "Consolidating memories...",
+    });
+    setIdle();
+    assert.deepEqual(getStatus(), { status: "idle", message: "" });
+    unsubscribe();
+    assert.deepEqual(seen, [
+        { status: "dreaming", message: "Consolidating memories..." },
+        { status: "idle", message: "" },
+    ]);
+});
+//# sourceMappingURL=status.test.js.map

package/dist/store/db.js

@@ -0,0 +1,290 @@
+import Database from "better-sqlite3";
+import { DB_PATH, ensureChapterhouseHome } from "../paths.js";
+let db;
+let logInsertCount = 0;
+let fts5Available = false;
+export function getDb() {
+    if (!db) {
+        ensureChapterhouseHome();
+        db = new Database(DB_PATH);
+        db.pragma("journal_mode = WAL");
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS worker_sessions (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        name TEXT UNIQUE NOT NULL,
+        copilot_session_id TEXT,
+        working_dir TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'idle',
+        last_output TEXT,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS agent_sessions (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        slug TEXT UNIQUE NOT NULL,
+        name TEXT NOT NULL,
+        model TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'idle',
+        current_task TEXT,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS agent_tasks (
+        task_id TEXT PRIMARY KEY,
+        agent_slug TEXT NOT NULL,
+        description TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'running',
+        result TEXT,
+        origin_channel TEXT,
+        started_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        completed_at DATETIME
+      )
+    `);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS max_state (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      )
+    `);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS conversation_log (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        role TEXT NOT NULL CHECK(role IN ('user', 'assistant', 'system')),
+        content TEXT NOT NULL,
+        source TEXT NOT NULL DEFAULT 'unknown',
+        ts DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS memories (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        category TEXT NOT NULL CHECK(category IN ('preference', 'fact', 'project', 'person', 'routine')),
+        content TEXT NOT NULL,
+        source TEXT NOT NULL DEFAULT 'user',
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        last_accessed DATETIME DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS project_squads (
+        project_root TEXT PRIMARY KEY,
+        squad_dir TEXT NOT NULL,
+        team_dir TEXT NOT NULL,
+        personal_dir TEXT,
+        mode TEXT NOT NULL CHECK(mode IN ('local', 'remote')),
+        project_key TEXT,
+        config_source TEXT,
+        registered INTEGER NOT NULL DEFAULT 0,
+        loaded_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS squad_agents (
+        project_root TEXT NOT NULL,
+        slug TEXT NOT NULL,
+        role TEXT NOT NULL,
+        description TEXT,
+        charter_path TEXT NOT NULL,
+        model_preference TEXT,
+        tools_json TEXT,
+        capabilities_json TEXT,
+        stale INTEGER NOT NULL DEFAULT 0,
+        loaded_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        PRIMARY KEY (project_root, slug)
+      )
+    `);
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS squad_task_links (
+        task_id TEXT PRIMARY KEY,
+        project_root TEXT NOT NULL,
+        squad_agent_slug TEXT NOT NULL,
+        wiki_decision_path TEXT NOT NULL
+      )
+    `);
+        // Migrate: if the table already existed with a stricter CHECK, recreate it
+        try {
+            db.prepare(`INSERT INTO conversation_log (role, content, source) VALUES ('system', '__migration_test__', 'test')`).run();
+            db.prepare(`DELETE FROM conversation_log WHERE content = '__migration_test__'`).run();
+        }
+        catch {
+            // CHECK constraint doesn't allow 'system' — recreate table preserving data
+            db.exec(`ALTER TABLE conversation_log RENAME TO conversation_log_old`);
+            db.exec(`
+        CREATE TABLE conversation_log (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          role TEXT NOT NULL CHECK(role IN ('user', 'assistant', 'system')),
+          content TEXT NOT NULL,
+          source TEXT NOT NULL DEFAULT 'unknown',
+          ts DATETIME DEFAULT CURRENT_TIMESTAMP
+        )
+      `);
+            db.exec(`INSERT INTO conversation_log (role, content, source, ts) SELECT role, content, source, ts FROM conversation_log_old`);
+            db.exec(`DROP TABLE conversation_log_old`);
+        }
+        // New persistent session table — one row per chat session (default or project)
+        db.exec(`
+      CREATE TABLE IF NOT EXISTS copilot_sessions (
+        session_key TEXT PRIMARY KEY,
+        mode TEXT NOT NULL CHECK(mode IN ('default', 'project')),
+        project_root TEXT,
+        copilot_session_id TEXT NOT NULL,
+        model TEXT,
+        updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+        // Migrate: add session_key column to conversation_log if not present
+        const convCols = db.prepare(`PRAGMA table_info(conversation_log)`).all();
+        if (!convCols.some((c) => c.name === 'session_key')) {
+            db.exec(`ALTER TABLE conversation_log ADD COLUMN session_key TEXT NOT NULL DEFAULT 'default'`);
+        }
+        // Migrate: add session_key column to agent_tasks if not present
+        const taskCols = db.prepare(`PRAGMA table_info(agent_tasks)`).all();
+        if (!taskCols.some((c) => c.name === 'session_key')) {
+            db.exec(`ALTER TABLE agent_tasks ADD COLUMN session_key TEXT NOT NULL DEFAULT 'default'`);
+        }
+        // Prune conversation log at startup — keep more history for better recovery
+        db.prepare(`DELETE FROM conversation_log WHERE id NOT IN (SELECT id FROM conversation_log ORDER BY id DESC LIMIT 1000)`).run();
+        // Set up FTS5 for memory search (graceful fallback if not available)
+        try {
+            db.exec(`
+        CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
+          content,
+          content_rowid='id'
+        )
+      `);
+            // Sync triggers
+            db.exec(`
+        CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN
+          INSERT INTO memories_fts(rowid, content) VALUES (new.id, new.content);
+        END
+      `);
+            db.exec(`
+        CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN
+          INSERT INTO memories_fts(memories_fts, rowid, content) VALUES ('delete', old.id, old.content);
+        END
+      `);
+            db.exec(`
+        CREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN
+          INSERT INTO memories_fts(memories_fts, rowid, content) VALUES ('delete', old.id, old.content);
+          INSERT INTO memories_fts(rowid, content) VALUES (new.id, new.content);
+        END
+      `);
+            // Backfill: check if FTS is in sync by comparing row counts
+            const memCount = db.prepare(`SELECT COUNT(*) as c FROM memories`).get().c;
+            const ftsCount = db.prepare(`SELECT COUNT(*) as c FROM memories_fts`).get().c;
+            if (memCount > 0 && ftsCount < memCount) {
+                db.exec(`INSERT INTO memories_fts(memories_fts) VALUES ('rebuild')`);
+            }
+            fts5Available = true;
+        }
+        catch {
+            // FTS5 not available in this SQLite build — fall back to LIKE queries
+            fts5Available = false;
+        }
+    }
+    return db;
+}
+export function getState(key) {
+    const db = getDb();
+    const row = db.prepare(`SELECT value FROM max_state WHERE key = ?`).get(key);
+    return row?.value;
+}
+export function setState(key, value) {
+    const db = getDb();
+    db.prepare(`INSERT OR REPLACE INTO max_state (key, value) VALUES (?, ?)`).run(key, value);
+}
+/** Remove a key from persistent state. */
+export function deleteState(key) {
+    const db = getDb();
+    db.prepare(`DELETE FROM max_state WHERE key = ?`).run(key);
+}
+/** Log a conversation turn (user, assistant, or system). */
+export function logConversation(role, content, source, sessionKey = "default") {
+    const db = getDb();
+    db.prepare(`INSERT INTO conversation_log (role, content, source, session_key) VALUES (?, ?, ?, ?)`).run(role, content, source, sessionKey);
+    // Keep last 1000 entries to support context recovery after session loss
+    logInsertCount++;
+    if (logInsertCount % 50 === 0) {
+        db.prepare(`DELETE FROM conversation_log WHERE id NOT IN (SELECT id FROM conversation_log ORDER BY id DESC LIMIT 1000)`).run();
+    }
+}
+/** Retrieve a stored Copilot session by key. */
+export function getCopilotSession(sessionKey) {
+    const db = getDb();
+    const row = db
+        .prepare(`SELECT copilot_session_id, model FROM copilot_sessions WHERE session_key = ?`)
+        .get(sessionKey);
+    if (!row)
+        return undefined;
+    return { copilotSessionId: row.copilot_session_id, model: row.model ?? undefined };
+}
+/** Insert or update a Copilot session record. */
+export function upsertCopilotSession(sessionKey, mode, copilotSessionId, projectRoot, model) {
+    const db = getDb();
+    db.prepare(`INSERT INTO copilot_sessions (session_key, mode, project_root, copilot_session_id, model, updated_at)
+     VALUES (?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+     ON CONFLICT(session_key) DO UPDATE SET
+       copilot_session_id = excluded.copilot_session_id,
+       model              = excluded.model,
+       project_root       = excluded.project_root,
+       updated_at         = CURRENT_TIMESTAMP`).run(sessionKey, mode, projectRoot ?? null, copilotSessionId, model ?? null);
+}
+/**
+ * Return the session_key stored against a task, or 'default' if the column
+ * doesn't exist yet (Kaylee will add it in a follow-on phase).
+ */
+export function getTaskSessionKey(taskId) {
+    const db = getDb();
+    try {
+        const row = db
+            .prepare(`SELECT session_key FROM agent_tasks WHERE task_id = ?`)
+            .get(taskId);
+        return row?.session_key ?? "default";
+    }
+    catch {
+        return "default";
+    }
+}
+/**
+ * Get recent conversation history formatted for injection into system message.
+ *
+ * When `sessionKey` is provided, only rows belonging to that session are
+ * returned — useful for project/squad sessions that must not bleed context
+ * from other sessions. When omitted, rows from all sessions are returned
+ * (legacy behavior for callers that don't care about session isolation).
+ */
+export function getRecentConversation(limit, sessionKey) {
+    const db = getDb();
+    const effectiveLimit = limit ?? 20;
+    const rows = sessionKey
+        ? db.prepare(`SELECT role, content, source, ts FROM conversation_log WHERE session_key = ? ORDER BY id DESC LIMIT ?`).all(sessionKey, effectiveLimit)
+        : db.prepare(`SELECT role, content, source, ts FROM conversation_log ORDER BY id DESC LIMIT ?`).all(effectiveLimit);
+    if (rows.length === 0)
+        return "";
+    // Reverse so oldest is first (chronological order)
+    rows.reverse();
+    return rows.map((r) => {
+        const tag = r.role === "user" ? `[${r.source}] User`
+            : r.role === "system" ? `[${r.source}] System`
+                : "Chapterhouse";
+        // Truncate long messages to keep context manageable
+        const content = r.content.length > 1500 ? r.content.slice(0, 1500) + "…" : r.content;
+        return `${tag}: ${content}`;
+    }).join("\n\n");
+}
+// ---------------------------------------------------------------------------
+// SQLite memory functions removed — wiki is the single source of truth.
+// The memories table and FTS5 index are preserved in the schema for safety
+// (existing data is not deleted), but no code reads or writes to them.
+// ---------------------------------------------------------------------------
+export function closeDb() {
+    if (db) {
+        db.close();
+        db = undefined;
+    }
+}
+//# sourceMappingURL=db.js.map

package/dist/store/db.test.js

@@ -0,0 +1,126 @@
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import test from "node:test";
+import Database from "better-sqlite3";
+const repoRoot = process.cwd();
+const sandboxRoot = join(repoRoot, ".test-work", `store-db-${process.pid}`);
+const chapterhouseHome = join(sandboxRoot, ".chapterhouse");
+const dbPath = join(chapterhouseHome, "chapterhouse.db");
+process.env.CHAPTERHOUSE_HOME = sandboxRoot;
+async function loadDbModule() {
+    return await import(new URL(`./db.js?case=${Date.now()}-${Math.random()}`, import.meta.url).href);
+}
+function resetSandbox() {
+    mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
+    rmSync(sandboxRoot, { recursive: true, force: true });
+    mkdirSync(chapterhouseHome, { recursive: true });
+}
+test.beforeEach(() => {
+    resetSandbox();
+});
+test.after(() => {
+    rmSync(sandboxRoot, { recursive: true, force: true });
+});
+test("getDb initializes schema, state helpers, and conversation formatting", async () => {
+    const dbModule = await loadDbModule();
+    try {
+        const db = dbModule.getDb();
+        const tables = db.prepare(`SELECT name FROM sqlite_master WHERE type = 'table'`).all();
+        const tableNames = new Set(tables.map((row) => row.name));
+        for (const name of [
+            "worker_sessions",
+            "agent_sessions",
+            "agent_tasks",
+            "max_state",
+            "conversation_log",
+            "memories",
+        ]) {
+            assert.equal(tableNames.has(name), true, `expected schema table ${name}`);
+        }
+        dbModule.setState("router_config", "enabled");
+        assert.equal(dbModule.getState("router_config"), "enabled");
+        dbModule.deleteState("router_config");
+        assert.equal(dbModule.getState("router_config"), undefined);
+        const longReply = "A".repeat(1_550);
+        dbModule.logConversation("system", "Started background sync", "worker");
+        dbModule.logConversation("user", "Please summarize the last deploy", "web");
+        dbModule.logConversation("assistant", longReply, "web");
+        assert.equal(dbModule.getRecentConversation(3), [
+            "[worker] System: Started background sync",
+            "[web] User: Please summarize the last deploy",
+            `Chapterhouse: ${"A".repeat(1_500)}…`,
+        ].join("\n\n"));
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
+test("getDb migrates legacy conversation_log tables to allow system messages", async () => {
+    const seedDb = new Database(dbPath);
+    seedDb.exec(`
+    CREATE TABLE conversation_log (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      role TEXT NOT NULL CHECK(role IN ('user', 'assistant')),
+      content TEXT NOT NULL,
+      source TEXT NOT NULL DEFAULT 'unknown',
+      ts DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+  `);
+    seedDb.prepare(`INSERT INTO conversation_log (role, content, source) VALUES (?, ?, ?)`)
+        .run("user", "Legacy turn", "cli");
+    seedDb.close();
+    const dbModule = await loadDbModule();
+    try {
+        dbModule.getDb();
+        dbModule.logConversation("system", "Migrated successfully", "migration");
+        const reopened = new Database(dbPath, { readonly: true });
+        const rows = reopened.prepare(`SELECT role, content, source FROM conversation_log ORDER BY id`).all();
+        reopened.close();
+        assert.deepEqual(rows, [
+            { role: "user", content: "Legacy turn", source: "cli" },
+            { role: "system", content: "Migrated successfully", source: "migration" },
+        ]);
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
+test("getDb prunes oversized conversation logs on startup and during inserts", async () => {
+    const seedDb = new Database(dbPath);
+    seedDb.exec(`
+    CREATE TABLE conversation_log (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      role TEXT NOT NULL CHECK(role IN ('user', 'assistant', 'system')),
+      content TEXT NOT NULL,
+      source TEXT NOT NULL DEFAULT 'unknown',
+      ts DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+  `);
+    const insert = seedDb.prepare(`INSERT INTO conversation_log (role, content, source) VALUES ('user', ?, 'seed')`);
+    seedDb.transaction(() => {
+        for (let i = 0; i < 1_025; i++) {
+            insert.run(`seed-${i}`);
+        }
+    })();
+    seedDb.close();
+    const dbModule = await loadDbModule();
+    try {
+        const db = dbModule.getDb();
+        let count = db.prepare(`SELECT COUNT(*) AS count FROM conversation_log`).get().count;
+        assert.equal(count, 1_000);
+        for (let i = 0; i < 50; i++) {
+            dbModule.logConversation("assistant", `fresh-${i}`, "web");
+        }
+        count = db.prepare(`SELECT COUNT(*) AS count FROM conversation_log`).get().count;
+        const oldest = db.prepare(`SELECT content FROM conversation_log ORDER BY id ASC LIMIT 1`).get();
+        const newest = db.prepare(`SELECT content FROM conversation_log ORDER BY id DESC LIMIT 1`).get();
+        assert.equal(count, 1_000);
+        assert.equal(oldest.content, "seed-75");
+        assert.equal(newest.content, "fresh-49");
+    }
+    finally {
+        dbModule.closeDb();
+    }
+});
+//# sourceMappingURL=db.test.js.map