chapterhouse 0.3.26 → 0.4.0

package/dist/memory/checkpoint.test.js

@@ -0,0 +1,255 @@
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import test from "node:test";
+const repoRoot = process.cwd();
+const sandboxRoot = join(repoRoot, ".test-work", `memory-checkpoint-${process.pid}`);
+const chapterhouseHome = join(sandboxRoot, ".chapterhouse");
+process.env.CHAPTERHOUSE_HOME = sandboxRoot;
+function resetSandbox() {
+    mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
+    rmSync(sandboxRoot, { recursive: true, force: true });
+    mkdirSync(chapterhouseHome, { recursive: true });
+}
+async function loadModules(cacheBust = `${Date.now()}-${Math.random()}`) {
+    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);
+    const checkpointPromptModule = await import(new URL(`./checkpoint-prompt.js?case=${cacheBust}`, import.meta.url).href);
+    return { dbModule, memoryModule, checkpointModule, checkpointPromptModule };
+}
+function getFunction(module, name) {
+    const value = module[name];
+    assert.equal(typeof value, "function", `expected ${name} to be exported`);
+    return value;
+}
+function getConstructor(module, name) {
+    const value = module[name];
+    assert.equal(typeof value, "function", `expected ${name} to be exported`);
+    return value;
+}
+test.beforeEach(async () => {
+    delete process.env.CHAPTERHOUSE_MEMORY_CHECKPOINT_ENABLED;
+    delete process.env.CHAPTERHOUSE_MEMORY_CHECKPOINT_ON_SCOPE_CHANGE;
+    delete process.env.CHAPTERHOUSE_MEMORY_CHECKPOINT_MIN_TURNS_FOR_SCOPE_FIRE;
+    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
+    dbModule.closeDb();
+    resetSandbox();
+});
+test.after(async () => {
+    delete process.env.CHAPTERHOUSE_MEMORY_CHECKPOINT_ENABLED;
+    delete process.env.CHAPTERHOUSE_MEMORY_CHECKPOINT_ON_SCOPE_CHANGE;
+    delete process.env.CHAPTERHOUSE_MEMORY_CHECKPOINT_MIN_TURNS_FOR_SCOPE_FIRE;
+    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
+    dbModule.closeDb();
+    rmSync(sandboxRoot, { recursive: true, force: true });
+});
+test("CheckpointTracker increments on orchestrator turns, fires at cadence, and resets after markFired", async () => {
+    const { checkpointModule } = await loadModules();
+    const CheckpointTracker = getConstructor(checkpointModule, "CheckpointTracker");
+    const tracker = new CheckpointTracker({ turns: 3, enabled: true });
+    assert.equal(tracker.turnsSinceLastFire(), 0);
+    assert.equal(tracker.shouldFire(), false);
+    tracker.tickOrchestratorTurn();
+    assert.equal(tracker.turnsSinceLastFire(), 1);
+    assert.equal(tracker.shouldFire(), false);
+    tracker.tickOrchestratorTurn();
+    assert.equal(tracker.turnsSinceLastFire(), 2);
+    assert.equal(tracker.shouldFire(), false);
+    tracker.tickOrchestratorTurn();
+    assert.equal(tracker.turnsSinceLastFire(), 3);
+    assert.equal(tracker.shouldFire(), true);
+    tracker.markFired();
+    assert.equal(tracker.turnsSinceLastFire(), 0);
+    assert.equal(tracker.shouldFire(), false);
+    tracker.tickOrchestratorTurn();
+    assert.equal(tracker.turnsSinceLastFire(), 1);
+    assert.equal(tracker.shouldFire(), false);
+    tracker.markScopeChangeFire();
+    assert.equal(tracker.turnsSinceLastFire(), 0);
+    tracker.reset();
+    assert.equal(tracker.turnsSinceLastFire(), 0);
+    assert.equal(tracker.shouldFire(), false);
+});
+test("CheckpointTracker stays disabled when CHAPTERHOUSE_MEMORY_CHECKPOINT_ENABLED=0", async () => {
+    process.env.CHAPTERHOUSE_MEMORY_CHECKPOINT_ENABLED = "0";
+    const { checkpointModule } = await loadModules("disabled");
+    const CheckpointTracker = getConstructor(checkpointModule, "CheckpointTracker");
+    const tracker = new CheckpointTracker();
+    for (let index = 0; index < 10; index++) {
+        tracker.tickOrchestratorTurn();
+    }
+    assert.equal(tracker.shouldFire(), false);
+});
+test("runCheckpointExtraction writes high-confidence memories, skips low-confidence duplicates, and caps at five writes", async () => {
+    const { dbModule, memoryModule, checkpointModule } = await loadModules();
+    dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const recordObservation = getFunction(memoryModule, "recordObservation");
+    const listObservations = getFunction(memoryModule, "listObservations");
+    const listDecisions = getFunction(memoryModule, "listDecisions");
+    const runCheckpointExtraction = getFunction(checkpointModule, "runCheckpointExtraction");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
+    recordObservation({
+        scope_id: chapterhouse.id,
+        content: "Base new memory implementation branches from origin/main after dependent PRs merge.",
+        source: "agent:test",
+    });
+    const result = await runCheckpointExtraction({
+        turns: [
+            {
+                user: "Implement checkpoint extraction after the response is committed.",
+                assistant: "I will add an async checkpoint pass with a five-turn cadence.",
+            },
+        ],
+        activeScope: chapterhouse,
+        copilotClient: {},
+        callLLM: async () => JSON.stringify({
+            proposals: [
+                {
+                    kind: "observation",
+                    content: "Base new memory implementation branches from origin/main after dependent PRs merge.",
+                    confidence: 0.99,
+                },
+                {
+                    kind: "decision",
+                    title: "Run checkpoint extraction asynchronously",
+                    content: "Checkpoint extraction runs in the background after the assistant response completes so the next user turn is never blocked.",
+                    confidence: 0.98,
+                },
+                {
+                    kind: "observation",
+                    content: "Only orchestrator turns count toward the checkpoint cadence.",
+                    confidence: 0.97,
+                },
+                {
+                    kind: "observation",
+                    content: "Checkpoint extraction skips overlapping runs instead of queueing them.",
+                    confidence: 0.96,
+                },
+                {
+                    kind: "observation",
+                    content: "Checkpoint extraction defaults to the active scope when writing remembered items.",
+                    confidence: 0.95,
+                },
+                {
+                    kind: "observation",
+                    content: "Checkpoint prompts include recent durable decisions already recorded in the active scope to avoid duplicates.",
+                    confidence: 0.94,
+                },
+                {
+                    kind: "observation",
+                    content: "Checkpoint prompts stay under a tight token budget.",
+                    confidence: 0.93,
+                },
+                {
+                    kind: "observation",
+                    content: "Low-confidence chatter about ephemeral commit messages should not be remembered.",
+                    confidence: 0.49,
+                },
+            ],
+        }),
+    });
+    assert.deepEqual(result.errors, []);
+    assert.equal(result.written, 5);
+    assert.equal(result.skipped, 3);
+    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();
+    dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const runCheckpointExtraction = getFunction(checkpointModule, "runCheckpointExtraction");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
+    const result = await runCheckpointExtraction({
+        turns: [{ user: "Remember this.", assistant: "Okay." }],
+        activeScope: chapterhouse,
+        copilotClient: {},
+        callLLM: async () => "{ definitely-not-json",
+    });
+    assert.equal(result.written, 0);
+    assert.ok(result.errors.length >= 1);
+});
+test("runCheckpointExtraction prevents overlapping executions with the in-flight guard", async () => {
+    const { dbModule, memoryModule, checkpointModule } = await loadModules();
+    dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const runCheckpointExtraction = getFunction(checkpointModule, "runCheckpointExtraction");
+    const isCheckpointInFlight = getFunction(checkpointModule, "isCheckpointInFlight");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
+    let resolveFirst;
+    let llmCalls = 0;
+    const pendingResponse = new Promise((resolve) => {
+        resolveFirst = resolve;
+    });
+    const firstRun = runCheckpointExtraction({
+        turns: [{ user: "First", assistant: "Turn" }],
+        activeScope: chapterhouse,
+        copilotClient: {},
+        callLLM: async () => {
+            llmCalls++;
+            return await pendingResponse;
+        },
+    });
+    assert.equal(isCheckpointInFlight(), true);
+    const secondRun = await runCheckpointExtraction({
+        turns: [{ user: "Second", assistant: "Turn" }],
+        activeScope: chapterhouse,
+        copilotClient: {},
+        callLLM: async () => {
+            llmCalls++;
+            return JSON.stringify({ proposals: [] });
+        },
+    });
+    assert.equal(secondRun.written, 0);
+    assert.equal(llmCalls, 1);
+    resolveFirst(JSON.stringify({ proposals: [] }));
+    await firstRun;
+    assert.equal(isCheckpointInFlight(), false);
+});
+test("buildCheckpointUserPrompt adds scope-change instructions when context is provided", async () => {
+    const { checkpointPromptModule } = await loadModules("scope-change-prompt");
+    const buildCheckpointUserPrompt = getFunction(checkpointPromptModule, "buildCheckpointUserPrompt");
+    const prompt = buildCheckpointUserPrompt({
+        turns: [{ user: "Wrap PR 4.5", assistant: "Switching to wiki lint next." }],
+        activeScope: {
+            id: 1,
+            slug: "chapterhouse",
+            title: "Chapterhouse",
+            description: "Core Chapterhouse work.",
+        },
+        entities: [],
+        decisions: [],
+        scopeChangeContext: { from: "chapterhouse", to: "wiki" },
+    });
+    assert.match(prompt, /moving from scope chapterhouse to wiki/i);
+    assert.match(prompt, /extract everything worth remembering about scope chapterhouse/i);
+});
+test("runCheckpointExtraction passes scope-change context through to the prompt", async () => {
+    const { dbModule, memoryModule, checkpointModule } = await loadModules("scope-change-context");
+    dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const runCheckpointExtraction = getFunction(checkpointModule, "runCheckpointExtraction");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
+    let capturedUserPrompt = "";
+    const result = await runCheckpointExtraction({
+        turns: [{ user: "Finish memory work", assistant: "Next I will move to wiki cleanup." }],
+        activeScope: chapterhouse,
+        copilotClient: {},
+        trigger: "scope_change",
+        scopeChangeContext: { from: "chapterhouse", to: "wiki" },
+        callLLM: async ({ user }) => {
+            capturedUserPrompt = user;
+            return JSON.stringify({ proposals: [] });
+        },
+    });
+    assert.deepEqual(result.errors, []);
+    assert.match(capturedUserPrompt, /moving from scope chapterhouse to wiki/i);
+    assert.match(capturedUserPrompt, /before the context shifts/i);
+});
+//# sourceMappingURL=checkpoint.test.js.map

package/dist/memory/decisions.js

@@ -0,0 +1,53 @@
+import { getDb } from "../store/db.js";
+function toDecision(row) {
+    return {
+        id: row.id,
+        scopeId: row.scope_id,
+        entityId: row.entity_id ?? undefined,
+        title: row.title,
+        rationale: row.rationale,
+        decidedAt: row.decided_at,
+        tier: row.tier,
+        supersededBy: row.superseded_by ?? undefined,
+        archivedAt: row.archived_at ?? undefined,
+        createdAt: row.created_at,
+    };
+}
+export function recordDecision(input) {
+    const result = getDb().prepare(`
+    INSERT INTO mem_decisions (scope_id, entity_id, title, rationale, decided_at, tier, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+  `).run(input.scope_id, input.entity_id ?? null, input.title, input.rationale, input.decided_at ?? new Date().toISOString().slice(0, 10), input.tier ?? "warm");
+    return getDecision(Number(result.lastInsertRowid));
+}
+export function getDecision(id) {
+    const row = getDb().prepare(`
+    SELECT id, scope_id, entity_id, title, rationale, decided_at, tier, superseded_by, archived_at, created_at
+    FROM mem_decisions
+    WHERE id = ?
+  `).get(id);
+    return row ? toDecision(row) : undefined;
+}
+export function listDecisions(input = {}) {
+    const rows = getDb().prepare(`
+    SELECT id, scope_id, entity_id, title, rationale, decided_at, tier, superseded_by, archived_at, created_at
+    FROM mem_decisions
+    WHERE (? IS NULL OR scope_id = ?)
+      AND (? IS NULL OR entity_id = ?)
+    ORDER BY decided_at DESC, id DESC
+    LIMIT ? OFFSET ?
+  `).all(input.scope_id ?? null, input.scope_id ?? null, input.entity_id ?? null, input.entity_id ?? null, input.limit ?? 50, input.offset ?? 0);
+    return rows.map(toDecision);
+}
+export function supersedeDecision(id, supersededByDecisionId) {
+    const result = getDb().prepare(`
+    UPDATE mem_decisions
+    SET superseded_by = ?
+    WHERE id = ?
+  `).run(supersededByDecisionId, id);
+    if (result.changes === 0) {
+        throw new Error(`Unknown decision id '${id}'.`);
+    }
+    return getDecision(id);
+}
+//# sourceMappingURL=decisions.js.map

package/dist/memory/decisions.test.js

@@ -0,0 +1,92 @@
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import test from "node:test";
+const repoRoot = process.cwd();
+const sandboxRoot = join(repoRoot, ".test-work", `memory-decisions-${process.pid}`);
+const chapterhouseHome = join(sandboxRoot, ".chapterhouse");
+process.env.CHAPTERHOUSE_HOME = sandboxRoot;
+function resetSandbox() {
+    mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
+    rmSync(sandboxRoot, { recursive: true, force: true });
+    mkdirSync(chapterhouseHome, { recursive: true });
+}
+async function loadModules() {
+    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
+    const memoryModule = await import(new URL("./index.js", import.meta.url).href);
+    return { dbModule, memoryModule };
+}
+function getFunction(module, name) {
+    const value = module[name];
+    assert.equal(typeof value, "function", `expected ${name} to be exported`);
+    return value;
+}
+test.beforeEach(async () => {
+    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
+    dbModule.closeDb();
+    resetSandbox();
+});
+test.after(async () => {
+    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
+    dbModule.closeDb();
+    rmSync(sandboxRoot, { recursive: true, force: true });
+});
+test("recordDecision supports CRUD, supersession, and keeps the decision FTS index in sync", async () => {
+    const { dbModule, memoryModule } = await loadModules();
+    const db = dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const recordDecision = getFunction(memoryModule, "recordDecision");
+    const getDecision = getFunction(memoryModule, "getDecision");
+    const listDecisions = getFunction(memoryModule, "listDecisions");
+    const supersedeDecision = getFunction(memoryModule, "supersedeDecision");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
+    const original = recordDecision({
+        scope_id: chapterhouse.id,
+        title: "Use SQLite for scoped memory",
+        rationale: "SQLite FTS5 keeps memory recall local, fast, and dependency-free.",
+        decided_at: "2026-05-13",
+    });
+    const replacement = recordDecision({
+        scope_id: chapterhouse.id,
+        title: "Keep SQLite for agent memory v1",
+        rationale: "SQLite remains the only persistence layer for PR 2.",
+        decided_at: "2026-05-14",
+    });
+    assert.equal(listDecisions({ scope_id: chapterhouse.id }).length >= 2, true);
+    assert.deepEqual(getDecision(original.id)?.title, original.title);
+    const initialHits = db.prepare(`
+    SELECT rowid
+    FROM mem_decisions_fts
+    WHERE mem_decisions_fts MATCH 'dependency'
+  `).all();
+    assert.deepEqual(initialHits, [{ rowid: original.id }]);
+    db.prepare(`
+    UPDATE mem_decisions
+    SET rationale = ?
+    WHERE id = ?
+  `).run("FTS snippets should refresh when the rationale changes.", original.id);
+    const oldHits = db.prepare(`
+    SELECT rowid
+    FROM mem_decisions_fts
+    WHERE mem_decisions_fts MATCH 'dependency'
+  `).all();
+    const newHits = db.prepare(`
+    SELECT rowid
+    FROM mem_decisions_fts
+    WHERE mem_decisions_fts MATCH 'snippets'
+  `).all();
+    assert.deepEqual(oldHits, []);
+    assert.deepEqual(newHits, [{ rowid: original.id }]);
+    const superseded = supersedeDecision(original.id, replacement.id);
+    assert.equal(superseded.supersededBy, replacement.id);
+    assert.equal(getDecision(original.id)?.supersededBy, replacement.id);
+    db.prepare(`DELETE FROM mem_decisions WHERE id = ?`).run(original.id);
+    const deletedHits = db.prepare(`
+    SELECT rowid
+    FROM mem_decisions_fts
+    WHERE mem_decisions_fts MATCH 'snippets'
+  `).all();
+    assert.deepEqual(deletedHits, []);
+});
+//# sourceMappingURL=decisions.test.js.map

package/dist/memory/entities.js

@@ -0,0 +1,59 @@
+import { getDb } from "../store/db.js";
+function toEntity(row) {
+    return {
+        id: row.id,
+        scopeId: row.scope_id,
+        kind: row.kind,
+        name: row.name,
+        summary: row.summary ?? undefined,
+        tier: row.tier,
+        confidence: row.confidence,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+export function getEntity(id) {
+    const row = getDb().prepare(`
+    SELECT id, scope_id, kind, name, summary, tier, confidence, created_at, updated_at
+    FROM mem_entities
+    WHERE id = ?
+  `).get(id);
+    return row ? toEntity(row) : undefined;
+}
+export function findEntityByName(scopeId, kind, name) {
+    const row = getDb().prepare(`
+    SELECT id, scope_id, kind, name, summary, tier, confidence, created_at, updated_at
+    FROM mem_entities
+    WHERE scope_id = ? AND kind = ? AND name = ?
+  `).get(scopeId, kind, name);
+    return row ? toEntity(row) : undefined;
+}
+export function upsertEntity(input) {
+    const db = getDb();
+    const existing = findEntityByName(input.scope_id, input.kind, input.name);
+    if (existing) {
+        db.prepare(`
+      UPDATE mem_entities
+      SET summary = ?, tier = ?, confidence = ?, updated_at = CURRENT_TIMESTAMP
+      WHERE id = ?
+    `).run(input.summary ?? existing.summary ?? null, input.tier ?? existing.tier, input.confidence ?? existing.confidence, existing.id);
+        return getEntity(existing.id);
+    }
+    const result = db.prepare(`
+    INSERT INTO mem_entities (scope_id, kind, name, summary, tier, confidence, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+  `).run(input.scope_id, input.kind, input.name, input.summary ?? null, input.tier ?? "warm", input.confidence ?? 1.0);
+    return getEntity(Number(result.lastInsertRowid));
+}
+export function listEntities(input = {}) {
+    const rows = getDb().prepare(`
+    SELECT id, scope_id, kind, name, summary, tier, confidence, created_at, updated_at
+    FROM mem_entities
+    WHERE (? IS NULL OR scope_id = ?)
+      AND (? IS NULL OR kind = ?)
+    ORDER BY updated_at DESC, id DESC
+    LIMIT ? OFFSET ?
+  `).all(input.scope_id ?? null, input.scope_id ?? null, input.kind ?? null, input.kind ?? null, input.limit ?? 50, input.offset ?? 0);
+    return rows.map(toEntity);
+}
+//# sourceMappingURL=entities.js.map

package/dist/memory/entities.test.js

@@ -0,0 +1,65 @@
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import test from "node:test";
+const repoRoot = process.cwd();
+const sandboxRoot = join(repoRoot, ".test-work", `memory-entities-${process.pid}`);
+const chapterhouseHome = join(sandboxRoot, ".chapterhouse");
+process.env.CHAPTERHOUSE_HOME = sandboxRoot;
+function resetSandbox() {
+    mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
+    rmSync(sandboxRoot, { recursive: true, force: true });
+    mkdirSync(chapterhouseHome, { recursive: true });
+}
+async function loadModules() {
+    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
+    const memoryModule = await import(new URL("./index.js", import.meta.url).href);
+    return { dbModule, memoryModule };
+}
+function getFunction(module, name) {
+    const value = module[name];
+    assert.equal(typeof value, "function", `expected ${name} to be exported`);
+    return value;
+}
+test.beforeEach(async () => {
+    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
+    dbModule.closeDb();
+    resetSandbox();
+});
+test.after(async () => {
+    const dbModule = await import(new URL("../store/db.js", import.meta.url).href);
+    dbModule.closeDb();
+    rmSync(sandboxRoot, { recursive: true, force: true });
+});
+test("upsertEntity is idempotent on scope, kind, and name", async () => {
+    const { dbModule, memoryModule } = await loadModules();
+    dbModule.getDb();
+    const getScope = getFunction(memoryModule, "getScope");
+    const upsertEntity = getFunction(memoryModule, "upsertEntity");
+    const getEntity = getFunction(memoryModule, "getEntity");
+    const findEntityByName = getFunction(memoryModule, "findEntityByName");
+    const listEntities = getFunction(memoryModule, "listEntities");
+    const chapterhouse = getScope("chapterhouse");
+    assert.ok(chapterhouse, "chapterhouse scope should be seeded");
+    const first = upsertEntity({
+        scope_id: chapterhouse.id,
+        kind: "tool",
+        name: "better-sqlite3",
+        summary: "SQLite driver used for memory persistence.",
+        tier: "warm",
+        confidence: 0.7,
+    });
+    const second = upsertEntity({
+        scope_id: chapterhouse.id,
+        kind: "tool",
+        name: "better-sqlite3",
+        summary: "Sync SQLite driver used throughout the daemon.",
+        tier: "hot",
+        confidence: 0.95,
+    });
+    assert.equal(second.id, first.id);
+    assert.equal(listEntities({ scope_id: chapterhouse.id, kind: "tool" }).length, 1);
+    assert.equal(findEntityByName(chapterhouse.id, "tool", "better-sqlite3")?.id, first.id);
+    assert.deepEqual(getEntity(first.id), second);
+});
+//# sourceMappingURL=entities.test.js.map