gsd-pi 2.78.0 → 2.78.1-dev.2ff77b0ce

package/src/resources/extensions/gsd/tests/integration/token-savings.test.ts

@@ -338,27 +338,4 @@ console.log('\n=== token-savings: quality — correct scoping, no cross-contamin
   rmSync(base, { recursive: true, force: true });
 }
 
-// ═══════════════════════════════════════════════════════════════════════════
-// Test: Fixture data realism — sufficient volume and distribution
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n=== token-savings: fixture data realism ===');
-{
-  // Verify fixture generators produce sufficient volume
-  assert.ok(DECISIONS_COUNT >= 20, `decisions count ≥ 20 (actual: ${DECISIONS_COUNT})`);
-  assert.ok(REQUIREMENTS_COUNT >= 20, `requirements count ≥ 20 (actual: ${REQUIREMENTS_COUNT})`);
-  assert.ok(MILESTONES.length >= 3, `milestones ≥ 3 (actual: ${MILESTONES.length})`);
-  assert.ok(SLICE_ASSIGNMENTS.length >= 5, `slice assignments ≥ 5 (actual: ${SLICE_ASSIGNMENTS.length})`);
-
-  // Verify markdown content is substantial
-  assert.ok(decisionsMarkdown.length > 1000, `decisions markdown > 1000 chars (actual: ${decisionsMarkdown.length})`);
-  assert.ok(requirementsMarkdown.length > 1000, `requirements markdown > 1000 chars (actual: ${requirementsMarkdown.length})`);
-
-  // Verify content structure
-  assert.match(decisionsMarkdown, /\| D001 \|/, 'decisions markdown has D001');
-  assert.match(decisionsMarkdown, /\| D024 \|/, 'decisions markdown has D024');
-  assert.match(requirementsMarkdown, /### R001/, 'requirements markdown has R001');
-  assert.match(requirementsMarkdown, /### R021/, 'requirements markdown has R021');
-}
-
 // ─── Report ────────────────────────────────────────────────────────────────

package/src/resources/extensions/gsd/tests/journal-integration.test.ts

@@ -410,7 +410,7 @@ test("runUnitPhase emits unit-start and unit-end with causedBy reference", async
   // Instead, we test that unit-start is emitted at the right point by examining
   // the event immediately after calling runUnitPhase with a session where
   // newSession resolves quickly, and we resolve the agent_end externally.
-  const { resolveAgentEnd, _resetPendingResolve } = await import("../auto-loop.js");
+  const { resolveAgentEnd, _resetPendingResolve } = await import("../auto/resolve.js");
   _resetPendingResolve();
 
   const deps = makeMockDeps(capture);
@@ -464,7 +464,7 @@ test("runUnitPhase emits unit-start and unit-end with causedBy reference", async
 
 test("runUnitPhase increments unitDispatchCount for repeated artifact-missing retries", async () => {
   const capture = createEventCapture();
-  const { resolveAgentEnd, _resetPendingResolve } = await import("../auto-loop.js");
+  const { resolveAgentEnd, _resetPendingResolve } = await import("../auto/resolve.js");
   _resetPendingResolve();
 
   const deps = makeMockDeps(capture);
@@ -499,7 +499,7 @@ test("runUnitPhase increments unitDispatchCount for repeated artifact-missing re
 
 test("all events from a mock iteration have monotonically increasing seq and same flowId", async () => {
   const capture = createEventCapture();
-  const { resolveAgentEnd, _resetPendingResolve } = await import("../auto-loop.js");
+  const { resolveAgentEnd, _resetPendingResolve } = await import("../auto/resolve.js");
   _resetPendingResolve();
 
   const deps = makeMockDeps(capture, {
@@ -708,6 +708,121 @@ test("#4671: plan-v2 missing CONTEXT.md reaches dispatch recovery instead of pau
   }
 });
 
+test("plan-v2 empty graph rederives state before pausing", async () => {
+  const basePath = mkdtempSync(join(tmpdir(), "gsd-plan-v2-empty-graph-"));
+  mkdirSync(join(basePath, ".gsd", "milestones", "M001"), { recursive: true });
+  writeFileSync(
+    join(basePath, ".gsd", "milestones", "M001", "M001-CONTEXT.md"),
+    "# M001: Test\n\nFinalized context.\n",
+  );
+  openDatabase(join(basePath, ".gsd", "gsd.db"));
+  try {
+    let deriveCalls = 0;
+    let invalidateCalls = 0;
+    let pauseCalls = 0;
+    const capture = createEventCapture();
+    const deps = makeMockDeps(capture, {
+      pauseAuto: async () => { pauseCalls++; },
+      invalidateAllCaches: () => { invalidateCalls++; },
+      deriveState: async () => {
+        deriveCalls++;
+        if (deriveCalls === 1) {
+          return {
+            phase: "validating-milestone",
+            activeMilestone: { id: "M001", title: "Test", status: "active" },
+            activeSlice: null,
+            activeTask: null,
+            registry: [{ id: "M001", status: "active" }],
+            blockers: [],
+            recentDecisions: [],
+            nextAction: "Validate milestone M001.",
+          } as any;
+        }
+        return {
+          phase: "pre-planning",
+          activeMilestone: { id: "M001", title: "Test", status: "active" },
+          activeSlice: null,
+          activeTask: null,
+          registry: [{ id: "M001", status: "active" }],
+          blockers: [],
+          recentDecisions: [],
+          nextAction: "Plan milestone M001.",
+        } as any;
+      },
+    });
+    const ic = makeIC(deps, {
+      prefs: { uok: { plan_v2: { enabled: true } } } as any,
+    });
+    ic.s.basePath = basePath;
+
+    const result = await runPreDispatch(ic, {
+      recentUnits: [],
+      stuckRecoveryAttempts: 0,
+      consecutiveFinalizeTimeouts: 0,
+    });
+
+    assert.equal(result.action, "next");
+    assert.equal(deriveCalls, 2, "empty plan graph should trigger one state rederive");
+    assert.ok(invalidateCalls >= 1, "empty plan graph recovery should clear caches before rederive");
+    assert.equal(pauseCalls, 0, "recoverable empty graph should not pause auto-mode");
+  } finally {
+    closeDatabase();
+    rmSync(basePath, { recursive: true, force: true });
+  }
+});
+
+test("plan-v2 empty graph pauses after one failed rederive", async () => {
+  const basePath = mkdtempSync(join(tmpdir(), "gsd-plan-v2-empty-graph-pause-"));
+  mkdirSync(join(basePath, ".gsd", "milestones", "M001"), { recursive: true });
+  writeFileSync(
+    join(basePath, ".gsd", "milestones", "M001", "M001-CONTEXT.md"),
+    "# M001: Test\n\nFinalized context.\n",
+  );
+  openDatabase(join(basePath, ".gsd", "gsd.db"));
+  try {
+    let deriveCalls = 0;
+    let invalidateCalls = 0;
+    let pauseCalls = 0;
+    const capture = createEventCapture();
+    const deps = makeMockDeps(capture, {
+      pauseAuto: async () => { pauseCalls++; },
+      invalidateAllCaches: () => { invalidateCalls++; },
+      deriveState: async () => {
+        deriveCalls++;
+        return {
+          phase: "validating-milestone",
+          activeMilestone: { id: "M001", title: "Test", status: "active" },
+          activeSlice: null,
+          activeTask: null,
+          registry: [{ id: "M001", status: "active" }],
+          blockers: [],
+          recentDecisions: [],
+          nextAction: "Validate milestone M001.",
+        } as any;
+      },
+    });
+    const ic = makeIC(deps, {
+      prefs: { uok: { plan_v2: { enabled: true } } } as any,
+    });
+    ic.s.basePath = basePath;
+
+    const result = await runPreDispatch(ic, {
+      recentUnits: [],
+      stuckRecoveryAttempts: 0,
+      consecutiveFinalizeTimeouts: 0,
+    });
+
+    assert.equal(result.action, "break");
+    assert.equal(result.reason, "plan-v2-gate-failed");
+    assert.equal(deriveCalls, 2, "empty plan graph should only rederive once");
+    assert.ok(invalidateCalls >= 1, "empty plan graph recovery should clear caches before rederive");
+    assert.equal(pauseCalls, 1, "persistent empty graph should pause auto-mode");
+  } finally {
+    closeDatabase();
+    rmSync(basePath, { recursive: true, force: true });
+  }
+});
+
 test("milestone-transition event is emitted when milestone changes", async () => {
   const capture = createEventCapture();
   const deps = makeMockDeps(capture, {
@@ -723,7 +838,9 @@ test("milestone-transition event is emitted when milestone changes", async () =>
       blockers: [],
     }) as any,
   });
-  const ic = makeIC(deps);
+  const ic = makeIC(deps, {
+    prefs: { uok: { plan_v2: { enabled: false } } } as any,
+  });
   // Session says current milestone is M001, but state will return M002
   ic.s.currentMilestoneId = "M001";
   const loopState: LoopState = { recentUnits: [], stuckRecoveryAttempts: 0, consecutiveFinalizeTimeouts: 0 };
@@ -739,7 +856,7 @@ test("milestone-transition event is emitted when milestone changes", async () =>
 
 test("unit-end event contains errorContext when unit is cancelled with structured error", async () => {
   const capture = createEventCapture();
-  const { resolveAgentEndCancelled, _resetPendingResolve } = await import("../auto-loop.js");
+  const { resolveAgentEndCancelled, _resetPendingResolve } = await import("../auto/resolve.js");
   _resetPendingResolve();
 
   let pauseCalls = 0;
@@ -794,7 +911,7 @@ test("unit-end event contains errorContext when unit is cancelled with structure
 
 test("session-failed cancellations close out and emit unit-end before hard stop", async () => {
   const capture = createEventCapture();
-  const { resolveAgentEndCancelled, _resetPendingResolve } = await import("../auto-loop.js");
+  const { resolveAgentEndCancelled, _resetPendingResolve } = await import("../auto/resolve.js");
   _resetPendingResolve();
 
   let closeoutCalls = 0;
@@ -906,7 +1023,7 @@ test("runFinalize pauses and emits unit-end when pre-verification times out", as
 
 test("transient session-failed cancellations pause instead of hard-stopping", async () => {
   const capture = createEventCapture();
-  const { resolveAgentEndCancelled, _resetPendingResolve } = await import("../auto-loop.js");
+  const { resolveAgentEndCancelled, _resetPendingResolve } = await import("../auto/resolve.js");
   _resetPendingResolve();
 
   const deps = makeMockDeps(capture);

package/src/resources/extensions/gsd/tests/markdown-renderer.test.ts

@@ -524,6 +524,76 @@ test('── markdown-renderer: renderPlanFromDb creates parse-compatible slice
   }
 });
 
+test('── markdown-renderer: slice plan summarizes task descriptions without leaking nested headings ──', async () => {
+  const tmpDir = makeTmpDir();
+  const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
+  openDatabase(dbPath);
+  clearAllCaches();
+
+  try {
+    scaffoldDirs(tmpDir, 'M001', ['S01']);
+
+    insertMilestone({ id: 'M001', title: 'Milestone', status: 'active' });
+    insertSlice({
+      id: 'S01',
+      milestoneId: 'M001',
+      title: 'Working app',
+      status: 'pending',
+      demo: 'The app works.',
+      planning: {
+        goal: 'Build a small app.',
+        successCriteria: 'Not provided.',
+        proofLevel: 'Not provided.',
+        integrationClosure: 'N/A',
+        observabilityImpact: 'None',
+      },
+    });
+    insertTask({
+      id: 'T01',
+      sliceId: 'S01',
+      milestoneId: 'M001',
+      title: 'Build app',
+      status: 'pending',
+      planning: {
+        description: [
+          'Create the static app files.',
+          '',
+          '## Steps',
+          '',
+          '- Create the HTML shell.',
+          '- Wire browser storage.',
+          '',
+          '## Must-Haves',
+          '',
+          '- Adding an item updates the list.',
+        ].join('\n'),
+        estimate: '30m',
+        files: ['index.html', 'app.js', 'style.css'],
+        verify: 'open index.html',
+        inputs: ['.gitignore'],
+        expectedOutput: ['index.html', 'app.js', 'style.css'],
+      },
+    });
+
+    const rendered = await renderPlanFromDb(tmpDir, 'M001', 'S01');
+    const planContent = fs.readFileSync(rendered.planPath, 'utf-8');
+    clearAllCaches();
+    const parsedPlan = parsePlan(planContent);
+
+    assert.doesNotMatch(planContent, /Not provided/i, 'placeholder values should not render');
+    assert.doesNotMatch(planContent, /^## Steps$/m, 'task detail headings must not escape into the slice plan');
+    assert.strictEqual((planContent.match(/^## Must-Haves$/gm) ?? []).length, 1, 'slice plan has only its own Must-Haves heading');
+    assert.strictEqual(parsedPlan.tasks[0].description.trim(), 'Create the static app files.');
+
+    const taskPlanContent = fs.readFileSync(path.join(tmpDir, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'tasks', 'T01-PLAN.md'), 'utf-8');
+    assert.match(taskPlanContent, /^## Steps$/m, 'task plan keeps detailed headings for executors');
+    assert.match(taskPlanContent, /^## Must-Haves$/m, 'task plan keeps detailed task must-haves');
+  } finally {
+    closeDatabase();
+    cleanupDir(tmpDir);
+  }
+});
+
 test('── markdown-renderer: renderTaskPlanFromDb throws for missing task ──', async () => {
   const tmpDir = makeTmpDir();
   const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
@@ -786,10 +856,10 @@ test('── markdown-renderer: renderAllFromDb produces all files ──', asyn
 });
 
 // ═══════════════════════════════════════════════════════════════════════════
-// Graceful Degradation (Disk Fallback)
+// DB-authoritative regeneration
 // ═══════════════════════════════════════════════════════════════════════════
 
-test('── markdown-renderer: graceful fallback reads from disk when artifact not in DB ──', async () => {
+test('── markdown-renderer: missing artifact regenerates from DB without importing disk projection ──', async () => {
   const tmpDir = makeTmpDir();
   const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
   openDatabase(dbPath);
@@ -804,7 +874,7 @@ test('── markdown-renderer: graceful fallback reads from disk when artifact
     // Write roadmap to disk but NOT in artifacts DB
     const roadmapContent = makeRoadmapContent([
       { id: 'S01', title: 'Core', done: false },
-    ]);
+    ]) + '\n\nDISK_ONLY_SENTINEL';
     const roadmapPath = path.join(tmpDir, '.gsd', 'milestones', 'M001', 'M001-ROADMAP.md');
     fs.writeFileSync(roadmapPath, roadmapContent);
     clearAllCaches();
@@ -813,14 +883,20 @@ test('── markdown-renderer: graceful fallback reads from disk when artifact
     const before = getArtifact('milestones/M001/M001-ROADMAP.md');
     assert.deepStrictEqual(before, null, 'artifact not in DB before render');
 
-    // Render — should read from disk, store in DB
+    // Render — should regenerate from DB rows, not import/patch disk content.
     const ok = await renderRoadmapCheckboxes(tmpDir, 'M001');
-    assert.ok(ok, 'render succeeds with disk fallback');
+    assert.ok(ok, 'render succeeds by regenerating from DB');
 
-    // Verify artifact now in DB (stored after reading from disk)
+    // Verify artifact now exists in DB but does not contain disk-only content.
     const after = getArtifact('milestones/M001/M001-ROADMAP.md');
-    assert.ok(after !== null, 'artifact stored in DB after disk fallback render');
-    assert.ok(after!.full_content.includes('[x] **S01:'), 'DB artifact reflects rendered state');
+    assert.ok(after !== null, 'artifact regenerated in DB');
+    assert.ok(!after!.full_content.includes('DISK_ONLY_SENTINEL'), 'disk projection content was not imported');
+    assert.ok(after!.full_content.includes('S01'), 'DB artifact reflects DB slice state');
+
+    assert.ok(fs.existsSync(roadmapPath), 'roadmap projection regenerated on disk');
+    const diskAfter = fs.readFileSync(roadmapPath, 'utf-8');
+    assert.ok(!diskAfter.includes('DISK_ONLY_SENTINEL'), 'disk projection was rewritten from DB');
+    assert.ok(diskAfter.includes('S01'), 'disk projection reflects DB slice state');
   } finally {
     closeDatabase();
     cleanupDir(tmpDir);
@@ -1158,4 +1234,3 @@ test('── markdown-renderer: detectStaleRenders finds missing slice summary a
 });
 
 // ═══════════════════════════════════════════════════════════════════════════
-

package/src/resources/extensions/gsd/tests/md-importer.test.ts

@@ -9,6 +9,7 @@ import {
   getRequirementById,
   getActiveRequirements,
   insertArtifact,
+  SCHEMA_VERSION,
   _getAdapter,
 } from '../gsd-db.ts';
 import {
@@ -363,7 +364,7 @@ test('md-importer: schema v1→v2 migration', () => {
   openDatabase(':memory:');
   const adapter = _getAdapter();
   const version = adapter?.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assert.deepStrictEqual(version?.v, 22, 'new DB should be at schema version 22');
+  assert.deepStrictEqual(version?.v, SCHEMA_VERSION, `new DB should be at schema version ${SCHEMA_VERSION}`);
 
   // Artifacts table should exist
   const tableCheck = adapter?.prepare("SELECT count(*) as c FROM sqlite_master WHERE type='table' AND name='artifacts'").get();

package/src/resources/extensions/gsd/tests/memory-store.test.ts

@@ -2,8 +2,14 @@ import {
   openDatabase,
   closeDatabase,
   isDbAvailable,
+  SCHEMA_VERSION,
   _getAdapter,
 } from '../gsd-db.ts';
+import {
+  _resetLogs,
+  peekLogs,
+  setStderrLoggingEnabled,
+} from '../workflow-logger.ts';
 import {
   getActiveMemories,
   getActiveMemoriesRanked,
@@ -323,9 +329,132 @@ test('memory-store: schema includes memories table', () => {
   const viewCount = adapter.prepare('SELECT count(*) as cnt FROM active_memories').get();
   assert.deepStrictEqual(viewCount?.['cnt'], 0, 'active_memories view should exist');
 
-  // Verify schema version is 22 (v22 quality_gates DDL fix included)
+  // Verify schema version is current (includes quality_gates DDL fix and later migrations)
   const version = adapter.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assert.deepStrictEqual(version?.["v"], 22, 'schema version should be 22');
+  assert.deepStrictEqual(version?.["v"], SCHEMA_VERSION, `schema version should be ${SCHEMA_VERSION}`);
+
+  closeDatabase();
+});
+
+// ═══════════════════════════════════════════════════════════════════════════
+// regression #4967 — createMemory must not silently swallow SQL errors
+// ═══════════════════════════════════════════════════════════════════════════
+
+test('memory-store: createMemory throws on memory-table SQL errors (regression #4967)', () => {
+  openDatabase(':memory:');
+
+  const adapter = _getAdapter()!;
+  // Drop FTS + dependents first to satisfy SQLite's trigger ordering, then
+  // the base memories table. IF EXISTS makes setup robust against schema
+  // versions that may not have created every dependent (e.g. embeddings).
+  adapter.prepare('DROP TABLE IF EXISTS memory_embeddings').run();
+  adapter.prepare('DROP TABLE IF EXISTS memories_fts').run();
+  adapter.prepare('DROP TABLE IF EXISTS memories').run();
+
+  // Pre-fix behaviour: returns null and the caller has no idea why.
+  // Post-fix behaviour: throws so the caller can surface the real SQL message.
+  assert.throws(
+    () => createMemory({ category: 'gotcha', content: 'broken store' }),
+    /memories|no such table/i,
+    'createMemory must surface SQL errors instead of returning null',
+  );
+
+  closeDatabase();
+});
+
+test('memory-store: VACUUM retry rolls back partial memory and logs recovery', () => {
+  openDatabase(':memory:');
+
+  const adapter = _getAdapter()!;
+  const originalPrepareMethod = adapter.prepare;
+  const originalPrepare = adapter.prepare.bind(adapter);
+  const previousStderrLogging = setStderrLoggingEnabled(false);
+  const streamAny = process.stderr as unknown as {
+    write: (chunk: string | Uint8Array, ...rest: unknown[]) => boolean;
+  };
+  const originalStderrWrite = streamAny.write.bind(streamAny);
+  let selectFailures = 0;
+  let vacuumRuns = 0;
+  _resetLogs();
+
+  adapter.prepare = ((sql: string) => {
+    if (sql === 'SELECT seq FROM memories WHERE id = :id' && selectFailures === 0) {
+      const stmt = originalPrepare(sql);
+      return {
+        run: (...params: unknown[]) => stmt.run(...params),
+        get: (..._params: unknown[]) => {
+          selectFailures++;
+          throw new Error('database disk image is malformed');
+        },
+        all: (...params: unknown[]) => stmt.all(...params),
+      };
+    }
+
+    if (sql === 'VACUUM') {
+      const stmt = originalPrepare(sql);
+      return {
+        run: (...params: unknown[]) => {
+          vacuumRuns++;
+          return stmt.run(...params);
+        },
+        get: (...params: unknown[]) => stmt.get(...params),
+        all: (...params: unknown[]) => stmt.all(...params),
+      };
+    }
+
+    return originalPrepare(sql);
+  }) as typeof adapter.prepare;
+  streamAny.write = (): boolean => true;
+
+  try {
+    const id = createMemory({ category: 'gotcha', content: 'recover without duplicate' });
+    assert.equal(id, 'MEM001', 'retry should create a single first memory');
+
+    const rows = adapter.prepare('SELECT id FROM memories ORDER BY seq').all();
+    assert.deepStrictEqual(
+      rows.map((row) => row['id']),
+      ['MEM001'],
+      'failed first attempt should not leave a live _TMP_ memory behind',
+    );
+    assert.equal(selectFailures, 1, 'test should simulate one malformed SELECT after INSERT');
+    assert.equal(vacuumRuns, 1, 'malformed recovery should run VACUUM once');
+    assert.ok(
+      peekLogs().some((entry) =>
+        entry.component === 'memory-store' &&
+        entry.message === 'recovered malformed memory store via VACUUM'
+      ),
+      'successful VACUUM recovery should be emitted to the workflow logger',
+    );
+  } finally {
+    adapter.prepare = originalPrepareMethod;
+    streamAny.write = originalStderrWrite;
+    setStderrLoggingEnabled(previousStderrLogging);
+    _resetLogs();
+    closeDatabase();
+  }
+});
+
+test('memory-store: applyMemoryActions stays non-fatal when memory store is broken (regression #4967)', () => {
+  openDatabase(':memory:');
+
+  const adapter = _getAdapter()!;
+  // Drop FTS + dependents first to satisfy SQLite's trigger ordering, then
+  // the base memories table. IF EXISTS makes setup robust against schema
+  // versions that may not have created every dependent (e.g. embeddings).
+  adapter.prepare('DROP TABLE IF EXISTS memory_embeddings').run();
+  adapter.prepare('DROP TABLE IF EXISTS memories_fts').run();
+  adapter.prepare('DROP TABLE IF EXISTS memories').run();
+
+  // applyMemoryActions wraps createMemory in a transaction with an outer
+  // catch. Even with createMemory now throwing, applyMemoryActions must not
+  // crash the auto-mode flow that calls it (memory extraction is best-effort).
+  const actions: MemoryAction[] = [
+    { action: 'CREATE', category: 'gotcha', content: 'inside-transaction call' },
+  ];
+  assert.doesNotThrow(
+    () => applyMemoryActions(actions),
+    'applyMemoryActions must absorb thrown errors so callers continue',
+  );
 
   closeDatabase();
 });

package/src/resources/extensions/gsd/tests/memory-tools.test.ts

@@ -1,7 +1,7 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 
-import { closeDatabase, openDatabase } from '../gsd-db.ts';
+import { _getAdapter, closeDatabase, openDatabase } from '../gsd-db.ts';
 import { createMemory, supersedeMemory } from '../memory-store.ts';
 import {
   executeGsdGraph,
@@ -293,3 +293,35 @@ test('memory-tools: gsd_graph errors when DB is closed', () => {
   assert.ok(result.isError);
   assert.equal(result.details.error, 'db_unavailable');
 });
+
+// ═══════════════════════════════════════════════════════════════════════════
+// regression #4967 — capture_thought must surface real SQL errors
+// ═══════════════════════════════════════════════════════════════════════════
+
+test('memory-tools: capture_thought surfaces underlying SQL error (regression #4967)', () => {
+  openDatabase(':memory:');
+
+  // Simulate the real-world failure mode where the memories table is gone.
+  // The original bug was a "database disk image is malformed" on the memory
+  // store; dropping the table produces a deterministic statement-time SQL
+  // error of the same shape — a thrown sqlite error during INSERT.
+  const adapter = _getAdapter()!;
+  adapter.prepare('DROP TABLE IF EXISTS memory_embeddings').run();
+  adapter.prepare('DROP TABLE IF EXISTS memories_fts').run();
+  adapter.prepare('DROP TABLE IF EXISTS memories').run();
+
+  const result = executeMemoryCapture({
+    category: 'gotcha',
+    content: 'should reveal the real reason',
+  });
+
+  assert.ok(result.isError, 'broken store should produce an error result');
+  assert.equal(result.details.operation, 'memory_capture');
+
+  const err = String(result.details.error ?? '');
+  assert.notEqual(err, 'create_failed', 'must not collapse to opaque create_failed');
+  assert.ok(err.length > 0, 'error detail must be populated');
+  assert.match(err, /memories|no such table/i, 'error must reference the underlying SQL fault');
+
+  closeDatabase();
+});