gsd-pi 2.78.0 → 2.78.1-dev.9d08d820b

package/src/resources/extensions/gsd/tests/health-widget.test.ts

@@ -66,16 +66,22 @@ test("detectHealthWidgetProjectState: milestone without metrics returns active",
   assert.equal(detectHealthWidgetProjectState(dir), "active");
 });
 
-test("buildHealthLines: none state shows onboarding copy", (t) => {
-  assert.deepEqual(buildHealthLines(activeData({ projectState: "none" })), [
-    "  GSD  No project loaded — run /gsd to start",
-  ]);
+test("buildHealthLines: none state shows single onboarding line pointing at /gsd", (t) => {
+  const lines = buildHealthLines(activeData({ projectState: "none" }));
+  assert.equal(lines.length, 1, "renders exactly one line");
+  // Should not show System OK / Budget / Last commit chrome when there's no project.
+  assert.ok(!/System OK|Budget|Last commit/.test(lines[0]!), "no active-project chrome");
+  // Should direct user to bootstrap via /gsd.
+  assert.match(lines[0]!, /\/gsd/);
 });
 
-test("buildHealthLines: initialized state shows continue setup copy", (t) => {
-  assert.deepEqual(buildHealthLines(activeData({ projectState: "initialized" })), [
-    "  GSD  Project initialized — run /gsd to continue setup",
-  ]);
+test("buildHealthLines: initialized state shows single setup line pointing at /gsd", (t) => {
+  const lines = buildHealthLines(activeData({ projectState: "initialized" }));
+  assert.equal(lines.length, 1, "renders exactly one line");
+  assert.ok(!/System OK|Budget|Last commit/.test(lines[0]!), "no active-project chrome");
+  // Distinct from "none" — must mention initialized/setup language and /gsd.
+  assert.match(lines[0]!, /\/gsd/);
+  assert.match(lines[0]!, /initiali[sz]ed|setup/i);
 });
 
 test("buildHealthLines: active state with ledger-driven spend shows spent summary", (t) => {
@@ -115,16 +121,20 @@ test("buildHealthLines: shows last commit with relative time and message", (t) =
   assert.match(lines[0]!, /feat\(widget\): add health display/);
 });
 
-test("buildHealthLines: truncates long commit messages", (t) => {
+test("buildHealthLines: truncates long commit messages with ellipsis", (t) => {
   const epoch = Math.floor(Date.now() / 1000) - 60;
-  const longMsg = "a".repeat(80);
+  const longMsg = "a".repeat(200); // far longer than any reasonable widget cap
   const lines = buildHealthLines(activeData({
     lastCommitEpoch: epoch,
     lastCommitMessage: longMsg,
   }));
   assert.equal(lines.length, 1);
-  assert.match(lines[0]!, /a{49}…/);
-  assert.ok(!lines[0]!.includes("a".repeat(51)), "message is truncated");
+  // Behavioural contract: rendered output is shorter than the input message
+  // and ends the message portion with the ellipsis character.
+  const aRun = lines[0]!.match(/a+…/);
+  assert.ok(aRun, "rendered output contains a run of a-chars terminated by an ellipsis");
+  assert.ok(aRun![0].length - 1 < longMsg.length, "truncated message is shorter than input");
+  assert.ok(!lines[0]!.includes("a".repeat(longMsg.length)), "untruncated message must not appear in output");
 });
 
 test("buildHealthLines: no last commit section when epoch is null", (t) => {

package/src/resources/extensions/gsd/tests/help-menu-coverage.test.ts

@@ -0,0 +1,57 @@
+// GSD-2 — Verify /gsd help menu covers all registered commands
+// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+import { TOP_LEVEL_SUBCOMMANDS } from "../commands/catalog.ts";
+
+/**
+ * Extracts command names from the showHelp("full") lines array.
+ * Each help line follows the pattern: "  /gsd <cmd>  ..."
+ */
+function extractHelpCommands(lines: string[]): Set<string> {
+  const cmds = new Set<string>();
+  for (const line of lines) {
+    const m = line.match(/^\s+\/gsd\s+(\S+)/);
+    if (m) cmds.add(m[1]);
+  }
+  return cmds;
+}
+
+describe("help menu coverage", () => {
+  test("every TOP_LEVEL_SUBCOMMAND appears in showHelp(\"full\") output", async () => {
+    // Import showHelp and capture its output via a mock ctx
+    const lines: string[] = [];
+    const mockCtx = {
+      ui: {
+        notify(message: string) {
+          lines.push(...message.split("\n"));
+        },
+        custom: async () => {},
+      },
+    };
+
+    const { showHelp } = await import("../commands/handlers/core.ts");
+    showHelp(mockCtx as any, "full");
+
+    const helpCmds = extractHelpCommands(lines);
+
+    // "help" is the command that shows the menu — it doesn't list itself
+    const SELF_REFERENTIAL = new Set(["help"]);
+
+    const missing: string[] = [];
+    for (const entry of TOP_LEVEL_SUBCOMMANDS) {
+      if (SELF_REFERENTIAL.has(entry.cmd)) continue;
+      if (!helpCmds.has(entry.cmd)) {
+        missing.push(entry.cmd);
+      }
+    }
+
+    assert.deepStrictEqual(
+      missing,
+      [],
+      `Commands registered in TOP_LEVEL_SUBCOMMANDS but missing from /gsd help full:\n  ${missing.join(", ")}`,
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/home-dir.test.ts

@@ -0,0 +1,52 @@
+/**
+ * Tests for getHomeDir() — cross-platform home directory resolution.
+ *
+ * @see https://github.com/gsd-build/gsd-2/issues/5015
+ */
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { homedir } from "node:os";
+
+describe("getHomeDir", () => {
+  let savedHome: string | undefined;
+  let savedUserProfile: string | undefined;
+  let getHomeDir: () => string;
+
+  beforeEach(async () => {
+    savedHome = process.env.HOME;
+    savedUserProfile = process.env.USERPROFILE;
+    const mod = await import("../home-dir.ts");
+    getHomeDir = mod.getHomeDir;
+  });
+
+  afterEach(() => {
+    if (savedHome !== undefined) {
+      process.env.HOME = savedHome;
+    } else {
+      delete process.env.HOME;
+    }
+    if (savedUserProfile !== undefined) {
+      process.env.USERPROFILE = savedUserProfile;
+    } else {
+      delete process.env.USERPROFILE;
+    }
+  });
+
+  it("returns HOME when set", () => {
+    process.env.HOME = "/test/home";
+    delete process.env.USERPROFILE;
+    assert.equal(getHomeDir(), "/test/home");
+  });
+
+  it("falls back to USERPROFILE when HOME is unset", () => {
+    delete process.env.HOME;
+    process.env.USERPROFILE = String.raw`C:\Users\test`;
+    assert.equal(getHomeDir(), String.raw`C:\Users\test`);
+  });
+
+  it("falls back to os.homedir() when both HOME and USERPROFILE are unset", () => {
+    delete process.env.HOME;
+    delete process.env.USERPROFILE;
+    assert.equal(getHomeDir(), homedir());
+  });
+});

package/src/resources/extensions/gsd/tests/import-done-milestones-runtime.test.ts

@@ -0,0 +1,145 @@
+/**
+ * Runtime regression — milestones with all-done roadmap slices import as
+ * `complete` (#3699 / #3390 / #3379), follow-up #4902.
+ *
+ * The deleted `import-done-milestones.test.ts` was a source-grep check
+ * for the literal `roadmap.slices.every(s => s.done)`. This rewrite
+ * exercises `migrateHierarchyToDb()` against a fixture roadmap whose
+ * slices are all `[x]` and asserts the milestone row's `status` is
+ * `complete` — the actual behaviour the every() check exists to
+ * produce.
+ */
+
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import {
+  openDatabase,
+  closeDatabase,
+  getAllMilestones,
+} from '../gsd-db.ts';
+import { migrateHierarchyToDb } from '../md-importer.ts';
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
+
+function createFixtureBase(): string {
+  const base = mkdtempSync(join(tmpdir(), 'gsd-import-done-'));
+  mkdirSync(join(base, '.gsd', 'milestones'), { recursive: true });
+  return base;
+}
+
+function writeFile(base: string, relativePath: string, content: string): void {
+  const full = join(base, '.gsd', relativePath);
+  mkdirSync(join(full, '..'), { recursive: true });
+  writeFileSync(full, content);
+}
+
+function cleanup(base: string): void {
+  rmSync(base, { recursive: true, force: true });
+}
+
+const ROADMAP_ALL_DONE = `# M001: Finished Milestone
+
+**Vision:** Done work.
+
+## Slices
+
+- [x] **S01: First Slice** \`risk:low\` \`depends:[]\`
+  > After this: Done.
+
+- [x] **S02: Second Slice** \`risk:medium\` \`depends:[S01]\`
+  > After this: Also done.
+`;
+
+const ROADMAP_PARTIAL = `# M002: In-Progress Milestone
+
+**Vision:** Mid-flight.
+
+## Slices
+
+- [x] **S01: Done Slice** \`risk:low\` \`depends:[]\`
+  > After this: Done.
+
+- [ ] **S02: Pending Slice** \`risk:medium\` \`depends:[S01]\`
+  > After this: TBD.
+`;
+
+const ROADMAP_EMPTY = `# M003: Empty Milestone
+
+**Vision:** No slices yet.
+
+## Slices
+
+`;
+
+describe('migrateHierarchyToDb: all-done milestones import as complete (#4902)', () => {
+  test('milestone with all [x] slices and no SUMMARY imports as complete', () => {
+    const base = createFixtureBase();
+    try {
+      writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_ALL_DONE);
+      // No SUMMARY.md — the all-done roadmap check is the authoritative signal.
+
+      openDatabase(':memory:');
+      migrateHierarchyToDb(base);
+
+      const milestones = getAllMilestones();
+      const m001 = milestones.find((m) => m.id === 'M001');
+      assert.ok(m001, 'M001 should be imported');
+      assert.equal(
+        m001!.status,
+        'complete',
+        'milestone with all-done slices must import as complete',
+      );
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+  });
+
+  test('milestone with one pending slice imports as active (negative case)', () => {
+    const base = createFixtureBase();
+    try {
+      writeFile(base, 'milestones/M002/M002-ROADMAP.md', ROADMAP_PARTIAL);
+
+      openDatabase(':memory:');
+      migrateHierarchyToDb(base);
+
+      const milestones = getAllMilestones();
+      const m002 = milestones.find((m) => m.id === 'M002');
+      assert.ok(m002, 'M002 should be imported');
+      assert.equal(
+        m002!.status,
+        'active',
+        'milestone with at least one pending slice must NOT be marked complete',
+      );
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+  });
+
+  test('milestone with empty slice list does not import as complete', () => {
+    // Guards the `roadmap.slices.length > 0` precondition: an empty roadmap
+    // must not be misread as "everything is done" (vacuous truth bug).
+    const base = createFixtureBase();
+    try {
+      writeFile(base, 'milestones/M003/M003-ROADMAP.md', ROADMAP_EMPTY);
+
+      openDatabase(':memory:');
+      migrateHierarchyToDb(base);
+
+      const milestones = getAllMilestones();
+      const m003 = milestones.find((m) => m.id === 'M003');
+      assert.ok(m003, 'M003 should be imported');
+      assert.notEqual(
+        m003!.status,
+        'complete',
+        'empty roadmap (no slices) must not import as complete',
+      );
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+  });
+});

package/src/resources/extensions/gsd/tests/init-prefs-routing.test.ts

@@ -12,7 +12,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 
 import { mapInitPrefsToWizardShape } from "../init-wizard.ts";
-import { writePreferencesFile } from "../commands-prefs-wizard.ts";
+import { handlePrefsWizard, writePreferencesFile } from "../commands-prefs-wizard.ts";
 
 test("mapInitPrefsToWizardShape — full roundtrip with all fields", () => {
   const out = mapInitPrefsToWizardShape({
@@ -123,6 +123,69 @@ test("writePreferencesFile — falls back to default body for new files", async
   }
 });
 
+test("handlePrefsWizard — Advanced config writes min_request_interval_ms", async () => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-init-prefs-routing-"));
+  const path = join(tmp, "PREFERENCES.md");
+
+  try {
+    const selectResponses = [
+      "Advanced",
+      "(keep current)",
+      "(keep current)",
+      "(keep current)",
+      "(keep current)",
+      "(keep current)",
+      "(keep current)",
+      "(keep current)",
+      "── Save & Exit ──",
+    ];
+    const inputResponses = ["250"];
+    const ctx = {
+      ui: {
+        notify: () => {},
+        select: async (_label: string, options: string[]) => {
+          const response = selectResponses.shift();
+          if (response === undefined) {
+            throw new Error(
+              `Unexpected extra select prompt in handlePrefsWizard flow: selectResponses queue exhausted for "${_label}" ` +
+                "(expected no additional select prompts)",
+            );
+          }
+          if (response === "Advanced") {
+            const advancedOption = options.find((option) => option.startsWith("Advanced"));
+            if (!advancedOption) {
+              throw new Error(`Expected an "Advanced" option in "${_label}" menu`);
+            }
+            return advancedOption;
+          }
+          return response;
+        },
+        input: async () => {
+          const response = inputResponses.shift();
+          if (response === undefined) {
+            throw new Error(
+              "Unexpected extra input prompt in handlePrefsWizard flow: inputResponses queue exhausted " +
+                "(expected no additional input prompts)",
+            );
+          }
+          return response;
+        },
+      },
+      waitForIdle: async () => {},
+      reload: async () => {},
+    };
+
+    await handlePrefsWizard(ctx as any, "project", {}, { pathOverride: path });
+
+    assert.equal(selectResponses.length, 0, "Expected all queued selectResponses to be consumed");
+    assert.equal(inputResponses.length, 0, "Expected all queued inputResponses to be consumed");
+    const content = readFileSync(path, "utf-8");
+    assert.match(content, /^min_request_interval_ms:\s*250$/m);
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
 // ─── Regression tests from #4457 codex adversarial review ──────────────────
 
 test("init — Step 9b shape: 'not_yet' option is recognized as defer (#4457 review)", async () => {

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

@@ -7,7 +7,7 @@
 
 import { describe, test, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, realpathSync } from "node:fs";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, realpathSync, symlinkSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
@@ -21,6 +21,7 @@ import {
   getAutoWorktreeOriginalBase,
   getActiveAutoWorktreeContext,
   syncGsdStateToWorktree,
+  _resetAutoWorktreeOriginalBaseForTests,
 } from "../../auto-worktree.ts";
 
 // Note: execSync is used intentionally in tests for git operations with
@@ -142,6 +143,54 @@ describe("auto-worktree lifecycle", () => {
     teardownAutoWorktree(tempDir, "M003");
   });
 
+  test("symlink-resolved auto worktree is detected after module state reset", () => {
+    tempDir = createTempRepo();
+    const savedGsdHome = process.env.GSD_HOME;
+    const fakeHome = realpathSync(mkdtempSync(join(tmpdir(), "auto-wt-home-")));
+    const storage = join(fakeHome, ".gsd", "projects", "abc123def456");
+    mkdirSync(join(storage, "milestones", "M001"), { recursive: true });
+    writeFileSync(join(storage, "milestones", "M001", "CONTEXT.md"), "# M001\n");
+    symlinkSync(storage, join(tempDir, ".gsd"));
+    process.env.GSD_HOME = join(fakeHome, ".gsd");
+
+    try {
+      const wtPath = createAutoWorktree(tempDir, "M001");
+      const realWtPath = realpathSync(wtPath);
+      assert.ok(realWtPath.startsWith(storage), "git registered the symlink-resolved worktree path");
+
+      _resetAutoWorktreeOriginalBaseForTests();
+      process.chdir(join(realWtPath, ".gsd", "milestones", "M001"));
+
+      assert.ok(isInAutoWorktree(tempDir), "structural detection works without module originalBase");
+      const resolved = getAutoWorktreePath(realWtPath, "M001");
+      assert.ok(resolved, "existing worktree is found when basePath is the worktree path");
+      assert.equal(realpathSync(resolved!), realWtPath);
+      assert.equal(existsSync(join(realWtPath, ".gsd", "worktrees", "M001")), false);
+
+      enterAutoWorktree(tempDir, "M001");
+      process.chdir(join(realWtPath, ".gsd", "milestones", "M001"));
+      assert.deepStrictEqual(
+        getActiveAutoWorktreeContext(),
+        {
+          originalBase: tempDir,
+          worktreeName: "M001",
+          branch: "milestone/M001",
+        },
+        "active context is detected from a symlink-resolved worktree cwd",
+      );
+    } finally {
+      process.chdir(tempDir);
+      try {
+        teardownAutoWorktree(tempDir, "M001");
+      } catch {
+        // Best-effort cleanup for partially-created temp worktrees.
+      }
+      if (savedGsdHome === undefined) delete process.env.GSD_HOME;
+      else process.env.GSD_HOME = savedGsdHome;
+      rmSync(fakeHome, { recursive: true, force: true });
+    }
+  });
+
   test("coexistence with manual worktree", async () => {
     tempDir = createTempRepo();
     const msDir = join(tempDir, ".gsd", "milestones", "M003");
@@ -345,4 +394,26 @@ describe("auto-worktree lifecycle", () => {
       teardownAutoWorktree(tempDir, "M003");
     }
   });
+
+  test("#2482: throws GSDError when repo has no commits", () => {
+    // Create a bare git init with no commits — HEAD is invalid
+    tempDir = realpathSync(mkdtempSync(join(tmpdir(), "auto-wt-empty-")));
+    run("git init", tempDir);
+    run("git config user.email test@test.com", tempDir);
+    run("git config user.name Test", tempDir);
+
+    assert.throws(
+      () => createAutoWorktree(tempDir, "M001"),
+      (err: unknown) => {
+        assert.ok(err instanceof Error, "should throw an Error");
+        assert.ok("code" in err, "should have a code property (GSDError)");
+        assert.strictEqual((err as { code: string }).code, "GSD_GIT_ERROR");
+        assert.ok(
+          err.message.includes("repository has no commits yet"),
+          `message should mention no commits, got: ${err.message}`,
+        );
+        return true;
+      },
+    );
+  });
 });

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/memory-store.test.ts

@@ -4,6 +4,11 @@ import {
   isDbAvailable,
   _getAdapter,
 } from '../gsd-db.ts';
+import {
+  _resetLogs,
+  peekLogs,
+  setStderrLoggingEnabled,
+} from '../workflow-logger.ts';
 import {
   getActiveMemories,
   getActiveMemoriesRanked,
@@ -329,3 +334,126 @@ test('memory-store: schema includes memories table', () => {
 
   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();
+});