chapterhouse 0.13.1 → 0.14.0

package/dist/memory/housekeeping.test.js

@@ -1,410 +0,0 @@
-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-housekeeping-${process.pid}`);
-const chapterhouseHome = join(sandboxRoot, ".chapterhouse");
-process.env.CHAPTERHOUSE_HOME = sandboxRoot;
-process.env.CHAPTERHOUSE_MEMORY_DECAY_DAYS = "30";
-process.env.CHAPTERHOUSE_MEMORY_INBOX_RETENTION_DAYS = "7";
-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);
-    const housekeepingModule = await import(new URL(`./housekeeping.js?case=${Date.now()}-${Math.random()}`, import.meta.url).href);
-    return { dbModule, memoryModule, housekeepingModule };
-}
-async function loadMockedHousekeepingModule(t, options = {}) {
-    t.mock.module("../config.js", {
-        namedExports: {
-            config: {
-                memoryDecayDays: 30,
-                memoryInboxRetentionDays: 7,
-                memoryHousekeepingSimilarityThreshold: 0.8,
-            },
-        },
-    });
-    t.mock.module("../store/db.js", {
-        namedExports: {
-            getDb: () => {
-                throw new Error("getDb should not be called in this test");
-            },
-        },
-    });
-    t.mock.module("../util/logger.js", {
-        namedExports: {
-            childLogger: () => ({
-                info: () => { },
-                warn: () => { },
-                error: () => { },
-            }),
-        },
-    });
-    t.mock.module("./active-scope.js", {
-        namedExports: {
-            getActiveScope: () => (options.activeScopeId === undefined ? null : { id: options.activeScopeId }),
-        },
-    });
-    t.mock.module("./scopes.js", {
-        namedExports: {
-            listScopes: () => options.scopes ?? [],
-        },
-    });
-    t.mock.module("./tiering.js", {
-        namedExports: {
-            tieringPass: (scopeId) => options.tieringPass?.(scopeId) ?? { pass: "tieringPass", examined: scopeId, modified: 1, errors: [] },
-        },
-    });
-    return await import(new URL(`./housekeeping.js?case=${Date.now()}-${Math.random()}`, import.meta.url).href);
-}
-function getFunction(module, name) {
-    const value = module[name];
-    assert.equal(typeof value, "function", `expected ${name} to be exported`);
-    return value;
-}
-function createTestScope(memoryModule, slug) {
-    const createScope = getFunction(memoryModule, "createScope");
-    return createScope({
-        slug,
-        title: slug.split("-").map((part) => part[0]?.toUpperCase() + part.slice(1)).join(" "),
-        description: `${slug} test scope`,
-        keywords: [slug],
-    });
-}
-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 });
-    delete process.env.CHAPTERHOUSE_MEMORY_DECAY_DAYS;
-    delete process.env.CHAPTERHOUSE_MEMORY_INBOX_RETENTION_DAYS;
-});
-test("dedupObservationsPass supersedes similar observations in scope deterministically and is idempotent", async () => {
-    const { dbModule, memoryModule, housekeepingModule } = await loadModules();
-    const db = dbModule.getDb();
-    const getScope = getFunction(memoryModule, "getScope");
-    const recordObservation = getFunction(memoryModule, "recordObservation");
-    const chapterhouse = getScope("chapterhouse");
-    const team = createTestScope(memoryModule, "team");
-    assert.ok(chapterhouse);
-    const first = recordObservation({
-        scope_id: team.id,
-        content: "The worker event stream uses server sent events for live task output.",
-        source: "test",
-        confidence: 0.4,
-    });
-    const keeper = recordObservation({
-        scope_id: team.id,
-        content: "Worker event streams use server sent events for live task output.",
-        source: "test",
-        confidence: 0.9,
-    });
-    const third = recordObservation({
-        scope_id: team.id,
-        content: "The worker event stream uses server sent events for live task output today.",
-        source: "test",
-        confidence: 0.9,
-    });
-    const otherScope = recordObservation({
-        scope_id: chapterhouse.id,
-        content: "Worker event streams use server sent events for live task output.",
-        source: "test",
-        confidence: 0.1,
-    });
-    const summary = housekeepingModule.dedupObservationsPass(team.id);
-    assert.equal(summary.pass, "dedupObservationsPass");
-    assert.equal(summary.examined, 3);
-    assert.equal(summary.modified, 2);
-    assert.deepEqual(summary.errors, []);
-    assert.deepEqual(db.prepare(`SELECT id, superseded_by FROM mem_observations WHERE id IN (?, ?, ?) ORDER BY id`).all(first.id, keeper.id, third.id), [
-        { id: first.id, superseded_by: keeper.id },
-        { id: keeper.id, superseded_by: null },
-        { id: third.id, superseded_by: keeper.id },
-    ]);
-    assert.equal(db.prepare(`SELECT superseded_by FROM mem_observations WHERE id = ?`).get(otherScope.id).superseded_by, null);
-    const second = housekeepingModule.dedupObservationsPass(team.id);
-    assert.equal(second.modified, 0);
-});
-test("dedupDecisionsPass supersedes similar active decisions within scope and keeps the latest decision", async () => {
-    const { dbModule, memoryModule, housekeepingModule } = await loadModules();
-    const db = dbModule.getDb();
-    const upsertEntity = getFunction(memoryModule, "upsertEntity");
-    const recordDecision = getFunction(memoryModule, "recordDecision");
-    const team = createTestScope(memoryModule, "team");
-    const infra = createTestScope(memoryModule, "infra");
-    const api = upsertEntity({ scope_id: team.id, kind: "component", name: "api" });
-    const web = upsertEntity({ scope_id: team.id, kind: "component", name: "web" });
-    const oldDecision = recordDecision({
-        scope_id: team.id,
-        entity_id: api.id,
-        title: "Use SQLite FTS5 for memory recall",
-        rationale: "Initial choice.",
-        decided_at: "2026-05-11",
-    });
-    const keeper = recordDecision({
-        scope_id: team.id,
-        entity_id: api.id,
-        title: "Use SQLite FTS5 for scoped memory recall",
-        rationale: "Latest choice.",
-        decided_at: "2026-05-13",
-    });
-    const otherEntity = recordDecision({
-        scope_id: team.id,
-        entity_id: web.id,
-        title: "Use SQLite FTS5 for memory recall",
-        rationale: "Same title, different entity context, but newer scope-level decision.",
-        decided_at: "2026-05-14",
-    });
-    const otherScope = recordDecision({
-        scope_id: infra.id,
-        title: "Use SQLite FTS5 for memory recall",
-        rationale: "Same title, different scope.",
-        decided_at: "2026-05-14",
-    });
-    const summary = housekeepingModule.dedupDecisionsPass(team.id);
-    assert.equal(summary.pass, "dedupDecisionsPass");
-    assert.equal(summary.examined, 3);
-    assert.equal(summary.modified, 2);
-    assert.deepEqual(summary.errors, []);
-    assert.equal(db.prepare(`SELECT superseded_by FROM mem_decisions WHERE id = ?`).get(oldDecision.id).superseded_by, otherEntity.id);
-    assert.equal(db.prepare(`SELECT superseded_by FROM mem_decisions WHERE id = ?`).get(keeper.id).superseded_by, otherEntity.id);
-    assert.equal(db.prepare(`SELECT superseded_by FROM mem_decisions WHERE id = ?`).get(otherEntity.id).superseded_by, null);
-    assert.equal(db.prepare(`SELECT superseded_by FROM mem_decisions WHERE id = ?`).get(otherScope.id).superseded_by, null);
-    const second = housekeepingModule.dedupDecisionsPass(team.id);
-    assert.equal(second.modified, 0);
-});
-test("compactSupersedeChainsPass collapses long supersede chains without looping on cycles", async () => {
-    const { dbModule, memoryModule, housekeepingModule } = await loadModules();
-    const db = dbModule.getDb();
-    const recordObservation = getFunction(memoryModule, "recordObservation");
-    const recordDecision = getFunction(memoryModule, "recordDecision");
-    const team = createTestScope(memoryModule, "team");
-    const firstObservation = recordObservation({ scope_id: team.id, content: "First observation", source: "test" });
-    const middleObservation = recordObservation({ scope_id: team.id, content: "Middle observation", source: "test" });
-    const keeperObservation = recordObservation({ scope_id: team.id, content: "Keeper observation", source: "test" });
-    const cycleLeft = recordObservation({ scope_id: team.id, content: "Cycle left", source: "test" });
-    const cycleRight = recordObservation({ scope_id: team.id, content: "Cycle right", source: "test" });
-    db.prepare(`UPDATE mem_observations SET superseded_by = ? WHERE id = ?`).run(middleObservation.id, firstObservation.id);
-    db.prepare(`UPDATE mem_observations SET superseded_by = ? WHERE id = ?`).run(keeperObservation.id, middleObservation.id);
-    db.prepare(`UPDATE mem_observations SET superseded_by = ? WHERE id = ?`).run(cycleRight.id, cycleLeft.id);
-    db.prepare(`UPDATE mem_observations SET superseded_by = ? WHERE id = ?`).run(cycleLeft.id, cycleRight.id);
-    const firstDecision = recordDecision({ scope_id: team.id, title: "Use local memory", rationale: "Initial.", decided_at: "2026-05-10" });
-    const middleDecision = recordDecision({ scope_id: team.id, title: "Use scoped memory", rationale: "Refined.", decided_at: "2026-05-11" });
-    const keeperDecision = recordDecision({ scope_id: team.id, title: "Use tiered scoped memory", rationale: "Final.", decided_at: "2026-05-12" });
-    db.prepare(`UPDATE mem_decisions SET superseded_by = ? WHERE id = ?`).run(middleDecision.id, firstDecision.id);
-    db.prepare(`UPDATE mem_decisions SET superseded_by = ? WHERE id = ?`).run(keeperDecision.id, middleDecision.id);
-    const summary = housekeepingModule.compactSupersedeChainsPass(team.id);
-    assert.equal(summary.pass, "compactSupersedeChainsPass");
-    assert.equal(summary.modified, 2);
-    assert.deepEqual(summary.errors, []);
-    assert.equal(db.prepare(`SELECT superseded_by FROM mem_observations WHERE id = ?`).get(firstObservation.id).superseded_by, keeperObservation.id);
-    assert.equal(db.prepare(`SELECT superseded_by FROM mem_decisions WHERE id = ?`).get(firstDecision.id).superseded_by, keeperDecision.id);
-    assert.deepEqual(db.prepare(`SELECT id, superseded_by FROM mem_observations WHERE id IN (?, ?) ORDER BY id`).all(cycleLeft.id, cycleRight.id), [
-        { id: cycleLeft.id, superseded_by: cycleRight.id },
-        { id: cycleRight.id, superseded_by: cycleLeft.id },
-    ]);
-    assert.equal(housekeepingModule.compactSupersedeChainsPass(team.id).modified, 0);
-});
-test("orphanCleanupPass clears missing observation entity references without touching valid or out-of-scope rows", async () => {
-    const { dbModule, memoryModule, housekeepingModule } = await loadModules();
-    const db = dbModule.getDb();
-    const getScope = getFunction(memoryModule, "getScope");
-    const upsertEntity = getFunction(memoryModule, "upsertEntity");
-    const recordObservation = getFunction(memoryModule, "recordObservation");
-    const chapterhouse = getScope("chapterhouse");
-    const team = createTestScope(memoryModule, "team");
-    assert.ok(chapterhouse);
-    const entity = upsertEntity({ scope_id: chapterhouse.id, kind: "tool", name: "sqlite" });
-    const valid = recordObservation({ scope_id: chapterhouse.id, entity_id: entity.id, content: "Valid entity reference", source: "test" });
-    const orphan = recordObservation({ scope_id: chapterhouse.id, content: "Will become orphaned", source: "test" });
-    const otherScope = recordObservation({ scope_id: team.id, content: "Other scope orphan", source: "test" });
-    db.pragma("foreign_keys = OFF");
-    db.prepare(`UPDATE mem_observations SET entity_id = 987654 WHERE id IN (?, ?)`).run(orphan.id, otherScope.id);
-    db.pragma("foreign_keys = ON");
-    const summary = housekeepingModule.orphanCleanupPass(chapterhouse.id);
-    assert.equal(summary.pass, "orphanCleanupPass");
-    assert.equal(summary.examined, 1);
-    assert.equal(summary.modified, 1);
-    assert.equal(db.prepare(`SELECT entity_id FROM mem_observations WHERE id = ?`).get(orphan.id).entity_id, null);
-    assert.equal(db.prepare(`SELECT entity_id FROM mem_observations WHERE id = ?`).get(valid.id).entity_id, entity.id);
-    assert.equal(db.prepare(`SELECT entity_id FROM mem_observations WHERE id = ?`).get(otherScope.id).entity_id, 987654);
-    const second = housekeepingModule.orphanCleanupPass(chapterhouse.id);
-    assert.equal(second.modified, 0);
-});
-test("decayPass archives old low-confidence observations only in scope and compactInboxPass removes resolved inbox rows after retention", async () => {
-    const { dbModule, memoryModule, housekeepingModule } = await loadModules();
-    const db = dbModule.getDb();
-    const getScope = getFunction(memoryModule, "getScope");
-    const recordObservation = getFunction(memoryModule, "recordObservation");
-    const chapterhouse = getScope("chapterhouse");
-    const team = createTestScope(memoryModule, "team");
-    assert.ok(chapterhouse);
-    const archiveMe = recordObservation({ scope_id: chapterhouse.id, content: "Old low confidence", source: "test", confidence: 0.2 });
-    const highConfidence = recordObservation({ scope_id: chapterhouse.id, content: "Old high confidence", source: "test", confidence: 0.9 });
-    const fresh = recordObservation({ scope_id: chapterhouse.id, content: "Fresh low confidence", source: "test", confidence: 0.2 });
-    const otherScope = recordObservation({ scope_id: team.id, content: "Other scope old low confidence", source: "test", confidence: 0.2 });
-    db.prepare(`UPDATE mem_observations SET created_at = datetime('now', '-31 days') WHERE id IN (?, ?, ?)`).run(archiveMe.id, highConfidence.id, otherScope.id);
-    const decay = housekeepingModule.decayPass(chapterhouse.id);
-    assert.equal(decay.pass, "decayPass");
-    assert.equal(decay.examined, 1);
-    assert.equal(decay.modified, 1);
-    assert.ok(db.prepare(`SELECT archived_at FROM mem_observations WHERE id = ?`).get(archiveMe.id).archived_at);
-    assert.equal(db.prepare(`SELECT archived_at FROM mem_observations WHERE id = ?`).get(highConfidence.id).archived_at, null);
-    assert.equal(db.prepare(`SELECT archived_at FROM mem_observations WHERE id = ?`).get(fresh.id).archived_at, null);
-    assert.equal(db.prepare(`SELECT archived_at FROM mem_observations WHERE id = ?`).get(otherScope.id).archived_at, null);
-    assert.equal(housekeepingModule.decayPass(chapterhouse.id).modified, 0);
-    db.prepare(`
-    INSERT INTO mem_inbox (scope_id, kind, payload, source_agent, status, created_at, resolved_at)
-    VALUES
-      (?, 'memory_proposal', '{}', 'test', 'accepted', datetime('now', '-20 days'), datetime('now', '-8 days')),
-      (?, 'memory_proposal', '{}', 'test', 'rejected', datetime('now', '-20 days'), datetime('now', '-6 days')),
-      (?, 'memory_proposal', '{}', 'test', 'pending', datetime('now', '-20 days'), NULL)
-  `).run(chapterhouse.id, chapterhouse.id, chapterhouse.id);
-    const compact = housekeepingModule.compactInboxPass();
-    assert.equal(compact.pass, "compactInboxPass");
-    assert.equal(compact.examined, 1);
-    assert.equal(compact.modified, 1);
-    assert.deepEqual(db.prepare(`SELECT status FROM mem_inbox ORDER BY id`).all(), [{ status: "rejected" }, { status: "pending" }]);
-    assert.equal(housekeepingModule.compactInboxPass().modified, 0);
-});
-test("runHousekeeping defaults to the active scope and can target all active scopes", async () => {
-    const { dbModule, memoryModule, housekeepingModule } = await loadModules();
-    const db = dbModule.getDb();
-    const getScope = getFunction(memoryModule, "getScope");
-    const setActiveScope = getFunction(memoryModule, "setActiveScope");
-    const recordObservation = getFunction(memoryModule, "recordObservation");
-    const chapterhouse = getScope("chapterhouse");
-    const team = createTestScope(memoryModule, "team");
-    assert.ok(chapterhouse);
-    const chapterhouseOld = recordObservation({ scope_id: chapterhouse.id, content: "Chapterhouse old low", source: "test", confidence: 0.1 });
-    const teamOld = recordObservation({ scope_id: team.id, content: "Team old low", source: "test", confidence: 0.1 });
-    db.prepare(`UPDATE mem_observations SET created_at = datetime('now', '-31 days') WHERE id IN (?, ?)`).run(chapterhouseOld.id, teamOld.id);
-    setActiveScope("chapterhouse");
-    const activeOnly = await housekeepingModule.runHousekeeping({ passes: ["decay"] });
-    assert.deepEqual(activeOnly.scopeIds, [chapterhouse.id]);
-    assert.equal(activeOnly.summaries.length, 1);
-    assert.equal(activeOnly.summaries[0]?.modified, 1);
-    assert.ok(db.prepare(`SELECT archived_at FROM mem_observations WHERE id = ?`).get(chapterhouseOld.id).archived_at);
-    assert.equal(db.prepare(`SELECT archived_at FROM mem_observations WHERE id = ?`).get(teamOld.id).archived_at, null);
-    const allScopes = await housekeepingModule.runHousekeeping({ allScopes: true, passes: ["decay"] });
-    assert.ok(allScopes.scopeIds.includes(team.id));
-    assert.equal(allScopes.summaries.some((summary) => summary.modified === 1), true);
-    assert.ok(db.prepare(`SELECT archived_at FROM mem_observations WHERE id = ?`).get(teamOld.id).archived_at);
-});
-test("runHousekeeping starts all scoped passes before awaiting completion", async (t) => {
-    const releases = new Map();
-    const startedScopes = [];
-    const housekeepingModule = await loadMockedHousekeepingModule(t, {
-        scopes: [
-            { id: 11, active: true },
-            { id: 22, active: true },
-        ],
-        tieringPass: async (scopeId) => {
-            startedScopes.push(scopeId);
-            await new Promise((resolve) => {
-                releases.set(scopeId, resolve);
-            });
-            return { pass: `tieringPass:${scopeId}`, examined: 1, modified: 1, errors: [] };
-        },
-    });
-    const pending = housekeepingModule.runHousekeeping({ allScopes: true, passes: ["tiering"] });
-    assert.equal(typeof pending.then, "function");
-    await Promise.resolve();
-    assert.deepEqual(startedScopes.sort((left, right) => left - right), [11, 22]);
-    releases.get(11)?.();
-    releases.get(22)?.();
-    const result = await pending;
-    assert.deepEqual(result.scopeIds, [11, 22]);
-    assert.deepEqual(result.summaries.map((summary) => summary.pass), ["tieringPass:11", "tieringPass:22"]);
-});
-test("runHousekeeping rejects overlapping runs that share an in-flight scope", async (t) => {
-    const releases = new Map();
-    const housekeepingModule = await loadMockedHousekeepingModule(t, {
-        scopes: [
-            { id: 11, active: true },
-            { id: 22, active: true },
-        ],
-        tieringPass: async (scopeId) => {
-            await new Promise((resolve) => {
-                releases.set(scopeId, resolve);
-            });
-            return { pass: `tieringPass:${scopeId}`, examined: 1, modified: 1, errors: [] };
-        },
-    });
-    const firstRun = housekeepingModule.runHousekeeping({ scopeIds: [11, 22], passes: ["tiering"] });
-    await Promise.resolve();
-    assert.equal(housekeepingModule.isHousekeepingInFlight([22], ["tiering"]), true);
-    const secondRun = await housekeepingModule.runHousekeeping({ scopeIds: [22], passes: ["tiering"] });
-    assert.deepEqual(secondRun.scopeIds, [22]);
-    assert.match(secondRun.summaries[0]?.errors[0] ?? "", /already in flight/i);
-    releases.get(11)?.();
-    releases.get(22)?.();
-    await firstRun;
-});
-test("tieringPass promotes and demotes rows from lifecycle signals and is idempotent", async () => {
-    const { dbModule, memoryModule, housekeepingModule } = await loadModules();
-    const db = dbModule.getDb();
-    const upsertEntity = getFunction(memoryModule, "upsertEntity");
-    const recordObservation = getFunction(memoryModule, "recordObservation");
-    const recordDecision = getFunction(memoryModule, "recordDecision");
-    const team = createTestScope(memoryModule, "team");
-    const entity = upsertEntity({ scope_id: team.id, kind: "component", name: "memory", tier: "warm" });
-    const referencedObservation = recordObservation({
-        scope_id: team.id,
-        entity_id: entity.id,
-        content: "Referenced by a recent decision through its entity.",
-        source: "test",
-        tier: "warm",
-    });
-    const recentDecision = recordDecision({
-        scope_id: team.id,
-        entity_id: entity.id,
-        title: "Restate memory tiering decision",
-        rationale: "Recent entity-linked decisions keep related observations hot.",
-        decided_at: new Date().toISOString(),
-        tier: "warm",
-    });
-    const oldHot = recordObservation({
-        scope_id: team.id,
-        content: "Old hot row with no recall activity should cool down.",
-        source: "test",
-        tier: "hot",
-    });
-    const staleLowConfidence = recordObservation({
-        scope_id: team.id,
-        content: "Low confidence stale row should go cold.",
-        source: "test",
-        tier: "warm",
-        confidence: 0.2,
-    });
-    const archived = recordObservation({
-        scope_id: team.id,
-        content: "Archived row should always be cold.",
-        source: "test",
-        tier: "hot",
-    });
-    db.prepare(`UPDATE mem_observations SET created_at = datetime('now', '-45 days') WHERE id = ?`).run(oldHot.id);
-    db.prepare(`UPDATE mem_observations SET created_at = datetime('now', '-61 days') WHERE id = ?`).run(staleLowConfidence.id);
-    db.prepare(`UPDATE mem_observations SET archived_at = CURRENT_TIMESTAMP WHERE id = ?`).run(archived.id);
-    const summary = housekeepingModule.tieringPass(team.id);
-    assert.equal(summary.pass, "tieringPass");
-    assert.equal(summary.modified, 5);
-    assert.deepEqual(summary.errors, []);
-    assert.equal(db.prepare(`SELECT tier FROM mem_observations WHERE id = ?`).get(referencedObservation.id).tier, "hot");
-    assert.equal(db.prepare(`SELECT tier FROM mem_decisions WHERE id = ?`).get(recentDecision.id).tier, "hot");
-    assert.equal(db.prepare(`SELECT tier FROM mem_observations WHERE id = ?`).get(oldHot.id).tier, "warm");
-    assert.equal(db.prepare(`SELECT tier FROM mem_observations WHERE id = ?`).get(staleLowConfidence.id).tier, "cold");
-    assert.equal(db.prepare(`SELECT tier FROM mem_observations WHERE id = ?`).get(archived.id).tier, "cold");
-    const second = housekeepingModule.tieringPass(team.id);
-    assert.equal(second.modified, 0);
-});
-//# sourceMappingURL=housekeeping.test.js.map

package/dist/memory/inbox.js

@@ -1,83 +0,0 @@
-import { getDb } from "../store/db.js";
-import { getActiveScope } from "./active-scope.js";
-import { getScope } from "./scopes.js";
-function toInboxItem(row) {
-    return {
-        id: row.id,
-        scopeId: row.scope_id ?? undefined,
-        kind: row.kind,
-        payload: row.payload,
-        sourceAgent: row.source_agent,
-        sourceTaskId: row.source_task_id ?? undefined,
-        status: row.status,
-        createdAt: row.created_at,
-        resolvedAt: row.resolved_at ?? undefined,
-        resolutionReason: row.resolution_reason ?? undefined,
-    };
-}
-export function resolveProposalScope(scopeSlug) {
-    if (scopeSlug) {
-        const explicit = getScope(scopeSlug);
-        if (!explicit) {
-            throw new Error(`Unknown memory scope '${scopeSlug}'.`);
-        }
-        return { scopeId: explicit.id, scopeSlug: explicit.slug };
-    }
-    const activeScope = getActiveScope();
-    if (!activeScope) {
-        throw new Error("No active memory scope is set. Use memory_set_scope or pass scope_slug explicitly.");
-    }
-    return { scopeId: activeScope.id, scopeSlug: activeScope.slug };
-}
-export function queueMemoryProposal(input) {
-    const { scopeId, scopeSlug } = resolveProposalScope(input.scopeSlug);
-    const envelope = {
-        kind: input.kind,
-        scope_slug: scopeSlug,
-        confidence: input.confidence ?? 0.5,
-        reason: input.reason,
-        payload: input.payload,
-    };
-    const result = getDb().prepare(`
-    INSERT INTO mem_inbox (scope_id, kind, payload, source_agent, source_task_id, status, created_at)
-    VALUES (?, 'memory_proposal', ?, ?, ?, 'pending', CURRENT_TIMESTAMP)
-  `).run(scopeId, JSON.stringify(envelope), input.sourceAgent, input.sourceTaskId ?? null);
-    return getInboxItem(Number(result.lastInsertRowid));
-}
-export function getInboxItem(id) {
-    const row = getDb().prepare(`
-    SELECT id, scope_id, kind, payload, source_agent, source_task_id, status, created_at, resolved_at, resolution_reason
-    FROM mem_inbox
-    WHERE id = ?
-  `).get(id);
-    return row ? toInboxItem(row) : undefined;
-}
-export function listPendingMemoryProposalsForTask(taskId) {
-    const rows = getDb().prepare(`
-    SELECT id, scope_id, kind, payload, source_agent, source_task_id, status, created_at, resolved_at, resolution_reason
-    FROM mem_inbox
-    WHERE source_task_id = ?
-      AND status = 'pending'
-      AND kind = 'memory_proposal'
-    ORDER BY id ASC
-  `).all(taskId);
-    return rows.map(toInboxItem);
-}
-export function listPendingInboxItems(input = {}) {
-    const rows = getDb().prepare(`
-    SELECT id, scope_id, kind, payload, source_agent, source_task_id, status, created_at, resolved_at, resolution_reason
-    FROM mem_inbox
-    WHERE status = 'pending'
-    ORDER BY id ASC
-    LIMIT ? OFFSET ?
-  `).all(input.limit ?? 100, input.offset ?? 0);
-    return rows.map(toInboxItem);
-}
-export function resolveInboxItem(id, status, reason) {
-    getDb().prepare(`
-    UPDATE mem_inbox
-    SET status = ?, resolution_reason = ?, resolved_at = CURRENT_TIMESTAMP
-    WHERE id = ?
-  `).run(status, reason, id);
-}
-//# sourceMappingURL=inbox.js.map

package/dist/memory/inbox.test.js

@@ -1,178 +0,0 @@
-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-inbox-${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 loadRealModules(cacheBust = `${Date.now()}-${Math.random()}`) {
-    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 inboxModule = await import(new URL(`./inbox.js?case=${cacheBust}`, import.meta.url).href);
-    return { dbModule, memoryModule, inboxModule };
-}
-async function loadMockedInboxModule(t, options) {
-    t.mock.module("../store/db.js", {
-        namedExports: {
-            getDb: () => ({ prepare: options.prepare }),
-        },
-    });
-    t.mock.module("./active-scope.js", {
-        namedExports: {
-            getActiveScope: () => options.activeScope ?? null,
-        },
-    });
-    t.mock.module("./scopes.js", {
-        namedExports: {
-            getScope: (slug) => options.explicitScopes?.[slug],
-        },
-    });
-    return await import(new URL(`./inbox.js?case=${Date.now()}-${Math.random()}`, import.meta.url).href);
-}
-function getFunction(module, name) {
-    const value = module[name];
-    assert.equal(typeof value, "function", `expected ${name} to be exported`);
-    return value;
-}
-function createTestScope(memoryModule, slug) {
-    const createScope = getFunction(memoryModule, "createScope");
-    return createScope({
-        slug,
-        title: slug.split("-").map((part) => part[0]?.toUpperCase() + part.slice(1)).join(" "),
-        description: `${slug} test scope`,
-        keywords: [slug],
-    });
-}
-test.beforeEach(async () => {
-    process.env.CHAPTERHOUSE_HOME = sandboxRoot;
-    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("resolveProposalScope returns explicit scopes and falls back to the active scope for missing or empty values", async () => {
-    const { dbModule, memoryModule, inboxModule } = await loadRealModules("resolve-fallback");
-    dbModule.getDb();
-    const docs = createTestScope(memoryModule, "docs");
-    const setActiveScope = getFunction(memoryModule, "setActiveScope");
-    const active = createTestScope(memoryModule, "team-memory");
-    setActiveScope(active.slug);
-    assert.deepEqual(inboxModule.resolveProposalScope(docs.slug), { scopeId: docs.id, scopeSlug: docs.slug });
-    assert.deepEqual(inboxModule.resolveProposalScope(undefined), { scopeId: active.id, scopeSlug: active.slug });
-    assert.deepEqual(inboxModule.resolveProposalScope(""), { scopeId: active.id, scopeSlug: active.slug });
-});
-test("resolveProposalScope rejects invalid explicit scopes and missing default scopes", async () => {
-    const { dbModule, inboxModule } = await loadRealModules("resolve-errors");
-    dbModule.getDb();
-    assert.throws(() => inboxModule.resolveProposalScope("does-not-exist"), /Unknown memory scope 'does-not-exist'\./);
-    assert.throws(() => inboxModule.resolveProposalScope(), /No active memory scope is set\. Use memory_set_scope or pass scope_slug explicitly\./);
-});
-test("queueMemoryProposal enqueues explicit-scope proposals with the expected envelope defaults", async () => {
-    const { dbModule, memoryModule, inboxModule } = await loadRealModules("explicit-queue");
-    const db = dbModule.getDb();
-    const docs = createTestScope(memoryModule, "docs-queue");
-    const queued = inboxModule.queueMemoryProposal({
-        kind: "observation",
-        scopeSlug: docs.slug,
-        payload: {
-            content: "Inbox tests should verify the stored proposal envelope.",
-            source: "oracle",
-        },
-        sourceAgent: "oracle",
-        sourceTaskId: "task-inbox-explicit",
-    });
-    assert.equal(typeof queued.id, "number");
-    assert.equal(queued.scopeId, docs.id);
-    assert.equal(queued.kind, "memory_proposal");
-    assert.equal(queued.status, "pending");
-    assert.equal(queued.sourceAgent, "oracle");
-    assert.equal(queued.sourceTaskId, "task-inbox-explicit");
-    assert.match(queued.createdAt, /\d{4}-\d{2}-\d{2}/);
-    const persisted = db.prepare(`
-    SELECT payload
-    FROM mem_inbox
-    WHERE id = ?
-  `).get(queued.id);
-    assert.ok(persisted, "queueMemoryProposal should persist a mem_inbox row");
-    assert.deepEqual(JSON.parse(persisted.payload), {
-        kind: "observation",
-        scope_slug: docs.slug,
-        confidence: 0.5,
-        payload: {
-            content: "Inbox tests should verify the stored proposal envelope.",
-            source: "oracle",
-        },
-    });
-    assert.deepEqual(inboxModule.getInboxItem(queued.id), queued);
-});
-test("queueMemoryProposal falls back to the active scope, does not deduplicate duplicates, and pending lists exclude resolved items", async () => {
-    const { dbModule, memoryModule, inboxModule } = await loadRealModules("active-scope-queue");
-    dbModule.getDb();
-    const setActiveScope = getFunction(memoryModule, "setActiveScope");
-    setActiveScope("chapterhouse");
-    const first = inboxModule.queueMemoryProposal({
-        kind: "observation",
-        scopeSlug: "",
-        payload: { content: "Duplicate proposal payloads should still queue separately." },
-        confidence: 0.8,
-        reason: "First proposal",
-        sourceAgent: "oracle",
-        sourceTaskId: "task-inbox-duplicates",
-    });
-    const second = inboxModule.queueMemoryProposal({
-        kind: "observation",
-        payload: { content: "Duplicate proposal payloads should still queue separately." },
-        confidence: 0.8,
-        reason: "Second proposal",
-        sourceAgent: "oracle",
-        sourceTaskId: "task-inbox-duplicates",
-    });
-    assert.notEqual(first.id, second.id);
-    assert.equal(first.scopeId, second.scopeId);
-    assert.deepEqual(inboxModule.listPendingMemoryProposalsForTask("task-inbox-duplicates").map((item) => item.id), [first.id, second.id]);
-    inboxModule.resolveInboxItem(first.id, "accepted", "Durable enough to keep");
-    const resolved = inboxModule.getInboxItem(first.id);
-    assert.equal(resolved?.status, "accepted");
-    assert.equal(resolved?.resolutionReason, "Durable enough to keep");
-    assert.match(resolved?.resolvedAt ?? "", /\d{4}-\d{2}-\d{2}/);
-    assert.deepEqual(inboxModule.listPendingMemoryProposalsForTask("task-inbox-duplicates").map((item) => item.id), [second.id]);
-});
-test("queueMemoryProposal surfaces insert failures such as a full queue", async (t) => {
-    const fullError = new Error("database or disk is full");
-    const seenStatements = [];
-    const inboxModule = await loadMockedInboxModule(t, {
-        activeScope: { id: 99, slug: "chapterhouse" },
-        prepare: (sql) => {
-            seenStatements.push(sql);
-            if (sql.includes("INSERT INTO mem_inbox")) {
-                return {
-                    run: () => {
-                        throw fullError;
-                    },
-                };
-            }
-            return {
-                run: () => ({ changes: 0 }),
-                get: () => undefined,
-                all: () => [],
-            };
-        },
-    });
-    assert.throws(() => inboxModule.queueMemoryProposal({
-        kind: "observation",
-        payload: { content: "This proposal should fail before it is persisted." },
-        sourceAgent: "oracle",
-    }), /database or disk is full/);
-    assert.equal(seenStatements.some((sql) => sql.includes("INSERT INTO mem_inbox")), true);
-});
-//# sourceMappingURL=inbox.test.js.map