chapterhouse 0.13.1 → 0.14.0

package/dist/memory/tiering.test.js

@@ -1,323 +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-tiering-${process.pid}`);
-const chapterhouseHome = join(sandboxRoot, ".chapterhouse");
-const DAY_MS = 24 * 60 * 60 * 1000;
-process.env.CHAPTERHOUSE_HOME = sandboxRoot;
-process.env.CHAPTERHOUSE_MEMORY_HOT_AGE_DAYS = "30";
-process.env.CHAPTERHOUSE_MEMORY_TIERING_ENABLED = "1";
-function resetSandbox() {
-    mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
-    rmSync(sandboxRoot, { recursive: true, force: true });
-    mkdirSync(chapterhouseHome, { recursive: true });
-}
-async function loadModules(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 tieringModule = await import(new URL(`./tiering.js?case=${cacheBust}`, import.meta.url).href);
-    return { dbModule, memoryModule, tieringModule };
-}
-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],
-    });
-}
-function isoAt(offsetMs) {
-    return new Date(Date.now() + offsetMs).toISOString();
-}
-function sqlAt(offsetMs) {
-    return isoAt(offsetMs).replace("T", " ").slice(0, 19);
-}
-test.beforeEach(async () => {
-    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
-    dbModule.closeDb();
-    resetSandbox();
-});
-test.after(async () => {
-    delete process.env.CHAPTERHOUSE_MEMORY_HOT_AGE_DAYS;
-    delete process.env.CHAPTERHOUSE_MEMORY_TIERING_ENABLED;
-    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
-    dbModule.closeDb();
-    rmSync(sandboxRoot, { recursive: true, force: true });
-});
-test("inferTierFromSignals maps archival, confidence, and 30-day recency boundaries to the expected tier", async () => {
-    const { tieringModule } = await loadModules("infer-boundaries");
-    const originalNow = Date.now;
-    const fixedNow = Date.parse("2026-05-14T15:00:00.000Z");
-    Date.now = () => fixedNow;
-    try {
-        assert.equal(tieringModule.inferTierFromSignals({}), "warm");
-        assert.equal(tieringModule.inferTierFromSignals({ archived_at: "2026-05-01 12:00:00" }), "cold");
-        assert.equal(tieringModule.inferTierFromSignals({ superseded_by: 42, tier: "hot" }), "cold");
-        assert.equal(tieringModule.inferTierFromSignals({ tier: "glacier" }), "cold");
-        assert.equal(tieringModule.inferTierFromSignals({
-            confidence: 0.71,
-            created_at: new Date(fixedNow - 30 * DAY_MS).toISOString(),
-        }), "hot");
-        assert.equal(tieringModule.inferTierFromSignals({
-            confidence: 0.71,
-            created_at: new Date(fixedNow - 30 * DAY_MS - 1).toISOString(),
-        }), "warm");
-        assert.equal(tieringModule.inferTierFromSignals({
-            confidence: 0.71,
-            decided_at: new Date(fixedNow - DAY_MS).toISOString(),
-        }), "hot");
-        assert.equal(tieringModule.inferTierFromSignals({
-            confidence: 0.71,
-            updated_at: new Date(fixedNow - DAY_MS).toISOString(),
-        }), "hot");
-        assert.equal(tieringModule.inferTierFromSignals({
-            confidence: 0.7,
-            created_at: new Date(fixedNow - DAY_MS).toISOString(),
-            tier: "hot",
-        }), "hot");
-        assert.equal(tieringModule.inferTierFromSignals({
-            confidence: 0.2,
-            created_at: new Date(fixedNow - 90 * DAY_MS).toISOString(),
-        }), "warm");
-        assert.equal(tieringModule.inferTierFromSignals({ tier: "cold" }), "cold");
-    }
-    finally {
-        Date.now = originalNow;
-    }
-});
-test("tieringPass reports empty scopes without changes", async () => {
-    const { dbModule, memoryModule, tieringModule } = await loadModules("empty-scope");
-    dbModule.getDb();
-    const scope = createTestScope(memoryModule, "tiering-empty");
-    assert.deepEqual(tieringModule.tieringPass(scope.id), {
-        pass: "tieringPass",
-        examined: 0,
-        modified: 0,
-        errors: [],
-    });
-});
-test("tieringPass promotes recent observations, decisions, entities, and due actions while aging stale hot rows", async () => {
-    const { dbModule, memoryModule, tieringModule } = await loadModules("promotions-and-aging");
-    const db = dbModule.getDb();
-    const scope = createTestScope(memoryModule, "tiering-promotions");
-    const upsertEntity = getFunction(memoryModule, "upsertEntity");
-    const recordObservation = getFunction(memoryModule, "recordObservation");
-    const recordDecision = getFunction(memoryModule, "recordDecision");
-    const recordActionItem = getFunction(memoryModule, "recordActionItem");
-    const completeActionItem = getFunction(memoryModule, "completeActionItem");
-    const entity = upsertEntity({
-        scope_id: scope.id,
-        kind: "component",
-        name: "memory-router",
-        tier: "warm",
-        confidence: 0.95,
-    });
-    const linkedObservation = recordObservation({
-        scope_id: scope.id,
-        entity_id: entity.id,
-        content: "Recent observation that should follow a fresh decision into hot tier.",
-        source: "test",
-        tier: "warm",
-        confidence: 0.9,
-    });
-    const supportingObservationTwo = recordObservation({
-        scope_id: scope.id,
-        entity_id: entity.id,
-        content: "Second recent observation keeps the entity active.",
-        source: "test",
-        tier: "warm",
-        confidence: 0.9,
-    });
-    const supportingObservationThree = recordObservation({
-        scope_id: scope.id,
-        entity_id: entity.id,
-        content: "Third recent observation pushes the entity over the hot threshold.",
-        source: "test",
-        tier: "warm",
-        confidence: 0.9,
-    });
-    const staleObservation = recordObservation({
-        scope_id: scope.id,
-        content: "Old hot observation with no recall should cool down.",
-        source: "test",
-        tier: "hot",
-        confidence: 0.8,
-    });
-    const boundaryObservation = recordObservation({
-        scope_id: scope.id,
-        content: "Hot observation inside the age window should stay hot.",
-        source: "test",
-        tier: "hot",
-        confidence: 0.8,
-    });
-    const recentDecision = recordDecision({
-        scope_id: scope.id,
-        entity_id: entity.id,
-        title: "Recent decision keeps related memories hot",
-        rationale: "Fresh decision activity should promote related observations.",
-        decided_at: sqlAt(-DAY_MS),
-        tier: "warm",
-    });
-    const staleDecision = recordDecision({
-        scope_id: scope.id,
-        title: "Old hot decision without recall cools off",
-        rationale: "No one has looked at it recently.",
-        decided_at: sqlAt(-31 * DAY_MS),
-        tier: "hot",
-    });
-    const boundaryDecision = recordDecision({
-        scope_id: scope.id,
-        title: "Boundary decision remains hot",
-        rationale: "Still inside the configured hot age.",
-        decided_at: sqlAt(-29 * DAY_MS),
-        tier: "hot",
-    });
-    const dueSoonAction = recordActionItem({
-        scope_id: scope.id,
-        title: "Due soon action item becomes hot",
-        due_at: sqlAt(6 * DAY_MS),
-        source: "test",
-        tier: "warm",
-    });
-    const dueLaterAction = recordActionItem({
-        scope_id: scope.id,
-        title: "Far future action item stays warm",
-        due_at: sqlAt(8 * DAY_MS),
-        source: "test",
-        tier: "warm",
-    });
-    const staleHotAction = recordActionItem({
-        scope_id: scope.id,
-        title: "Old hot action item cools without recall",
-        source: "test",
-        tier: "hot",
-    });
-    const resolvedAction = recordActionItem({
-        scope_id: scope.id,
-        title: "Resolved action item becomes cold",
-        source: "test",
-        tier: "warm",
-    });
-    completeActionItem(resolvedAction.id, "Shipped");
-    for (const id of [linkedObservation.id, supportingObservationTwo.id, supportingObservationThree.id]) {
-        db.prepare(`UPDATE mem_observations SET created_at = ? WHERE id = ?`).run(sqlAt(-2 * DAY_MS), id);
-    }
-    db.prepare(`UPDATE mem_observations SET created_at = ?, last_recalled_at = NULL WHERE id = ?`).run(sqlAt(-31 * DAY_MS), staleObservation.id);
-    db.prepare(`UPDATE mem_observations SET created_at = ?, last_recalled_at = NULL WHERE id = ?`).run(sqlAt(-29 * DAY_MS), boundaryObservation.id);
-    db.prepare(`UPDATE mem_action_items SET created_at = ?, last_recalled_at = NULL WHERE id = ?`).run(sqlAt(-31 * DAY_MS), staleHotAction.id);
-    const summary = tieringModule.tieringPass(scope.id);
-    assert.equal(summary.pass, "tieringPass");
-    assert.equal(summary.examined, 13);
-    assert.equal(summary.modified, 10);
-    assert.deepEqual(summary.errors, []);
-    for (const id of [linkedObservation.id, supportingObservationTwo.id, supportingObservationThree.id]) {
-        assert.deepEqual(db.prepare(`SELECT tier, tier_reason FROM mem_observations WHERE id = ?`).get(id), { tier: "hot", tier_reason: "referenced by recent entity decision" });
-    }
-    assert.deepEqual(db.prepare(`SELECT tier, tier_reason FROM mem_observations WHERE id = ?`).get(linkedObservation.id), { tier: "hot", tier_reason: "referenced by recent entity decision" });
-    assert.deepEqual(db.prepare(`SELECT tier, tier_reason FROM mem_observations WHERE id = ?`).get(staleObservation.id), { tier: "warm", tier_reason: "hot age threshold without recall" });
-    assert.deepEqual(db.prepare(`SELECT tier, tier_reason FROM mem_observations WHERE id = ?`).get(boundaryObservation.id), { tier: "hot", tier_reason: null });
-    assert.deepEqual(db.prepare(`SELECT tier, tier_reason FROM mem_entities WHERE id = ?`).get(entity.id), { tier: "hot", tier_reason: "referenced by three recent observations" });
-    assert.deepEqual(db.prepare(`SELECT tier, tier_reason FROM mem_decisions WHERE id = ?`).get(recentDecision.id), { tier: "hot", tier_reason: "recent decision restatement" });
-    assert.deepEqual(db.prepare(`SELECT tier, tier_reason FROM mem_decisions WHERE id = ?`).get(staleDecision.id), { tier: "warm", tier_reason: "hot age threshold without recall" });
-    assert.deepEqual(db.prepare(`SELECT tier, tier_reason FROM mem_decisions WHERE id = ?`).get(boundaryDecision.id), { tier: "hot", tier_reason: null });
-    assert.deepEqual(db.prepare(`SELECT tier, tier_reason FROM mem_action_items WHERE id = ?`).get(dueSoonAction.id), { tier: "hot", tier_reason: "open action item due soon" });
-    assert.deepEqual(db.prepare(`SELECT tier, tier_reason FROM mem_action_items WHERE id = ?`).get(dueLaterAction.id), { tier: "warm", tier_reason: null });
-    assert.deepEqual(db.prepare(`SELECT tier, tier_reason FROM mem_action_items WHERE id = ?`).get(staleHotAction.id), { tier: "warm", tier_reason: "hot age threshold without recall" });
-    assert.deepEqual(db.prepare(`SELECT tier, tier_reason FROM mem_action_items WHERE id = ?`).get(resolvedAction.id), { tier: "cold", tier_reason: "resolved action item" });
-});
-test("tieringPass drops archived, superseded, and stale low-confidence rows to cold", async () => {
-    const { dbModule, memoryModule, tieringModule } = await loadModules("archival-and-stale");
-    const db = dbModule.getDb();
-    const scope = createTestScope(memoryModule, "tiering-archival");
-    const upsertEntity = getFunction(memoryModule, "upsertEntity");
-    const recordObservation = getFunction(memoryModule, "recordObservation");
-    const recordDecision = getFunction(memoryModule, "recordDecision");
-    const archivedObservation = recordObservation({
-        scope_id: scope.id,
-        content: "Archived observation should be cold.",
-        source: "test",
-        tier: "hot",
-        confidence: 0.9,
-    });
-    const keeperDecision = recordDecision({
-        scope_id: scope.id,
-        title: "Current decision",
-        rationale: "Used as the superseding target.",
-        decided_at: sqlAt(-DAY_MS),
-        tier: "warm",
-    });
-    const supersededDecision = recordDecision({
-        scope_id: scope.id,
-        title: "Old decision",
-        rationale: "Should become cold once superseded.",
-        decided_at: sqlAt(-10 * DAY_MS),
-        tier: "hot",
-    });
-    const staleObservation = recordObservation({
-        scope_id: scope.id,
-        content: "Low-confidence warm observation should eventually archive.",
-        source: "test",
-        tier: "warm",
-        confidence: 0.2,
-    });
-    const staleEntity = upsertEntity({
-        scope_id: scope.id,
-        kind: "doc",
-        name: "stale-entity",
-        tier: "warm",
-        confidence: 0.2,
-    });
-    db.prepare(`UPDATE mem_observations SET archived_at = ? WHERE id = ?`).run(sqlAt(-DAY_MS), archivedObservation.id);
-    db.prepare(`UPDATE mem_decisions SET superseded_by = ? WHERE id = ?`).run(keeperDecision.id, supersededDecision.id);
-    db.prepare(`UPDATE mem_observations SET created_at = ? WHERE id = ?`).run(sqlAt(-61 * DAY_MS), staleObservation.id);
-    db.prepare(`UPDATE mem_entities SET updated_at = ? WHERE id = ?`).run(sqlAt(-61 * DAY_MS), staleEntity.id);
-    const summary = tieringModule.tieringPass(scope.id);
-    assert.equal(summary.examined, 5);
-    assert.equal(summary.modified, 5);
-    assert.deepEqual(summary.errors, []);
-    assert.deepEqual(db.prepare(`SELECT tier, tier_reason FROM mem_observations WHERE id = ?`).get(archivedObservation.id), { tier: "cold", tier_reason: "archived or superseded" });
-    assert.deepEqual(db.prepare(`SELECT tier, tier_reason FROM mem_decisions WHERE id = ?`).get(keeperDecision.id), { tier: "hot", tier_reason: "recent decision restatement" });
-    assert.deepEqual(db.prepare(`SELECT tier, tier_reason FROM mem_decisions WHERE id = ?`).get(supersededDecision.id), { tier: "cold", tier_reason: "archived or superseded" });
-    assert.deepEqual(db.prepare(`SELECT tier, tier_reason FROM mem_observations WHERE id = ?`).get(staleObservation.id), { tier: "cold", tier_reason: "stale low confidence" });
-    assert.deepEqual(db.prepare(`SELECT tier, tier_reason FROM mem_entities WHERE id = ?`).get(staleEntity.id), { tier: "cold", tier_reason: "stale low confidence" });
-});
-test("tieringPass follows a single observation through creation, recall, aging, and archival", async () => {
-    const { dbModule, memoryModule, tieringModule } = await loadModules("observation-lifecycle");
-    const db = dbModule.getDb();
-    const scope = createTestScope(memoryModule, "tiering-lifecycle");
-    const recordObservation = getFunction(memoryModule, "recordObservation");
-    const created = recordObservation({
-        scope_id: scope.id,
-        content: "A durable observation should start hot, stay hot when recalled, then cool and archive.",
-        source: "test",
-        tier: "hot",
-        confidence: 0.95,
-    });
-    const createdRow = db.prepare(`
-    SELECT tier, confidence, archived_at, superseded_by, created_at
-    FROM mem_observations
-    WHERE id = ?
-  `).get(created.id);
-    assert.equal(tieringModule.inferTierFromSignals(createdRow), "hot");
-    db.prepare(`UPDATE mem_observations SET created_at = ?, last_recalled_at = ? WHERE id = ?`).run(sqlAt(-45 * DAY_MS), sqlAt(-DAY_MS), created.id);
-    let summary = tieringModule.tieringPass(scope.id);
-    assert.equal(summary.modified, 0);
-    assert.deepEqual(db.prepare(`SELECT tier, tier_reason FROM mem_observations WHERE id = ?`).get(created.id), { tier: "hot", tier_reason: null });
-    db.prepare(`UPDATE mem_observations SET last_recalled_at = NULL WHERE id = ?`).run(created.id);
-    summary = tieringModule.tieringPass(scope.id);
-    assert.equal(summary.modified, 1);
-    assert.deepEqual(db.prepare(`SELECT tier, tier_reason FROM mem_observations WHERE id = ?`).get(created.id), { tier: "warm", tier_reason: "hot age threshold without recall" });
-    db.prepare(`UPDATE mem_observations SET archived_at = ? WHERE id = ?`).run(sqlAt(0), created.id);
-    summary = tieringModule.tieringPass(scope.id);
-    assert.equal(summary.modified, 1);
-    assert.deepEqual(db.prepare(`SELECT tier, tier_reason FROM mem_observations WHERE id = ?`).get(created.id), { tier: "cold", tier_reason: "archived or superseded" });
-});
-//# sourceMappingURL=tiering.test.js.map

package/dist/memory/types.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=types.js.map