chapterhouse 0.13.1 → 0.14.1

package/dist/memory/reflect.js

@@ -1,273 +0,0 @@
-import { config } from "../config.js";
-import { getClient } from "../copilot/client.js";
-import { runOneShotPrompt } from "../copilot/oneshot.js";
-import { childLogger } from "../util/logger.js";
-import { getScope, listScopes } from "./scopes.js";
-const log = childLogger("memory.reflect");
-const MIN_GROUP_SIZE = 3;
-const SIMILARITY_THRESHOLD = 0.35;
-const MAX_GROUP_OBSERVATIONS = 8;
-const GLOBAL_SCOPE_SLUG = "global";
-function normalizeText(value) {
-    return value
-        .toLowerCase()
-        .replace(/[^a-z0-9\s]/g, " ")
-        .replace(/\s+/g, " ")
-        .trim();
-}
-function tokenize(value) {
-    return new Set(normalizeText(value)
-        .split(" ")
-        .map((token) => token.replace(/s$/u, ""))
-        .filter((token) => token.length > 2));
-}
-function overlapCount(left, right) {
-    let overlap = 0;
-    for (const token of left) {
-        if (right.has(token)) {
-            overlap++;
-        }
-    }
-    return overlap;
-}
-function jaccard(left, right) {
-    if (left.size === 0 || right.size === 0) {
-        return 0;
-    }
-    const overlap = overlapCount(left, right);
-    const union = left.size + right.size - overlap;
-    return union === 0 ? 0 : overlap / union;
-}
-function compareObservation(left, right) {
-    if (left.created_at !== right.created_at) {
-        return left.created_at.localeCompare(right.created_at);
-    }
-    return left.id - right.id;
-}
-function canonicalObservationIds(observations) {
-    return observations
-        .map((observation) => observation.id)
-        .sort((left, right) => left - right)
-        .join(",");
-}
-function buildEntityGroups(observations) {
-    const grouped = new Map();
-    for (const observation of observations) {
-        if (!observation.entity_id) {
-            continue;
-        }
-        const existing = grouped.get(observation.entity_id) ?? [];
-        existing.push(observation);
-        grouped.set(observation.entity_id, existing);
-    }
-    return [...grouped.entries()]
-        .map(([entityId, rows]) => ({
-        kind: "entity",
-        key: `entity:${entityId}`,
-        observations: rows.sort(compareObservation),
-    }))
-        .filter((group) => group.observations.length >= MIN_GROUP_SIZE);
-}
-function buildTopicGroups(observations) {
-    const tokensByObservation = new Map();
-    for (const observation of observations) {
-        tokensByObservation.set(observation.id, tokenize(observation.content));
-    }
-    const groups = [];
-    const seenKeys = new Set();
-    const ordered = [...observations].sort(compareObservation);
-    for (const seed of ordered) {
-        const seedTokens = tokensByObservation.get(seed.id) ?? new Set();
-        const cluster = ordered.filter((candidate) => {
-            const candidateTokens = tokensByObservation.get(candidate.id) ?? new Set();
-            return overlapCount(seedTokens, candidateTokens) >= 3
-                && jaccard(seedTokens, candidateTokens) >= SIMILARITY_THRESHOLD;
-        });
-        if (cluster.length < MIN_GROUP_SIZE) {
-            continue;
-        }
-        const key = `topic:${canonicalObservationIds(cluster)}`;
-        if (seenKeys.has(key)) {
-            continue;
-        }
-        seenKeys.add(key);
-        groups.push({ kind: "topic", key, observations: cluster.sort(compareObservation) });
-    }
-    return groups;
-}
-function buildGroups(observations) {
-    const groups = [...buildEntityGroups(observations), ...buildTopicGroups(observations)];
-    const deduped = new Map();
-    for (const group of groups) {
-        const key = canonicalObservationIds(group.observations);
-        if (!deduped.has(key)) {
-            deduped.set(key, group);
-        }
-    }
-    return [...deduped.values()];
-}
-function buildFallbackPattern(group) {
-    const [first] = group.observations;
-    const entityTitle = first?.entity_name ? `${first.entity_name} pattern` : "Observed pattern";
-    return {
-        title: entityTitle,
-        summary: group.observations.slice(0, 3).map((observation) => observation.content).join(" "),
-        confidence: Math.max(0.5, Math.min(0.95, Number((group.observations.reduce((sum, observation) => sum + observation.confidence, 0) / group.observations.length).toFixed(2)))),
-    };
-}
-function parseSynthesizedPattern(raw, group) {
-    try {
-        const parsed = JSON.parse(raw);
-        if (typeof parsed.title === "string" && typeof parsed.summary === "string") {
-            return {
-                title: parsed.title.trim() || buildFallbackPattern(group).title,
-                summary: parsed.summary.trim() || buildFallbackPattern(group).summary,
-                confidence: typeof parsed.confidence === "number"
-                    ? Math.max(0, Math.min(1, parsed.confidence))
-                    : buildFallbackPattern(group).confidence,
-            };
-        }
-    }
-    catch {
-        // Fall through to the heuristic fallback.
-    }
-    return buildFallbackPattern(group);
-}
-async function synthesizePattern(scopeSlug, group) {
-    const client = await getClient();
-    const system = [
-        "You synthesize durable memory patterns from repeated observations.",
-        "Return JSON only with keys: title, summary, confidence.",
-        "title should be short and specific.",
-        "summary should describe the stable pattern in 1-2 sentences.",
-        "confidence must be a number between 0 and 1.",
-    ].join("\n");
-    const user = JSON.stringify({
-        scope: scopeSlug,
-        group_kind: group.kind,
-        observations: group.observations.slice(0, MAX_GROUP_OBSERVATIONS).map((observation) => ({
-            id: observation.id,
-            scope: observation.scope_slug,
-            entity: observation.entity_name,
-            content: observation.content,
-            source: observation.source,
-            confidence: observation.confidence,
-            created_at: observation.created_at,
-        })),
-    }, null, 2);
-    const response = await runOneShotPrompt({
-        client,
-        model: config.copilotModel,
-        system,
-        user,
-        expectJson: true,
-    });
-    return parseSynthesizedPattern(response.content, group);
-}
-function containsContradictionSignal(value) {
-    return /\b(?:no longer|changed to|now uses|now use|moved to|switched to|was .+ now .+)\b/i.test(value);
-}
-function countContradictions(groups) {
-    let contradictions = 0;
-    for (const group of groups) {
-        if (group.kind !== "entity") {
-            continue;
-        }
-        if (group.observations.some((observation) => containsContradictionSignal(observation.content))) {
-            contradictions++;
-        }
-    }
-    return contradictions;
-}
-function loadObservations(scopeSlug, db) {
-    const scope = getScope(scopeSlug);
-    if (!scope) {
-        throw new Error(`Unknown memory scope '${scopeSlug}'.`);
-    }
-    const globalScope = scopeSlug === GLOBAL_SCOPE_SLUG ? null : getScope(GLOBAL_SCOPE_SLUG);
-    const scopeIds = globalScope ? [scope.id, globalScope.id] : [scope.id];
-    const placeholders = scopeIds.map(() => "?").join(", ");
-    return db.prepare(`
-    SELECT
-      o.id,
-      o.scope_id,
-      s.slug AS scope_slug,
-      o.entity_id,
-      e.name AS entity_name,
-      e.kind AS entity_kind,
-      o.content,
-      o.source,
-      o.tier,
-      o.confidence,
-      o.created_at
-    FROM mem_observations o
-    JOIN mem_scopes s ON s.id = o.scope_id
-    LEFT JOIN mem_entities e ON e.id = o.entity_id
-    WHERE o.scope_id IN (${placeholders})
-      AND o.tier IN ('hot', 'warm')
-      AND o.superseded_by IS NULL
-      AND o.archived_at IS NULL
-    ORDER BY o.created_at ASC, o.id ASC
-  `).all(...scopeIds);
-}
-function upsertPattern(db, scopeId, synthesized, observations) {
-    const sourceObservationIds = JSON.stringify(observations.map((observation) => observation.id));
-    const existing = db.prepare(`
-    SELECT id, title, source_observation_ids
-    FROM mem_patterns
-    WHERE scope_id = ? AND title = ?
-    ORDER BY id DESC
-    LIMIT 1
-  `).get(scopeId, synthesized.title);
-    if (existing) {
-        db.prepare(`
-      UPDATE mem_patterns
-      SET summary = ?,
-          source_observation_ids = ?,
-          confidence = ?,
-          tier = 'warm',
-          last_updated = CURRENT_TIMESTAMP
-      WHERE id = ?
-    `).run(synthesized.summary, sourceObservationIds, synthesized.confidence, existing.id);
-        return "updated";
-    }
-    db.prepare(`
-    INSERT INTO mem_patterns (
-      scope_id, title, summary, source_observation_ids, confidence, tier, created_at, last_updated
-    )
-    VALUES (?, ?, ?, ?, ?, 'warm', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
-  `).run(scopeId, synthesized.title, synthesized.summary, sourceObservationIds, synthesized.confidence);
-    return "created";
-}
-export async function reflectOnScope(scopeSlug, db) {
-    const scope = getScope(scopeSlug);
-    if (!scope) {
-        throw new Error(`Unknown memory scope '${scopeSlug}'.`);
-    }
-    const observations = loadObservations(scopeSlug, db);
-    const groups = buildGroups(observations);
-    const contradictionsFound = countContradictions(groups);
-    let patternsCreated = 0;
-    let patternsUpdated = 0;
-    for (const group of groups) {
-        const synthesized = await synthesizePattern(scopeSlug, group);
-        const outcome = upsertPattern(db, scope.id, synthesized, group.observations);
-        if (outcome === "created") {
-            patternsCreated++;
-        }
-        else {
-            patternsUpdated++;
-        }
-    }
-    const result = { patternsCreated, patternsUpdated, contradictionsFound };
-    log.info({ scope: scopeSlug, ...result }, "memory.reflect.scope.complete");
-    return result;
-}
-export async function reflectAllScopes(db) {
-    const results = {};
-    for (const scope of listScopes().filter((entry) => entry.active)) {
-        results[scope.slug] = await reflectOnScope(scope.slug, db);
-    }
-    return results;
-}
-//# sourceMappingURL=reflect.js.map

package/dist/memory/reflect.test.js

@@ -1,256 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import test from "node:test";
-const repoRoot = process.cwd();
-const testWorkRoot = join(repoRoot, ".test-work");
-let sandboxRoot = "";
-function resetSandbox() {
-    mkdirSync(testWorkRoot, { recursive: true });
-    sandboxRoot = mkdtempSync(join(testWorkRoot, "memory-reflect-"));
-    process.env.CHAPTERHOUSE_HOME = sandboxRoot;
-}
-async function loadBaseModules() {
-    const nonce = `${Date.now()}-${Math.random()}`;
-    const dbModule = await import(new URL(`../store/db.js?case=${nonce}`, import.meta.url).href);
-    const memoryModule = await import(new URL(`./index.js?case=${nonce}`, import.meta.url).href);
-    return { dbModule, memoryModule };
-}
-async function loadReflectModule(t, llmResponse) {
-    t.mock.module("../copilot/oneshot.js", {
-        namedExports: {
-            runOneShotPrompt: async () => ({ content: llmResponse, model: "mock-model", attempts: 1 }),
-        },
-    });
-    t.mock.module("../copilot/client.js", {
-        namedExports: {
-            getClient: async () => ({}),
-        },
-    });
-    t.mock.module("../util/logger.js", {
-        namedExports: {
-            logger: { info: () => { }, warn: () => { }, error: () => { } },
-            childLogger: () => ({ info: () => { }, warn: () => { }, error: () => { } }),
-        },
-    });
-    return await import(new URL(`./reflect.js?case=${Date.now()}-${Math.random()}`, import.meta.url).href);
-}
-async function loadToolsModule(t) {
-    t.mock.module("../copilot/orchestrator.js", {
-        namedExports: {
-            getCurrentSourceChannel: () => "web",
-            getCurrentActivityCallback: () => undefined,
-            getCurrentActiveProjectRules: () => null,
-            getCurrentAuthenticatedUser: () => undefined,
-            getLastAuthenticatedUser: () => undefined,
-            getCurrentAuthorizationHeader: () => undefined,
-            getCurrentSessionKey: () => "session-reflect-test",
-            sendToAgentSession: async () => "",
-            invalidateOrchestratorSession: () => { },
-            maybeScheduleScopeChangeCheckpoint: () => { },
-            resetCheckpointSessionState: () => { },
-            switchSessionModel: async () => { },
-        },
-    });
-    t.mock.module("../memory/reflect.js", {
-        namedExports: {
-            reflectOnScope: async () => ({ patternsCreated: 1, patternsUpdated: 0, contradictionsFound: 0 }),
-            reflectAllScopes: async () => ({
-                chapterhouse: { patternsCreated: 1, patternsUpdated: 0, contradictionsFound: 0 },
-            }),
-        },
-    });
-    t.mock.module("../util/logger.js", {
-        namedExports: {
-            logger: { info: () => { }, warn: () => { }, error: () => { } },
-            childLogger: () => ({ info: () => { }, warn: () => { }, error: () => { } }),
-        },
-    });
-    const nonce = `${Date.now()}-${Math.random()}`;
-    const toolsModule = await import(new URL(`../copilot/tools.js?case=${nonce}`, import.meta.url).href);
-    const agentsModule = await import(new URL(`../copilot/agents.js?case=${nonce}`, import.meta.url).href);
-    const dbModule = await import(new URL(`../store/db.js?case=${nonce}`, import.meta.url).href);
-    return { toolsModule, agentsModule, dbModule };
-}
-function getFunction(module, name) {
-    const value = module[name];
-    assert.equal(typeof value, "function", `expected ${name} to be exported`);
-    return value;
-}
-function findTool(tools, name) {
-    const tool = tools.find((entry) => entry.name === name);
-    assert.ok(tool, `${name} tool should be registered`);
-    return tool;
-}
-test.beforeEach(async () => {
-    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
-    dbModule.closeDb();
-    resetSandbox();
-});
-test.afterEach(async () => {
-    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
-    dbModule.closeDb();
-    if (sandboxRoot) {
-        rmSync(sandboxRoot, { recursive: true, force: true });
-    }
-});
-test("reflectOnScope creates a pattern when three similar observations accumulate for one entity", async (t) => {
-    const { dbModule, memoryModule } = await loadBaseModules();
-    const db = dbModule.getDb();
-    const getScope = getFunction(memoryModule, "getScope");
-    const upsertEntity = getFunction(memoryModule, "upsertEntity");
-    const recordObservation = getFunction(memoryModule, "recordObservation");
-    const chapterhouse = getScope("chapterhouse");
-    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
-    const workerQueue = upsertEntity({ scope_id: chapterhouse.id, kind: "subsystem", name: "worker-queue" });
-    const first = recordObservation({
-        scope_id: chapterhouse.id,
-        entity_id: workerQueue.id,
-        content: "The worker queue serializes task execution through SQLite state.",
-        source: "test",
-        tier: "hot",
-    });
-    const second = recordObservation({
-        scope_id: chapterhouse.id,
-        entity_id: workerQueue.id,
-        content: "Worker queue execution is serialized using SQLite-backed state.",
-        source: "test",
-        tier: "warm",
-    });
-    const third = recordObservation({
-        scope_id: chapterhouse.id,
-        entity_id: workerQueue.id,
-        content: "SQLite keeps worker queue execution serialized across turns.",
-        source: "test",
-        tier: "warm",
-    });
-    const reflectModule = await loadReflectModule(t, JSON.stringify({
-        title: "Queue execution pattern",
-        summary: "Worker queue execution stays serialized through SQLite-backed coordination.",
-        confidence: 0.88,
-    }));
-    const result = await reflectModule.reflectOnScope("chapterhouse", db);
-    assert.equal(result.patternsCreated >= 1, true);
-    assert.equal(result.patternsCreated + result.patternsUpdated >= 1, true);
-    assert.equal(result.contradictionsFound, 0);
-    const pattern = db.prepare(`
-    SELECT title, summary, source_observation_ids, confidence, tier
-    FROM mem_patterns
-    ORDER BY id DESC
-    LIMIT 1
-  `).get();
-    assert.ok(pattern, "reflectOnScope should persist a pattern");
-    assert.equal(pattern.title, "Queue execution pattern");
-    assert.match(pattern.summary, /serialized/i);
-    assert.deepEqual(JSON.parse(pattern.source_observation_ids), [first.id, second.id, third.id]);
-    assert.equal(pattern.confidence, 0.88);
-    assert.equal(pattern.tier, "warm");
-});
-test("reflectOnScope counts contradictions inside the same entity group", async (t) => {
-    const { dbModule, memoryModule } = await loadBaseModules();
-    const db = dbModule.getDb();
-    const getScope = getFunction(memoryModule, "getScope");
-    const upsertEntity = getFunction(memoryModule, "upsertEntity");
-    const recordObservation = getFunction(memoryModule, "recordObservation");
-    const chapterhouse = getScope("chapterhouse");
-    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
-    const auth = upsertEntity({ scope_id: chapterhouse.id, kind: "subsystem", name: "auth" });
-    recordObservation({ scope_id: chapterhouse.id, entity_id: auth.id, content: "Auth used GitHub login for sign-in.", source: "test" });
-    recordObservation({ scope_id: chapterhouse.id, entity_id: auth.id, content: "Auth changed to Entra ID for sign-in.", source: "test" });
-    recordObservation({ scope_id: chapterhouse.id, entity_id: auth.id, content: "Auth no longer uses GitHub login.", source: "test" });
-    const reflectModule = await loadReflectModule(t, JSON.stringify({
-        title: "Auth provider transition",
-        summary: "Authentication moved away from GitHub login toward Entra ID.",
-        confidence: 0.82,
-    }));
-    const result = await reflectModule.reflectOnScope("chapterhouse", db);
-    assert.equal(result.contradictionsFound, 1);
-});
-test("reflectOnScope folds global observations into project-scope reflection", async (t) => {
-    const { dbModule, memoryModule } = await loadBaseModules();
-    const db = dbModule.getDb();
-    const getScope = getFunction(memoryModule, "getScope");
-    const recordObservation = getFunction(memoryModule, "recordObservation");
-    const chapterhouse = getScope("chapterhouse");
-    const global = getScope("global");
-    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
-    assert.ok(global, "global scope should be seeded");
-    const globalObservation = recordObservation({
-        scope_id: global.id,
-        content: "SQLite WAL keeps Chapterhouse memory writes fast.",
-        source: "test",
-        tier: "warm",
-    });
-    const scopedOne = recordObservation({
-        scope_id: chapterhouse.id,
-        content: "Chapterhouse memory writes stay fast because SQLite uses WAL mode.",
-        source: "test",
-        tier: "hot",
-    });
-    const scopedTwo = recordObservation({
-        scope_id: chapterhouse.id,
-        content: "WAL mode keeps Chapterhouse memory writes quick under concurrency.",
-        source: "test",
-        tier: "warm",
-    });
-    const reflectModule = await loadReflectModule(t, JSON.stringify({
-        title: "SQLite WAL performance pattern",
-        summary: "Across scopes, Chapterhouse relies on SQLite WAL mode for fast memory writes.",
-        confidence: 0.91,
-    }));
-    const result = await reflectModule.reflectOnScope("chapterhouse", db);
-    assert.equal(result.patternsCreated, 1);
-    const pattern = db.prepare(`
-    SELECT source_observation_ids
-    FROM mem_patterns
-    ORDER BY id DESC
-    LIMIT 1
-  `).get();
-    assert.ok(pattern, "cross-scope reflection should persist a pattern");
-    assert.deepEqual(JSON.parse(pattern.source_observation_ids), [globalObservation.id, scopedOne.id, scopedTwo.id]);
-});
-test("memory_reflect runs end-to-end for chapterhouse and is only bound to orchestrator tools", async (t) => {
-    const { toolsModule, agentsModule, dbModule } = await loadToolsModule(t);
-    const db = dbModule.getDb();
-    const tools = toolsModule.createTools({
-        client: { async listModels() { return []; } },
-        onAgentTaskComplete: () => { },
-    });
-    const bindToolsToAgent = agentsModule.bindToolsToAgent;
-    const filterToolsForAgent = agentsModule.filterToolsForAgent;
-    assert.equal(typeof bindToolsToAgent, "function", "bindToolsToAgent should be exported");
-    assert.equal(typeof filterToolsForAgent, "function", "filterToolsForAgent should be exported");
-    const chapterhouseVisibleTools = filterToolsForAgent({
-        slug: "chapterhouse",
-        name: "Chapterhouse",
-        description: "Orchestrator",
-        model: "auto",
-        systemMessage: "test",
-    }, tools);
-    const coderVisibleTools = filterToolsForAgent({
-        slug: "coder",
-        name: "Coder",
-        description: "Software engineer",
-        model: "gpt-5.4",
-        systemMessage: "test",
-    }, tools);
-    const chapterhouseTools = bindToolsToAgent("chapterhouse", chapterhouseVisibleTools);
-    const coderTools = bindToolsToAgent("coder", coderVisibleTools);
-    assert.equal(chapterhouseTools.some((tool) => tool.name === "memory_reflect"), true);
-    assert.equal(coderTools.some((tool) => tool.name === "memory_reflect"), false);
-    const scope = db.prepare(`SELECT id FROM mem_scopes WHERE slug = 'chapterhouse'`).get();
-    db.prepare(`
-    INSERT INTO mem_observations (scope_id, content, source, tier)
-    VALUES (?, ?, 'test', 'hot'), (?, ?, 'test', 'warm'), (?, ?, 'test', 'warm')
-  `).run(scope.id, "The worker queue serializes task execution through SQLite state.", scope.id, "Worker queue execution is serialized using SQLite-backed state.", scope.id, "SQLite keeps worker queue execution serialized across turns.");
-    const memoryReflect = findTool(chapterhouseTools, "memory_reflect");
-    const result = await memoryReflect.handler({ scope: "chapterhouse" }, {});
-    assert.deepEqual(result, {
-        ok: true,
-        scope: "chapterhouse",
-        patterns_created: 1,
-        patterns_updated: 0,
-        contradictions_found: 0,
-    });
-});
-//# sourceMappingURL=reflect.test.js.map

package/dist/memory/scope-lock.js

@@ -1,26 +0,0 @@
-const inFlightScopeWrites = new Set();
-function uniqueScopeIds(scopeIds) {
-    return [...new Set(scopeIds)].sort((left, right) => left - right);
-}
-export function tryAcquireScopeWriteLocks(scopeIds) {
-    const uniqueScopeIdsToAcquire = uniqueScopeIds(scopeIds);
-    if (uniqueScopeIdsToAcquire.some((scopeId) => inFlightScopeWrites.has(scopeId))) {
-        return false;
-    }
-    for (const scopeId of uniqueScopeIdsToAcquire) {
-        inFlightScopeWrites.add(scopeId);
-    }
-    return true;
-}
-export function releaseScopeWriteLocks(scopeIds) {
-    for (const scopeId of uniqueScopeIds(scopeIds)) {
-        inFlightScopeWrites.delete(scopeId);
-    }
-}
-export function isScopeWriteLocked(scopeIds) {
-    if (!scopeIds || scopeIds.length === 0) {
-        return inFlightScopeWrites.size > 0;
-    }
-    return uniqueScopeIds(scopeIds).some((scopeId) => inFlightScopeWrites.has(scopeId));
-}
-//# sourceMappingURL=scope-lock.js.map

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

@@ -1,118 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-const sharedScope = {
-    id: 11,
-    slug: "shared",
-    title: "Shared",
-    description: "Shared scope for lock tests.",
-    keywords: ["shared"],
-    active: true,
-    createdAt: new Date().toISOString(),
-    updatedAt: new Date().toISOString(),
-};
-async function loadModules(t, tieringPass) {
-    t.mock.module("../config.js", {
-        namedExports: {
-            config: {
-                copilotModel: "test-model",
-                memoryDecayDays: 30,
-                memoryInboxRetentionDays: 7,
-                memoryCheckpointTurns: 5,
-                memoryCheckpointEnabled: true,
-            },
-        },
-    });
-    t.mock.module("../copilot/oneshot.js", {
-        namedExports: {
-            runOneShotPrompt: async () => ({ content: JSON.stringify({ proposals: [] }) }),
-        },
-    });
-    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: () => sharedScope,
-        },
-    });
-    t.mock.module("./scopes.js", {
-        namedExports: {
-            getScope: (slug) => (slug === sharedScope.slug ? sharedScope : null),
-            listScopes: () => [{ id: sharedScope.id, active: true }],
-        },
-    });
-    t.mock.module("./entities.js", {
-        namedExports: {
-            listEntities: () => [],
-        },
-    });
-    t.mock.module("./decisions.js", {
-        namedExports: {
-            listDecisions: () => [],
-            recordDecision: () => ({ id: 1 }),
-        },
-    });
-    t.mock.module("./observations.js", {
-        namedExports: {
-            listObservations: () => [],
-            recordObservation: () => ({ id: 1 }),
-        },
-    });
-    t.mock.module("./checkpoint-prompt.js", {
-        namedExports: {
-            buildCheckpointSystemPrompt: () => "system",
-            buildCheckpointUserPrompt: () => "user",
-        },
-    });
-    t.mock.module("./tiering.js", {
-        namedExports: {
-            tieringPass,
-        },
-    });
-    const checkpointModule = await import(new URL(`./checkpoint.js?case=${Date.now()}-${Math.random()}`, import.meta.url).href);
-    const housekeepingModule = await import(new URL(`./housekeeping.js?case=${Date.now()}-${Math.random()}`, import.meta.url).href);
-    return { checkpointModule, housekeepingModule };
-}
-test("runCheckpointExtraction skips writes while housekeeping holds the same scope lock", async (t) => {
-    let releaseHousekeeping;
-    const { checkpointModule, housekeepingModule } = await loadModules(t, async (scopeId) => {
-        assert.equal(scopeId, sharedScope.id);
-        await new Promise((resolve) => {
-            releaseHousekeeping = resolve;
-        });
-        return { pass: `tieringPass:${scopeId}`, examined: 1, modified: 1, errors: [] };
-    });
-    const housekeepingRun = housekeepingModule.runHousekeeping({ scopeIds: [sharedScope.id], passes: ["tiering"] });
-    await Promise.resolve();
-    const checkpointResult = await checkpointModule.runCheckpointExtraction({
-        turns: [{ user: "Remember this.", assistant: "Okay." }],
-        activeScope: sharedScope,
-        copilotClient: {},
-        callLLM: async () => JSON.stringify({
-            proposals: [
-                {
-                    kind: "observation",
-                    content: "Shared scope writes should not overlap housekeeping.",
-                    confidence: 0.95,
-                },
-            ],
-        }),
-    });
-    assert.deepEqual(checkpointResult, { written: 0, skipped: 0, errors: [] });
-    releaseHousekeeping?.();
-    await housekeepingRun;
-});
-//# sourceMappingURL=scope-lock.test.js.map