chapterhouse 0.9.2 → 0.10.0

package/dist/memory/checkpoint.js

@@ -5,6 +5,7 @@ import { recordDecision } from "./decisions.js";
 import { listEntities } from "./entities.js";
 import { recordObservation, listObservations } from "./observations.js";
 import { getScope } from "./scopes.js";
+import { releaseScopeWriteLocks, tryAcquireScopeWriteLocks } from "./scope-lock.js";
 import { listDecisions } from "./decisions.js";
 import { buildCheckpointSystemPrompt, buildCheckpointUserPrompt, } from "./checkpoint-prompt.js";
 const log = childLogger("memory.checkpoint");
@@ -48,29 +49,35 @@ function calculateSimilarity(left, right) {
     return overlap / new Set([...leftTokens, ...rightTokens]).size;
 }
 function parseProposals(raw) {
-    const parsed = JSON.parse(raw);
-    if (!Array.isArray(parsed.proposals)) {
-        return [];
-    }
-    return parsed.proposals.flatMap((proposal) => {
-        if (!proposal || typeof proposal !== "object") {
-            return [];
-        }
-        const candidate = proposal;
-        if ((candidate.kind !== "observation" && candidate.kind !== "decision")
-            || typeof candidate.content !== "string"
-            || typeof candidate.confidence !== "number") {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed.proposals)) {
             return [];
         }
-        return [{
-                kind: candidate.kind,
-                title: typeof candidate.title === "string" ? candidate.title.trim() : undefined,
-                content: candidate.content.trim(),
-                scope: typeof candidate.scope === "string" ? candidate.scope.trim() : undefined,
-                confidence: candidate.confidence,
-                decided_at: typeof candidate.decided_at === "string" ? candidate.decided_at.trim() : undefined,
-            }];
-    });
+        return parsed.proposals.flatMap((proposal) => {
+            if (!proposal || typeof proposal !== "object") {
+                return [];
+            }
+            const candidate = proposal;
+            if ((candidate.kind !== "observation" && candidate.kind !== "decision")
+                || typeof candidate.content !== "string"
+                || typeof candidate.confidence !== "number") {
+                return [];
+            }
+            return [{
+                    kind: candidate.kind,
+                    title: typeof candidate.title === "string" ? candidate.title.trim() : undefined,
+                    content: candidate.content.trim(),
+                    scope: typeof candidate.scope === "string" ? candidate.scope.trim() : undefined,
+                    confidence: candidate.confidence,
+                    decided_at: typeof candidate.decided_at === "string" ? candidate.decided_at.trim() : undefined,
+                }];
+        });
+    }
+    catch (err) {
+        log.warn({ err }, "malformed checkpoint proposals response");
+        return [];
+    }
 }
 function resolveProposalScope(proposal, activeScope) {
     if (!proposal.scope || proposal.scope === activeScope.slug) {
@@ -81,14 +88,15 @@ function resolveProposalScope(proposal, activeScope) {
 function isDuplicateObservation(content, scopeId, batchContents) {
     const existing = listObservations({ scope_id: scopeId, limit: RECENT_MEMORY_LIMIT });
     const combined = [...existing.map((observation) => observation.content), ...batchContents];
-    return combined.some((candidate) => calculateSimilarity(candidate, content) >= 0.85);
+    return combined.some((candidate) => calculateSimilarity(candidate, content) >= config.memoryCheckpointDuplicateThreshold);
 }
 function isDuplicateDecision(proposal, scopeId) {
     const existing = listDecisions({ scope_id: scopeId, limit: RECENT_MEMORY_LIMIT });
     return existing.some((decision) => {
         const titleSimilarity = proposal.title ? calculateSimilarity(decision.title, proposal.title) : 0;
         const rationaleSimilarity = calculateSimilarity(decision.rationale, proposal.content);
-        return titleSimilarity >= 0.85 || rationaleSimilarity >= 0.85;
+        return titleSimilarity >= config.memoryCheckpointDuplicateThreshold
+            || rationaleSimilarity >= config.memoryCheckpointDuplicateThreshold;
     });
 }
 export class CheckpointTracker {
@@ -96,12 +104,8 @@ export class CheckpointTracker {
     cadence;
     enabled;
     constructor(options = {}) {
-        const rawTurns = process.env.CHAPTERHOUSE_MEMORY_CHECKPOINT_TURNS?.trim();
-        const envTurns = rawTurns && /^\d+$/.test(rawTurns) ? Number(rawTurns) : undefined;
-        const rawEnabled = process.env.CHAPTERHOUSE_MEMORY_CHECKPOINT_ENABLED?.trim();
-        const envEnabled = rawEnabled === "0" ? false : rawEnabled === "1" ? true : undefined;
-        this.cadence = options.turns ?? envTurns ?? config.memoryCheckpointTurns;
-        this.enabled = options.enabled ?? envEnabled ?? config.memoryCheckpointEnabled;
+        this.cadence = options.turns ?? config.memoryCheckpointTurns;
+        this.enabled = options.enabled ?? config.memoryCheckpointEnabled;
     }
     tickOrchestratorTurn() {
         this.turnCountSinceLastFire++;
@@ -180,65 +184,78 @@ export async function runCheckpointExtraction(input) {
             scope: input.activeScope.slug,
             sessionKey: input.sessionKey ?? "default",
         }, "memory.checkpoint.proposal_count");
+        const resolvedProposals = proposals.map((proposal) => ({
+            proposal,
+            scope: resolveProposalScope(proposal, input.activeScope),
+        }));
+        const lockedScopeIds = [...new Set(resolvedProposals.flatMap(({ scope }) => (scope ? [scope.id] : [])))];
+        if (lockedScopeIds.length > 0 && !tryAcquireScopeWriteLocks(lockedScopeIds)) {
+            log.info({ sessionKey: input.sessionKey ?? "default", scope: input.activeScope.slug }, "memory.checkpoint.scope_in_flight_skip");
+            return { written: 0, skipped: 0, errors };
+        }
         let written = 0;
         let skipped = 0;
         const pendingObservationContents = [];
-        for (const proposal of proposals) {
-            if (proposal.confidence < MIN_CONFIDENCE) {
-                skipped++;
-                log.info({ reason: "low_confidence", confidence: proposal.confidence, scope: input.activeScope.slug }, "memory.checkpoint.skip");
-                continue;
-            }
-            if (written >= MAX_WRITES_PER_CHECKPOINT) {
-                skipped++;
-                log.info({ reason: "cap_exceeded", scope: input.activeScope.slug }, "memory.checkpoint.skip");
-                continue;
-            }
-            const scope = resolveProposalScope(proposal, input.activeScope);
-            if (!scope) {
-                skipped++;
-                log.info({ reason: "no_scope", scope: proposal.scope ?? input.activeScope.slug }, "memory.checkpoint.skip");
-                continue;
-            }
-            if (proposal.kind === "observation" && isDuplicateObservation(proposal.content, scope.id, pendingObservationContents)) {
-                skipped++;
-                log.info({ reason: "duplicate", scope_id: scope.id }, "memory.checkpoint.skip");
-                continue;
-            }
-            if (proposal.kind === "decision") {
-                if (!proposal.title) {
+        try {
+            for (const { proposal, scope } of resolvedProposals) {
+                if (proposal.confidence < MIN_CONFIDENCE) {
                     skipped++;
-                    log.info({ reason: "missing_title", scope_id: scope.id }, "memory.checkpoint.skip");
+                    log.info({ reason: "low_confidence", confidence: proposal.confidence, scope: input.activeScope.slug }, "memory.checkpoint.skip");
                     continue;
                 }
-                if (isDuplicateDecision(proposal, scope.id)) {
+                if (written >= MAX_WRITES_PER_CHECKPOINT) {
+                    skipped++;
+                    log.info({ reason: "cap_exceeded", scope: input.activeScope.slug }, "memory.checkpoint.skip");
+                    continue;
+                }
+                if (!scope) {
+                    skipped++;
+                    log.info({ reason: "no_scope", scope: proposal.scope ?? input.activeScope.slug }, "memory.checkpoint.skip");
+                    continue;
+                }
+                if (proposal.kind === "observation" && isDuplicateObservation(proposal.content, scope.id, pendingObservationContents)) {
                     skipped++;
                     log.info({ reason: "duplicate", scope_id: scope.id }, "memory.checkpoint.skip");
                     continue;
                 }
-                const decision = recordDecision({
+                if (proposal.kind === "decision") {
+                    if (!proposal.title) {
+                        skipped++;
+                        log.info({ reason: "missing_title", scope_id: scope.id }, "memory.checkpoint.skip");
+                        continue;
+                    }
+                    if (isDuplicateDecision(proposal, scope.id)) {
+                        skipped++;
+                        log.info({ reason: "duplicate", scope_id: scope.id }, "memory.checkpoint.skip");
+                        continue;
+                    }
+                    const decision = recordDecision({
+                        scope_id: scope.id,
+                        title: proposal.title,
+                        rationale: proposal.content,
+                        decided_at: proposal.decided_at || new Date().toISOString().slice(0, 10),
+                        tier: "warm",
+                    });
+                    written++;
+                    log.info({ kind: "decision", scope_id: scope.id, id: decision.id }, "memory.checkpoint.write");
+                    continue;
+                }
+                const observation = recordObservation({
                     scope_id: scope.id,
-                    title: proposal.title,
-                    rationale: proposal.content,
-                    decided_at: proposal.decided_at || new Date().toISOString().slice(0, 10),
+                    content: proposal.content,
+                    source: "checkpoint:orchestrator",
                     tier: "warm",
+                    confidence: proposal.confidence,
                 });
+                pendingObservationContents.push(proposal.content);
                 written++;
-                log.info({ kind: "decision", scope_id: scope.id, id: decision.id }, "memory.checkpoint.write");
-                continue;
+                log.info({ kind: "observation", scope_id: scope.id, id: observation.id }, "memory.checkpoint.write");
             }
-            const observation = recordObservation({
-                scope_id: scope.id,
-                content: proposal.content,
-                source: "checkpoint:orchestrator",
-                tier: "warm",
-                confidence: proposal.confidence,
-            });
-            pendingObservationContents.push(proposal.content);
-            written++;
-            log.info({ kind: "observation", scope_id: scope.id, id: observation.id }, "memory.checkpoint.write");
+            return { written, skipped, errors };
+        }
+        finally {
+            releaseScopeWriteLocks(lockedScopeIds);
         }
-        return { written, skipped, errors };
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);

package/dist/memory/checkpoint.test.js

@@ -18,6 +18,24 @@ async function loadModules(cacheBust = `${Date.now()}-${Math.random()}`) {
     const checkpointPromptModule = await import(new URL(`./checkpoint-prompt.js?case=${cacheBust}`, import.meta.url).href);
     return { dbModule, memoryModule, checkpointModule, checkpointPromptModule };
 }
+async function loadModulesWithWarnSpy(t, cacheBust) {
+    const warnings = [];
+    t.mock.module("../util/logger.js", {
+        namedExports: {
+            childLogger: () => ({
+                info: () => { },
+                warn: (...args) => {
+                    warnings.push(args);
+                },
+                error: () => { },
+            }),
+        },
+    });
+    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 checkpointModule = await import(new URL(`./checkpoint.js?case=${cacheBust}`, import.meta.url).href);
+    return { dbModule, memoryModule, checkpointModule, warnings };
+}
 function getFunction(module, name) {
     const value = module[name];
     assert.equal(typeof value, "function", `expected ${name} to be exported`);
@@ -157,8 +175,8 @@ test("runCheckpointExtraction writes high-confidence memories, skips low-confide
     assert.equal(listDecisions({ scope_id: chapterhouse.id }).some((row) => row.title === "Run checkpoint extraction asynchronously"), true);
     assert.equal(listObservations({ scope_id: chapterhouse.id, limit: 20 }).filter((row) => row.content === "Base new memory implementation branches from origin/main after dependent PRs merge.").length, 1);
 });
-test("runCheckpointExtraction handles malformed JSON responses without crashing", async () => {
-    const { dbModule, memoryModule, checkpointModule } = await loadModules();
+test("runCheckpointExtraction ignores malformed JSON responses and warns", async (t) => {
+    const { dbModule, memoryModule, checkpointModule, warnings } = await loadModulesWithWarnSpy(t, "malformed-json");
     dbModule.getDb();
     const getScope = getFunction(memoryModule, "getScope");
     const runCheckpointExtraction = getFunction(checkpointModule, "runCheckpointExtraction");
@@ -171,7 +189,9 @@ test("runCheckpointExtraction handles malformed JSON responses without crashing"
         callLLM: async () => "{ definitely-not-json",
     });
     assert.equal(result.written, 0);
-    assert.ok(result.errors.length >= 1);
+    assert.equal(result.skipped, 0);
+    assert.deepEqual(result.errors, []);
+    assert.equal(warnings.length, 1);
 });
 test("runCheckpointExtraction prevents overlapping executions with the in-flight guard", async () => {
     const { dbModule, memoryModule, checkpointModule } = await loadModules();

package/dist/memory/eot.js

@@ -11,28 +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() {
-    const raw = process.env.CHAPTERHOUSE_MEMORY_EOT_FRICTION_ENABLED?.trim();
-    if (raw === "0")
-        return false;
-    if (raw === "1")
-        return true;
-    return false;
+    return config.memoryEndOfTaskFrictionEnabled;
 }
 function buildReviewerSystemPrompt() {
     return [
@@ -71,77 +56,89 @@ 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 {
@@ -368,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) {

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,6 +761,76 @@ 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");

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);