chapterhouse 0.9.1 → 0.10.0

package/dist/memory/eot.js

@@ -11,20 +11,13 @@ import { getActiveScope } from "./active-scope.js";
 import { getScope } from "./scopes.js";
 const log = childLogger("memory.eot");
 function isEndOfTaskHookEnabled() {
-    const raw = process.env.CHAPTERHOUSE_MEMORY_EOT_HOOK_ENABLED?.trim();
-    if (raw === "0")
-        return false;
-    if (raw === "1")
-        return true;
-    return true;
+    return config.memoryEndOfTaskHookEnabled;
 }
 function isMemoryAutoAcceptEnabled() {
-    const raw = process.env.CHAPTERHOUSE_MEMORY_AUTO_ACCEPT?.trim();
-    if (raw === "0")
-        return false;
-    if (raw === "1")
-        return true;
-    return true;
+    return config.memoryAutoAcceptEnabled;
+}
+function isFrictionHookEnabled() {
+    return config.memoryEndOfTaskFrictionEnabled;
 }
 function buildReviewerSystemPrompt() {
     return [
@@ -48,78 +41,132 @@ function buildReviewerUserPrompt(finalResult, proposals) {
         })),
     }, null, 2);
 }
+function buildFrictionSystemPrompt() {
+    return [
+        "You review a completed agent task for tool friction.",
+        "Tool friction is: missing validation feedback, missing batch capability, silent failures,",
+        "overly strict input constraints, or tool gaps that caused the agent to work around limitations.",
+        "If you identify friction, return a JSON array of action items.",
+        "Each item must have: title (string), detail (string), source (always 'eot:friction').",
+        "If no friction was found, return an empty array [].",
+        "Return JSON only. No prose, no wrapping.",
+    ].join("\n");
+}
+function buildFrictionUserPrompt(finalResult) {
+    return JSON.stringify({ final_result: finalResult }, null, 2);
+}
 function parseEnvelope(raw) {
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed !== "object") {
-        throw new Error("Invalid memory proposal payload.");
-    }
-    if (parsed.kind !== "observation"
-        && parsed.kind !== "decision"
-        && parsed.kind !== "entity"
-        && parsed.kind !== "action_item") {
-        throw new Error("Invalid proposal kind.");
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object") {
+            throw new Error("Invalid memory proposal payload.");
+        }
+        if (parsed.kind !== "observation"
+            && parsed.kind !== "decision"
+            && parsed.kind !== "entity"
+            && parsed.kind !== "action_item") {
+            throw new Error("Invalid proposal kind.");
+        }
+        if (!parsed.payload || typeof parsed.payload !== "object") {
+            throw new Error("Invalid proposal payload.");
+        }
+        return {
+            kind: parsed.kind,
+            scope_slug: typeof parsed.scope_slug === "string" ? parsed.scope_slug : undefined,
+            confidence: typeof parsed.confidence === "number" ? parsed.confidence : 0.5,
+            reason: typeof parsed.reason === "string" ? parsed.reason : undefined,
+            payload: parsed.payload,
+        };
     }
-    if (!parsed.payload || typeof parsed.payload !== "object") {
-        throw new Error("Invalid proposal payload.");
+    catch (err) {
+        log.warn({ err }, "malformed memory proposal payload");
+        return null;
     }
-    return {
-        kind: parsed.kind,
-        scope_slug: typeof parsed.scope_slug === "string" ? parsed.scope_slug : undefined,
-        confidence: typeof parsed.confidence === "number" ? parsed.confidence : 0.5,
-        reason: typeof parsed.reason === "string" ? parsed.reason : undefined,
-        payload: parsed.payload,
-    };
 }
 function parseReviewerResponse(raw) {
-    const parsed = JSON.parse(raw);
-    return {
-        decisions: Array.isArray(parsed.decisions)
-            ? parsed.decisions.flatMap((entry) => {
-                if (!entry || typeof entry !== "object") {
-                    return [];
-                }
-                const candidate = entry;
-                if (typeof candidate.proposal_id !== "number") {
-                    return [];
-                }
-                if (candidate.decision !== "accept" && candidate.decision !== "reject") {
-                    return [];
-                }
-                if (typeof candidate.reason !== "string" || candidate.reason.trim().length === 0) {
-                    return [];
-                }
-                return [{
-                        proposal_id: candidate.proposal_id,
-                        decision: candidate.decision,
-                        reason: candidate.reason.trim(),
-                    }];
-            })
-            : [],
-        implicit_memories: Array.isArray(parsed.implicit_memories)
-            ? parsed.implicit_memories.flatMap((entry) => {
-                if (!entry || typeof entry !== "object") {
-                    return [];
-                }
-                const candidate = entry;
-                if (candidate.kind !== "observation"
-                    && candidate.kind !== "decision"
-                    && candidate.kind !== "entity"
-                    && candidate.kind !== "action_item") {
-                    return [];
-                }
-                if (typeof candidate.scope_slug !== "string" || !candidate.payload || typeof candidate.payload !== "object") {
-                    return [];
-                }
-                return [{
-                        kind: candidate.kind,
-                        scope_slug: candidate.scope_slug,
-                        payload: candidate.payload,
-                        confidence: typeof candidate.confidence === "number" ? candidate.confidence : undefined,
-                        reason: typeof candidate.reason === "string" ? candidate.reason : undefined,
-                    }];
-            })
-            : [],
-    };
+    try {
+        const parsed = JSON.parse(raw);
+        return {
+            decisions: Array.isArray(parsed.decisions)
+                ? parsed.decisions.flatMap((entry) => {
+                    if (!entry || typeof entry !== "object") {
+                        return [];
+                    }
+                    const candidate = entry;
+                    if (typeof candidate.proposal_id !== "number") {
+                        return [];
+                    }
+                    if (candidate.decision !== "accept" && candidate.decision !== "reject") {
+                        return [];
+                    }
+                    if (typeof candidate.reason !== "string" || candidate.reason.trim().length === 0) {
+                        return [];
+                    }
+                    return [{
+                            proposal_id: candidate.proposal_id,
+                            decision: candidate.decision,
+                            reason: candidate.reason.trim(),
+                        }];
+                })
+                : [],
+            implicit_memories: Array.isArray(parsed.implicit_memories)
+                ? parsed.implicit_memories.flatMap((entry) => {
+                    if (!entry || typeof entry !== "object") {
+                        return [];
+                    }
+                    const candidate = entry;
+                    if (candidate.kind !== "observation"
+                        && candidate.kind !== "decision"
+                        && candidate.kind !== "entity"
+                        && candidate.kind !== "action_item") {
+                        return [];
+                    }
+                    if (typeof candidate.scope_slug !== "string" || !candidate.payload || typeof candidate.payload !== "object") {
+                        return [];
+                    }
+                    return [{
+                            kind: candidate.kind,
+                            scope_slug: candidate.scope_slug,
+                            payload: candidate.payload,
+                            confidence: typeof candidate.confidence === "number" ? candidate.confidence : undefined,
+                            reason: typeof candidate.reason === "string" ? candidate.reason : undefined,
+                        }];
+                })
+                : [],
+        };
+    }
+    catch (err) {
+        log.warn({ err }, "malformed reviewer response");
+        return { decisions: [], implicit_memories: [] };
+    }
+}
+function parseFrictionResponse(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed)) {
+            return [];
+        }
+        return parsed.flatMap((entry) => {
+            if (!entry || typeof entry !== "object") {
+                return [];
+            }
+            const candidate = entry;
+            if (!isNonEmptyString(candidate.title) || typeof candidate.detail !== "string") {
+                return [];
+            }
+            if (candidate.source !== "eot:friction") {
+                return [];
+            }
+            return [{
+                    title: candidate.title.trim(),
+                    detail: candidate.detail,
+                    source: "eot:friction",
+                }];
+        }).slice(0, 3);
+    }
+    catch {
+        return [];
+    }
 }
 function isNonEmptyString(value) {
     return typeof value === "string" && value.trim().length > 0;
@@ -199,6 +246,25 @@ function resolveAcceptedProposalScopeSlug(envelope, proposal) {
     }
     throw new Error("No memory scope could be resolved for this proposal.");
 }
+function resolveActiveScopeSlug() {
+    const activeScope = getActiveScope();
+    if (activeScope) {
+        return activeScope.slug;
+    }
+    return getScope("chapterhouse")?.slug;
+}
+function resolveCallLLM(input) {
+    return input.callLLM ?? (async ({ system, user, model }) => {
+        const result = await runOneShotPrompt({
+            client: input.copilotClient,
+            model,
+            system,
+            user,
+            expectJson: true,
+        });
+        return result.content;
+    });
+}
 function rememberAcceptedMemory(kind, scopeSlug, payload, source, confidence, sourceAgent) {
     const scope = getScope(scopeSlug);
     if (!scope) {
@@ -279,16 +345,7 @@ export async function runEndOfTaskMemoryHook(input) {
     }
     const proposals = listPendingMemoryProposalsForTask(input.taskId);
     summary.proposals_total = proposals.length;
-    const callLLM = input.callLLM ?? (async ({ system, user, model }) => {
-        const result = await runOneShotPrompt({
-            client: input.copilotClient,
-            model,
-            system,
-            user,
-            expectJson: true,
-        });
-        return result.content;
-    });
+    const callLLM = resolveCallLLM(input);
     const review = parseReviewerResponse(await callLLM({
         system: buildReviewerSystemPrompt(),
         user: buildReviewerUserPrompt(input.finalResult, proposals),
@@ -308,6 +365,11 @@ export async function runEndOfTaskMemoryHook(input) {
             }
             else {
                 const envelope = parseEnvelope(proposal.payload);
+                if (!envelope) {
+                    resolveInboxItem(proposal.id, "rejected", "Malformed memory proposal payload.");
+                    summary.rejected++;
+                    continue;
+                }
                 try {
                     const accepted = rememberAcceptedMemory(envelope.kind, resolveAcceptedProposalScopeSlug(envelope, proposal), envelope.payload, `agent:${proposal.sourceAgent}`, envelope.confidence, proposal.sourceAgent);
                     if (!accepted) {
@@ -347,8 +409,51 @@ export async function runEndOfTaskMemoryHook(input) {
             }
         }
     }
+    await runFrictionHook({
+        taskId: input.taskId,
+        finalResult: input.finalResult,
+        copilotClient: input.copilotClient,
+        callLLM,
+        model: input.model,
+    });
     log.info(summary, "memory.eot.processed");
     input.onProcessed?.(summary);
     return summary;
 }
+export async function runFrictionHook(input) {
+    try {
+        if (!isFrictionHookEnabled()) {
+            return;
+        }
+        if (input.finalResult.trim().length <= 100) {
+            return;
+        }
+        const scopeSlug = resolveActiveScopeSlug();
+        if (!scopeSlug) {
+            return;
+        }
+        const callLLM = resolveCallLLM(input);
+        const raw = await callLLM({
+            system: buildFrictionSystemPrompt(),
+            user: buildFrictionUserPrompt(input.finalResult),
+            model: input.model ?? config.copilotModel,
+        });
+        const frictionItems = parseFrictionResponse(raw);
+        for (const item of frictionItems) {
+            try {
+                rememberAcceptedMemory("action_item", scopeSlug, {
+                    title: item.title,
+                    detail: item.detail,
+                    source: item.source,
+                }, "eot:friction");
+            }
+            catch (err) {
+                log.warn({ err, taskId: input.taskId, title: item.title }, "friction hook: failed to record action item");
+            }
+        }
+    }
+    catch (err) {
+        log.warn({ err, taskId: input.taskId }, "friction hook failed");
+    }
+}
 //# sourceMappingURL=eot.js.map

package/dist/memory/eot.test.js

@@ -218,7 +218,6 @@ test("runEndOfTaskMemoryHook rejects invalid action_item proposals with a clear
     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");
@@ -352,7 +351,6 @@ test("runEndOfTaskMemoryHook rejects action_item proposals with ambiguous entity
     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");
@@ -593,7 +591,7 @@ test("runEndOfTaskMemoryHook rejects pending same-task proposals omitted by the
     assert.match(row.resolution_reason ?? "", /did not select/i);
 });
 test("runEndOfTaskMemoryHook can persist implicit extracted memories that were not explicitly proposed", async () => {
-    const { dbModule, memoryModule, eotModule } = await loadModules("implicit");
+    const { memoryModule, eotModule } = await loadModules("implicit");
     const getScope = getFunction(memoryModule, "getScope");
     const listObservations = getFunction(memoryModule, "listObservations");
     const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
@@ -763,4 +761,189 @@ test("runEndOfTaskMemoryHook persists implicit observation memories with valid c
     assert.equal(summary.implicit_extracted, 1);
     assert.equal(warnings.length, 0);
 });
+test("runEndOfTaskMemoryHook treats malformed reviewer JSON as an empty review and warns", async (t) => {
+    const { dbModule, memoryModule, eotModule, warnings } = await loadModulesWithWarnSpy(t, "reviewer-malformed-json");
+    const db = dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
+    const inserted = db.prepare(`
+    INSERT INTO mem_inbox (scope_id, kind, payload, source_agent, source_task_id, status)
+    VALUES (?, 'memory_proposal', ?, 'coder', 'task-eot-reviewer-malformed-json', 'pending')
+  `).run(chapterhouse.id, JSON.stringify({
+        kind: "observation",
+        payload: { content: "Malformed reviewer JSON must not crash the hook." },
+        confidence: 0.9,
+    }));
+    const summary = await runEndOfTaskMemoryHook({
+        taskId: "task-eot-reviewer-malformed-json",
+        finalResult: "The reviewer returned malformed JSON, so the hook should fail closed and continue.",
+        copilotClient: {},
+        callLLM: async () => "{ definitely-not-json",
+    });
+    const inbox = db.prepare(`
+    SELECT status, resolution_reason
+    FROM mem_inbox
+    WHERE id = ?
+  `).get(Number(inserted.lastInsertRowid));
+    assert.equal(summary.accepted, 0);
+    assert.equal(summary.rejected, 1);
+    assert.equal(inbox.status, "rejected");
+    assert.match(inbox.resolution_reason ?? "", /reviewer did not select/i);
+    assert.equal(warnings.length, 1);
+});
+test("runEndOfTaskMemoryHook rejects malformed accepted proposal payload JSON and warns", async (t) => {
+    const { dbModule, memoryModule, eotModule, warnings } = await loadModulesWithWarnSpy(t, "proposal-malformed-json");
+    const db = dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const listObservations = getFunction(memoryModule, "listObservations");
+    const runEndOfTaskMemoryHook = getFunction(eotModule, "runEndOfTaskMemoryHook");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
+    const beforeCount = listObservations({ scope_id: chapterhouse.id }).length;
+    const inserted = db.prepare(`
+    INSERT INTO mem_inbox (scope_id, kind, payload, source_agent, source_task_id, status)
+    VALUES (?, 'memory_proposal', ?, 'coder', 'task-eot-proposal-malformed-json', 'pending')
+  `).run(chapterhouse.id, "{ definitely-not-json");
+    const summary = await runEndOfTaskMemoryHook({
+        taskId: "task-eot-proposal-malformed-json",
+        finalResult: "The accepted proposal payload is malformed JSON, so the hook should reject it safely.",
+        copilotClient: {},
+        callLLM: async () => JSON.stringify({
+            decisions: [{
+                    proposal_id: Number(inserted.lastInsertRowid),
+                    decision: "accept",
+                    reason: "Looks durable.",
+                }],
+            implicit_memories: [],
+        }),
+    });
+    const inbox = db.prepare(`
+    SELECT status, resolution_reason
+    FROM mem_inbox
+    WHERE id = ?
+  `).get(Number(inserted.lastInsertRowid));
+    assert.equal(listObservations({ scope_id: chapterhouse.id }).length, beforeCount);
+    assert.equal(summary.accepted, 0);
+    assert.equal(summary.rejected, 1);
+    assert.equal(inbox.status, "rejected");
+    assert.match(inbox.resolution_reason ?? "", /malformed/i);
+    assert.equal(warnings.length, 1);
+});
+test("runFrictionHook does nothing by default when CHAPTERHOUSE_MEMORY_EOT_FRICTION_ENABLED is unset", async () => {
+    const { eotModule } = await loadModules("friction-disabled-default");
+    const runFrictionHook = getFunction(eotModule, "runFrictionHook");
+    let llmCalls = 0;
+    await runFrictionHook({
+        taskId: "task-friction-disabled-default",
+        finalResult: "A substantive final result that is definitely longer than one hundred characters to prove the friction hook still stays off by default.",
+        copilotClient: {},
+        callLLM: async () => {
+            llmCalls++;
+            return "[]";
+        },
+    });
+    assert.equal(llmCalls, 0);
+});
+test("runFrictionHook skips short final results even when enabled", async () => {
+    process.env.CHAPTERHOUSE_MEMORY_EOT_FRICTION_ENABLED = "1";
+    const { eotModule } = await loadModules("friction-short-result");
+    const runFrictionHook = getFunction(eotModule, "runFrictionHook");
+    let llmCalls = 0;
+    await runFrictionHook({
+        taskId: "task-friction-short-result",
+        finalResult: "too short",
+        copilotClient: {},
+        callLLM: async () => {
+            llmCalls++;
+            return "[]";
+        },
+    });
+    assert.equal(llmCalls, 0);
+});
+test("runFrictionHook records action items when enabled and the task result is substantive", async () => {
+    process.env.CHAPTERHOUSE_MEMORY_EOT_FRICTION_ENABLED = "1";
+    const { memoryModule, eotModule } = await loadModules("friction-records-action-items");
+    const getScope = getFunction(memoryModule, "getScope");
+    const setActiveScope = getFunction(memoryModule, "setActiveScope");
+    const listActionItems = getFunction(memoryModule, "listActionItems");
+    const runFrictionHook = getFunction(eotModule, "runFrictionHook");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
+    setActiveScope("chapterhouse");
+    await runFrictionHook({
+        taskId: "task-friction-records-action-items",
+        finalResult: "The agent had to retry the same command several times because the tool returned a generic error with no validation detail, which made the task materially slower and harder to finish cleanly.",
+        copilotClient: {},
+        callLLM: async () => JSON.stringify([
+            {
+                title: "Improve validation feedback for memory tools",
+                detail: "Return the rejected field name and allowed values instead of a generic failure.",
+                source: "eot:friction",
+            },
+        ]),
+    });
+    const actionItems = listActionItems({ scope_id: chapterhouse.id });
+    assert.equal(actionItems.length, 1);
+    assert.equal(actionItems[0]?.title, "Improve validation feedback for memory tools");
+    assert.equal(actionItems[0]?.detail, "Return the rejected field name and allowed values instead of a generic failure.");
+    assert.equal(actionItems[0]?.source, "eot:friction");
+    assert.equal(actionItems[0]?.status, "open");
+});
+test("runFrictionHook caps parsed friction items at 3", async () => {
+    process.env.CHAPTERHOUSE_MEMORY_EOT_FRICTION_ENABLED = "1";
+    const { memoryModule, eotModule } = await loadModules("friction-cap");
+    const getScope = getFunction(memoryModule, "getScope");
+    const setActiveScope = getFunction(memoryModule, "setActiveScope");
+    const listActionItems = getFunction(memoryModule, "listActionItems");
+    const runFrictionHook = getFunction(eotModule, "runFrictionHook");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
+    setActiveScope("chapterhouse");
+    await runFrictionHook({
+        taskId: "task-friction-cap",
+        finalResult: "The toolchain created several distinct sources of friction across the task, and the result is long enough that the friction hook should inspect it and write only the first three issues back into memory.",
+        copilotClient: {},
+        callLLM: async () => JSON.stringify([
+            { title: "Item 1", detail: "detail 1", source: "eot:friction" },
+            { title: "Item 2", detail: "detail 2", source: "eot:friction" },
+            { title: "Item 3", detail: "detail 3", source: "eot:friction" },
+            { title: "Item 4", detail: "detail 4", source: "eot:friction" },
+        ]),
+    });
+    assert.deepEqual(listActionItems({ scope_id: chapterhouse.id }).map((item) => item.title).sort(), ["Item 1", "Item 2", "Item 3"]);
+});
+test("runFrictionHook treats malformed JSON as no friction items", async () => {
+    process.env.CHAPTERHOUSE_MEMORY_EOT_FRICTION_ENABLED = "1";
+    const { memoryModule, eotModule } = await loadModules("friction-malformed-json");
+    const getScope = getFunction(memoryModule, "getScope");
+    const setActiveScope = getFunction(memoryModule, "setActiveScope");
+    const listActionItems = getFunction(memoryModule, "listActionItems");
+    const runFrictionHook = getFunction(eotModule, "runFrictionHook");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
+    setActiveScope("chapterhouse");
+    await runFrictionHook({
+        taskId: "task-friction-malformed-json",
+        finalResult: "The agent hit confusing tool friction repeatedly, but the friction reviewer returned malformed JSON and the hook should safely ignore it without writing any action items.",
+        copilotClient: {},
+        callLLM: async () => "{not valid json",
+    });
+    assert.deepEqual(listActionItems({ scope_id: chapterhouse.id }), []);
+});
+test("runFrictionHook never propagates errors from the LLM call", async (t) => {
+    process.env.CHAPTERHOUSE_MEMORY_EOT_FRICTION_ENABLED = "1";
+    const { eotModule, warnings } = await loadModulesWithWarnSpy(t, "friction-no-throw");
+    const runFrictionHook = getFunction(eotModule, "runFrictionHook");
+    await assert.doesNotReject(() => runFrictionHook({
+        taskId: "task-friction-no-throw",
+        finalResult: "The agent encountered enough friction to trigger the hook, but the LLM call itself crashed and the hook must still fail closed without breaking end-of-task processing.",
+        copilotClient: {},
+        callLLM: async () => {
+            throw new Error("boom");
+        },
+    }));
+    assert.equal(warnings.length, 1);
+});
 //# sourceMappingURL=eot.test.js.map

package/dist/memory/hooks.js

@@ -1,4 +1,5 @@
 import { childLogger } from "../util/logger.js";
+import { config } from "../config.js";
 import { getActiveScope } from "./active-scope.js";
 import { recordObservation } from "./observations.js";
 import { getScope } from "./scopes.js";
@@ -7,10 +8,7 @@ const log = childLogger("memory.hooks");
 // Env knob
 // ---------------------------------------------------------------------------
 function isHooksEnabled() {
-    const raw = process.env.CHAPTERHOUSE_MEMORY_HOOKS_ENABLED?.trim();
-    if (raw === "false" || raw === "0")
-        return false;
-    return true;
+    return config.memoryHooksEnabled;
 }
 // ---------------------------------------------------------------------------
 // Dispatcher

package/dist/memory/housekeeping-scheduler.js

@@ -44,7 +44,7 @@ export class MemoryHousekeepingScheduler {
     reflectIntervalDays;
     lastReflectAtMs;
     constructor(options = {}) {
-        this.env = options.env ?? process.env;
+        this.env = options.env ?? {};
         this.runHousekeepingImpl = options.runHousekeeping ?? runHousekeeping;
         this.runReflectAllScopesImpl = options.runReflectAllScopes ?? reflectAllScopes;
         this.nowImpl = options.nowImpl ?? Date.now;

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

@@ -227,8 +227,7 @@ test("MemoryHousekeepingScheduler runs weekly reflection after housekeeping and
     assert.equal(reflectRuns.length, 0);
     now = 7 * DAY_MS;
     timers.intervals[0]?.callback();
-    await Promise.resolve();
-    await Promise.resolve();
+    await scheduler.stop();
     assert.equal(housekeepingRuns.length, 2);
     assert.equal(reflectRuns.length, 1);
     assert.equal(infos.some((entry) => entry.msg.includes("Memory reflect scheduled run complete")), true);