chapterhouse 0.9.1 → 0.10.0

package/dist/integrations/ado-client.js

@@ -4,6 +4,85 @@ import { ADO_ORG, ADO_PROJECT, FIELDS, STD_FIELDS, UNIT_FIELD, WIT } from "./ado
 function escapeWiqlLiteral(value) {
     return value.replace(/'/g, "''");
 }
+const ALLOWED_WIQL_FIELDS = new Set([
+    "System.Id",
+    "System.TeamProject",
+    "System.WorkItemType",
+    STD_FIELDS.TITLE,
+    STD_FIELDS.STATE,
+    STD_FIELDS.PARENT,
+    STD_FIELDS.ASSIGNED_TO,
+    STD_FIELDS.TAGS,
+    FIELDS.CURRENT_VALUE,
+    FIELDS.TARGET_VALUE,
+    FIELDS.OKR_PERIOD,
+    FIELDS.OKR_OWNER,
+    UNIT_FIELD,
+]);
+const ALLOWED_WIQL_OPERATORS = new Set(["=", "<>", "IN", "CONTAINS"]);
+const ALLOWED_WIQL_MACROS = new Set(["@project"]);
+function quoteWiqlField(field) {
+    if (!ALLOWED_WIQL_FIELDS.has(field)) {
+        throw new Error(`Unsupported WIQL field: ${field}`);
+    }
+    return `[${field}]`;
+}
+function normalizeWiqlOperator(operator) {
+    if (ALLOWED_WIQL_OPERATORS.has(operator)) {
+        return operator;
+    }
+    throw new Error(`Unsupported WIQL operator: ${operator}`);
+}
+function formatWiqlScalar(value) {
+    if (typeof value === "number") {
+        if (!Number.isFinite(value)) {
+            throw new Error(`Unsupported WIQL number: ${value}`);
+        }
+        return String(value);
+    }
+    return `'${escapeWiqlLiteral(value)}'`;
+}
+function formatWiqlValue(value, operator) {
+    if (Array.isArray(value)) {
+        if (operator !== "IN") {
+            throw new Error(`WIQL operator ${operator} does not accept a list value.`);
+        }
+        if (value.length === 0) {
+            throw new Error("WIQL IN clauses require at least one value.");
+        }
+        return `(${value.map((item) => formatWiqlScalar(item)).join(", ")})`;
+    }
+    if (typeof value === "object" && value !== null && "macro" in value) {
+        if (!ALLOWED_WIQL_MACROS.has(value.macro)) {
+            throw new Error(`Unsupported WIQL macro: ${value.macro}`);
+        }
+        return value.macro;
+    }
+    if (typeof value === "string" || typeof value === "number") {
+        return formatWiqlScalar(value);
+    }
+    throw new Error("Unsupported WIQL value.");
+}
+function formatWiqlCondition(condition) {
+    const field = quoteWiqlField(condition.field);
+    const operator = normalizeWiqlOperator(condition.operator);
+    return `${field} ${operator} ${formatWiqlValue(condition.value, operator)}`;
+}
+export function buildWiqlQuery(query) {
+    if (query.select.length === 0) {
+        throw new Error("WIQL queries must select at least one field.");
+    }
+    if (query.where.length === 0) {
+        throw new Error("WIQL queries must include at least one filter.");
+    }
+    const selectClause = query.select.map((field) => quoteWiqlField(field)).join(", ");
+    const whereClause = query.where.map((condition) => formatWiqlCondition(condition)).join(" AND ");
+    return [
+        `SELECT ${selectClause}`,
+        "FROM WorkItems",
+        `WHERE ${whereClause}`,
+    ].join(" ");
+}
 function getStringField(fields, fieldName) {
     const value = fields?.[fieldName];
     if (typeof value === "string") {
@@ -47,15 +126,17 @@ function toPercentComplete(currentValue, targetValue) {
     return Math.max(0, Math.min(100, Math.round((currentValue / targetValue) * 100)));
 }
 function buildWiql(workItemType, period) {
-    const periodClause = period
-        ? ` AND [${FIELDS.OKR_PERIOD}] = '${escapeWiqlLiteral(period)}'`
-        : "";
-    return [
-        "SELECT [System.Id]",
-        "FROM WorkItems",
-        "WHERE [System.TeamProject] = @project",
-        `AND [System.WorkItemType] = '${workItemType}'${periodClause}`,
-    ].join(" ");
+    const where = [
+        { field: "System.TeamProject", operator: "=", value: { macro: "@project" } },
+        { field: "System.WorkItemType", operator: "=", value: workItemType },
+    ];
+    if (period) {
+        where.push({ field: FIELDS.OKR_PERIOD, operator: "=", value: period });
+    }
+    return buildWiqlQuery({
+        select: ["System.Id"],
+        where,
+    });
 }
 function getWorkItemIds(result) {
     return (result.workItems ?? [])

package/dist/integrations/ado-client.test.js

@@ -173,4 +173,60 @@ test("getOKRSummary computes percent complete from KR progress", async () => {
     assert.equal(summary.objectives[0]?.keyResults[0]?.percentComplete, 75);
     assert.equal(summary.objectives[0]?.keyResults[1]?.percentComplete, 50);
 });
+test("buildWiqlQuery rejects non-whitelisted field names", async () => {
+    const ado = await loadAdoClientModule();
+    assert.ok(ado, "ado client module should exist");
+    assert.throws(() => ado.buildWiqlQuery({
+        select: ["System.Id"],
+        where: [
+            {
+                field: "System.Title] OR [System.Id",
+                operator: "=",
+                value: "Ship SSO to all tenants",
+            },
+        ],
+    }), /Unsupported WIQL field/);
+});
+test("buildWiqlQuery rejects non-whitelisted operators", async () => {
+    const ado = await loadAdoClientModule();
+    assert.ok(ado, "ado client module should exist");
+    assert.throws(() => ado.buildWiqlQuery({
+        select: ["System.Id"],
+        where: [
+            {
+                field: "System.Title",
+                operator: "= '' OR [System.Id] > 0",
+                value: "Ship SSO to all tenants",
+            },
+        ],
+    }), /Unsupported WIQL operator/);
+});
+test("getKeyResults escapes WIQL literal values before querying", async () => {
+    const ado = await loadAdoClientModule();
+    assert.ok(ado, "ado client module should exist");
+    const queries = [];
+    const client = new ado.AdoClient({
+        org: "https://dev.azure.com/example-org",
+        project: "example-project",
+        pat: "test-pat",
+        workItemTrackingApi: {
+            async queryByWiql(wiql) {
+                queries.push(wiql.query ?? "");
+                return { workItems: [] };
+            },
+            async getWorkItems() {
+                throw new Error("not used in this test");
+            },
+            async updateWorkItem() {
+                throw new Error("not used in this test");
+            },
+            async addComment() {
+                throw new Error("not used in this test");
+            },
+        },
+    });
+    await client.getKeyResults("2026-Q2' OR [System.Id] > 0 OR 'x'='x");
+    assert.equal(queries.length, 1);
+    assert.match(queries[0] ?? "", /\[Custom\.OKRPeriod\] = '2026-Q2'' OR \[System\.Id\] > 0 OR ''x''=''x'/);
+});
 //# sourceMappingURL=ado-client.test.js.map

package/dist/integrations/team-push.js

@@ -17,6 +17,7 @@ export class TeamPushClient {
         this.getCurrentUser = options.getCurrentUser;
         this.modeContext = new ModeContext({
             ...config,
+            chapterhouseMode: options.chapterhouseMode ?? config.chapterhouseMode,
             teamChapterhouseUrl: this.teamChapterhouseUrl,
             standaloneMode: this.standaloneMode,
         });

package/dist/integrations/team-push.test.js

@@ -13,6 +13,7 @@ test("pushUpdate sends the expected payload to the team update endpoint", async
     assert.ok(teamPushModule, "team push module should exist");
     const requests = [];
     const client = new teamPushModule.TeamPushClient({
+        chapterhouseMode: "team",
         teamChapterhouseUrl: "https://team.example.com/",
         standaloneMode: false,
         getAuthorizationHeader: () => "Bearer entra-token",
@@ -61,6 +62,7 @@ test("pushUpdate throws descriptive errors for auth and network failures", async
     const teamPushModule = await loadTeamPushModule();
     assert.ok(teamPushModule, "team push module should exist");
     const unauthorizedClient = new teamPushModule.TeamPushClient({
+        chapterhouseMode: "team",
         teamChapterhouseUrl: "https://team.example.com",
         teamChapterhouseToken: "fallback-token",
         standaloneMode: false,
@@ -73,6 +75,7 @@ test("pushUpdate throws descriptive errors for auth and network failures", async
     });
     await assert.rejects(unauthorizedClient.pushUpdate({ activity: "shipped auth refactor", krId: "O1-KR2", delta: 5 }), /Failed to push OKR update: unauthorized \(HTTP 401\)/i);
     const networkClient = new teamPushModule.TeamPushClient({
+        chapterhouseMode: "team",
         teamChapterhouseUrl: "https://team.example.com",
         standaloneMode: false,
         getAuthorizationHeader: () => "Bearer entra-token",
@@ -92,6 +95,7 @@ test("fetchOKRs returns raw OKR page content for the requested period", async ()
     assert.ok(teamPushModule, "team push module should exist");
     const requests = [];
     const client = new teamPushModule.TeamPushClient({
+        chapterhouseMode: "team",
         teamChapterhouseUrl: "https://team.example.com",
         standaloneMode: false,
         getAuthorizationHeader: () => "Bearer entra-token",
@@ -120,6 +124,7 @@ test("writePage PUTs shared wiki content to the team wiki endpoint", async () =>
     assert.ok(teamPushModule, "team push module should exist");
     const requests = [];
     const client = new teamPushModule.TeamPushClient({
+        chapterhouseMode: "team",
         teamChapterhouseUrl: "https://team.example.com/",
         standaloneMode: false,
         getAuthorizationHeader: () => "Bearer entra-token",
@@ -152,6 +157,7 @@ test("team push silently no-ops when team integration is disabled", async () =>
     assert.ok(teamPushModule, "team push module should exist");
     let called = false;
     const client = new teamPushModule.TeamPushClient({
+        chapterhouseMode: "team",
         teamChapterhouseUrl: "",
         standaloneMode: false,
         fetchImpl: async () => {

package/dist/integrations/teams-notify.js

@@ -17,6 +17,7 @@ export class TeamsNotifier {
         this.warn = options.warn ?? ((message) => log.warn(message));
         this.modeContext = new ModeContext({
             ...config,
+            chapterhouseMode: options.chapterhouseMode ?? config.chapterhouseMode,
             teamsWebhookUrl: this.webhookUrl,
             teamsNotificationsEnabled: this.enabled,
         });

package/dist/integrations/teams-notify.test.js

@@ -13,6 +13,7 @@ test("sendMessage formats a Teams MessageCard payload", async () => {
     assert.ok(teamsNotify, "teams notifier module should exist");
     const calls = [];
     const notifier = new teamsNotify.TeamsNotifier({
+        chapterhouseMode: "team",
         webhookUrl: "https://teams.example.test/webhook",
         enabled: true,
         fetchImpl: async (input, init) => {
@@ -39,6 +40,7 @@ for (const milestone of [25, 50, 75, 100]) {
         assert.ok(teamsNotify, "teams notifier module should exist");
         const calls = [];
         const notifier = new teamsNotify.TeamsNotifier({
+            chapterhouseMode: "team",
             webhookUrl: "https://teams.example.test/webhook",
             enabled: true,
             fetchImpl: async (input, init) => {
@@ -70,6 +72,7 @@ test("sendMessage does not call Teams when notifications are disabled", async ()
     let fetchCalls = 0;
     const warnings = [];
     const notifier = new teamsNotify.TeamsNotifier({
+        chapterhouseMode: "team",
         webhookUrl: "https://teams.example.test/webhook",
         enabled: false,
         fetchImpl: async () => {
@@ -89,6 +92,7 @@ test("notifyWeeklyHealthCheck sends an OKR summary card", async () => {
     assert.ok(teamsNotify, "teams notifier module should exist");
     const calls = [];
     const notifier = new teamsNotify.TeamsNotifier({
+        chapterhouseMode: "team",
         webhookUrl: "https://teams.example.test/webhook",
         enabled: true,
         fetchImpl: async (input, init) => {
@@ -114,6 +118,7 @@ test("notifyStandup sends the member update summary", async () => {
     assert.ok(teamsNotify, "teams notifier module should exist");
     const calls = [];
     const notifier = new teamsNotify.TeamsNotifier({
+        chapterhouseMode: "team",
         webhookUrl: "https://teams.example.test/webhook",
         enabled: true,
         fetchImpl: async (input, init) => {

package/dist/memory/active-scope.test.js

@@ -34,7 +34,6 @@ test.after(async () => {
 test("active scope can be set, read, and cleared without changing scope activation status", async () => {
     const { dbModule, memoryModule } = await loadModules();
     dbModule.getDb();
-    const getScope = getFunction(memoryModule, "getScope");
     const getActiveScope = getFunction(memoryModule, "getActiveScope");
     const setActiveScope = getFunction(memoryModule, "setActiveScope");
     const deactivateScope = getFunction(memoryModule, "deactivateScope");

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