chapterhouse 0.5.0 → 0.5.2

package/dist/memory/eot.js

@@ -1,4 +1,5 @@
 import { config } from "../config.js";
+import { getAgent, loadAgents } from "../copilot/agents.js";
 import { runOneShotPrompt } from "../copilot/oneshot.js";
 import { childLogger } from "../util/logger.js";
 import { recordDecision } from "./decisions.js";
@@ -6,6 +7,7 @@ import { upsertEntity } from "./entities.js";
 import { listPendingMemoryProposalsForTask, resolveInboxItem } from "./inbox.js";
 import { recordObservation } from "./observations.js";
 import { recordActionItem } from "./action-items.js";
+import { getActiveScope } from "./active-scope.js";
 import { getScope } from "./scopes.js";
 const log = childLogger("memory.eot");
 function isEndOfTaskHookEnabled() {
@@ -119,7 +121,75 @@ function parseReviewerResponse(raw) {
             : [],
     };
 }
-function rememberAcceptedMemory(kind, scopeSlug, payload, source, confidence) {
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function isIsoTimestamp(value) {
+    return !Number.isNaN(Date.parse(value));
+}
+function validateActionItemPayload(payload) {
+    const actionItem = payload;
+    if (!isNonEmptyString(actionItem.title)) {
+        throw new Error("Action item proposal payload requires a non-empty title.");
+    }
+    if (actionItem.detail !== undefined && typeof actionItem.detail !== "string") {
+        throw new Error("Action item proposal payload detail must be a string.");
+    }
+    if (actionItem.due_at !== undefined && (typeof actionItem.due_at !== "string" || !isIsoTimestamp(actionItem.due_at))) {
+        throw new Error("Action item proposal payload due_at must be an ISO timestamp.");
+    }
+    if (actionItem.entity_id !== undefined && (!Number.isInteger(actionItem.entity_id) || actionItem.entity_id <= 0)) {
+        throw new Error("Action item proposal payload entity_id must be a positive integer.");
+    }
+    if (actionItem.entity_id !== undefined && actionItem.entity_name !== undefined) {
+        throw new Error("Action item proposal payload must provide either entity_id or entity_name/entity_kind, not both.");
+    }
+    const hasEntityName = actionItem.entity_name !== undefined;
+    const hasEntityKind = actionItem.entity_kind !== undefined;
+    if (hasEntityName !== hasEntityKind) {
+        throw new Error("Action item proposal payload entity_name and entity_kind must be provided together.");
+    }
+    if (hasEntityName && !isNonEmptyString(actionItem.entity_name)) {
+        throw new Error("Action item proposal payload entity_name must be non-empty when provided.");
+    }
+    if (hasEntityKind && !isNonEmptyString(actionItem.entity_kind)) {
+        throw new Error("Action item proposal payload entity_kind must be non-empty when provided.");
+    }
+    return {
+        title: actionItem.title.trim(),
+        detail: actionItem.detail,
+        due_at: actionItem.due_at,
+        source: actionItem.source,
+        entity_id: actionItem.entity_id,
+        entity_name: actionItem.entity_name?.trim(),
+        entity_kind: actionItem.entity_kind?.trim(),
+    };
+}
+function getBoundScopeSlug(sourceAgent) {
+    const agent = getAgent(sourceAgent);
+    return agent?.scope ?? loadAgents().find((entry) => entry.slug === sourceAgent)?.scope;
+}
+function resolveAcceptedProposalScopeSlug(envelope, proposal) {
+    if (isNonEmptyString(envelope.scope_slug)) {
+        return envelope.scope_slug.trim();
+    }
+    const boundScope = getBoundScopeSlug(proposal.sourceAgent);
+    if (boundScope) {
+        return boundScope;
+    }
+    const activeScope = getActiveScope();
+    if (activeScope) {
+        return activeScope.slug;
+    }
+    if (proposal.scopeId) {
+        const queuedScope = getScope(proposal.scopeId);
+        if (queuedScope) {
+            return queuedScope.slug;
+        }
+    }
+    throw new Error("No memory scope could be resolved for this proposal.");
+}
+function rememberAcceptedMemory(kind, scopeSlug, payload, source, confidence, sourceAgent) {
     const scope = getScope(scopeSlug);
     if (!scope) {
         throw new Error(`Unknown memory scope '${scopeSlug}'.`);
@@ -146,14 +216,22 @@ function rememberAcceptedMemory(kind, scopeSlug, payload, source, confidence) {
         return;
     }
     if (kind === "action_item") {
-        const actionItem = payload;
+        const actionItem = validateActionItemPayload(payload);
+        const entity = actionItem.entity_name && actionItem.entity_kind
+            ? upsertEntity({
+                scope_id: scope.id,
+                kind: actionItem.entity_kind,
+                name: actionItem.entity_name,
+                confidence,
+            })
+            : undefined;
         recordActionItem({
             scope_id: scope.id,
-            entity_id: actionItem.entity_id,
+            entity_id: entity?.id ?? actionItem.entity_id,
             title: actionItem.title,
             detail: actionItem.detail,
             due_at: actionItem.due_at,
-            source: actionItem.source ?? source,
+            source: sourceAgent ? `subagent_proposal:${sourceAgent}` : actionItem.source ?? source,
         });
         return;
     }
@@ -209,11 +287,21 @@ export async function runEndOfTaskMemoryHook(input) {
         }
         reviewedProposalIds.add(proposal.id);
         if (decision.decision === "accept") {
-            summary.accepted++;
-            if (autoAcceptEnabled) {
+            if (!autoAcceptEnabled) {
+                summary.accepted++;
+            }
+            else {
                 const envelope = parseEnvelope(proposal.payload);
-                rememberAcceptedMemory(envelope.kind, envelope.scope_slug ?? getScope(proposal.scopeId).slug, envelope.payload, `agent:${proposal.sourceAgent}`, envelope.confidence);
-                resolveInboxItem(proposal.id, "accepted", decision.reason);
+                try {
+                    rememberAcceptedMemory(envelope.kind, resolveAcceptedProposalScopeSlug(envelope, proposal), envelope.payload, `agent:${proposal.sourceAgent}`, envelope.confidence, proposal.sourceAgent);
+                    resolveInboxItem(proposal.id, "accepted", decision.reason);
+                    summary.accepted++;
+                }
+                catch (err) {
+                    const reason = err instanceof Error ? err.message : String(err);
+                    resolveInboxItem(proposal.id, "rejected", reason);
+                    summary.rejected++;
+                }
             }
             continue;
         }

package/dist/memory/eot.test.js

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { mkdirSync, rmSync } from "node:fs";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import test from "node:test";
 const repoRoot = process.cwd();
@@ -15,7 +15,8 @@ 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 eotModule = await import(new URL(`./eot.js?case=${cacheBust}`, import.meta.url).href);
-    return { dbModule, memoryModule, eotModule };
+    const agentsModule = await import(new URL(`../copilot/agents.js?case=${cacheBust}`, import.meta.url).href);
+    return { dbModule, memoryModule, eotModule, agentsModule };
 }
 function getFunction(module, name) {
     const value = module[name];
@@ -171,7 +172,6 @@ test("runEndOfTaskMemoryHook accepts action_item proposals into mem_action_items
         payload: {
             title: "Migrate feature ideas",
             detail: "Move feature-ideas.md into mem_action_items.",
-            source: "subagent_proposal",
         },
         confidence: 0.9,
     }));
@@ -189,11 +189,192 @@ test("runEndOfTaskMemoryHook accepts action_item proposals into mem_action_items
         }),
     });
     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 actionItem = actionItems.find((item) => item.title === "Migrate feature ideas");
+    assert.ok(actionItem);
+    assert.equal(actionItem.detail, "Move feature-ideas.md into mem_action_items.");
+    assert.equal(actionItem.status, "open");
+    assert.equal(actionItem.source, "subagent_proposal:coder");
     const inbox = db.prepare(`SELECT status FROM mem_inbox WHERE id = ?`).get(Number(inserted.lastInsertRowid));
     assert.equal(inbox.status, "accepted");
 });
+test("runEndOfTaskMemoryHook rejects invalid action_item proposals with a clear reason", async () => {
+    const { dbModule, memoryModule, eotModule } = await loadModules("action-item-invalid");
+    const db = dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const createScope = getFunction(memoryModule, "createScope");
+    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-invalid', 'pending')
+  `).run(chapterhouse.id, JSON.stringify({
+        kind: "action_item",
+        payload: {
+            detail: "A title is required before this can become an action item.",
+        },
+        confidence: 0.9,
+    }));
+    await runEndOfTaskMemoryHook({
+        taskId: "task-eot-action-item-invalid",
+        finalResult: "Completed and proposed a malformed follow-up.",
+        copilotClient: {},
+        callLLM: async () => JSON.stringify({
+            decisions: [{
+                    proposal_id: Number(inserted.lastInsertRowid),
+                    decision: "accept",
+                    reason: "Concrete follow-up.",
+                }],
+            implicit_memories: [],
+        }),
+    });
+    assert.deepEqual(listActionItems({ scope_id: chapterhouse.id }), []);
+    const inbox = db.prepare(`
+    SELECT status, resolution_reason, resolved_at
+    FROM mem_inbox
+    WHERE id = ?
+  `).get(Number(inserted.lastInsertRowid));
+    assert.equal(inbox.status, "rejected");
+    assert.match(inbox.resolution_reason ?? "", /title/i);
+    assert.ok(inbox.resolved_at);
+});
+test("runEndOfTaskMemoryHook rejects action_item proposals with ambiguous entity references", async () => {
+    const { dbModule, memoryModule, eotModule } = await loadModules("action-item-ambiguous-entity");
+    const db = dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const createScope = getFunction(memoryModule, "createScope");
+    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-ambiguous-entity', 'pending')
+  `).run(chapterhouse.id, JSON.stringify({
+        kind: "action_item",
+        payload: {
+            title: "Resolve ambiguous entity link",
+            entity_id: 1,
+            entity_name: "Bellonda",
+            entity_kind: "agent",
+        },
+        confidence: 0.9,
+    }));
+    await runEndOfTaskMemoryHook({
+        taskId: "task-eot-action-item-ambiguous-entity",
+        finalResult: "Completed and proposed an ambiguous follow-up.",
+        copilotClient: {},
+        callLLM: async () => JSON.stringify({
+            decisions: [{
+                    proposal_id: Number(inserted.lastInsertRowid),
+                    decision: "accept",
+                    reason: "Concrete follow-up.",
+                }],
+            implicit_memories: [],
+        }),
+    });
+    assert.deepEqual(listActionItems({ scope_id: chapterhouse.id }), []);
+    const inbox = db.prepare(`
+    SELECT status, resolution_reason
+    FROM mem_inbox
+    WHERE id = ?
+  `).get(Number(inserted.lastInsertRowid));
+    assert.equal(inbox.status, "rejected");
+    assert.match(inbox.resolution_reason ?? "", /entity_id.*entity_name|entity_name.*entity_id/i);
+});
+test("runEndOfTaskMemoryHook falls back to the source agent bound scope for action_item proposals without scope_slug", async () => {
+    const home = process.env.CHAPTERHOUSE_HOME;
+    assert.ok(home, "test home should be set");
+    const { AGENTS_DIR: agentsDir } = await import("../paths.js");
+    mkdirSync(agentsDir, { recursive: true });
+    writeFileSync(join(agentsDir, "bellonda.agent.md"), [
+        "---",
+        "name: Bellonda",
+        "description: Mentat of the infrastructure domain",
+        "model: claude-sonnet-4.6",
+        "persistent: true",
+        "scope: infra",
+        "---",
+        "",
+        "You are Bellonda.",
+    ].join("\n"));
+    const { dbModule, memoryModule, eotModule, agentsModule } = await loadModules("action-item-bound-scope");
+    agentsModule.loadAgents();
+    const db = dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const createScope = getFunction(memoryModule, "createScope");
+    const listActionItems = getFunction(memoryModule, "listActionItems");
+    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
+    const chapterhouse = getScope("chapterhouse");
+    const infra = createScope({
+        slug: "infra",
+        title: "Infra",
+        description: "Infra test scope",
+        keywords: ["infra"],
+    });
+    assert.ok(chapterhouse);
+    const inserted = db.prepare(`
+    INSERT INTO mem_inbox (scope_id, kind, payload, source_agent, source_task_id, status)
+    VALUES (?, 'memory_proposal', ?, 'bellonda', 'task-eot-action-item-bound-scope', 'pending')
+  `).run(chapterhouse.id, JSON.stringify({
+        kind: "action_item",
+        payload: {
+            title: "Review NAS disk alerts",
+        },
+        confidence: 0.9,
+    }));
+    await runEndOfTaskMemoryHook({
+        taskId: "task-eot-action-item-bound-scope",
+        finalResult: "Bellonda proposed an infra follow-up.",
+        copilotClient: {},
+        callLLM: async () => JSON.stringify({
+            decisions: [{
+                    proposal_id: Number(inserted.lastInsertRowid),
+                    decision: "accept",
+                    reason: "Concrete infra follow-up.",
+                }],
+            implicit_memories: [],
+        }),
+    });
+    assert.equal(listActionItems({ scope_id: infra.id }).some((item) => item.title === "Review NAS disk alerts"), true);
+    assert.equal(listActionItems({ scope_id: chapterhouse.id }).some((item) => item.title === "Review NAS disk alerts"), false);
+});
+test("runEndOfTaskMemoryHook still accepts observation, decision, and entity proposals", async () => {
+    const { dbModule, memoryModule, eotModule } = await loadModules("existing-proposal-kinds");
+    const db = dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const listObservations = getFunction(memoryModule, "listObservations");
+    const listDecisions = getFunction(memoryModule, "listDecisions");
+    const listEntities = getFunction(memoryModule, "listEntities");
+    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse);
+    const proposals = [
+        { kind: "observation", payload: { content: "Existing observation proposals still persist." } },
+        { kind: "decision", payload: { title: "Keep auto-accept", rationale: "It is required for EOT memory promotion." } },
+        { kind: "entity", payload: { name: "Bellonda", entity_kind: "agent", summary: "Infrastructure mentat." } },
+    ].map((envelope) => db.prepare(`
+    INSERT INTO mem_inbox (scope_id, kind, payload, source_agent, source_task_id, status)
+    VALUES (?, 'memory_proposal', ?, 'coder', 'task-eot-existing-kinds', 'pending')
+  `).run(chapterhouse.id, JSON.stringify(envelope)));
+    await runEndOfTaskMemoryHook({
+        taskId: "task-eot-existing-kinds",
+        finalResult: "Completed with several proposal kinds.",
+        copilotClient: {},
+        callLLM: async () => JSON.stringify({
+            decisions: proposals.map((proposal) => ({
+                proposal_id: Number(proposal.lastInsertRowid),
+                decision: "accept",
+                reason: "Valid durable memory.",
+            })),
+            implicit_memories: [],
+        }),
+    });
+    assert.equal(listObservations({ scope_id: chapterhouse.id }).some((row) => row.content === "Existing observation proposals still persist."), true);
+    assert.equal(listDecisions({ scope_id: chapterhouse.id }).some((row) => row.title === "Keep auto-accept" && row.rationale === "It is required for EOT memory promotion."), true);
+    assert.equal(listEntities({ scope_id: chapterhouse.id, kind: "agent" }).some((row) => row.name === "Bellonda"), true);
+});
 test("runEndOfTaskMemoryHook accepts entity proposals with entity_kind into mem_entities", async () => {
     const { dbModule, memoryModule, eotModule } = await loadModules("entity-accept");
     const db = dbModule.getDb();

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

@@ -108,12 +108,17 @@ test("active-scope hot-tier queries do not leak rows from other scopes", async (
     const { dbModule, memoryModule, hotTierModule } = await loadModules();
     dbModule.getDb();
     const getScope = getFunction(memoryModule, "getScope");
+    const createScope = getFunction(memoryModule, "createScope");
     const setActiveScope = getFunction(memoryModule, "setActiveScope");
     const recordObservation = getFunction(memoryModule, "recordObservation");
     const chapterhouse = getScope("chapterhouse");
-    const team = getScope("team");
+    const team = createScope({
+        slug: "team",
+        title: "Team",
+        description: "Team test scope",
+        keywords: ["team"],
+    });
     assert.ok(chapterhouse);
-    assert.ok(team);
     recordObservation({
         scope_id: chapterhouse.id,
         content: "Chapterhouse hot entry",
@@ -135,11 +140,16 @@ test("renderHotTierXML includes open active-scope action items in a bounded acti
     const { dbModule, memoryModule, hotTierModule } = await loadModules();
     dbModule.getDb();
     const getScope = getFunction(memoryModule, "getScope");
+    const createScope = getFunction(memoryModule, "createScope");
     const recordActionItem = getFunction(memoryModule, "recordActionItem");
     const chapterhouse = getScope("chapterhouse");
-    const team = getScope("team");
+    const team = createScope({
+        slug: "team",
+        title: "Team",
+        description: "Team test scope",
+        keywords: ["team"],
+    });
     assert.ok(chapterhouse);
-    assert.ok(team);
     const urgent = recordActionItem({
         scope_id: chapterhouse.id,
         title: "Migrate <feature ideas>",

package/dist/memory/housekeeping.js

@@ -8,7 +8,8 @@ import { tieringPass } from "./tiering.js";
 export { tieringPass };
 const log = childLogger("memory.housekeeping");
 const SIMILARITY_THRESHOLD = 0.8;
-const inFlightKeys = new Set();
+const GLOBAL_PASS_SCOPE = Symbol("global-housekeeping-pass-scope");
+const inFlightScopesByPass = new Map();
 const PASS_ORDER = [
     "dedup_observations",
     "dedup_decisions",
@@ -280,38 +281,91 @@ function resolveScopeIds(input) {
     const activeScope = getActiveScope();
     return activeScope ? [activeScope.id] : [];
 }
-function runPass(pass, scopeId) {
+function getInFlightScopes(pass) {
+    let scopes = inFlightScopesByPass.get(pass);
+    if (!scopes) {
+        scopes = new Set();
+        inFlightScopesByPass.set(pass, scopes);
+    }
+    return scopes;
+}
+function getReservedPassScopes(scopeIds, passes) {
+    const reserved = [];
+    for (const pass of passes) {
+        if (pass === "compact_inbox") {
+            reserved.push({ pass, scope: GLOBAL_PASS_SCOPE });
+            continue;
+        }
+        for (const scopeId of scopeIds) {
+            reserved.push({ pass, scope: scopeId });
+        }
+    }
+    return reserved;
+}
+function reservePassScopes(reserved) {
+    if (reserved.some(({ pass, scope }) => getInFlightScopes(pass).has(scope))) {
+        return false;
+    }
+    for (const { pass, scope } of reserved) {
+        getInFlightScopes(pass).add(scope);
+    }
+    return true;
+}
+function releasePassScopes(reserved) {
+    for (const { pass, scope } of reserved) {
+        const scopes = inFlightScopesByPass.get(pass);
+        scopes?.delete(scope);
+        if (scopes && scopes.size === 0) {
+            inFlightScopesByPass.delete(pass);
+        }
+    }
+}
+async function runPass(pass, scopeId) {
     switch (pass) {
         case "dedup_observations":
-            return dedupObservationsPass(scopeId);
+            return await Promise.resolve(dedupObservationsPass(scopeId));
         case "dedup_decisions":
-            return dedupDecisionsPass(scopeId);
+            return await Promise.resolve(dedupDecisionsPass(scopeId));
         case "orphan_cleanup":
-            return orphanCleanupPass(scopeId);
+            return await Promise.resolve(orphanCleanupPass(scopeId));
         case "decay":
-            return decayPass(scopeId);
+            return await Promise.resolve(decayPass(scopeId));
         case "compact_inbox":
-            return compactInboxPass();
+            return await Promise.resolve(compactInboxPass());
         case "tiering":
-            return tieringPass(scopeId);
+            return await Promise.resolve(tieringPass(scopeId));
     }
 }
-function inFlightKey(scopeIds, passes) {
-    return `${scopeIds.join(",") || "none"}:${passes.join(",")}`;
+async function runScopePasses(scopeId, passes) {
+    const summaries = [];
+    for (const pass of passes) {
+        summaries.push(await runPass(pass, scopeId));
+    }
+    return summaries;
 }
 export function isHousekeepingInFlight(scopeIds, passes) {
+    const normalizedPasses = passes?.map(normalizePassName) ?? PASS_ORDER;
     if (!scopeIds || scopeIds.length === 0) {
-        return inFlightKeys.size > 0;
+        return normalizedPasses.some((pass) => (inFlightScopesByPass.get(pass)?.size ?? 0) > 0);
     }
-    const normalizedPasses = passes?.map(normalizePassName) ?? PASS_ORDER;
-    return inFlightKeys.has(inFlightKey([...new Set(scopeIds)].sort((a, b) => a - b), normalizedPasses));
+    const uniqueScopeIds = [...new Set(scopeIds)].sort((a, b) => a - b);
+    return normalizedPasses.some((pass) => {
+        const scopes = inFlightScopesByPass.get(pass);
+        if (!scopes) {
+            return false;
+        }
+        if (pass === "compact_inbox") {
+            return scopes.has(GLOBAL_PASS_SCOPE);
+        }
+        return uniqueScopeIds.some((scopeId) => scopes.has(scopeId));
+    });
 }
-export function runHousekeeping(opts = {}) {
+export async 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)) {
+    const reservedPassScopes = getReservedPassScopes(scopeIds, passes);
+    if (!reservePassScopes(reservedPassScopes)) {
         return {
             scopeIds,
             summaries: [passSummary("runHousekeeping", 0, 0, ["Housekeeping is already in flight for this scope/pass set."])],
@@ -320,18 +374,12 @@ export function runHousekeeping(opts = {}) {
             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));
-            }
-        }
+        const summaries = (await Promise.all(scopeIds.map((scopeId) => runScopePasses(scopeId, scopedPasses)))).flat();
         if (hasCompactInbox) {
-            summaries.push(compactInboxPass());
+            summaries.push(await runPass("compact_inbox", undefined));
         }
         const totalExamined = summaries.reduce((sum, summary) => sum + summary.examined, 0);
         const totalModified = summaries.reduce((sum, summary) => sum + summary.modified, 0);
@@ -346,7 +394,7 @@ export function runHousekeeping(opts = {}) {
         return { scopeIds, summaries, totalExamined, totalModified, durationMs };
     }
     finally {
-        inFlightKeys.delete(key);
+        releasePassScopes(reservedPassScopes);
     }
 }
 //# sourceMappingURL=housekeeping.js.map