chapterhouse 0.5.1 → 0.6.0

package/dist/copilot/tools.js

@@ -6,6 +6,7 @@ import { join } from "path";
 import { homedir } from "os";
 import { listSkills, createSkill, removeSkill } from "./skills.js";
 import { config, persistModel } from "../config.js";
+import { ModeContext } from "../mode-context.js";
 import { agentEventBus } from "./agent-event-bus.js";
 import { getCurrentSourceChannel, getCurrentActivityCallback, getCurrentActiveProjectRules, getCurrentAuthenticatedUser, getLastAuthenticatedUser, getCurrentAuthorizationHeader, getCurrentSessionKey, sendToAgentSession, invalidateOrchestratorSession, maybeScheduleScopeChangeCheckpoint, resetCheckpointSessionState, switchSessionModel, } from "./orchestrator.js";
 import { getRouterConfig, updateRouterConfig } from "./router.js";
@@ -31,6 +32,7 @@ import { OKRMapper, parseOKRPageContent } from "./okr-mapper.js";
 import { childLogger } from "../util/logger.js";
 import { getActiveScope as getMemoryActiveScope, createScope as createMemoryScope, getScope as getMemoryScope, inferScopeFromText, completeActionItem, demoteToCold, demoteToWarm, dropActionItem, queueMemoryProposal, recall as recallMemory, listActionItems, recordDecision, recordActionItem, recordObservation, runHousekeeping, setActiveScope as setMemoryActiveScope, snoozeActionItem, promoteToHot, upsertEntity, } from "../memory/index.js";
 const log = childLogger("tools");
+const modeContext = new ModeContext(config);
 /** Escape a string for safe inclusion as a single-line YAML scalar value. */
 function yamlEscape(value) {
     // Always quote and escape backslashes, double quotes, and newlines.
@@ -51,6 +53,21 @@ function yamlListItem(value) {
 function indexSafe(text) {
     return text.replace(/[\r\n|]/g, " ").trim();
 }
+function sanitizeWikiUpdateError(err) {
+    if (err instanceof z.ZodError) {
+        return err.issues.map((issue) => issue.message).join("; ") || "Invalid wiki_update arguments.";
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    if (message.startsWith("Wiki page frontmatter violates the required shape:")
+        || message.startsWith("Wiki path")
+        || message.startsWith("Wiki page paths must end in .md:")
+        || message.startsWith("Refused unsafe wiki path:")
+        || message.startsWith("Refused: only pages under pages/")
+        || message === "Wiki path is required") {
+        return message;
+    }
+    return "Wiki update failed. Check the page path and frontmatter, then try again.";
+}
 function isTimeoutError(err) {
     const msg = err instanceof Error ? err.message : String(err);
     return /timeout|timed?\s*out/i.test(msg);
@@ -187,6 +204,13 @@ const memoryProposeArgsSchema = z.object({
     }
 });
 const memoryTierTableSchema = z.enum(["observation", "decision", "entity", "action_item"]);
+const wikiUpdateArgsSchema = z.object({
+    path: z.string().describe("Page path relative to wiki root (e.g. 'pages/projects/chapterhouse/index.md', 'pages/projects/chapterhouse/decisions.md', 'pages/people/brian/index.md')"),
+    title: z.string().describe("Page title for the index"),
+    summary: z.string().describe("One-line summary for the index"),
+    section: z.string().optional().describe("Index section (default: 'Knowledge')"),
+    content: z.string().describe("Full page content (markdown)"),
+});
 function getCurrentQuarter(now = new Date()) {
     return `${now.getUTCFullYear()}-Q${Math.floor(now.getUTCMonth() / 3) + 1}`;
 }
@@ -536,7 +560,7 @@ export function createTools(deps) {
                 notes: z.string().optional().describe("Optional notes about the work"),
             }),
             handler: async (args) => {
-                if (config.chapterhouseMode !== "personal") {
+                if (!modeContext.canLogToAdo()) {
                     return "OKR progress logging is only available from personal Chapterhouse instances.";
                 }
                 const mapper = createOKRMapper();
@@ -1246,7 +1270,7 @@ export function createTools(deps) {
                     if (args.scope_slug && !requestedScope) {
                         return `Unknown memory scope '${args.scope_slug}'.`;
                     }
-                    const result = runHousekeeping({
+                    const result = await runHousekeeping({
                         scopeIds: requestedScope ? [requestedScope.id] : undefined,
                         allScopes: args.all_scopes,
                         passes: args.passes,
@@ -1659,46 +1683,48 @@ export function createTools(deps) {
                 "topic overview or a facet name (e.g. 'decisions', 'feature-ideas') — exactly one topic level, " +
                 "lowercase slugs only. Flat-category pages MUST be 'pages/<category>.md' (preferences, facts, " +
                 "routines, decisions). Bad paths are rejected with a suggested correction.",
-            parameters: z.object({
-                path: z.string().describe("Page path relative to wiki root (e.g. 'pages/projects/chapterhouse/index.md', 'pages/projects/chapterhouse/decisions.md', 'pages/people/brian/index.md')"),
-                title: z.string().describe("Page title for the index"),
-                summary: z.string().describe("One-line summary for the index"),
-                section: z.string().optional().describe("Index section (default: 'Knowledge')"),
-                content: z.string().describe("Full page content (markdown)"),
-            }),
+            parameters: wikiUpdateArgsSchema,
             handler: async (args) => {
-                return withWikiWrite(async () => {
-                    ensureWikiStructure();
-                    assertPagePath(args.path);
-                    const validation = validateWikiFrontmatter(args.content, {
-                        allowedTags: loadTaxonomy(),
-                    });
-                    if (!validation.valid) {
-                        throw new Error(validation.errors.map((error) => error.message).join("\n\n"));
-                    }
-                    writePage(args.path, args.content);
-                    // Rebuild from disk so the index summary/tags/updated reflect the actual page.
-                    const today = new Date().toISOString().slice(0, 10);
-                    const rebuilt = buildIndexEntryForPage(args.path, {
-                        section: args.section || "Knowledge",
-                        updated: today,
-                    });
-                    if (rebuilt) {
-                        rebuilt.section = args.section || "Knowledge";
-                        addToIndex(rebuilt);
-                    }
-                    else {
-                        addToIndex({
-                            path: args.path,
-                            title: args.title,
-                            summary: indexSafe(args.summary).slice(0, 160),
-                            section: args.section || "Knowledge",
+                try {
+                    const parsedArgs = wikiUpdateArgsSchema.parse(args);
+                    return await withWikiWrite(async () => {
+                        ensureWikiStructure();
+                        assertPagePath(parsedArgs.path);
+                        const validation = validateWikiFrontmatter(parsedArgs.content, {
+                            allowedTags: loadTaxonomy(),
+                        });
+                        if (!validation.valid) {
+                            throw new Error(validation.errors.map((error) => error.message).join("\n\n"));
+                        }
+                        writePage(parsedArgs.path, parsedArgs.content);
+                        // Rebuild from disk so the index summary/tags/updated reflect the actual page.
+                        const today = new Date().toISOString().slice(0, 10);
+                        const rebuilt = buildIndexEntryForPage(parsedArgs.path, {
+                            section: parsedArgs.section || "Knowledge",
                             updated: today,
                         });
-                    }
-                    appendLog("update", `wiki_update: ${indexSafe(args.title)} (${args.path})`);
-                    return `Wiki page updated: ${args.title} (${args.path})`;
-                });
+                        if (rebuilt) {
+                            rebuilt.section = parsedArgs.section || "Knowledge";
+                            addToIndex(rebuilt);
+                        }
+                        else {
+                            addToIndex({
+                                path: parsedArgs.path,
+                                title: parsedArgs.title,
+                                summary: indexSafe(parsedArgs.summary).slice(0, 160),
+                                section: parsedArgs.section || "Knowledge",
+                                updated: today,
+                            });
+                        }
+                        appendLog("update", `wiki_update: ${indexSafe(parsedArgs.title)} (${parsedArgs.path})`);
+                        return `Wiki page updated: ${parsedArgs.title} (${parsedArgs.path})`;
+                    });
+                }
+                catch (err) {
+                    const error = sanitizeWikiUpdateError(err);
+                    log.error({ err: err instanceof Error ? err.message : err, path: typeof args?.path === "string" ? args.path : undefined }, "wiki_update failed");
+                    return { error };
+                }
             },
         }),
         defineTool("wiki_ingest", {

package/dist/copilot/tools.wiki.test.js

@@ -23,7 +23,7 @@ test.afterEach(async () => {
         rmSync(home, { recursive: true, force: true });
     }
 });
-test("wiki_update rejects content without required frontmatter", async () => {
+test("wiki_update returns validation errors instead of throwing for invalid frontmatter", async () => {
     const toolsModule = await loadToolsModule();
     const tools = toolsModule.createTools({
         client: { async listModels() { return []; } },
@@ -31,14 +31,19 @@ test("wiki_update rejects content without required frontmatter", async () => {
     });
     const tool = tools.find((entry) => entry.name === "wiki_update");
     assert.ok(tool);
-    await assert.rejects(tool.handler({
+    const result = await tool.handler({
         path: "pages/shared/chapterhouse.md",
         title: "Chapterhouse",
         summary: "Runtime notes",
         content: "# Chapterhouse\n\nRuntime notes.\n",
-    }), /Wiki page frontmatter violates the required shape/i);
+    });
+    assert.deepEqual(result, {
+        error: "Wiki page frontmatter violates the required shape: missing YAML frontmatter. Use:\n---\ntitle: <title>\nsummary: <plain-text one-line summary, max 200 chars>\nupdated: YYYY-MM-DD\ntags: []\nrelated: []\n---",
+    });
+    const wikiFs = await readWikiArtifacts();
+    assert.equal(wikiFs.readPage("pages/shared/chapterhouse.md"), undefined);
 });
-test("wiki_update rejects malformed summaries and unknown tags", async () => {
+test("wiki_update returns descriptive validation errors for malformed summaries and unknown tags", async () => {
     const toolsModule = await loadToolsModule();
     const tools = toolsModule.createTools({
         client: { async listModels() { return []; } },
@@ -46,7 +51,7 @@ test("wiki_update rejects malformed summaries and unknown tags", async () => {
     });
     const tool = tools.find((entry) => entry.name === "wiki_update");
     assert.ok(tool);
-    await assert.rejects(tool.handler({
+    const result = await tool.handler({
         path: "pages/shared/chapterhouse.md",
         title: "Chapterhouse",
         summary: "Runtime notes",
@@ -60,7 +65,11 @@ tags: [engineering, made-up-tag]
 
 Runtime notes.
 `,
-    }), /Add it to `pages\/_meta\/taxonomy\.md` first\./);
+    });
+    assert.equal(typeof result, "object");
+    assert.match(result.error, /invalid 'summary'/i);
+    assert.match(result.error, /unknown tag 'made-up-tag'/i);
+    assert.match(result.error, /pages\/_meta\/taxonomy\.md/);
 });
 test("wiki_update accepts valid frontmatter and refreshes the index entry", async () => {
     const toolsModule = await loadToolsModule();

package/dist/daemon.js

@@ -4,6 +4,7 @@ import { stopEpisodeWriter } from "./copilot/episode-writer.js";
 import { startApiServer, broadcastToSSE } from "./api/server.js";
 import { getDb, closeDb, getState } from "./store/db.js";
 import { config } from "./config.js";
+import { ModeContext } from "./mode-context.js";
 import { spawn } from "child_process";
 import { readdirSync, statSync, rmSync } from "fs";
 import { join } from "path";
@@ -21,6 +22,7 @@ import { CHAPTERHOUSE_VERSION } from "./version.js";
 import { isWorkiqAutoInstallEnabled, ensureWorkiqMcpEntry } from "./copilot/workiq-installer.js";
 import { MemoryHousekeepingScheduler } from "./memory/housekeeping-scheduler.js";
 const log = logger.child({ module: "daemon" });
+const modeContext = new ModeContext(config);
 let memoryHousekeepingScheduler;
 const SEVEN_DAYS_MS = 7 * 24 * 60 * 60 * 1000;
 /**
@@ -86,6 +88,9 @@ async function main() {
     if (config.selfEditEnabled) {
         log.warn("Self-edit mode enabled — Chapterhouse can modify his own source code");
     }
+    for (const warning of config.modeCompatibilityWarnings) {
+        log.warn({ mode: config.chapterhouseMode }, warning);
+    }
     // Set up message logging to daemon console
     setMessageLogger((direction, source, text) => {
         const arrow = direction === "in" ? "⟶" : "⟵";
@@ -100,7 +105,7 @@ async function main() {
     if (wikiIsNew) {
         log.info("Created wiki");
     }
-    if (config.chapterhouseMode === "team") {
+    if (modeContext.isTeam()) {
         const seed = seedTeamWiki();
         if (seed.created.length > 0) {
             log.info({ pages: seed.created }, "Seeded team wiki pages");
@@ -153,7 +158,7 @@ async function main() {
     await startApiServer();
     memoryHousekeepingScheduler = new MemoryHousekeepingScheduler();
     memoryHousekeepingScheduler.start();
-    if (config.chapterhouseMode === "personal" && (config.adoPat || config.teamChapterhouseUrl)) {
+    if (modeContext.canLogToAdo() && (config.adoPat || config.teamChapterhouseUrl)) {
         new StandupScheduler().schedule();
     }
     const url = `http://${getDisplayHost(config.apiHost)}:${config.apiPort}`;

package/dist/integrations/team-push.js

@@ -1,4 +1,5 @@
 import { config } from "../config.js";
+import { ModeContext } from "../mode-context.js";
 export class TeamPushClient {
     teamChapterhouseUrl;
     teamChapterhouseToken;
@@ -6,6 +7,7 @@ export class TeamPushClient {
     fetchImpl;
     getAuthorizationHeader;
     getCurrentUser;
+    modeContext;
     constructor(options = {}) {
         this.teamChapterhouseUrl = (options.teamChapterhouseUrl ?? config.teamChapterhouseUrl).trim().replace(/\/+$/, "");
         this.teamChapterhouseToken = (options.teamChapterhouseToken ?? config.teamChapterhouseToken).trim();
@@ -13,6 +15,11 @@ export class TeamPushClient {
         this.fetchImpl = options.fetchImpl ?? fetch;
         this.getAuthorizationHeader = options.getAuthorizationHeader;
         this.getCurrentUser = options.getCurrentUser;
+        this.modeContext = new ModeContext({
+            ...config,
+            teamChapterhouseUrl: this.teamChapterhouseUrl,
+            standaloneMode: this.standaloneMode,
+        });
     }
     async pushUpdate(payload) {
         if (!this.isEnabled()) {
@@ -129,7 +136,7 @@ export class TeamPushClient {
         throw new Error("Failed to push OKR update: no authenticated engineer identity is available");
     }
     isEnabled() {
-        return !this.standaloneMode && this.teamChapterhouseUrl.length > 0;
+        return this.modeContext.canSyncTeamWiki();
     }
 }
 function describeHttpFailure(status) {

package/dist/integrations/teams-notify.js

@@ -1,4 +1,5 @@
 import { config } from "../config.js";
+import { ModeContext } from "../mode-context.js";
 import { childLogger } from "../util/logger.js";
 const log = childLogger("teams-notify");
 export const TEAMS_MILESTONE_THRESHOLDS = [25, 50, 75, 100];
@@ -8,11 +9,17 @@ export class TeamsNotifier {
     enabled;
     fetchImpl;
     warn;
+    modeContext;
     constructor(options = {}) {
         this.webhookUrl = (options.webhookUrl ?? config.teamsWebhookUrl).trim();
         this.enabled = options.enabled ?? config.teamsNotificationsEnabled;
         this.fetchImpl = options.fetchImpl ?? fetch;
         this.warn = options.warn ?? ((message) => log.warn(message));
+        this.modeContext = new ModeContext({
+            ...config,
+            teamsWebhookUrl: this.webhookUrl,
+            teamsNotificationsEnabled: this.enabled,
+        });
     }
     async sendMessage(title, body, color = DEFAULT_COLOR) {
         return await this.postCard({
@@ -61,7 +68,7 @@ export class TeamsNotifier {
         });
     }
     async postCard(card) {
-        if (!this.enabled || this.webhookUrl.length === 0) {
+        if (!this.modeContext.canSyncToTeams()) {
             this.warn("[teams] Teams notifications are disabled or TEAMS_WEBHOOK_URL is empty.");
             return false;
         }

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

package/dist/memory/housekeeping.test.js

@@ -16,9 +16,51 @@ function resetSandbox() {
 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);
+    const housekeepingModule = await import(new URL(`./housekeeping.js?case=${Date.now()}-${Math.random()}`, import.meta.url).href);
     return { dbModule, memoryModule, housekeepingModule };
 }
+async function loadMockedHousekeepingModule(t, options = {}) {
+    t.mock.module("../config.js", {
+        namedExports: {
+            config: {
+                memoryDecayDays: 30,
+                memoryInboxRetentionDays: 7,
+            },
+        },
+    });
+    t.mock.module("../store/db.js", {
+        namedExports: {
+            getDb: () => {
+                throw new Error("getDb should not be called in this test");
+            },
+        },
+    });
+    t.mock.module("../util/logger.js", {
+        namedExports: {
+            childLogger: () => ({
+                info: () => { },
+                warn: () => { },
+                error: () => { },
+            }),
+        },
+    });
+    t.mock.module("./active-scope.js", {
+        namedExports: {
+            getActiveScope: () => (options.activeScopeId === undefined ? null : { id: options.activeScopeId }),
+        },
+    });
+    t.mock.module("./scopes.js", {
+        namedExports: {
+            listScopes: () => options.scopes ?? [],
+        },
+    });
+    t.mock.module("./tiering.js", {
+        namedExports: {
+            tieringPass: (scopeId) => options.tieringPass?.(scopeId) ?? { pass: "tieringPass", examined: scopeId, modified: 1, errors: [] },
+        },
+    });
+    return await import(new URL(`./housekeeping.js?case=${Date.now()}-${Math.random()}`, import.meta.url).href);
+}
 function getFunction(module, name) {
     const value = module[name];
     assert.equal(typeof value, "function", `expected ${name} to be exported`);
@@ -215,17 +257,67 @@ test("runHousekeeping defaults to the active scope and can target all active sco
     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"] });
+    const activeOnly = await housekeepingModule.runHousekeeping({ passes: ["decay"] });
     assert.deepEqual(activeOnly.scopeIds, [chapterhouse.id]);
     assert.equal(activeOnly.summaries.length, 1);
     assert.equal(activeOnly.summaries[0]?.modified, 1);
     assert.ok(db.prepare(`SELECT archived_at FROM mem_observations WHERE id = ?`).get(chapterhouseOld.id).archived_at);
     assert.equal(db.prepare(`SELECT archived_at FROM mem_observations WHERE id = ?`).get(teamOld.id).archived_at, null);
-    const allScopes = housekeepingModule.runHousekeeping({ allScopes: true, passes: ["decay"] });
+    const allScopes = await housekeepingModule.runHousekeeping({ allScopes: true, passes: ["decay"] });
     assert.ok(allScopes.scopeIds.includes(team.id));
     assert.equal(allScopes.summaries.some((summary) => summary.modified === 1), true);
     assert.ok(db.prepare(`SELECT archived_at FROM mem_observations WHERE id = ?`).get(teamOld.id).archived_at);
 });
+test("runHousekeeping starts all scoped passes before awaiting completion", async (t) => {
+    const releases = new Map();
+    const startedScopes = [];
+    const housekeepingModule = await loadMockedHousekeepingModule(t, {
+        scopes: [
+            { id: 11, active: true },
+            { id: 22, active: true },
+        ],
+        tieringPass: async (scopeId) => {
+            startedScopes.push(scopeId);
+            await new Promise((resolve) => {
+                releases.set(scopeId, resolve);
+            });
+            return { pass: `tieringPass:${scopeId}`, examined: 1, modified: 1, errors: [] };
+        },
+    });
+    const pending = housekeepingModule.runHousekeeping({ allScopes: true, passes: ["tiering"] });
+    assert.equal(typeof pending.then, "function");
+    await Promise.resolve();
+    assert.deepEqual(startedScopes.sort((left, right) => left - right), [11, 22]);
+    releases.get(11)?.();
+    releases.get(22)?.();
+    const result = await pending;
+    assert.deepEqual(result.scopeIds, [11, 22]);
+    assert.deepEqual(result.summaries.map((summary) => summary.pass), ["tieringPass:11", "tieringPass:22"]);
+});
+test("runHousekeeping rejects overlapping runs that share an in-flight scope", async (t) => {
+    const releases = new Map();
+    const housekeepingModule = await loadMockedHousekeepingModule(t, {
+        scopes: [
+            { id: 11, active: true },
+            { id: 22, active: true },
+        ],
+        tieringPass: async (scopeId) => {
+            await new Promise((resolve) => {
+                releases.set(scopeId, resolve);
+            });
+            return { pass: `tieringPass:${scopeId}`, examined: 1, modified: 1, errors: [] };
+        },
+    });
+    const firstRun = housekeepingModule.runHousekeeping({ scopeIds: [11, 22], passes: ["tiering"] });
+    await Promise.resolve();
+    assert.equal(housekeepingModule.isHousekeepingInFlight([22], ["tiering"]), true);
+    const secondRun = await housekeepingModule.runHousekeeping({ scopeIds: [22], passes: ["tiering"] });
+    assert.deepEqual(secondRun.scopeIds, [22]);
+    assert.match(secondRun.summaries[0]?.errors[0] ?? "", /already in flight/i);
+    releases.get(11)?.();
+    releases.get(22)?.();
+    await firstRun;
+});
 test("tieringPass promotes and demotes rows from lifecycle signals and is idempotent", async () => {
     const { dbModule, memoryModule, housekeepingModule } = await loadModules();
     const db = dbModule.getDb();