chapterhouse 0.4.1 → 0.4.3

package/dist/memory/eot.test.js

@@ -65,7 +65,7 @@ test("runEndOfTaskMemoryHook does nothing when CHAPTERHOUSE_MEMORY_EOT_HOOK_ENAB
         },
     });
     assert.equal(llmCalls, 0);
-    assert.equal(listObservations({ scope_id: chapterhouse.id }).length, 0);
+    assert.equal(listObservations({ scope_id: chapterhouse.id }).some((row) => row.content === "Disabled hooks must not persist memory."), false);
     const row = db.prepare(`SELECT status FROM mem_inbox WHERE id = ?`).get(Number(inserted.lastInsertRowid));
     assert.equal(row.status, "pending");
 });
@@ -155,6 +155,85 @@ test("runEndOfTaskMemoryHook accepts matching proposals, rejects others from the
             auto_accept: true,
         }]);
 });
+test("runEndOfTaskMemoryHook accepts action_item proposals into mem_action_items", async () => {
+    const { dbModule, memoryModule, eotModule } = await loadModules("action-item-accept");
+    const db = dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const listActionItems = getFunction(memoryModule, "listActionItems");
+    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse);
+    const inserted = db.prepare(`
+    INSERT INTO mem_inbox (scope_id, kind, payload, source_agent, source_task_id, status)
+    VALUES (?, 'memory_proposal', ?, 'coder', 'task-eot-action-item', 'pending')
+  `).run(chapterhouse.id, JSON.stringify({
+        kind: "action_item",
+        payload: {
+            title: "Migrate feature ideas",
+            detail: "Move feature-ideas.md into mem_action_items.",
+            source: "subagent_proposal",
+        },
+        confidence: 0.9,
+    }));
+    await runEndOfTaskMemoryHook({
+        taskId: "task-eot-action-item",
+        finalResult: "Completed and proposed a follow-up action item.",
+        copilotClient: {},
+        callLLM: async () => JSON.stringify({
+            decisions: [{
+                    proposal_id: Number(inserted.lastInsertRowid),
+                    decision: "accept",
+                    reason: "Concrete follow-up.",
+                }],
+            implicit_memories: [],
+        }),
+    });
+    const actionItems = listActionItems({ scope_id: chapterhouse.id });
+    assert.equal(actionItems.some((item) => item.title === "Migrate feature ideas"
+        && item.detail === "Move feature-ideas.md into mem_action_items."), true);
+    const inbox = db.prepare(`SELECT status FROM mem_inbox WHERE id = ?`).get(Number(inserted.lastInsertRowid));
+    assert.equal(inbox.status, "accepted");
+});
+test("runEndOfTaskMemoryHook accepts entity proposals with entity_kind into mem_entities", async () => {
+    const { dbModule, memoryModule, eotModule } = await loadModules("entity-accept");
+    const db = dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const listEntities = getFunction(memoryModule, "listEntities");
+    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse);
+    const inserted = db.prepare(`
+    INSERT INTO mem_inbox (scope_id, kind, payload, source_agent, source_task_id, status)
+    VALUES (?, 'memory_proposal', ?, 'coder', 'task-eot-entity', 'pending')
+  `).run(chapterhouse.id, JSON.stringify({
+        kind: "entity",
+        payload: {
+            name: "truenas",
+            entity_kind: "host",
+            summary: "NAS host used by Bellonda.",
+        },
+        confidence: 0.9,
+    }));
+    await runEndOfTaskMemoryHook({
+        taskId: "task-eot-entity",
+        finalResult: "Completed and proposed a durable host entity.",
+        copilotClient: {},
+        callLLM: async () => JSON.stringify({
+            decisions: [{
+                    proposal_id: Number(inserted.lastInsertRowid),
+                    decision: "accept",
+                    reason: "Durable entity.",
+                }],
+            implicit_memories: [],
+        }),
+    });
+    const entities = listEntities({ scope_id: chapterhouse.id, kind: "host" });
+    assert.equal(entities.some((entity) => entity.name === "truenas"
+        && entity.kind === "host"
+        && entity.summary === "NAS host used by Bellonda."), true);
+    const inbox = db.prepare(`SELECT status FROM mem_inbox WHERE id = ?`).get(Number(inserted.lastInsertRowid));
+    assert.equal(inbox.status, "accepted");
+});
 test("runEndOfTaskMemoryHook leaves reviewed proposals pending when CHAPTERHOUSE_MEMORY_AUTO_ACCEPT=0", async () => {
     process.env.CHAPTERHOUSE_MEMORY_AUTO_ACCEPT = "0";
     const { dbModule, memoryModule, eotModule } = await loadModules("pending");
@@ -185,7 +264,7 @@ test("runEndOfTaskMemoryHook leaves reviewed proposals pending when CHAPTERHOUSE
             implicit_memories: [],
         }),
     });
-    assert.equal(listObservations({ scope_id: chapterhouse.id }).length, 0);
+    assert.equal(listObservations({ scope_id: chapterhouse.id }).some((row) => row.content === "Review can approve this, but auto-accept is disabled."), false);
     const row = db.prepare(`SELECT status FROM mem_inbox WHERE id = ?`).get(Number(inserted.lastInsertRowid));
     assert.equal(row.status, "pending");
 });
@@ -214,7 +293,7 @@ test("runEndOfTaskMemoryHook rejects pending same-task proposals omitted by the
             implicit_memories: [],
         }),
     });
-    assert.equal(listObservations({ scope_id: chapterhouse.id }).length, 0);
+    assert.equal(listObservations({ scope_id: chapterhouse.id }).some((row) => row.content === "Reviewer omissions should not silently leave proposals pending."), false);
     const row = db.prepare(`
     SELECT status, resolution_reason
     FROM mem_inbox
@@ -260,4 +339,33 @@ test("runEndOfTaskMemoryHook can persist implicit extracted memories that were n
             auto_accept: true,
         }]);
 });
+test("runEndOfTaskMemoryHook accepts implicit entity memories with entity_kind", async () => {
+    const { memoryModule, eotModule } = await loadModules("implicit-entity");
+    const getScope = getFunction(memoryModule, "getScope");
+    const listEntities = getFunction(memoryModule, "listEntities");
+    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
+    await runEndOfTaskMemoryHook({
+        taskId: "task-eot-implicit-entity",
+        finalResult: "The subagent discovered a durable host entity while finishing the task.",
+        copilotClient: {},
+        callLLM: async () => JSON.stringify({
+            decisions: [],
+            implicit_memories: [{
+                    kind: "entity",
+                    scope_slug: "chapterhouse",
+                    payload: {
+                        name: "synology",
+                        entity_kind: "host",
+                        summary: "NAS host used by Bellonda.",
+                    },
+                }],
+        }),
+    });
+    const entities = listEntities({ scope_id: chapterhouse.id, kind: "host" });
+    assert.equal(entities.some((entity) => entity.name === "synology"
+        && entity.kind === "host"
+        && entity.summary === "NAS host used by Bellonda."), true);
+});
 //# sourceMappingURL=eot.test.js.map

package/dist/memory/hot-tier.js

@@ -2,6 +2,7 @@ import { getDb } from "../store/db.js";
 import { getActiveScope } from "./active-scope.js";
 import { getScope } from "./scopes.js";
 const HOT_TIER_LIMIT = 30;
+const HOT_TIER_ACTION_ITEM_LIMIT = 10;
 function toEntity(row) {
     return {
         id: row.id,
@@ -44,6 +45,27 @@ function toDecision(row) {
         createdAt: row.created_at,
     };
 }
+function toActionItem(row) {
+    return {
+        id: row.id,
+        scopeId: row.scope_id,
+        entityId: row.entity_id ?? undefined,
+        title: row.title,
+        detail: row.detail ?? undefined,
+        status: row.status,
+        dueAt: row.due_at ?? undefined,
+        snoozeUntil: row.snooze_until ?? undefined,
+        source: row.source ?? undefined,
+        tier: row.tier,
+        tierPinnedAt: row.tier_pinned_at ?? undefined,
+        tierReason: row.tier_reason ?? undefined,
+        lastRecalledAt: row.last_recalled_at ?? undefined,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        resolvedAt: row.resolved_at ?? undefined,
+        resolutionReason: row.resolution_reason ?? undefined,
+    };
+}
 function escapeXmlText(value) {
     return value
         .replaceAll("&", "&")
@@ -108,6 +130,27 @@ function loadHotDecisions(scopeId, options) {
   `).all(scopeId, options.includeSuperseded ? 1 : 0, options.includeArchived ? 1 : 0, HOT_TIER_LIMIT);
     return rows.map((row) => ({ ...toDecision(row), sortKey: row.decided_at }));
 }
+function loadOpenActionItems(scopeId) {
+    const rows = getDb().prepare(`
+    SELECT
+      id, scope_id, entity_id, title, detail, status, due_at, snooze_until, source,
+      created_at, updated_at, resolved_at, resolution_reason, tier, tier_pinned_at,
+      tier_reason, last_recalled_at
+    FROM mem_action_items
+    WHERE scope_id = ?
+      AND (
+        status = 'open'
+        OR (status = 'snoozed' AND snooze_until IS NOT NULL AND datetime(snooze_until) <= datetime('now'))
+      )
+    ORDER BY
+      CASE WHEN due_at IS NULL THEN 1 ELSE 0 END ASC,
+      datetime(due_at) ASC,
+      datetime(created_at) DESC,
+      id DESC
+    LIMIT ?
+  `).all(scopeId, HOT_TIER_ACTION_ITEM_LIMIT);
+    return rows.map(toActionItem);
+}
 export function getHotTierEntries(scope_id, options = {}) {
     const scope = getHotTierScope(scope_id);
     if (!scope) {
@@ -116,6 +159,7 @@ export function getHotTierEntries(scope_id, options = {}) {
             entities: [],
             observations: [],
             decisions: [],
+            actionItems: [],
         };
     }
     const merged = [
@@ -130,13 +174,17 @@ export function getHotTierEntries(scope_id, options = {}) {
         entities: merged.filter((entry) => entry.type === "entity"),
         observations: merged.filter((entry) => entry.type === "observation"),
         decisions: merged.filter((entry) => entry.type === "decision"),
+        actionItems: loadOpenActionItems(scope.id),
     };
 }
 export function renderHotTierXML(entries) {
     if (!entries.scope) {
         return "";
     }
-    if (entries.entities.length === 0 && entries.observations.length === 0 && entries.decisions.length === 0) {
+    if (entries.entities.length === 0
+        && entries.observations.length === 0
+        && entries.decisions.length === 0
+        && entries.actionItems.length === 0) {
         return "";
     }
     const observationsByEntity = new Map();
@@ -174,6 +222,17 @@ export function renderHotTierXML(entries) {
         const truncated = truncateObservation(observation.content);
         lines.push(`  <observation id="observation-${observation.id}" tier="${escapeXmlAttr(observation.tier)}" confidence="${observation.confidence}" created_at="${escapeXmlAttr(observation.createdAt)}"${truncated.truncated ? ` truncated="true"` : ""}>`, `    ${escapeXmlText(truncated.content)}`, "  </observation>");
     }
+    if (entries.actionItems.length > 0) {
+        lines.push("  <action_items>");
+        for (const item of entries.actionItems) {
+            lines.push(`    <action_item id="action-item-${item.id}" status="${escapeXmlAttr(item.status)}" created_at="${escapeXmlAttr(item.createdAt)}"${item.dueAt ? ` due_at="${escapeXmlAttr(item.dueAt)}"` : ""}>`, `      <title>${escapeXmlText(item.title)}</title>`);
+            if (item.detail) {
+                lines.push(`      <detail>${escapeXmlText(item.detail)}</detail>`);
+            }
+            lines.push("    </action_item>");
+        }
+        lines.push("  </action_items>");
+    }
     lines.push("</memory_context>");
     return `${lines.join("\n")}\n`;
 }

package/dist/memory/hot-tier.test.js

@@ -41,6 +41,7 @@ test("renderHotTierForActiveScope returns an empty string when no active scope i
         entities: [],
         observations: [],
         decisions: [],
+        actionItems: [],
     });
 });
 test("renderHotTierXML escapes content, merges recency across stores, and enforces the 30-entry cap", async () => {
@@ -130,6 +131,43 @@ test("active-scope hot-tier queries do not leak rows from other scopes", async (
     assert.match(xml, /Chapterhouse hot entry/);
     assert.doesNotMatch(xml, /Team-only hot entry/);
 });
+test("renderHotTierXML includes open active-scope action items in a bounded action_items block", async () => {
+    const { dbModule, memoryModule, hotTierModule } = await loadModules();
+    dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const recordActionItem = getFunction(memoryModule, "recordActionItem");
+    const chapterhouse = getScope("chapterhouse");
+    const team = getScope("team");
+    assert.ok(chapterhouse);
+    assert.ok(team);
+    const urgent = recordActionItem({
+        scope_id: chapterhouse.id,
+        title: "Migrate <feature ideas>",
+        detail: "Move feature-ideas.md into memory & keep source links.",
+        due_at: "2026-05-14T12:00:00.000Z",
+        source: "test",
+    });
+    recordActionItem({
+        scope_id: chapterhouse.id,
+        title: "Undated backlog item",
+        detail: "Should appear after dated items.",
+        source: "test",
+    });
+    recordActionItem({
+        scope_id: team.id,
+        title: "Other scope action",
+        source: "test",
+    });
+    const entries = hotTierModule.getHotTierEntries(chapterhouse.id);
+    const xml = hotTierModule.renderHotTierXML(entries);
+    assert.equal(entries.actionItems.length, 2);
+    assert.match(xml, /<action_items>/);
+    assert.match(xml, new RegExp(`<action_item[^>]*id="action-item-${urgent.id}"[^>]*status="open"`));
+    assert.match(xml, /<title>Migrate &lt;feature ideas&gt;<\/title>/);
+    assert.match(xml, /<detail>Move feature-ideas\.md into memory &amp; keep source links\.<\/detail>/);
+    assert.ok(xml.indexOf("Migrate &lt;feature ideas&gt;") < xml.indexOf("Undated backlog item"));
+    assert.doesNotMatch(xml, /Other scope action/);
+});
 test("hot-tier entries exclude superseded and archived observations and decisions by default with opt-in inclusion", async () => {
     const { dbModule, memoryModule, hotTierModule } = await loadModules();
     const db = dbModule.getDb();

package/dist/memory/housekeeping-scheduler.js

@@ -0,0 +1,152 @@
+import { childLogger } from "../util/logger.js";
+import { isHousekeepingInFlight, runHousekeeping } from "./housekeeping.js";
+export const DEFAULT_MEMORY_HOUSEKEEP_INTERVAL_MS = 21_600_000;
+export const DEFAULT_MEMORY_HOUSEKEEP_INITIAL_DELAY_MS = 300_000;
+function parseNonNegativeIntegerEnv(name, rawValue, defaultValue) {
+    const normalized = rawValue?.trim();
+    if (!normalized) {
+        return defaultValue;
+    }
+    const parsed = Number(normalized);
+    if (!Number.isInteger(parsed) || parsed < 0) {
+        throw new Error(`${name} must be a non-negative integer, got: "${rawValue}"`);
+    }
+    return parsed;
+}
+function toPassCounts(result) {
+    return Object.fromEntries(result.summaries.map((summary) => [
+        summary.pass,
+        {
+            examined: summary.examined,
+            modified: summary.modified,
+            errors: summary.errors,
+        },
+    ]));
+}
+export class MemoryHousekeepingScheduler {
+    env;
+    runHousekeepingImpl;
+    log;
+    setTimeoutImpl;
+    clearTimeoutImpl;
+    setIntervalImpl;
+    clearIntervalImpl;
+    timeoutHandle;
+    intervalHandle;
+    activeRun;
+    running = false;
+    started = false;
+    constructor(options = {}) {
+        this.env = options.env ?? process.env;
+        this.runHousekeepingImpl = options.runHousekeeping ?? runHousekeeping;
+        this.log = options.log ?? childLogger("memory.housekeeping.scheduler");
+        this.setTimeoutImpl = options.setTimeoutImpl ?? setTimeout;
+        this.clearTimeoutImpl = options.clearTimeoutImpl ?? ((handle) => clearTimeout(handle));
+        this.setIntervalImpl = options.setIntervalImpl ?? setInterval;
+        this.clearIntervalImpl = options.clearIntervalImpl ?? ((handle) => clearInterval(handle));
+    }
+    start() {
+        if (this.started) {
+            return;
+        }
+        const intervalMs = parseNonNegativeIntegerEnv("CHAPTERHOUSE_MEMORY_HOUSEKEEP_INTERVAL_MS", this.env.CHAPTERHOUSE_MEMORY_HOUSEKEEP_INTERVAL_MS, DEFAULT_MEMORY_HOUSEKEEP_INTERVAL_MS);
+        if (intervalMs === 0) {
+            this.log.info({ interval_ms: intervalMs }, "Memory housekeeping scheduler disabled");
+            return;
+        }
+        const initialDelayMs = parseNonNegativeIntegerEnv("CHAPTERHOUSE_MEMORY_HOUSEKEEP_INITIAL_DELAY_MS", this.env.CHAPTERHOUSE_MEMORY_HOUSEKEEP_INITIAL_DELAY_MS, DEFAULT_MEMORY_HOUSEKEEP_INITIAL_DELAY_MS);
+        this.started = true;
+        this.timeoutHandle = this.setTimeoutImpl(() => {
+            this.timeoutHandle = undefined;
+            this.startScheduledRun("initial_delay");
+            this.intervalHandle = this.setIntervalImpl(() => {
+                this.startScheduledRun("interval");
+            }, intervalMs);
+            this.intervalHandle?.unref?.();
+        }, initialDelayMs);
+        this.timeoutHandle?.unref?.();
+        this.log.info({ interval_ms: intervalMs, initial_delay_ms: initialDelayMs }, "Memory housekeeping scheduler started");
+    }
+    async stop() {
+        if (this.timeoutHandle) {
+            this.clearTimeoutImpl(this.timeoutHandle);
+            this.timeoutHandle = undefined;
+        }
+        if (this.intervalHandle) {
+            this.clearIntervalImpl(this.intervalHandle);
+            this.intervalHandle = undefined;
+        }
+        this.started = false;
+        await this.activeRun;
+    }
+    startScheduledRun(trigger) {
+        const run = this.runScheduledHousekeeping(trigger);
+        const tracked = run.finally(() => {
+            if (this.activeRun === tracked) {
+                this.activeRun = undefined;
+            }
+        });
+        this.activeRun = tracked;
+        void this.activeRun;
+    }
+    async runScheduledHousekeeping(trigger) {
+        if (this.running || isHousekeepingInFlight()) {
+            this.log.warn({ trigger }, "Memory housekeeping run skipped because a previous run is still active");
+            return;
+        }
+        this.running = true;
+        try {
+            const result = await this.runHousekeepingImpl({ allScopes: true });
+            if (isHousekeepingRunResult(result)) {
+                if (isContentionResult(result)) {
+                    this.log.warn({
+                        trigger,
+                        scope_ids: result.scopeIds,
+                        summaries: result.summaries,
+                    }, "Memory housekeeping run skipped because a previous run is still active");
+                    return;
+                }
+                this.log.info({
+                    trigger,
+                    scope_ids: result.scopeIds,
+                    summaries: result.summaries,
+                    pass_counts: toPassCounts(result),
+                    total_examined: result.totalExamined,
+                    total_modified: result.totalModified,
+                    duration_ms: result.durationMs,
+                }, "Memory housekeeping scheduled run complete");
+            }
+            else {
+                this.log.info({ trigger }, "Memory housekeeping scheduled run complete");
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (this.log.error) {
+                this.log.error({ trigger, err: message }, "Memory housekeeping scheduled run failed");
+            }
+            else {
+                this.log.warn({ trigger, err: message }, "Memory housekeeping scheduled run failed");
+            }
+        }
+        finally {
+            this.running = false;
+        }
+    }
+}
+function isContentionResult(result) {
+    return result.summaries.some((summary) => (summary.pass === "runHousekeeping"
+        && summary.errors.some((error) => /already in flight/i.test(error))));
+}
+function isHousekeepingRunResult(value) {
+    if (!value || typeof value !== "object") {
+        return false;
+    }
+    const candidate = value;
+    return Array.isArray(candidate.scopeIds)
+        && Array.isArray(candidate.summaries)
+        && typeof candidate.totalExamined === "number"
+        && typeof candidate.totalModified === "number"
+        && typeof candidate.durationMs === "number";
+}
+//# sourceMappingURL=housekeeping-scheduler.js.map

package/dist/memory/housekeeping-scheduler.test.js

@@ -0,0 +1,187 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+async function loadSchedulerModule() {
+    return await import(new URL(`./housekeeping-scheduler.js?cachebust=${Date.now()}-${Math.random()}`, import.meta.url).href);
+}
+function createTimers() {
+    let nextId = 1;
+    const timeouts = [];
+    const intervals = [];
+    return {
+        timeouts,
+        intervals,
+        setTimeoutImpl(callback, delayMs) {
+            const handle = { kind: "timeout", id: nextId++, unref() { } };
+            timeouts.push({ handle, callback, delayMs, cleared: false });
+            return handle;
+        },
+        clearTimeoutImpl(handle) {
+            const entry = timeouts.find((item) => item.handle === handle);
+            if (entry)
+                entry.cleared = true;
+        },
+        setIntervalImpl(callback, delayMs) {
+            const handle = { kind: "interval", id: nextId++, unref() { } };
+            intervals.push({ handle, callback, delayMs, cleared: false });
+            return handle;
+        },
+        clearIntervalImpl(handle) {
+            const entry = intervals.find((item) => item.handle === handle);
+            if (entry)
+                entry.cleared = true;
+        },
+    };
+}
+test("MemoryHousekeepingScheduler registers with the default 6h interval when env is unset", async () => {
+    const schedulerModule = await loadSchedulerModule();
+    const timers = createTimers();
+    const scheduler = new schedulerModule.MemoryHousekeepingScheduler({
+        env: {},
+        runHousekeeping: () => ({ scopeIds: [], summaries: [], totalExamined: 0, totalModified: 0, durationMs: 0 }),
+        setTimeoutImpl: timers.setTimeoutImpl,
+        clearTimeoutImpl: timers.clearTimeoutImpl,
+        setIntervalImpl: timers.setIntervalImpl,
+        clearIntervalImpl: timers.clearIntervalImpl,
+    });
+    scheduler.start();
+    timers.timeouts[0]?.callback();
+    assert.equal(schedulerModule.DEFAULT_MEMORY_HOUSEKEEP_INTERVAL_MS, 21_600_000);
+    assert.equal(timers.intervals.length, 1);
+    assert.equal(timers.intervals[0]?.delayMs, 21_600_000);
+});
+test("MemoryHousekeepingScheduler is disabled when CHAPTERHOUSE_MEMORY_HOUSEKEEP_INTERVAL_MS is 0", async () => {
+    const schedulerModule = await loadSchedulerModule();
+    const timers = createTimers();
+    let runs = 0;
+    const scheduler = new schedulerModule.MemoryHousekeepingScheduler({
+        env: { CHAPTERHOUSE_MEMORY_HOUSEKEEP_INTERVAL_MS: "0" },
+        runHousekeeping: () => {
+            runs += 1;
+        },
+        setTimeoutImpl: timers.setTimeoutImpl,
+        clearTimeoutImpl: timers.clearTimeoutImpl,
+        setIntervalImpl: timers.setIntervalImpl,
+        clearIntervalImpl: timers.clearIntervalImpl,
+    });
+    scheduler.start();
+    assert.equal(timers.timeouts.length, 0);
+    assert.equal(timers.intervals.length, 0);
+    assert.equal(runs, 0);
+});
+test("MemoryHousekeepingScheduler waits for the initial delay before the first run", async () => {
+    const schedulerModule = await loadSchedulerModule();
+    const timers = createTimers();
+    let runs = 0;
+    const scheduler = new schedulerModule.MemoryHousekeepingScheduler({
+        env: {},
+        runHousekeeping: () => {
+            runs += 1;
+        },
+        setTimeoutImpl: timers.setTimeoutImpl,
+        clearTimeoutImpl: timers.clearTimeoutImpl,
+        setIntervalImpl: timers.setIntervalImpl,
+        clearIntervalImpl: timers.clearIntervalImpl,
+    });
+    scheduler.start();
+    assert.equal(schedulerModule.DEFAULT_MEMORY_HOUSEKEEP_INITIAL_DELAY_MS, 300_000);
+    assert.equal(timers.timeouts.length, 1);
+    assert.equal(timers.timeouts[0]?.delayMs, 300_000);
+    assert.equal(runs, 0);
+    timers.timeouts[0]?.callback();
+    await Promise.resolve();
+    assert.equal(runs, 1);
+});
+test("MemoryHousekeepingScheduler does not overlap runs when an interval fires during an active run", async () => {
+    const schedulerModule = await loadSchedulerModule();
+    const timers = createTimers();
+    const warnings = [];
+    let runs = 0;
+    let releaseRun;
+    const scheduler = new schedulerModule.MemoryHousekeepingScheduler({
+        env: {
+            CHAPTERHOUSE_MEMORY_HOUSEKEEP_INITIAL_DELAY_MS: "1",
+            CHAPTERHOUSE_MEMORY_HOUSEKEEP_INTERVAL_MS: "2",
+        },
+        runHousekeeping: () => {
+            runs += 1;
+            return new Promise((resolve) => {
+                releaseRun = resolve;
+            });
+        },
+        log: {
+            info: () => { },
+            warn: (_obj, msg) => warnings.push(msg),
+        },
+        setTimeoutImpl: timers.setTimeoutImpl,
+        clearTimeoutImpl: timers.clearTimeoutImpl,
+        setIntervalImpl: timers.setIntervalImpl,
+        clearIntervalImpl: timers.clearIntervalImpl,
+    });
+    scheduler.start();
+    timers.timeouts[0]?.callback();
+    await Promise.resolve();
+    timers.intervals[0]?.callback();
+    await Promise.resolve();
+    assert.equal(runs, 1);
+    assert.ok(warnings.some((entry) => entry.includes("Memory housekeeping run skipped")));
+    releaseRun?.();
+    await Promise.resolve();
+    timers.intervals[0]?.callback();
+    await Promise.resolve();
+    assert.equal(runs, 2);
+});
+test("MemoryHousekeepingScheduler stop clears pending initial-delay and active interval timers", async () => {
+    const schedulerModule = await loadSchedulerModule();
+    const timers = createTimers();
+    const beforeInitialRun = new schedulerModule.MemoryHousekeepingScheduler({
+        env: {},
+        runHousekeeping: () => { },
+        setTimeoutImpl: timers.setTimeoutImpl,
+        clearTimeoutImpl: timers.clearTimeoutImpl,
+        setIntervalImpl: timers.setIntervalImpl,
+        clearIntervalImpl: timers.clearIntervalImpl,
+    });
+    beforeInitialRun.start();
+    await beforeInitialRun.stop();
+    assert.equal(timers.timeouts[0]?.cleared, true);
+    const afterInitialRun = new schedulerModule.MemoryHousekeepingScheduler({
+        env: {},
+        runHousekeeping: () => { },
+        setTimeoutImpl: timers.setTimeoutImpl,
+        clearTimeoutImpl: timers.clearTimeoutImpl,
+        setIntervalImpl: timers.setIntervalImpl,
+        clearIntervalImpl: timers.clearIntervalImpl,
+    });
+    afterInitialRun.start();
+    timers.timeouts[1]?.callback();
+    await afterInitialRun.stop();
+    assert.equal(timers.intervals[0]?.cleared, true);
+});
+test("MemoryHousekeepingScheduler stop waits for an in-flight run to finish without aborting it", async () => {
+    const schedulerModule = await loadSchedulerModule();
+    const timers = createTimers();
+    let releaseRun;
+    let stopResolved = false;
+    const scheduler = new schedulerModule.MemoryHousekeepingScheduler({
+        env: {},
+        runHousekeeping: () => new Promise((resolve) => {
+            releaseRun = resolve;
+        }),
+        setTimeoutImpl: timers.setTimeoutImpl,
+        clearTimeoutImpl: timers.clearTimeoutImpl,
+        setIntervalImpl: timers.setIntervalImpl,
+        clearIntervalImpl: timers.clearIntervalImpl,
+    });
+    scheduler.start();
+    timers.timeouts[0]?.callback();
+    await Promise.resolve();
+    const stopped = scheduler.stop().then(() => {
+        stopResolved = true;
+    });
+    await Promise.resolve();
+    assert.equal(stopResolved, false);
+    releaseRun?.();
+    await stopped;
+    assert.equal(stopResolved, true);
+});
+//# sourceMappingURL=housekeeping-scheduler.test.js.map