chapterhouse 0.3.26 → 0.4.1

package/dist/memory/housekeeping.js

@@ -0,0 +1,352 @@
+import { performance } from "node:perf_hooks";
+import { config } from "../config.js";
+import { getDb } from "../store/db.js";
+import { childLogger } from "../util/logger.js";
+import { getActiveScope } from "./active-scope.js";
+import { listScopes } from "./scopes.js";
+import { tieringPass } from "./tiering.js";
+export { tieringPass };
+const log = childLogger("memory.housekeeping");
+const SIMILARITY_THRESHOLD = 0.8;
+const inFlightKeys = new Set();
+const PASS_ORDER = [
+    "dedup_observations",
+    "dedup_decisions",
+    "orphan_cleanup",
+    "decay",
+    "compact_inbox",
+    "tiering",
+];
+function passSummary(pass, examined = 0, modified = 0, errors = []) {
+    return { pass, examined, modified, errors };
+}
+function tokens(value) {
+    const words = value
+        .toLowerCase()
+        .split(/[^a-z0-9]+/u)
+        .map((word) => word.replace(/s$/, ""))
+        .filter((word) => word.length > 1);
+    return new Set(words);
+}
+function jaccard(left, right) {
+    const leftTokens = tokens(left);
+    const rightTokens = tokens(right);
+    if (leftTokens.size === 0 || rightTokens.size === 0) {
+        return 0;
+    }
+    let intersection = 0;
+    for (const token of leftTokens) {
+        if (rightTokens.has(token)) {
+            intersection++;
+        }
+    }
+    const union = leftTokens.size + rightTokens.size - intersection;
+    return union === 0 ? 0 : intersection / union;
+}
+function isSimilar(left, right) {
+    if (left.trim().toLowerCase() === right.trim().toLowerCase()) {
+        return true;
+    }
+    return jaccard(left, right) >= SIMILARITY_THRESHOLD;
+}
+function compareObservationKeeper(left, right) {
+    if (right.confidence !== left.confidence) {
+        return right.confidence - left.confidence;
+    }
+    if (right.created_at !== left.created_at) {
+        return right.created_at.localeCompare(left.created_at);
+    }
+    return left.id - right.id;
+}
+function compareDecisionKeeper(left, right) {
+    if (right.decided_at !== left.decided_at) {
+        return right.decided_at.localeCompare(left.decided_at);
+    }
+    if (right.created_at !== left.created_at) {
+        return right.created_at.localeCompare(left.created_at);
+    }
+    return left.id - right.id;
+}
+function normalizePassName(pass) {
+    const normalized = pass.trim().toLowerCase().replace(/-/g, "_");
+    const aliases = {
+        dedup_observations: "dedup_observations",
+        dedupobservations: "dedup_observations",
+        dedupobservationspass: "dedup_observations",
+        observations: "dedup_observations",
+        dedup_decisions: "dedup_decisions",
+        dedupdecisions: "dedup_decisions",
+        dedupdecisionspass: "dedup_decisions",
+        decisions: "dedup_decisions",
+        orphan_cleanup: "orphan_cleanup",
+        orphancleanup: "orphan_cleanup",
+        orphancleanuppass: "orphan_cleanup",
+        orphans: "orphan_cleanup",
+        decay: "decay",
+        decaypass: "decay",
+        compact_inbox: "compact_inbox",
+        compactinbox: "compact_inbox",
+        compactinboxpass: "compact_inbox",
+        inbox: "compact_inbox",
+        tiering: "tiering",
+        tieringpass: "tiering",
+        tiers: "tiering",
+    };
+    const resolved = aliases[normalized];
+    if (!resolved) {
+        throw new Error(`Unknown housekeeping pass '${pass}'. Valid passes: ${PASS_ORDER.join(", ")}`);
+    }
+    return resolved;
+}
+export function dedupObservationsPass(scopeId) {
+    try {
+        const db = getDb();
+        const candidates = db.prepare(`
+      SELECT id, content, confidence, created_at
+      FROM mem_observations
+      WHERE scope_id = ?
+        AND superseded_by IS NULL
+        AND archived_at IS NULL
+      ORDER BY id ASC
+    `).all(scopeId);
+        let modified = 0;
+        const visited = new Set();
+        const update = db.prepare(`UPDATE mem_observations SET superseded_by = ? WHERE id = ? AND superseded_by IS NULL`);
+        const tx = db.transaction(() => {
+            for (const candidate of candidates) {
+                if (visited.has(candidate.id)) {
+                    continue;
+                }
+                const cluster = candidates.filter((entry) => !visited.has(entry.id) && isSimilar(candidate.content, entry.content));
+                for (const entry of cluster) {
+                    visited.add(entry.id);
+                }
+                if (cluster.length < 2) {
+                    continue;
+                }
+                const [keeper] = cluster.sort(compareObservationKeeper);
+                if (!keeper) {
+                    continue;
+                }
+                for (const entry of cluster) {
+                    if (entry.id === keeper.id) {
+                        continue;
+                    }
+                    modified += update.run(keeper.id, entry.id).changes;
+                }
+            }
+        });
+        tx();
+        return passSummary("dedupObservationsPass", candidates.length, modified);
+    }
+    catch (error) {
+        return passSummary("dedupObservationsPass", 0, 0, [error instanceof Error ? error.message : String(error)]);
+    }
+}
+export function dedupDecisionsPass(scopeId) {
+    try {
+        const db = getDb();
+        const candidates = db.prepare(`
+      SELECT id, entity_id, title, decided_at, created_at
+      FROM mem_decisions
+      WHERE scope_id = ?
+        AND superseded_by IS NULL
+        AND archived_at IS NULL
+      ORDER BY id ASC
+    `).all(scopeId);
+        let modified = 0;
+        const update = db.prepare(`UPDATE mem_decisions SET superseded_by = ? WHERE id = ? AND superseded_by IS NULL`);
+        const tx = db.transaction(() => {
+            const visited = new Set();
+            for (const candidate of candidates) {
+                if (visited.has(candidate.id)) {
+                    continue;
+                }
+                const cluster = candidates.filter((entry) => !visited.has(entry.id) && isSimilar(candidate.title, entry.title));
+                for (const entry of cluster) {
+                    visited.add(entry.id);
+                }
+                if (cluster.length < 2) {
+                    continue;
+                }
+                const [keeper] = cluster.sort(compareDecisionKeeper);
+                if (!keeper) {
+                    continue;
+                }
+                for (const entry of cluster) {
+                    if (entry.id === keeper.id) {
+                        continue;
+                    }
+                    modified += update.run(keeper.id, entry.id).changes;
+                }
+            }
+        });
+        tx();
+        return passSummary("dedupDecisionsPass", candidates.length, modified);
+    }
+    catch (error) {
+        return passSummary("dedupDecisionsPass", 0, 0, [error instanceof Error ? error.message : String(error)]);
+    }
+}
+export function orphanCleanupPass(scopeId) {
+    try {
+        const db = getDb();
+        const orphanIds = db.prepare(`
+      SELECT o.id
+      FROM mem_observations o
+      LEFT JOIN mem_entities e ON e.id = o.entity_id
+      WHERE o.scope_id = ?
+        AND o.entity_id IS NOT NULL
+        AND e.id IS NULL
+      ORDER BY o.id ASC
+    `).all(scopeId);
+        const tx = db.transaction(() => db.prepare(`
+      UPDATE mem_observations
+      SET entity_id = NULL
+      WHERE scope_id = ?
+        AND entity_id IS NOT NULL
+        AND NOT EXISTS (SELECT 1 FROM mem_entities e WHERE e.id = mem_observations.entity_id)
+    `).run(scopeId).changes);
+        const modified = tx();
+        if (modified > 0) {
+            log.info({ scope_id: scopeId, count: modified }, "memory.housekeeping.orphan_cleanup");
+        }
+        return passSummary("orphanCleanupPass", orphanIds.length, modified);
+    }
+    catch (error) {
+        return passSummary("orphanCleanupPass", 0, 0, [error instanceof Error ? error.message : String(error)]);
+    }
+}
+export function decayPass(scopeId) {
+    try {
+        const db = getDb();
+        const candidateIds = db.prepare(`
+      SELECT id
+      FROM mem_observations
+      WHERE scope_id = ?
+        AND superseded_by IS NULL
+        AND archived_at IS NULL
+        AND confidence < 0.3
+        AND datetime(created_at) < datetime('now', ?)
+      ORDER BY id ASC
+    `).all(scopeId, `-${config.memoryDecayDays} days`);
+        const tx = db.transaction(() => db.prepare(`
+      UPDATE mem_observations
+      SET archived_at = CURRENT_TIMESTAMP
+      WHERE scope_id = ?
+        AND superseded_by IS NULL
+        AND archived_at IS NULL
+        AND confidence < 0.3
+        AND datetime(created_at) < datetime('now', ?)
+    `).run(scopeId, `-${config.memoryDecayDays} days`).changes);
+        const modified = tx();
+        return passSummary("decayPass", candidateIds.length, modified);
+    }
+    catch (error) {
+        return passSummary("decayPass", 0, 0, [error instanceof Error ? error.message : String(error)]);
+    }
+}
+export function compactInboxPass() {
+    try {
+        const db = getDb();
+        const candidateIds = db.prepare(`
+      SELECT id
+      FROM mem_inbox
+      WHERE status IN ('accepted', 'rejected')
+        AND resolved_at IS NOT NULL
+        AND datetime(resolved_at) < datetime('now', ?)
+      ORDER BY id ASC
+    `).all(`-${config.memoryInboxRetentionDays} days`);
+        const tx = db.transaction(() => db.prepare(`
+      DELETE FROM mem_inbox
+      WHERE status IN ('accepted', 'rejected')
+        AND resolved_at IS NOT NULL
+        AND datetime(resolved_at) < datetime('now', ?)
+    `).run(`-${config.memoryInboxRetentionDays} days`).changes);
+        const modified = tx();
+        return passSummary("compactInboxPass", candidateIds.length, modified);
+    }
+    catch (error) {
+        return passSummary("compactInboxPass", 0, 0, [error instanceof Error ? error.message : String(error)]);
+    }
+}
+function resolveScopeIds(input) {
+    if (input?.scopeIds && input.scopeIds.length > 0) {
+        return [...new Set(input.scopeIds)];
+    }
+    if (input?.allScopes) {
+        return listScopes().filter((scope) => scope.active).map((scope) => scope.id);
+    }
+    const activeScope = getActiveScope();
+    return activeScope ? [activeScope.id] : [];
+}
+function runPass(pass, scopeId) {
+    switch (pass) {
+        case "dedup_observations":
+            return dedupObservationsPass(scopeId);
+        case "dedup_decisions":
+            return dedupDecisionsPass(scopeId);
+        case "orphan_cleanup":
+            return orphanCleanupPass(scopeId);
+        case "decay":
+            return decayPass(scopeId);
+        case "compact_inbox":
+            return compactInboxPass();
+        case "tiering":
+            return tieringPass(scopeId);
+    }
+}
+function inFlightKey(scopeIds, passes) {
+    return `${scopeIds.join(",") || "none"}:${passes.join(",")}`;
+}
+export function isHousekeepingInFlight(scopeIds, passes) {
+    if (!scopeIds || scopeIds.length === 0) {
+        return inFlightKeys.size > 0;
+    }
+    const normalizedPasses = passes?.map(normalizePassName) ?? PASS_ORDER;
+    return inFlightKeys.has(inFlightKey([...new Set(scopeIds)].sort((a, b) => a - b), normalizedPasses));
+}
+export function runHousekeeping(opts = {}) {
+    const started = performance.now();
+    const scopeIds = resolveScopeIds(opts).sort((a, b) => a - b);
+    const passes = opts.passes?.length ? opts.passes.map(normalizePassName) : PASS_ORDER;
+    const key = inFlightKey(scopeIds, passes);
+    if (inFlightKeys.has(key)) {
+        return {
+            scopeIds,
+            summaries: [passSummary("runHousekeeping", 0, 0, ["Housekeeping is already in flight for this scope/pass set."])],
+            totalExamined: 0,
+            totalModified: 0,
+            durationMs: 0,
+        };
+    }
+    inFlightKeys.add(key);
+    const summaries = [];
+    try {
+        const scopedPasses = passes.filter((pass) => pass !== "compact_inbox");
+        const hasCompactInbox = passes.includes("compact_inbox");
+        for (const scopeId of scopeIds) {
+            for (const pass of scopedPasses) {
+                summaries.push(runPass(pass, scopeId));
+            }
+        }
+        if (hasCompactInbox) {
+            summaries.push(compactInboxPass());
+        }
+        const totalExamined = summaries.reduce((sum, summary) => sum + summary.examined, 0);
+        const totalModified = summaries.reduce((sum, summary) => sum + summary.modified, 0);
+        const durationMs = Math.round(performance.now() - started);
+        log.info({
+            passes_run: summaries.map((summary) => summary.pass),
+            total_examined: totalExamined,
+            total_modified: totalModified,
+            duration_ms: durationMs,
+            scope_ids: scopeIds,
+        }, "memory.housekeeping.run");
+        return { scopeIds, summaries, totalExamined, totalModified, durationMs };
+    }
+    finally {
+        inFlightKeys.delete(key);
+    }
+}
+//# sourceMappingURL=housekeeping.js.map

package/dist/memory/housekeeping.test.js

@@ -0,0 +1,280 @@
+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", import.meta.url).href);
+    return { dbModule, memoryModule, housekeepingModule };
+}
+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 });
+    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 = getScope("team");
+    assert.ok(chapterhouse && team);
+    const first = recordObservation({
+        scope_id: chapterhouse.id,
+        content: "The worker event stream uses server sent events for live task output.",
+        source: "test",
+        confidence: 0.4,
+    });
+    const keeper = recordObservation({
+        scope_id: chapterhouse.id,
+        content: "Worker event streams use server sent events for live task output.",
+        source: "test",
+        confidence: 0.9,
+    });
+    const third = recordObservation({
+        scope_id: chapterhouse.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: team.id,
+        content: "Worker event streams use server sent events for live task output.",
+        source: "test",
+        confidence: 0.1,
+    });
+    const summary = housekeepingModule.dedupObservationsPass(chapterhouse.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(chapterhouse.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 getScope = getFunction(memoryModule, "getScope");
+    const upsertEntity = getFunction(memoryModule, "upsertEntity");
+    const recordDecision = getFunction(memoryModule, "recordDecision");
+    const chapterhouse = getScope("chapterhouse");
+    const team = getScope("team");
+    assert.ok(chapterhouse && team);
+    const api = upsertEntity({ scope_id: chapterhouse.id, kind: "component", name: "api" });
+    const web = upsertEntity({ scope_id: chapterhouse.id, kind: "component", name: "web" });
+    const oldDecision = recordDecision({
+        scope_id: chapterhouse.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: chapterhouse.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: chapterhouse.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: team.id,
+        title: "Use SQLite FTS5 for memory recall",
+        rationale: "Same title, different scope.",
+        decided_at: "2026-05-14",
+    });
+    const summary = housekeepingModule.dedupDecisionsPass(chapterhouse.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(chapterhouse.id);
+    assert.equal(second.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 = getScope("team");
+    assert.ok(chapterhouse && team);
+    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 = getScope("team");
+    assert.ok(chapterhouse && team);
+    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 = getScope("team");
+    assert.ok(chapterhouse && team);
+    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 = 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 = 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("tieringPass promotes and demotes rows from lifecycle signals and is idempotent", 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 recordDecision = getFunction(memoryModule, "recordDecision");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse);
+    const entity = upsertEntity({ scope_id: chapterhouse.id, kind: "component", name: "memory", tier: "warm" });
+    const referencedObservation = recordObservation({
+        scope_id: chapterhouse.id,
+        entity_id: entity.id,
+        content: "Referenced by a recent decision through its entity.",
+        source: "test",
+        tier: "warm",
+    });
+    const recentDecision = recordDecision({
+        scope_id: chapterhouse.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: chapterhouse.id,
+        content: "Old hot row with no recall activity should cool down.",
+        source: "test",
+        tier: "hot",
+    });
+    const staleLowConfidence = recordObservation({
+        scope_id: chapterhouse.id,
+        content: "Low confidence stale row should go cold.",
+        source: "test",
+        tier: "warm",
+        confidence: 0.2,
+    });
+    const archived = recordObservation({
+        scope_id: chapterhouse.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(chapterhouse.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(chapterhouse.id);
+    assert.equal(second.modified, 0);
+});
+//# sourceMappingURL=housekeeping.test.js.map