@opengsd/gsd-pi 1.3.0-dev.72e3af2a → 1.3.0-dev.738160b9

package/src/resources/extensions/gsd/tests/auto-budget-alerts.test.ts

@@ -8,6 +8,7 @@ import {
   getNewBudgetAlertLevel,
   resolveCompactionThresholdPercent,
   shouldRerootStepSessionForContext,
+  shouldWarnStepSessionForContext,
 } from "../auto.js";
 import {
   getUnitCostSpikeAction,
@@ -73,11 +74,19 @@ test("resolveCompactionThresholdPercent defaults to 60 and accepts ratio prefs",
   assert.equal(resolveCompactionThresholdPercent(0.4), 60);
 });
 
-test("shouldRerootStepSessionForContext uses compaction threshold pref", () => {
-  assert.equal(shouldRerootStepSessionForContext(59.9, 0.6), false);
-  assert.equal(shouldRerootStepSessionForContext(60, 0.6), true);
-  assert.equal(shouldRerootStepSessionForContext(273.8, 0.6), true);
-  assert.equal(shouldRerootStepSessionForContext(undefined, 0.6), false);
+test("shouldWarnStepSessionForContext uses compaction threshold pref", () => {
+  assert.equal(shouldWarnStepSessionForContext(59.9, 0.6), false);
+  assert.equal(shouldWarnStepSessionForContext(60, 0.6), true);
+  assert.equal(shouldWarnStepSessionForContext(72, 0.6), true);
+  assert.equal(shouldWarnStepSessionForContext(undefined, 0.6), false);
+});
+
+test("shouldRerootStepSessionForContext only fires at the hard context threshold", () => {
+  assert.equal(shouldRerootStepSessionForContext(72), false);
+  assert.equal(shouldRerootStepSessionForContext(89.9), false);
+  assert.equal(shouldRerootStepSessionForContext(90), true);
+  assert.equal(shouldRerootStepSessionForContext(273.8), true);
+  assert.equal(shouldRerootStepSessionForContext(undefined), false);
 });
 
 test("resolveUnitCostSpikeMultiplier disables the spike pause for burn-max", () => {

package/src/resources/extensions/gsd/tests/auto-pause-double-entry-guard.test.ts

@@ -14,6 +14,7 @@ import { capturePauseAutoUnitIdentity, pauseAuto, isAutoActive } from "../auto.t
 import { _resetPendingResolve, _setCurrentResolve } from "../auto/resolve.ts";
 import { autoSession } from "../auto-runtime-state.ts";
 import { _isPauseOriginCancelledResult } from "../auto/phase-helpers.ts";
+import { handleAutoCommand } from "../commands/handlers/auto.ts";
 
 test("pauseAuto sets s.active = false synchronously before first await (blocks concurrent re-entry)", async () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-double-pause-guard-"));
@@ -80,6 +81,41 @@ test("pauseAuto marks paused and cancels the in-flight unit before first await",
   }
 });
 
+test("/gsd pause aborts the active pi turn before first await", async () => {
+  autoSession.reset();
+  autoSession.active = true;
+  let abortCount = 0;
+  const ctx = {
+    hasUI: false,
+    isIdle: () => false,
+    abort: () => {
+      abortCount += 1;
+    },
+    sessionManager: {
+      getSessionFile: () => null,
+    },
+    ui: {
+      setStatus() {},
+      setWidget() {},
+      notify() {},
+    },
+  } as any;
+
+  try {
+    const pausePromise = handleAutoCommand("pause", ctx, {} as any);
+
+    assert.equal(
+      abortCount,
+      1,
+      "pauseAuto must abort the active pi turn before reporting auto-mode paused",
+    );
+
+    await pausePromise.catch(() => {});
+  } finally {
+    autoSession.reset();
+  }
+});
+
 test("transient-abort errorContext is not classified as pause-origin cancellation", () => {
   // The phases.ts fix passes unitResult.errorContext to pauseAuto for transient aborts.
   // _isPauseOriginCancelledResult must return false when errorContext is present, ensuring

package/src/resources/extensions/gsd/tests/auto-paused-ui-cleanup.test.ts

@@ -3,13 +3,14 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
 import { execFileSync } from "node:child_process";
-import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join, dirname } from "node:path";
 
 import {
   anchorProcessCwdForAutoResume,
   cleanupAfterLoopExit,
+  maybeRerootStepSessionForHighContext,
   pauseAuto,
   rerootCommandSession,
   stopAuto,
@@ -478,8 +479,8 @@ test("cleanupAfterLoopExit preserves step-mode surface and worktree session afte
   }
 });
 
-test("cleanupAfterLoopExit re-roots step-mode session when context exceeds compaction threshold", async (t) => {
-  const base = mkdtempSync(join(tmpdir(), "gsd-step-reroot-"));
+test("cleanupAfterLoopExit warns but does not re-root step-mode session at soft compaction threshold", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-step-soft-context-"));
   const worktree = join(base, ".gsd", "worktrees", "M001");
   const previousCwd = process.cwd();
   const newSessionWorkspaces: string[] = [];
@@ -515,7 +516,59 @@ test("cleanupAfterLoopExit re-roots step-mode session when context exceeds compa
       },
     } as any);
 
-    assert.deepEqual(newSessionWorkspaces, [worktree], "hot step-mode cleanup should re-root in the active worktree");
+    assert.deepEqual(newSessionWorkspaces, [], "soft context pressure must not force a new command session");
+    assert.equal(
+      notifyMessages.some((msg) => msg.includes("context at 72.0%") && msg.includes("Use /compact")),
+      true,
+      "soft threshold should warn with a non-disruptive compaction prompt",
+    );
+    assert.equal(autoSession.basePath, worktree);
+    assert.equal(realpathSync(process.cwd()), realpathSync(worktree));
+  } finally {
+    autoSession.reset();
+    process.chdir(previousCwd);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("cleanupAfterLoopExit re-roots step-mode session at hard context threshold", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-step-reroot-"));
+  const worktree = join(base, ".gsd", "worktrees", "M001");
+  const previousCwd = process.cwd();
+  const newSessionWorkspaces: string[] = [];
+  const notifyMessages: string[] = [];
+
+  t.mock.method(WorktreeLifecycle.prototype, "restoreToProjectRoot", function () {});
+
+  mkdirSync(worktree, { recursive: true });
+  process.chdir(worktree);
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.paused = false;
+  autoSession.stepMode = true;
+  autoSession.preserveStepSurfaceAfterLoopExit = true;
+  autoSession.basePath = worktree;
+  autoSession.originalBasePath = base;
+  autoSession.cmdCtx = {
+    getContextUsage: () => ({ percent: 92, tokens: 920_000, contextWindow: 1_000_000 }),
+    newSession: async ({ workspaceRoot }: { workspaceRoot: string }) => {
+      newSessionWorkspaces.push(workspaceRoot);
+      return { cancelled: false };
+    },
+  } as any;
+
+  try {
+    await cleanupAfterLoopExit({
+      hasUI: true,
+      ui: {
+        setStatus: () => {},
+        setWidget: () => {},
+        setHeader: () => {},
+        notify: (_msg: string) => notifyMessages.push(_msg),
+      },
+    } as any);
+
+    assert.deepEqual(newSessionWorkspaces, [worktree], "critical context pressure should re-root in the active worktree");
     assert.equal(
       notifyMessages.some((msg) => msg.includes("Fresh session ready for /gsd next")),
       true,
@@ -530,6 +583,131 @@ test("cleanupAfterLoopExit re-roots step-mode session when context exceeds compa
   }
 });
 
+test("maybeRerootStepSessionForHighContext re-roots at the hard threshold even when the soft pref is set above it", async () => {
+  // Regression: the hard 90% re-root must not be gated behind the configurable
+  // soft warn threshold, which is allowed up to 0.95. At 92% usage with a 0.95
+  // soft pref the soft warn predicate is false, but the session must still
+  // re-root because usage crossed the fixed hard boundary.
+  const dir = mkdtempSync(join(tmpdir(), "gsd-hard-reroot-high-soft-"));
+  const project = join(dir, "project");
+  const gsdHomeDir = join(dir, "home");
+  const previousCwd = process.cwd();
+  const previousGsdHome = process.env.GSD_HOME;
+
+  mkdirSync(join(project, ".gsd"), { recursive: true });
+  mkdirSync(gsdHomeDir, { recursive: true });
+  writeFileSync(
+    join(project, ".gsd", "PREFERENCES.md"),
+    ["---", "version: 1", "context_management:", "  compaction_threshold_percent: 0.95", "---", ""].join("\n"),
+    "utf-8",
+  );
+
+  process.env.GSD_HOME = gsdHomeDir;
+  process.chdir(project);
+
+  const newSessionWorkspaces: string[] = [];
+  const notifyMessages: string[] = [];
+  const cmdCtx = {
+    getContextUsage: () => ({ percent: 92, tokens: 920_000, contextWindow: 1_000_000 }),
+    newSession: async ({ workspaceRoot }: { workspaceRoot: string }) => {
+      newSessionWorkspaces.push(workspaceRoot);
+      return { cancelled: false };
+    },
+  } as any;
+  const ctx = { ui: { notify: (msg: string) => notifyMessages.push(msg) } } as any;
+
+  try {
+    const result = await maybeRerootStepSessionForHighContext(ctx, project, cmdCtx, project);
+
+    assert.equal(result.rerooted, true, "92% usage must re-root even when the soft pref is 95%");
+    assert.deepEqual(newSessionWorkspaces, [project], "hard context pressure must re-root the command session");
+    const rerootMessage = notifyMessages.find((msg) => msg.includes("Fresh session ready for /gsd next"));
+    assert.ok(rerootMessage, "hard re-root should notify the user");
+    // The re-root was triggered by the 90% hard limit, so the notification must
+    // cite that limit and not the configured 95% soft compaction threshold.
+    assert.match(
+      rerootMessage,
+      /hard threshold: 90%/,
+      "hard re-root notification must cite the 90% hard threshold",
+    );
+    assert.equal(
+      rerootMessage.includes("95%"),
+      false,
+      "hard re-root notification must not cite the configured soft compaction threshold",
+    );
+  } finally {
+    process.chdir(previousCwd);
+    if (previousGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = previousGsdHome;
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("maybeRerootStepSessionForHighContext writes a compaction snapshot only at the hard boundary", async () => {
+  // Regression: the snapshot is reserved for the hard re-root. Soft-only
+  // pressure must warn without writing a compaction snapshot.
+  const dir = mkdtempSync(join(tmpdir(), "gsd-soft-no-snapshot-"));
+  const project = join(dir, "project");
+  const gsdHomeDir = join(dir, "home");
+  const previousCwd = process.cwd();
+  const previousGsdHome = process.env.GSD_HOME;
+
+  mkdirSync(join(project, ".gsd"), { recursive: true });
+  mkdirSync(gsdHomeDir, { recursive: true });
+  writeFileSync(
+    join(project, ".gsd", "PREFERENCES.md"),
+    ["---", "version: 1", "context_management:", "  compaction_threshold_percent: 0.6", "---", ""].join("\n"),
+    "utf-8",
+  );
+
+  process.env.GSD_HOME = gsdHomeDir;
+  process.chdir(project);
+
+  const newSessionWorkspaces: string[] = [];
+  const notifyMessages: string[] = [];
+  let contextPercent = 72;
+  const cmdCtx = {
+    getContextUsage: () => ({ percent: contextPercent, tokens: contextPercent * 10_000, contextWindow: 1_000_000 }),
+    newSession: async ({ workspaceRoot }: { workspaceRoot: string }) => {
+      newSessionWorkspaces.push(workspaceRoot);
+      return { cancelled: false };
+    },
+  } as any;
+  const ctx = { ui: { notify: (msg: string) => notifyMessages.push(msg) } } as any;
+  const snapshotPath = join(project, ".gsd", "last-snapshot.md");
+
+  try {
+    const softResult = await maybeRerootStepSessionForHighContext(ctx, project, cmdCtx, project);
+    assert.equal(softResult.rerooted, false, "soft pressure must not re-root");
+    assert.deepEqual(newSessionWorkspaces, [], "soft pressure must not open a new session");
+    assert.equal(
+      existsSync(snapshotPath),
+      false,
+      "soft-only pressure must not write a compaction snapshot",
+    );
+    assert.equal(
+      notifyMessages.some((msg) => msg.includes("context at 72.0%") && msg.includes("Use /compact")),
+      true,
+      "soft threshold should warn with a non-disruptive compaction prompt",
+    );
+
+    contextPercent = 92;
+    const hardResult = await maybeRerootStepSessionForHighContext(ctx, project, cmdCtx, project);
+    assert.equal(hardResult.rerooted, true, "hard pressure must re-root");
+    assert.deepEqual(newSessionWorkspaces, [project], "hard pressure should re-root once");
+    assert.equal(
+      existsSync(snapshotPath),
+      true,
+      "hard boundary must write the compaction snapshot",
+    );
+  } finally {
+    process.chdir(previousCwd);
+    if (previousGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = previousGsdHome;
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
 test("cleanupAfterLoopExit restores project root through lifecycle and preserves chdir", async (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-cleanup-lifecycle-"));
   const worktree = join(base, ".gsd", "worktrees", "M001");

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

@@ -1917,6 +1917,41 @@ test("#57: writeReactiveExecuteBlocker reconciles batch task statuses and append
   }
 });
 
+test("#1088: writeReactiveExecuteBlocker preserves deferred batch task statuses", () => {
+  const base = makeTmpBase();
+  try {
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "pending" });
+    insertTask({ id: "T01", milestoneId: "M001", sliceId: "S01", title: "One", status: "deferred" });
+    insertTask({ id: "T02", milestoneId: "M001", sliceId: "S01", title: "Two", status: "deferred" });
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-SUMMARY.md"),
+      "# T01 Summary\n",
+      "utf-8",
+    );
+
+    const recovery = writeReactiveExecuteBlocker(
+      "M001/S01/reactive+T01,T02",
+      base,
+      "verification retries exhausted",
+    );
+
+    assert.ok(recovery, "recovery should run with DB available");
+    assert.deepEqual(recovery!.completedTaskIds, []);
+    assert.deepEqual(recovery!.skippedTaskIds, []);
+    assert.deepEqual(recovery!.unchangedTaskIds, ["T01", "T02"]);
+    assert.equal(getTask("M001", "S01", "T01")?.status, "deferred");
+    assert.equal(getTask("M001", "S01", "T02")?.status, "deferred");
+
+    const events = readEvents(join(base, ".gsd", "event-log.jsonl"));
+    assert.equal(events.some((e) => e.params.taskId === "T01" || e.params.taskId === "T02"), false);
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
 test("#4414: verifyExpectedArtifact parallel-research succeeds when all research-ready slices have RESEARCH", () => {
   const base = makeTmpBase();
   try {

package/src/resources/extensions/gsd/tests/auto-retry-mcp-churn-fixes.test.ts

@@ -15,15 +15,21 @@
 
 import { describe, it, beforeEach } from "node:test";
 import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, statSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 
 import {
   resetEvidence,
   getEvidence,
   recordToolCall,
   recordToolResult,
+  saveEvidenceToDisk,
   type BashEvidence,
 } from "../safety/evidence-collector.js";
 
+const waitForMtimeTick = () => new Promise(resolve => setTimeout(resolve, 25));
+
 describe("evidence-collector: toolCallId-based matching (A-3)", () => {
   beforeEach(() => {
     resetEvidence();
@@ -119,4 +125,28 @@ describe("evidence-collector: toolCallId-based matching (A-3)", () => {
     assert.equal(entries[1].kind, "bash");
     assert.equal(entries[1].command, "rg TODO");
   });
+
+  it("skips byte-identical evidence file rewrites", async (t) => {
+    const base = mkdtempSync(join(tmpdir(), "gsd-evidence-dedupe-"));
+    t.after(() => rmSync(base, { recursive: true, force: true }));
+
+    recordToolCall("tc-bash-1", "bash", { command: "pnpm test" });
+    saveEvidenceToDisk(base, "M001", "S01", "T03");
+
+    const evidenceFile = join(base, ".gsd", "safety", "evidence-M001-S01-T03.json");
+    const firstMtime = statSync(evidenceFile, { bigint: true }).mtimeNs;
+
+    await waitForMtimeTick();
+    saveEvidenceToDisk(base, "M001", "S01", "T03");
+    const secondMtime = statSync(evidenceFile, { bigint: true }).mtimeNs;
+
+    assert.equal(secondMtime, firstMtime, "unchanged evidence must not rewrite the evidence file");
+
+    await waitForMtimeTick();
+    recordToolResult("tc-bash-1", "bash", "Command exited with code 0\nok\n", false);
+    saveEvidenceToDisk(base, "M001", "S01", "T03");
+    const thirdMtime = statSync(evidenceFile, { bigint: true }).mtimeNs;
+
+    assert.ok(thirdMtime > secondMtime, "changed evidence must still be persisted");
+  });
 });

package/src/resources/extensions/gsd/tests/complete-milestone.test.ts

@@ -312,6 +312,34 @@ console.log('\n=== complete-milestone: incomplete slices block closeout ===');
   cleanup(dbPath);
 }
 
+// ═══════════════════════════════════════════════════════════════════════════
+// complete-milestone: deferred slices are inactive for closeout
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== complete-milestone: deferred slices do not block closeout ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+  const { basePath } = createTempProject();
+  seedCompletedMilestone({ basePath, validationVerdict: 'pass' });
+  insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Deferred Slice', status: 'deferred' });
+  insertTask({
+    id: 'T02',
+    sliceId: 'S02',
+    milestoneId: 'M001',
+    status: 'pending',
+    title: 'Deferred Slice Task',
+  });
+
+  const result = await handleCompleteMilestone(makeValidParams(), basePath);
+
+  assertTrue(!('error' in result), 'deferred slice should not block milestone completion');
+  assertEq(getMilestone('M001')!.status, 'complete', 'milestone should complete with deferred inactive slice');
+
+  cleanupDir(basePath);
+  cleanup(dbPath);
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // complete-milestone: deep task check (slice closed, task not)
 // ═══════════════════════════════════════════════════════════════════════════

package/src/resources/extensions/gsd/tests/complete-slice-reopen-handoff.test.ts

@@ -7,6 +7,10 @@ import { join } from "node:path";
 
 import { postUnitPreVerification } from "../auto-post-unit.ts";
 import { AutoSession } from "../auto/session.ts";
+import {
+  decideVerificationRetry,
+  hashVerificationFailureContext,
+} from "../auto/verification-retry-policy.ts";
 import { cleanup, makeTempRepo } from "./test-utils.ts";
 
 function makePostUnitContext(base: string, s: AutoSession, notifications: string[]) {
@@ -227,3 +231,68 @@ test("complete-slice with gsd_replan_slice but no REPLAN artifact retries", asyn
     cleanup(base);
   }
 });
+
+test("artifact retry context stays stable across attempts while notifications show attempt count", async () => {
+  const base = makeTempRepo("gsd-artifact-retry-stable-context-");
+  try {
+    mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01"), { recursive: true });
+
+    const s = new AutoSession();
+    s.active = true;
+    s.basePath = base;
+    s.currentUnit = { type: "complete-slice", id: "M001/S01", startedAt: Date.now() };
+
+    const notifications: string[] = [];
+    const pctx = makePostUnitContext(base, s, notifications);
+    const opts = {
+      skipSettleDelay: true,
+      skipWorktreeSync: true,
+      agentEndMessages: [
+        {
+          role: "toolResult",
+          toolName: "gsd_replan_slice",
+          isError: false,
+          content: "Slice replanned with reopened task T02.",
+        },
+      ],
+    };
+
+    assert.equal(await postUnitPreVerification(pctx, opts), "retry");
+    const firstRetry = s.pendingVerificationRetry;
+    assert.ok(firstRetry);
+    assert.equal(firstRetry.attempt, 1);
+    assert.doesNotMatch(firstRetry.failureContext, /\(attempt \d\/3\)\.$/);
+    const firstFailureHash = hashVerificationFailureContext(firstRetry.failureContext);
+
+    assert.equal(await postUnitPreVerification(pctx, opts), "retry");
+    const secondRetry = s.pendingVerificationRetry;
+    assert.ok(secondRetry);
+    assert.equal(secondRetry.attempt, 2);
+    assert.equal(secondRetry.failureContext, firstRetry.failureContext);
+    assert.equal(hashVerificationFailureContext(secondRetry.failureContext), firstFailureHash);
+    assert.deepEqual(
+      decideVerificationRetry({
+        unitType: s.currentUnit.type,
+        retryInfo: secondRetry,
+        previousFailureHash: firstFailureHash,
+        random: () => 0.5,
+      }),
+      {
+        action: "pause",
+        reason: "duplicate-failure-context",
+        key: "complete-slice:M001/S01",
+        failureHash: firstFailureHash,
+      },
+    );
+    assert.ok(
+      notifications.some((message) => message.includes("Retrying (attempt 1/3).")),
+      `expected first attempt notification, got: ${notifications.join("\n")}`,
+    );
+    assert.ok(
+      notifications.some((message) => message.includes("Retrying (attempt 2/3).")),
+      `expected second attempt notification, got: ${notifications.join("\n")}`,
+    );
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/db-memory-fts-schema.test.ts

@@ -3,11 +3,16 @@
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
+import { createRequire } from "node:module";
 import {
+  MEMORIES_FTS_REBUILT_KEY,
   isMemoriesFtsAvailableSchema,
+  rebuildMemoriesFtsSchemaOnce,
   tryCreateMemoriesFtsSchema,
 } from "../db-memory-fts-schema.ts";
-import type { DbAdapter, DbStatement } from "../db-adapter.ts";
+import { createDbAdapter, type DbAdapter, type DbStatement } from "../db-adapter.ts";
+
+const _require = createRequire(import.meta.url);
 
 class FakeStatement implements DbStatement {
   private readonly row: Record<string, unknown> | undefined;
@@ -32,6 +37,7 @@ class FakeStatement implements DbStatement {
 class FakeAdapter implements DbAdapter {
   readonly execCalls: string[] = [];
   hasFts = false;
+  hasRebuildMarker = false;
   failExec = false;
 
   exec(sql: string): void {
@@ -39,13 +45,26 @@ class FakeAdapter implements DbAdapter {
     if (this.failExec) throw new Error("fts unavailable");
   }
 
-  prepare(): DbStatement {
-    return new FakeStatement(this.hasFts ? { name: "memories_fts" } : undefined);
+  prepare(sql: string): DbStatement {
+    if (sql.includes("sqlite_master")) {
+      return new FakeStatement(this.hasFts ? { name: "memories_fts" } : undefined);
+    }
+    if (sql.includes("runtime_kv")) {
+      return new FakeStatement(this.hasRebuildMarker ? { present: 1 } : undefined);
+    }
+    return new FakeStatement(undefined);
   }
 
   close(): void {}
 }
 
+function openMemoryAdapter(): { db: DbAdapter; close: () => void } {
+  const sqlite = _require("node:sqlite") as { DatabaseSync: new (path: string) => unknown };
+  const raw = new sqlite.DatabaseSync(":memory:");
+  const db = createDbAdapter(raw);
+  return { db, close: () => db.close() };
+}
+
 describe("db-memory-fts-schema", () => {
   test("creates memories_fts and insert/delete/update triggers", () => {
     const db = new FakeAdapter();
@@ -83,4 +102,40 @@ describe("db-memory-fts-schema", () => {
     db.hasFts = true;
     assert.equal(isMemoriesFtsAvailableSchema(db), true);
   });
+
+  test("rebuilds the external-content index once and records a marker", () => {
+    const { db, close } = openMemoryAdapter();
+    try {
+      db.exec("CREATE TABLE memories (seq INTEGER PRIMARY KEY AUTOINCREMENT, content TEXT NOT NULL)");
+      db.exec("INSERT INTO memories (content) VALUES ('pre FTS auth memory must be searchable')");
+
+      const ok = tryCreateMemoriesFtsSchema(db);
+      if (!ok) return;
+
+      const before = db.prepare("SELECT rowid FROM memories_fts WHERE memories_fts MATCH 'auth'").all();
+      assert.equal(before.length, 0, "external-content FTS starts empty for existing rows");
+
+      rebuildMemoriesFtsSchemaOnce(db);
+
+      const after = db.prepare("SELECT rowid FROM memories_fts WHERE memories_fts MATCH 'auth'").all();
+      assert.deepEqual(after.map((row) => row["rowid"]), [1]);
+      const marker = db.prepare(
+        "SELECT value_json FROM runtime_kv WHERE scope = 'global' AND scope_id = '' AND key = :key",
+      ).get({ ":key": MEMORIES_FTS_REBUILT_KEY });
+      assert.ok(marker, "rebuild marker should be stored");
+    } finally {
+      close();
+    }
+  });
+
+  test("skips rebuild when marker already exists", () => {
+    const db = new FakeAdapter();
+    db.hasFts = true;
+    db.hasRebuildMarker = true;
+
+    rebuildMemoriesFtsSchemaOnce(db);
+
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE TABLE IF NOT EXISTS runtime_kv")));
+    assert.ok(!db.execCalls.some((sql) => sql.includes("VALUES('rebuild')")));
+  });
 });

package/src/resources/extensions/gsd/tests/decisions-projection-from-memories.test.ts

@@ -142,6 +142,57 @@ test("backfill is idempotent — re-running over migrated rows is a no-op", () =
   }
 });
 
+test("backfill skips a decision whose memory insert throws and continues later rows", () => {
+  const base = makeTmpBase();
+  try {
+    seedRawDecision({
+      id: "D001",
+      when_context: "M001",
+      scope: "M001",
+      decision: "before poison",
+      choice: "A",
+      rationale: "first row",
+    });
+    seedRawDecision({
+      id: "D002",
+      when_context: "M001",
+      scope: "M001",
+      decision: "poison",
+      choice: "B",
+      rationale: "this insert throws",
+    });
+    seedRawDecision({
+      id: "D003",
+      when_context: "M001",
+      scope: "M001",
+      decision: "after poison",
+      choice: "C",
+      rationale: "tail row",
+    });
+
+    const adapter = _getAdapter();
+    assert.ok(adapter);
+    adapter.exec(`
+      CREATE TRIGGER fail_d002_memory_insert
+      BEFORE INSERT ON memories
+      WHEN json_extract(NEW.structured_fields, '$.sourceDecisionId') = 'D002'
+      BEGIN
+        SELECT RAISE(ABORT, 'poison decision D002');
+      END
+    `);
+
+    const written = backfillDecisionsToMemories();
+    assert.equal(written, 2, "one poisoned row should not abort the batch");
+    assert.deepEqual(
+      getAllDecisionsFromMemories().map((d) => d.id),
+      ["D001", "D003"],
+      "rows after the poisoned decision should still be migrated",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
 // ─── Drift auto-heal ───────────────────────────────────────────────────────
 
 test("backfill auto-heals when a source decision's superseded_by changes after migration", () => {