chapterhouse 0.3.26 → 0.4.1

package/dist/memory/decisions.test.js

@@ -0,0 +1,92 @@
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import test from "node:test";
+const repoRoot = process.cwd();
+const sandboxRoot = join(repoRoot, ".test-work", `memory-decisions-${process.pid}`);
+const chapterhouseHome = join(sandboxRoot, ".chapterhouse");
+process.env.CHAPTERHOUSE_HOME = sandboxRoot;
+function resetSandbox() {
+    mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
+    rmSync(sandboxRoot, { recursive: true, force: true });
+    mkdirSync(chapterhouseHome, { recursive: true });
+}
+async function loadModules() {
+    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
+    const memoryModule = await import(new URL("./index.js", import.meta.url).href);
+    return { dbModule, memoryModule };
+}
+function getFunction(module, name) {
+    const value = module[name];
+    assert.equal(typeof value, "function", `expected ${name} to be exported`);
+    return value;
+}
+test.beforeEach(async () => {
+    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
+    dbModule.closeDb();
+    resetSandbox();
+});
+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("recordDecision supports CRUD, supersession, and keeps the decision FTS index in sync", async () => {
+    const { dbModule, memoryModule } = await loadModules();
+    const db = dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const recordDecision = getFunction(memoryModule, "recordDecision");
+    const getDecision = getFunction(memoryModule, "getDecision");
+    const listDecisions = getFunction(memoryModule, "listDecisions");
+    const supersedeDecision = getFunction(memoryModule, "supersedeDecision");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
+    const original = recordDecision({
+        scope_id: chapterhouse.id,
+        title: "Use SQLite for scoped memory",
+        rationale: "SQLite FTS5 keeps memory recall local, fast, and dependency-free.",
+        decided_at: "2026-05-13",
+    });
+    const replacement = recordDecision({
+        scope_id: chapterhouse.id,
+        title: "Keep SQLite for agent memory v1",
+        rationale: "SQLite remains the only persistence layer for PR 2.",
+        decided_at: "2026-05-14",
+    });
+    assert.equal(listDecisions({ scope_id: chapterhouse.id }).length >= 2, true);
+    assert.deepEqual(getDecision(original.id)?.title, original.title);
+    const initialHits = db.prepare(`
+    SELECT rowid
+    FROM mem_decisions_fts
+    WHERE mem_decisions_fts MATCH 'dependency'
+  `).all();
+    assert.deepEqual(initialHits, [{ rowid: original.id }]);
+    db.prepare(`
+    UPDATE mem_decisions
+    SET rationale = ?
+    WHERE id = ?
+  `).run("FTS snippets should refresh when the rationale changes.", original.id);
+    const oldHits = db.prepare(`
+    SELECT rowid
+    FROM mem_decisions_fts
+    WHERE mem_decisions_fts MATCH 'dependency'
+  `).all();
+    const newHits = db.prepare(`
+    SELECT rowid
+    FROM mem_decisions_fts
+    WHERE mem_decisions_fts MATCH 'snippets'
+  `).all();
+    assert.deepEqual(oldHits, []);
+    assert.deepEqual(newHits, [{ rowid: original.id }]);
+    const superseded = supersedeDecision(original.id, replacement.id);
+    assert.equal(superseded.supersededBy, replacement.id);
+    assert.equal(getDecision(original.id)?.supersededBy, replacement.id);
+    db.prepare(`DELETE FROM mem_decisions WHERE id = ?`).run(original.id);
+    const deletedHits = db.prepare(`
+    SELECT rowid
+    FROM mem_decisions_fts
+    WHERE mem_decisions_fts MATCH 'snippets'
+  `).all();
+    assert.deepEqual(deletedHits, []);
+});
+//# sourceMappingURL=decisions.test.js.map

package/dist/memory/entities.js

@@ -0,0 +1,59 @@
+import { getDb } from "../store/db.js";
+function toEntity(row) {
+    return {
+        id: row.id,
+        scopeId: row.scope_id,
+        kind: row.kind,
+        name: row.name,
+        summary: row.summary ?? undefined,
+        tier: row.tier,
+        confidence: row.confidence,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+export function getEntity(id) {
+    const row = getDb().prepare(`
+    SELECT id, scope_id, kind, name, summary, tier, confidence, created_at, updated_at
+    FROM mem_entities
+    WHERE id = ?
+  `).get(id);
+    return row ? toEntity(row) : undefined;
+}
+export function findEntityByName(scopeId, kind, name) {
+    const row = getDb().prepare(`
+    SELECT id, scope_id, kind, name, summary, tier, confidence, created_at, updated_at
+    FROM mem_entities
+    WHERE scope_id = ? AND kind = ? AND name = ?
+  `).get(scopeId, kind, name);
+    return row ? toEntity(row) : undefined;
+}
+export function upsertEntity(input) {
+    const db = getDb();
+    const existing = findEntityByName(input.scope_id, input.kind, input.name);
+    if (existing) {
+        db.prepare(`
+      UPDATE mem_entities
+      SET summary = ?, tier = ?, confidence = ?, updated_at = CURRENT_TIMESTAMP
+      WHERE id = ?
+    `).run(input.summary ?? existing.summary ?? null, input.tier ?? existing.tier, input.confidence ?? existing.confidence, existing.id);
+        return getEntity(existing.id);
+    }
+    const result = db.prepare(`
+    INSERT INTO mem_entities (scope_id, kind, name, summary, tier, confidence, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+  `).run(input.scope_id, input.kind, input.name, input.summary ?? null, input.tier ?? "warm", input.confidence ?? 1.0);
+    return getEntity(Number(result.lastInsertRowid));
+}
+export function listEntities(input = {}) {
+    const rows = getDb().prepare(`
+    SELECT id, scope_id, kind, name, summary, tier, confidence, created_at, updated_at
+    FROM mem_entities
+    WHERE (? IS NULL OR scope_id = ?)
+      AND (? IS NULL OR kind = ?)
+    ORDER BY updated_at DESC, id DESC
+    LIMIT ? OFFSET ?
+  `).all(input.scope_id ?? null, input.scope_id ?? null, input.kind ?? null, input.kind ?? null, input.limit ?? 50, input.offset ?? 0);
+    return rows.map(toEntity);
+}
+//# sourceMappingURL=entities.js.map

package/dist/memory/entities.test.js

@@ -0,0 +1,65 @@
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import test from "node:test";
+const repoRoot = process.cwd();
+const sandboxRoot = join(repoRoot, ".test-work", `memory-entities-${process.pid}`);
+const chapterhouseHome = join(sandboxRoot, ".chapterhouse");
+process.env.CHAPTERHOUSE_HOME = sandboxRoot;
+function resetSandbox() {
+    mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
+    rmSync(sandboxRoot, { recursive: true, force: true });
+    mkdirSync(chapterhouseHome, { recursive: true });
+}
+async function loadModules() {
+    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
+    const memoryModule = await import(new URL("./index.js", import.meta.url).href);
+    return { dbModule, memoryModule };
+}
+function getFunction(module, name) {
+    const value = module[name];
+    assert.equal(typeof value, "function", `expected ${name} to be exported`);
+    return value;
+}
+test.beforeEach(async () => {
+    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
+    dbModule.closeDb();
+    resetSandbox();
+});
+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("upsertEntity is idempotent on scope, kind, and name", async () => {
+    const { dbModule, memoryModule } = await loadModules();
+    dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const upsertEntity = getFunction(memoryModule, "upsertEntity");
+    const getEntity = getFunction(memoryModule, "getEntity");
+    const findEntityByName = getFunction(memoryModule, "findEntityByName");
+    const listEntities = getFunction(memoryModule, "listEntities");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
+    const first = upsertEntity({
+        scope_id: chapterhouse.id,
+        kind: "tool",
+        name: "better-sqlite3",
+        summary: "SQLite driver used for memory persistence.",
+        tier: "warm",
+        confidence: 0.7,
+    });
+    const second = upsertEntity({
+        scope_id: chapterhouse.id,
+        kind: "tool",
+        name: "better-sqlite3",
+        summary: "Sync SQLite driver used throughout the daemon.",
+        tier: "hot",
+        confidence: 0.95,
+    });
+    assert.equal(second.id, first.id);
+    assert.equal(listEntities({ scope_id: chapterhouse.id, kind: "tool" }).length, 1);
+    assert.equal(findEntityByName(chapterhouse.id, "tool", "better-sqlite3")?.id, first.id);
+    assert.deepEqual(getEntity(first.id), second);
+});
+//# sourceMappingURL=entities.test.js.map

package/dist/memory/eot.js

@@ -0,0 +1,219 @@
+import { config } from "../config.js";
+import { runOneShotPrompt } from "../copilot/oneshot.js";
+import { childLogger } from "../util/logger.js";
+import { recordDecision } from "./decisions.js";
+import { upsertEntity } from "./entities.js";
+import { listPendingMemoryProposalsForTask, resolveInboxItem } from "./inbox.js";
+import { recordObservation } from "./observations.js";
+import { getScope } from "./scopes.js";
+const log = childLogger("memory.eot");
+function isEndOfTaskHookEnabled() {
+    const raw = process.env.CHAPTERHOUSE_MEMORY_EOT_HOOK_ENABLED?.trim();
+    if (raw === "0")
+        return false;
+    if (raw === "1")
+        return true;
+    return true;
+}
+function isMemoryAutoAcceptEnabled() {
+    const raw = process.env.CHAPTERHOUSE_MEMORY_AUTO_ACCEPT?.trim();
+    if (raw === "0")
+        return false;
+    if (raw === "1")
+        return true;
+    return true;
+}
+function buildReviewerSystemPrompt() {
+    return [
+        "You review subagent memory proposals at end-of-task.",
+        "Decide accept or reject for each proposal id.",
+        "Optionally extract additional implicit durable memories from the task summary.",
+        "Return JSON only with keys: decisions, implicit_memories.",
+        "Each decision must include proposal_id, decision, reason.",
+        "Each implicit memory must include kind, scope_slug, payload, and may include confidence/reason.",
+    ].join("\n");
+}
+function buildReviewerUserPrompt(finalResult, proposals) {
+    return JSON.stringify({
+        final_result: finalResult,
+        proposals: proposals.map((proposal) => ({
+            id: proposal.id,
+            source_agent: proposal.sourceAgent,
+            payload: proposal.payload,
+        })),
+    }, null, 2);
+}
+function parseEnvelope(raw) {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") {
+        throw new Error("Invalid memory proposal payload.");
+    }
+    if (parsed.kind !== "observation" && parsed.kind !== "decision" && parsed.kind !== "entity") {
+        throw new Error("Invalid proposal kind.");
+    }
+    if (!parsed.payload || typeof parsed.payload !== "object") {
+        throw new Error("Invalid proposal payload.");
+    }
+    return {
+        kind: parsed.kind,
+        scope_slug: typeof parsed.scope_slug === "string" ? parsed.scope_slug : undefined,
+        confidence: typeof parsed.confidence === "number" ? parsed.confidence : 0.5,
+        reason: typeof parsed.reason === "string" ? parsed.reason : undefined,
+        payload: parsed.payload,
+    };
+}
+function parseReviewerResponse(raw) {
+    const parsed = JSON.parse(raw);
+    return {
+        decisions: Array.isArray(parsed.decisions)
+            ? parsed.decisions.flatMap((entry) => {
+                if (!entry || typeof entry !== "object") {
+                    return [];
+                }
+                const candidate = entry;
+                if (typeof candidate.proposal_id !== "number") {
+                    return [];
+                }
+                if (candidate.decision !== "accept" && candidate.decision !== "reject") {
+                    return [];
+                }
+                if (typeof candidate.reason !== "string" || candidate.reason.trim().length === 0) {
+                    return [];
+                }
+                return [{
+                        proposal_id: candidate.proposal_id,
+                        decision: candidate.decision,
+                        reason: candidate.reason.trim(),
+                    }];
+            })
+            : [],
+        implicit_memories: Array.isArray(parsed.implicit_memories)
+            ? parsed.implicit_memories.flatMap((entry) => {
+                if (!entry || typeof entry !== "object") {
+                    return [];
+                }
+                const candidate = entry;
+                if (candidate.kind !== "observation" && candidate.kind !== "decision" && candidate.kind !== "entity") {
+                    return [];
+                }
+                if (typeof candidate.scope_slug !== "string" || !candidate.payload || typeof candidate.payload !== "object") {
+                    return [];
+                }
+                return [{
+                        kind: candidate.kind,
+                        scope_slug: candidate.scope_slug,
+                        payload: candidate.payload,
+                        confidence: typeof candidate.confidence === "number" ? candidate.confidence : undefined,
+                        reason: typeof candidate.reason === "string" ? candidate.reason : undefined,
+                    }];
+            })
+            : [],
+    };
+}
+function rememberAcceptedMemory(kind, scopeSlug, payload, source, confidence) {
+    const scope = getScope(scopeSlug);
+    if (!scope) {
+        throw new Error(`Unknown memory scope '${scopeSlug}'.`);
+    }
+    if (kind === "observation") {
+        const observation = payload;
+        recordObservation({
+            scope_id: scope.id,
+            entity_id: observation.entity_id,
+            content: observation.content,
+            source: observation.source ?? source,
+            confidence,
+        });
+        return;
+    }
+    if (kind === "decision") {
+        const decision = payload;
+        recordDecision({
+            scope_id: scope.id,
+            title: decision.title,
+            rationale: decision.rationale ?? decision.title,
+            decided_at: decision.decided_at,
+        });
+        return;
+    }
+    const entity = payload;
+    upsertEntity({
+        scope_id: scope.id,
+        kind: entity.kind,
+        name: entity.name,
+        summary: entity.summary,
+        confidence,
+    });
+}
+export async function runEndOfTaskMemoryHook(input) {
+    const autoAcceptEnabled = isMemoryAutoAcceptEnabled();
+    const summary = {
+        task_id: input.taskId,
+        proposals_total: 0,
+        accepted: 0,
+        rejected: 0,
+        implicit_extracted: 0,
+        auto_accept: autoAcceptEnabled,
+    };
+    if (!isEndOfTaskHookEnabled()) {
+        return summary;
+    }
+    const proposals = listPendingMemoryProposalsForTask(input.taskId);
+    summary.proposals_total = proposals.length;
+    const callLLM = input.callLLM ?? (async ({ system, user, model }) => {
+        const result = await runOneShotPrompt({
+            client: input.copilotClient,
+            model,
+            system,
+            user,
+            expectJson: true,
+        });
+        return result.content;
+    });
+    const review = parseReviewerResponse(await callLLM({
+        system: buildReviewerSystemPrompt(),
+        user: buildReviewerUserPrompt(input.finalResult, proposals),
+        model: input.model ?? config.copilotModel,
+    }));
+    const proposalsById = new Map(proposals.map((proposal) => [proposal.id, proposal]));
+    const reviewedProposalIds = new Set();
+    for (const decision of review.decisions) {
+        const proposal = proposalsById.get(decision.proposal_id);
+        if (!proposal) {
+            continue;
+        }
+        reviewedProposalIds.add(proposal.id);
+        if (decision.decision === "accept") {
+            summary.accepted++;
+            if (autoAcceptEnabled) {
+                const envelope = parseEnvelope(proposal.payload);
+                rememberAcceptedMemory(envelope.kind, envelope.scope_slug ?? getScope(proposal.scopeId).slug, envelope.payload, `agent:${proposal.sourceAgent}`, envelope.confidence);
+                resolveInboxItem(proposal.id, "accepted", decision.reason);
+            }
+            continue;
+        }
+        summary.rejected++;
+        if (autoAcceptEnabled) {
+            resolveInboxItem(proposal.id, "rejected", decision.reason);
+        }
+    }
+    for (const proposal of proposals) {
+        if (reviewedProposalIds.has(proposal.id)) {
+            continue;
+        }
+        summary.rejected++;
+        if (autoAcceptEnabled) {
+            resolveInboxItem(proposal.id, "rejected", "Reviewer did not select this proposal for acceptance.");
+        }
+    }
+    if (autoAcceptEnabled) {
+        for (const implicitMemory of review.implicit_memories) {
+            rememberAcceptedMemory(implicitMemory.kind, implicitMemory.scope_slug, implicitMemory.payload, "agent:eot", implicitMemory.confidence);
+            summary.implicit_extracted++;
+        }
+    }
+    log.info(summary, "memory.eot.processed");
+    input.onProcessed?.(summary);
+    return summary;
+}
+//# sourceMappingURL=eot.js.map