chapterhouse 0.7.0 → 0.8.1

package/dist/memory/eot.test.js

@@ -2,6 +2,7 @@ import assert from "node:assert/strict";
 import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import test from "node:test";
+import { resetSingletons } from "../test/helpers/reset-singletons.js";
 const repoRoot = process.cwd();
 const sandboxRoot = join(repoRoot, ".test-work", `memory-eot-${process.pid}`);
 const chapterhouseHome = join(sandboxRoot, ".chapterhouse");
@@ -18,24 +19,40 @@ async function loadModules(cacheBust = `${Date.now()}-${Math.random()}`) {
     const agentsModule = await import(new URL(`../copilot/agents.js?case=${cacheBust}`, import.meta.url).href);
     return { dbModule, memoryModule, eotModule, agentsModule };
 }
+async function loadModulesWithWarnSpy(t, cacheBust) {
+    const warnings = [];
+    t.mock.module("../util/logger.js", {
+        namedExports: {
+            childLogger: () => ({
+                info: () => { },
+                warn: (...args) => {
+                    warnings.push(args);
+                },
+                error: () => { },
+            }),
+        },
+    });
+    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
+    const memoryModule = await import(new URL(`./index.js?case=${cacheBust}`, import.meta.url).href);
+    const eotModule = await import(new URL(`./eot.js?case=${cacheBust}`, import.meta.url).href);
+    return { dbModule, memoryModule, eotModule, warnings };
+}
 function getFunction(module, name) {
     const value = module[name];
     assert.equal(typeof value, "function", `expected ${name} to be exported`);
     return value;
 }
-test.beforeEach(async () => {
+test.beforeEach(() => {
     process.env.CHAPTERHOUSE_HOME = sandboxRoot;
     delete process.env.CHAPTERHOUSE_MEMORY_EOT_HOOK_ENABLED;
     delete process.env.CHAPTERHOUSE_MEMORY_AUTO_ACCEPT;
-    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
-    dbModule.closeDb();
     resetSandbox();
+    resetSingletons();
 });
-test.after(async () => {
+test.after(() => {
     delete process.env.CHAPTERHOUSE_MEMORY_EOT_HOOK_ENABLED;
     delete process.env.CHAPTERHOUSE_MEMORY_AUTO_ACCEPT;
-    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
-    dbModule.closeDb();
+    resetSingletons();
     rmSync(sandboxRoot, { recursive: true, force: true });
 });
 test("runEndOfTaskMemoryHook does nothing when CHAPTERHOUSE_MEMORY_EOT_HOOK_ENABLED=0", async () => {
@@ -239,6 +256,98 @@ test("runEndOfTaskMemoryHook rejects invalid action_item proposals with a clear
     assert.match(inbox.resolution_reason ?? "", /title/i);
     assert.ok(inbox.resolved_at);
 });
+async function runAcceptedObservationHookScenario(t, cacheBust, taskId, payload) {
+    const warnings = [];
+    t.mock.module("../util/logger.js", {
+        namedExports: {
+            childLogger: () => ({
+                info: () => { },
+                warn: (obj, msg) => warnings.push({ obj, msg }),
+                error: () => { },
+            }),
+        },
+    });
+    const { dbModule, memoryModule, eotModule } = await loadModules(cacheBust);
+    const db = dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const listObservations = getFunction(memoryModule, "listObservations");
+    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse);
+    const before = listObservations({ scope_id: chapterhouse.id });
+    const inserted = db.prepare(`
+    INSERT INTO mem_inbox (scope_id, kind, payload, source_agent, source_task_id, status)
+    VALUES (?, 'memory_proposal', ?, 'coder', ?, 'pending')
+  `).run(chapterhouse.id, JSON.stringify({
+        kind: "observation",
+        payload,
+        confidence: 0.9,
+    }), taskId);
+    await runEndOfTaskMemoryHook({
+        taskId,
+        finalResult: "Completed and reviewed an observation proposal.",
+        copilotClient: {},
+        callLLM: async () => JSON.stringify({
+            decisions: [{
+                    proposal_id: Number(inserted.lastInsertRowid),
+                    decision: "accept",
+                    reason: "Durable finding.",
+                }],
+            implicit_memories: [],
+        }),
+    });
+    const inbox = db.prepare(`
+    SELECT status, resolution_reason
+    FROM mem_inbox
+    WHERE id = ?
+  `).get(Number(inserted.lastInsertRowid));
+    return {
+        beforeCount: before.length,
+        after: listObservations({ scope_id: chapterhouse.id }),
+        warnings,
+        inbox,
+    };
+}
+test("runEndOfTaskMemoryHook skips accepted observation proposals with null content and warns", async (t) => {
+    const result = await runAcceptedObservationHookScenario(t, "observation-null-content", "task-eot-observation-null-content", { content: null });
+    assert.equal(result.after.length, result.beforeCount);
+    assert.equal(result.after.some((row) => row.content.trim().length === 0), false);
+    assert.equal(result.inbox.status, "accepted");
+    assert.equal(result.inbox.resolution_reason, "Durable finding.");
+    assert.ok(result.warnings.some((entry) => /empty content/i.test(entry.msg)));
+});
+test("runEndOfTaskMemoryHook skips accepted observation proposals with undefined content and warns", async (t) => {
+    const result = await runAcceptedObservationHookScenario(t, "observation-undefined-content", "task-eot-observation-undefined-content", {});
+    assert.equal(result.after.length, result.beforeCount);
+    assert.equal(result.after.some((row) => row.content.trim().length === 0), false);
+    assert.equal(result.inbox.status, "accepted");
+    assert.equal(result.inbox.resolution_reason, "Durable finding.");
+    assert.ok(result.warnings.some((entry) => /empty content/i.test(entry.msg)));
+});
+test("runEndOfTaskMemoryHook skips accepted observation proposals with empty string content and warns", async (t) => {
+    const result = await runAcceptedObservationHookScenario(t, "observation-empty-string-content", "task-eot-observation-empty-string-content", { content: "" });
+    assert.equal(result.after.length, result.beforeCount);
+    assert.equal(result.after.some((row) => row.content.trim().length === 0), false);
+    assert.equal(result.inbox.status, "accepted");
+    assert.equal(result.inbox.resolution_reason, "Durable finding.");
+    assert.ok(result.warnings.some((entry) => /empty content/i.test(entry.msg)));
+});
+test("runEndOfTaskMemoryHook skips accepted observation proposals with whitespace-only content and warns", async (t) => {
+    const result = await runAcceptedObservationHookScenario(t, "observation-whitespace-content", "task-eot-observation-whitespace-content", { content: "   " });
+    assert.equal(result.after.length, result.beforeCount);
+    assert.equal(result.after.some((row) => row.content.trim().length === 0), false);
+    assert.equal(result.inbox.status, "accepted");
+    assert.equal(result.inbox.resolution_reason, "Durable finding.");
+    assert.ok(result.warnings.some((entry) => /empty content/i.test(entry.msg)));
+});
+test("runEndOfTaskMemoryHook inserts accepted observation proposals with valid content", async (t) => {
+    const result = await runAcceptedObservationHookScenario(t, "observation-valid-content", "task-eot-observation-valid-content", { content: " Durable finding from the task. " });
+    assert.equal(result.after.length, result.beforeCount + 1);
+    assert.ok(result.after.some((row) => row.content === "Durable finding from the task."));
+    assert.equal(result.inbox.status, "accepted");
+    assert.equal(result.inbox.resolution_reason, "Durable finding.");
+    assert.equal(result.warnings.length, 0);
+});
 test("runEndOfTaskMemoryHook rejects action_item proposals with ambiguous entity references", async () => {
     const { dbModule, memoryModule, eotModule } = await loadModules("action-item-ambiguous-entity");
     const db = dbModule.getDb();
@@ -549,4 +658,109 @@ test("runEndOfTaskMemoryHook accepts implicit entity memories with entity_kind",
         && entity.kind === "host"
         && entity.summary === "NAS host used by Bellonda."), true);
 });
+test("runEndOfTaskMemoryHook skips implicit observation memories with null content and warns", async (t) => {
+    const { memoryModule, eotModule, warnings } = await loadModulesWithWarnSpy(t, "implicit-null-content");
+    const getScope = getFunction(memoryModule, "getScope");
+    const listObservations = getFunction(memoryModule, "listObservations");
+    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
+    const initialCount = listObservations({ scope_id: chapterhouse.id }).length;
+    const summary = await runEndOfTaskMemoryHook({
+        taskId: "task-eot-implicit-null",
+        finalResult: "The reviewer attempted to persist an invalid implicit memory.",
+        copilotClient: {},
+        callLLM: async () => JSON.stringify({
+            decisions: [],
+            implicit_memories: [{
+                    kind: "observation",
+                    scope_slug: "chapterhouse",
+                    payload: {
+                        content: null,
+                    },
+                }],
+        }),
+    });
+    assert.equal(listObservations({ scope_id: chapterhouse.id }).length, initialCount);
+    assert.equal(summary.implicit_extracted, 0);
+    assert.equal(warnings.length, 1);
+});
+test("runEndOfTaskMemoryHook skips implicit observation memories with undefined content and warns", async (t) => {
+    const { memoryModule, eotModule, warnings } = await loadModulesWithWarnSpy(t, "implicit-undefined-content");
+    const getScope = getFunction(memoryModule, "getScope");
+    const listObservations = getFunction(memoryModule, "listObservations");
+    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
+    const initialCount = listObservations({ scope_id: chapterhouse.id }).length;
+    const summary = await runEndOfTaskMemoryHook({
+        taskId: "task-eot-implicit-undefined",
+        finalResult: "The reviewer attempted to persist an invalid implicit memory.",
+        copilotClient: {},
+        callLLM: async () => JSON.stringify({
+            decisions: [],
+            implicit_memories: [{
+                    kind: "observation",
+                    scope_slug: "chapterhouse",
+                    payload: {},
+                }],
+        }),
+    });
+    assert.equal(listObservations({ scope_id: chapterhouse.id }).length, initialCount);
+    assert.equal(summary.implicit_extracted, 0);
+    assert.equal(warnings.length, 1);
+});
+test("runEndOfTaskMemoryHook skips implicit observation memories with empty content and warns", async (t) => {
+    const { memoryModule, eotModule, warnings } = await loadModulesWithWarnSpy(t, "implicit-empty-content");
+    const getScope = getFunction(memoryModule, "getScope");
+    const listObservations = getFunction(memoryModule, "listObservations");
+    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
+    const initialCount = listObservations({ scope_id: chapterhouse.id }).length;
+    const summary = await runEndOfTaskMemoryHook({
+        taskId: "task-eot-implicit-empty",
+        finalResult: "The reviewer attempted to persist an invalid implicit memory.",
+        copilotClient: {},
+        callLLM: async () => JSON.stringify({
+            decisions: [],
+            implicit_memories: [{
+                    kind: "observation",
+                    scope_slug: "chapterhouse",
+                    payload: {
+                        content: "   ",
+                    },
+                }],
+        }),
+    });
+    assert.equal(listObservations({ scope_id: chapterhouse.id }).length, initialCount);
+    assert.equal(summary.implicit_extracted, 0);
+    assert.equal(warnings.length, 1);
+});
+test("runEndOfTaskMemoryHook persists implicit observation memories with valid content", async (t) => {
+    const { memoryModule, eotModule, warnings } = await loadModulesWithWarnSpy(t, "implicit-valid-content");
+    const getScope = getFunction(memoryModule, "getScope");
+    const listObservations = getFunction(memoryModule, "listObservations");
+    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
+    const summary = await runEndOfTaskMemoryHook({
+        taskId: "task-eot-implicit-valid",
+        finalResult: "The reviewer discovered a valid durable memory.",
+        copilotClient: {},
+        callLLM: async () => JSON.stringify({
+            decisions: [],
+            implicit_memories: [{
+                    kind: "observation",
+                    scope_slug: "chapterhouse",
+                    payload: {
+                        content: "A valid implicit memory should still be stored.",
+                    },
+                }],
+        }),
+    });
+    assert.equal(listObservations({ scope_id: chapterhouse.id }).some((row) => row.content === "A valid implicit memory should still be stored."), true);
+    assert.equal(summary.implicit_extracted, 1);
+    assert.equal(warnings.length, 0);
+});
 //# sourceMappingURL=eot.test.js.map

package/dist/memory/hooks.js

@@ -0,0 +1,151 @@
+import { childLogger } from "../util/logger.js";
+import { getActiveScope } from "./active-scope.js";
+import { recordObservation } from "./observations.js";
+import { getScope } from "./scopes.js";
+const log = childLogger("memory.hooks");
+// ---------------------------------------------------------------------------
+// Env knob
+// ---------------------------------------------------------------------------
+function isHooksEnabled() {
+    const raw = process.env.CHAPTERHOUSE_MEMORY_HOOKS_ENABLED?.trim();
+    if (raw === "false" || raw === "0")
+        return false;
+    return true;
+}
+// ---------------------------------------------------------------------------
+// Dispatcher
+// ---------------------------------------------------------------------------
+export class MemoryHookDispatcher {
+    handlers = new Map();
+    register(event, handler) {
+        const bucket = this.handlers.get(event) ?? [];
+        bucket.push(handler);
+        this.handlers.set(event, bucket);
+    }
+    async dispatch(event, payload) {
+        if (!isHooksEnabled()) {
+            log.debug({ event }, "memory.hooks.skip.disabled");
+            return;
+        }
+        const bucket = this.handlers.get(event) ?? [];
+        if (bucket.length === 0) {
+            log.debug({ event }, "memory.hooks.no_handlers");
+            return;
+        }
+        log.info({ event, handlerCount: bucket.length }, "memory.hooks.dispatch");
+        for (const handler of bucket) {
+            try {
+                await handler(payload);
+            }
+            catch (err) {
+                log.error({ err, event }, "memory.hooks.handler_error");
+            }
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Singleton dispatcher — shared across the process
+// ---------------------------------------------------------------------------
+export const hookDispatcher = new MemoryHookDispatcher();
+// ---------------------------------------------------------------------------
+// Built-in handler: git:commit → observation in active scope
+// ---------------------------------------------------------------------------
+function buildGitCommitContent(payload) {
+    const lines = [`Git commit: ${payload.message}`];
+    if (payload.stat?.trim()) {
+        lines.push("", "Changed files:", payload.stat.trim());
+    }
+    return lines.join("\n");
+}
+function resolveGlobalOrActiveScope() {
+    const active = getActiveScope();
+    if (active)
+        return active;
+    return getScope("global") ?? null;
+}
+export async function handleGitCommitHook(payload) {
+    if (!isHooksEnabled()) {
+        log.debug("memory.hooks.git_commit.disabled");
+        return { observation_id: "disabled" };
+    }
+    const scope = resolveGlobalOrActiveScope();
+    if (!scope) {
+        throw new Error("No active or global memory scope found. Create a scope before using memory hooks.");
+    }
+    const content = buildGitCommitContent(payload);
+    const observation = recordObservation({
+        scope_id: scope.id,
+        content,
+        source: "git:commit",
+        tier: "warm",
+        confidence: 1.0,
+    });
+    log.info({ scope: scope.slug, observation_id: observation.id }, "memory.hooks.git_commit.recorded");
+    return { observation_id: String(observation.id) };
+}
+// ---------------------------------------------------------------------------
+// Built-in handler: pr:merge → observation
+// ---------------------------------------------------------------------------
+function buildPrMergeContent(payload) {
+    const lines = [`PR #${payload.number} merged: ${payload.title}`];
+    if (payload.body?.trim()) {
+        lines.push("", payload.body.trim());
+    }
+    if (payload.files_changed && payload.files_changed.length > 0) {
+        lines.push("", "Files changed:");
+        for (const file of payload.files_changed) {
+            lines.push(`  ${file}`);
+        }
+    }
+    return lines.join("\n");
+}
+export async function handlePrMergeHook(payload) {
+    if (!isHooksEnabled()) {
+        log.debug("memory.hooks.pr_merge.disabled");
+        return { observation_id: "disabled" };
+    }
+    const scope = resolveGlobalOrActiveScope();
+    if (!scope) {
+        throw new Error("No active or global memory scope found. Create a scope before using memory hooks.");
+    }
+    const content = buildPrMergeContent(payload);
+    const observation = recordObservation({
+        scope_id: scope.id,
+        content,
+        source: "pr:merge",
+        tier: "warm",
+        confidence: 1.0,
+    });
+    log.info({ scope: scope.slug, observation_id: observation.id, pr: payload.number }, "memory.hooks.pr_merge.recorded");
+    return { observation_id: String(observation.id) };
+}
+// ---------------------------------------------------------------------------
+// Built-in handler: scope:created → observation in global scope
+// ---------------------------------------------------------------------------
+hookDispatcher.register("scope:created", async (payload) => {
+    const globalScope = getScope("global");
+    if (!globalScope) {
+        log.debug("memory.hooks.scope_created.no_global_scope");
+        return;
+    }
+    const content = `Scope '${payload.slug}' created: ${payload.description || payload.title}`;
+    const observation = recordObservation({
+        scope_id: globalScope.id,
+        content,
+        source: "scope:created",
+        tier: "warm",
+        confidence: 1.0,
+    });
+    log.info({ scope: payload.slug, observation_id: observation.id }, "memory.hooks.scope_created.recorded");
+});
+// ---------------------------------------------------------------------------
+// Built-in handler: memory:decision → structured log event
+// ---------------------------------------------------------------------------
+hookDispatcher.register("memory:decision", async (payload) => {
+    log.info({
+        decision_id: payload.id,
+        scope_id: payload.scope_id,
+        title: payload.title,
+    }, "memory.hooks.decision.recorded");
+});
+//# sourceMappingURL=hooks.js.map