gsd-pi 2.78.0 → 2.78.1-dev.42ef05fbe

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

@@ -1,5 +1,8 @@
 import test, { mock } from "node:test";
 import assert from "node:assert/strict";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 
 import {
   resolveAgentEnd,
@@ -26,6 +29,24 @@ function makeEvent(
   return { messages };
 }
 
+async function drainMicrotasks(turns = 20): Promise<void> {
+  for (let i = 0; i < turns; i++) {
+    await Promise.resolve();
+  }
+}
+
+async function waitForMicrotasks(
+  condition: () => boolean,
+  label: string,
+  turns = 500,
+): Promise<void> {
+  for (let i = 0; i < turns; i++) {
+    if (condition()) return;
+    await Promise.resolve();
+  }
+  assert.fail(`Timed out waiting for ${label}`);
+}
+
 /**
  * Build a minimal mock AutoSession with controllable newSession behavior.
  */
@@ -42,6 +63,7 @@ function makeMockSession(opts?: {
   const session = {
     active: true,
     verbose: false,
+    basePath: process.cwd(),
     cmdCtx: {
       newSession: (options?: { abortSignal?: AbortSignal }) => {
         opts?.onNewSessionStart?.(session);
@@ -607,7 +629,11 @@ function makeMockDeps(
         blockers: [],
       } as any;
     },
-    loadEffectiveGSDPreferences: () => ({ preferences: {} }),
+    loadEffectiveGSDPreferences: () => ({
+      // These loop-mechanics tests mock executing state without plan-v2 artifacts.
+      // Plan-v2 default-on coverage lives in uok-plan-v2-wiring.test.ts.
+      preferences: { uok: { plan_v2: { enabled: false } } },
+    }),
     preDispatchHealthGate: async () => ({ proceed: true, fixesApplied: [] }),
     syncProjectRootToWorktree: () => {},
     checkResourcesStale: () => null,
@@ -716,7 +742,7 @@ function makeLoopSession(overrides?: Partial<Record<string, unknown>>) {
     verbose: false,
     stepMode: false,
     paused: false,
-    basePath: "/tmp/project",
+    basePath: mkdtempSync(join(tmpdir(), "gsd-auto-loop-")),
     originalBasePath: "",
     currentMilestoneId: "M001",
     currentUnit: null,
@@ -736,6 +762,7 @@ function makeLoopSession(overrides?: Partial<Record<string, unknown>>) {
     unitRecoveryCount: new Map<string, number>(),
     verificationRetryCount: new Map<string, number>(),
     gitService: null,
+    lastRequestTimestamp: 0,
     autoStartTime: Date.now(),
     cmdCtx: {
       newSession: () => Promise.resolve({ cancelled: false }),
@@ -2156,6 +2183,87 @@ test("autoLoop rejects execute-task with 0 tool calls as hallucinated (#1833)",
   );
 });
 
+test("autoLoop pauses user-driven deep question instead of flagging 0 tool calls", async () => {
+  _resetPendingResolve();
+
+  const ctx = makeMockCtx();
+  ctx.ui.setStatus = () => {};
+  ctx.sessionManager = { getSessionFile: () => "/tmp/session.json" };
+  const pi = makeMockPi();
+
+  const notifications: string[] = [];
+  ctx.ui.notify = (msg: string) => { notifications.push(msg); };
+
+  const s = makeLoopSession();
+  const mockLedger = {
+    version: 1,
+    projectStartedAt: Date.now(),
+    units: [] as any[],
+  };
+
+  const deps = makeMockDeps({
+    deriveState: async () => {
+      deps.callLog.push("deriveState");
+      return {
+        phase: "executing",
+        activeMilestone: { id: "M001", title: "Bootstrap", status: "active" },
+        activeSlice: null,
+        activeTask: null,
+        registry: [{ id: "M001", status: "active" }],
+        blockers: [],
+      } as any;
+    },
+    resolveDispatch: async () => {
+      deps.callLog.push("resolveDispatch");
+      return {
+        action: "dispatch" as const,
+        unitType: "discuss-project",
+        unitId: "PROJECT",
+        prompt: "ask what to build",
+      };
+    },
+    closeoutUnit: async () => {
+      mockLedger.units.push({
+        type: "discuss-project",
+        id: "PROJECT",
+        startedAt: s.currentUnit?.startedAt ?? Date.now(),
+        toolCalls: 0,
+        assistantMessages: 1,
+        tokens: { input: 100, output: 20, total: 120, cacheRead: 0, cacheWrite: 0 },
+        cost: 0.01,
+      });
+    },
+    getLedger: () => mockLedger,
+    postUnitPreVerification: async () => {
+      deps.callLog.push("postUnitPreVerification");
+      return "dispatched" as const;
+    },
+  });
+
+  const loopPromise = autoLoop(ctx, pi, s, deps);
+
+  await new Promise((r) => setTimeout(r, 50));
+  resolveAgentEnd(makeEvent([
+    {
+      role: "assistant",
+      content: [
+        { type: "text", text: "What do you want to build?" },
+      ],
+    },
+  ]));
+
+  await loopPromise;
+
+  assert.ok(
+    deps.callLog.includes("postUnitPreVerification"),
+    "questioning units should reach post-unit verification so the pause path can run",
+  );
+  assert.ok(
+    !notifications.some((n) => n.includes("context exhaustion")),
+    "questioning units should not show the context-exhaustion warning",
+  );
+});
+
 test("autoLoop rejects complete-slice with 0 tool calls as context-exhausted (#2653)", async () => {
   _resetPendingResolve();
 
@@ -2361,6 +2469,164 @@ test("autoLoop warns but proceeds for greenfield project (no project files) (#18
   );
 });
 
+// ── Proactive rate limiting (#2996) ──────────────────────────────────────────
+
+test("autoLoop enforces min_request_interval_ms delay between LLM dispatches (#2996)", async () => {
+  _resetPendingResolve();
+  mock.timers.enable({ apis: ["Date", "setTimeout"], now: 1_000 });
+
+  try {
+    const ctx = makeMockCtx();
+    ctx.ui.setStatus = () => {};
+    ctx.sessionManager = { getSessionFile: () => "/tmp/session.json" };
+    const pi = makeMockPi();
+    const originalSendMessage = pi.sendMessage;
+    const dispatchTimestamps: number[] = [];
+    pi.sendMessage = (...args: unknown[]) => {
+      dispatchTimestamps.push(Date.now());
+      return originalSendMessage(...args);
+    };
+
+    let iterCount = 0;
+
+    const s = makeLoopSession();
+
+    const deps = makeMockDeps({
+      loadEffectiveGSDPreferences: () => ({
+        preferences: {
+          min_request_interval_ms: 300,
+          uok: { plan_v2: { enabled: false } },
+        },
+      }),
+      deriveState: async () => {
+        iterCount++;
+        deps.callLog.push("deriveState");
+        return {
+          phase: "executing",
+          activeMilestone: { id: "M001", title: "Test", status: "active" },
+          activeSlice: { id: "S01", title: "Slice" },
+          activeTask: { id: "T01" },
+          registry: [{ id: "M001", status: "active" }],
+          blockers: [],
+        } as any;
+      },
+      postUnitPostVerification: async () => {
+        deps.callLog.push("postUnitPostVerification");
+        if (iterCount >= 2) {
+          s.active = false;
+        }
+        return "continue" as const;
+      },
+    });
+
+    const loopPromise = autoLoop(ctx, pi, s, deps);
+
+    await waitForMicrotasks(() => dispatchTimestamps.length === 1, "first dispatch");
+    resolveAgentEnd(makeEvent());
+    await waitForMicrotasks(
+      () => deps.callLog.filter((entry) => entry === "resolveDispatch").length >= 2,
+      "second dispatch planning",
+    );
+
+    await drainMicrotasks(100);
+    mock.timers.tick(299);
+    await drainMicrotasks(100);
+    assert.equal(dispatchTimestamps.length, 1, "second dispatch should wait for the configured interval");
+
+    mock.timers.tick(1);
+    await waitForMicrotasks(() => dispatchTimestamps.length === 2, "second dispatch");
+    resolveAgentEnd(makeEvent());
+
+    await loopPromise;
+
+    assert.ok(iterCount >= 2, `expected at least 2 iterations, got ${iterCount}`);
+    assert.ok(dispatchTimestamps.length >= 2, `expected at least 2 dispatches, got ${dispatchTimestamps.length}`);
+
+    assert.equal(
+      (s as any).lastRequestTimestamp,
+      dispatchTimestamps[1],
+      "lastRequestTimestamp should record the actual dispatch time",
+    );
+
+    const gap = dispatchTimestamps[1]! - dispatchTimestamps[0]!;
+    assert.equal(
+      gap,
+      300,
+      `gap between dispatches should match min_request_interval_ms=300 (got ${gap}ms)`,
+    );
+  } finally {
+    mock.timers.reset();
+  }
+});
+
+test("autoLoop skips rate-limit delay when min_request_interval_ms is 0 (default)", async () => {
+  _resetPendingResolve();
+  mock.timers.enable({ apis: ["Date", "setTimeout"], now: 2_000 });
+
+  try {
+    const ctx = makeMockCtx();
+    ctx.ui.setStatus = () => {};
+    ctx.sessionManager = { getSessionFile: () => "/tmp/session.json" };
+    const pi = makeMockPi();
+    const originalSendMessage = pi.sendMessage;
+    const dispatchTimestamps: number[] = [];
+    pi.sendMessage = (...args: unknown[]) => {
+      dispatchTimestamps.push(Date.now());
+      return originalSendMessage(...args);
+    };
+
+    let iterCount = 0;
+
+    const s = makeLoopSession();
+
+    const deps = makeMockDeps({
+      loadEffectiveGSDPreferences: () => ({
+        preferences: { uok: { plan_v2: { enabled: false } } },
+      }),
+      deriveState: async () => {
+        iterCount++;
+        deps.callLog.push("deriveState");
+        return {
+          phase: "executing",
+          activeMilestone: { id: "M001", title: "Test", status: "active" },
+          activeSlice: { id: "S01", title: "Slice" },
+          activeTask: { id: "T01" },
+          registry: [{ id: "M001", status: "active" }],
+          blockers: [],
+        } as any;
+      },
+      postUnitPostVerification: async () => {
+        deps.callLog.push("postUnitPostVerification");
+        if (iterCount >= 3) {
+          s.active = false;
+        }
+        return "continue" as const;
+      },
+    });
+
+    const loopPromise = autoLoop(ctx, pi, s, deps);
+
+    for (let i = 1; i <= 3; i++) {
+      await waitForMicrotasks(() => dispatchTimestamps.length === i, `dispatch ${i}`);
+      resolveAgentEnd(makeEvent());
+    }
+
+    await loopPromise;
+
+    assert.ok(iterCount >= 3, `expected at least 3 iterations, got ${iterCount}`);
+    assert.ok(dispatchTimestamps.length >= 3, `expected at least 3 dispatches, got ${dispatchTimestamps.length}`);
+
+    const gap = dispatchTimestamps[2]! - dispatchTimestamps[1]!;
+    assert.equal(
+      gap,
+      0,
+      `gap should be 0ms under mocked time without rate limiting (got ${gap}ms)`,
+    );
+  } finally {
+    mock.timers.reset();
+  }
+});
+
 // ─── #4850: pre-send model-policy block is non-retryable ────────────────────
 test("autoLoop classifies ModelPolicyDispatchBlockedError as blocked, not a retryable error", async () => {
   _resetPendingResolve();

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

@@ -731,6 +731,64 @@ test("hasImplementationArtifacts uses milestone path history instead of rolling
   }
 });
 
+test("hasImplementationArtifacts finds implementation commits when .gsd/ is gitignored (#5033)", () => {
+  const base = makeGitBase();
+  try {
+    // Simulate external/untracked .gsd/ via .git/info/exclude — milestone
+    // planning artifacts never enter git, but real implementation files do.
+    writeFileSync(join(base, ".git", "info", "exclude"), ".gsd/\n");
+    mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-SUMMARY.md"),
+      "# Summary",
+    );
+
+    mkdirSync(join(base, "benchmarks", "M001"), { recursive: true });
+    writeFileSync(join(base, "benchmarks", "M001", "manifest.yaml"), "cases: []\n");
+
+    execFileSync("git", ["add", "."], { cwd: base, stdio: "ignore" });
+    execFileSync(
+      "git",
+      ["commit", "-m", "feat: materialize M001 evidence\n\nGSD-Task: S01/T01"],
+      { cwd: base, stdio: "ignore" },
+    );
+
+    const result = hasImplementationArtifacts(base, "M001");
+    assert.equal(
+      result,
+      "present",
+      "milestone-tagged commit binding must work when .gsd/ is gitignored",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("hasImplementationArtifacts ignores malformed milestone IDs in commit-message fallback", () => {
+  const base = makeGitBase();
+  try {
+    writeFileSync(join(base, ".git", "info", "exclude"), ".gsd/\n");
+    mkdirSync(join(base, "src"), { recursive: true });
+    writeFileSync(join(base, "src", "feature.ts"), "export function feature() {}\n");
+
+    execFileSync("git", ["add", "."], { cwd: base, stdio: "ignore" });
+    execFileSync(
+      "git",
+      ["commit", "-m", "feat: materialize M001(foo evidence\n\nGSD-Task: S01/T01"],
+      { cwd: base, stdio: "ignore" },
+    );
+
+    const result = hasImplementationArtifacts(base, "M001(");
+    assert.equal(
+      result,
+      "absent",
+      "malformed milestone IDs must not bind implementation commits through message scanning",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("hasImplementationArtifacts returns true on non-git directory (fail-open)", () => {
   const base = join(tmpdir(), `gsd-test-nogit-${randomUUID()}`);
   mkdirSync(base, { recursive: true });

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

@@ -14,10 +14,12 @@ import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
+import { AutoSession } from "../auto/session.ts";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const AUTO_TS_PATH = join(__dirname, "..", "auto.ts");
 const SESSION_TS_PATH = join(__dirname, "..", "auto", "session.ts");
+const RUNTIME_STATE_TS_PATH = join(__dirname, "..", "auto-runtime-state.ts");
 
 function getAutoTsSource(): string {
   return readFileSync(AUTO_TS_PATH, "utf-8");
@@ -27,6 +29,24 @@ function getSessionTsSource(): string {
   return readFileSync(SESSION_TS_PATH, "utf-8");
 }
 
+function getRuntimeStateTsSource(): string {
+  return readFileSync(RUNTIME_STATE_TS_PATH, "utf-8");
+}
+
+test("AutoSession.lockBasePath uses GSD_PROJECT_ROOT for symlink-resolved worktrees", () => {
+  const savedProjectRoot = process.env.GSD_PROJECT_ROOT;
+  process.env.GSD_PROJECT_ROOT = "/real/project";
+  try {
+    const session = new AutoSession();
+    session.basePath = "/Users/dev/.gsd/projects/abc123/worktrees/M001/slices/S01";
+
+    assert.equal(session.lockBasePath, "/real/project");
+  } finally {
+    if (savedProjectRoot === undefined) delete process.env.GSD_PROJECT_ROOT;
+    else process.env.GSD_PROJECT_ROOT = savedProjectRoot;
+  }
+});
+
 // ── Invariant 1: No module-level mutable variables in auto.ts ────────────────
 
 test("auto.ts has no module-level let declarations", () => {
@@ -75,18 +95,18 @@ test("auto.ts has no module-level var declarations", () => {
 
 // ── Invariant 2: AutoSession singleton is the only mutable module-level binding ──
 
-test("auto.ts has exactly one module-level const for AutoSession", () => {
-  const source = getAutoTsSource();
+test("auto-runtime-state.ts has exactly one module-level const for AutoSession", () => {
+  const source = getRuntimeStateTsSource();
   const lines = source.split("\n");
 
   const sessionConsts = lines.filter(line =>
-    /^const\s+\w+\s*=\s*new\s+AutoSession/.test(line),
+    /^(export\s+)?const\s+\w+\s*=\s*new\s+AutoSession/.test(line),
   );
 
   assert.equal(
     sessionConsts.length,
     1,
-    `auto.ts should have exactly one \`const s = new AutoSession()\`. ` +
+    `auto-runtime-state.ts should have exactly one \`const autoSession = new AutoSession()\`. ` +
     `Found ${sessionConsts.length}: ${sessionConsts.join(", ")}`,
   );
 });
@@ -201,7 +221,6 @@ test("auto.ts module-level consts are only AutoSession instance, true constants,
 
   // Patterns that are acceptable at module level
   const allowedPatterns = [
-    /^const s = new AutoSession/,                 // The session singleton
     /^const [A-Z_]+\s*=/,                          // UPPER_CASE constants
     /^const \w+StateAccessors/,                    // Static accessor objects
     /^const \w+:\s*\w+\s*=/,                       // Typed constants

package/src/resources/extensions/gsd/tests/auto-start-clean-runtime-db-gated.test.ts

@@ -7,9 +7,12 @@
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+import { cleanStaleRuntimeUnits } from "../auto-worktree.ts";
 import { extractSourceRegion } from "./test-helpers.ts";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -61,4 +64,32 @@ describe("auto-start cleanStaleRuntimeUnits DB gating (#4663)", () => {
       "legacy FS-fallback branch should still use SUMMARY file presence",
     );
   });
+
+  test("cleanStaleRuntimeUnits removes legacy pseudo deep-setup runtime files", () => {
+    const base = join(tmpdir(), `gsd-clean-runtime-${randomUUID()}`);
+    const gsdRoot = join(base, ".gsd");
+    const unitsDir = join(gsdRoot, "runtime", "units");
+    try {
+      mkdirSync(unitsDir, { recursive: true });
+      const staleFiles = [
+        "discuss-milestone-PROJECT.json",
+        "workflow-preferences-WORKFLOW-PREFS.json",
+        "discuss-project-PROJECT.json",
+        "discuss-requirements-REQUIREMENTS.json",
+        "research-decision-RESEARCH-DECISION.json",
+        "research-project-RESEARCH-PROJECT.json",
+      ];
+      const valid = join(unitsDir, "discuss-milestone-M001.json");
+      for (const file of staleFiles) writeFileSync(join(unitsDir, file), "{}\n", "utf-8");
+      writeFileSync(valid, "{}\n", "utf-8");
+
+      const cleaned = cleanStaleRuntimeUnits(gsdRoot, () => false);
+
+      assert.equal(cleaned, staleFiles.length);
+      for (const file of staleFiles) assert.equal(existsSync(join(unitsDir, file)), false);
+      assert.equal(existsSync(valid), true);
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  });
 });

package/src/resources/extensions/gsd/tests/auto-supervisor.test.mjs

@@ -7,10 +7,27 @@ import { writeUnitRuntimeRecord, readUnitRuntimeRecord } from '../unit-runtime.t
 import { resolveAutoSupervisorConfig } from '../preferences.ts';
 
 test('resolveAutoSupervisorConfig provides safe timeout defaults', () => {
-  const supervisor = resolveAutoSupervisorConfig();
-  assert.equal(supervisor.soft_timeout_minutes, 20);
-  assert.equal(supervisor.idle_timeout_minutes, 10);
-  assert.equal(supervisor.hard_timeout_minutes, 30);
+  // Isolate from any developer ~/.gsd/PREFERENCES.md that overrides these
+  // defaults — the test pins what resolveAutoSupervisorConfig() returns when
+  // no preferences file exists, so it must not pick up the runner's home dir.
+  const previousGsdHome = process.env.GSD_HOME;
+  const previousCwd = process.cwd();
+  const isolated = mkdtempSync(join(tmpdir(), 'gsd-supervisor-defaults-'));
+  process.env.GSD_HOME = isolated;
+  process.chdir(isolated);
+  try {
+    const supervisor = resolveAutoSupervisorConfig();
+    assert.equal(supervisor.soft_timeout_minutes, 20);
+    assert.equal(supervisor.idle_timeout_minutes, 10);
+    assert.equal(supervisor.hard_timeout_minutes, 30);
+  } finally {
+    if (previousGsdHome === undefined) {
+      delete process.env.GSD_HOME;
+    } else {
+      process.env.GSD_HOME = previousGsdHome;
+    }
+    process.chdir(previousCwd);
+  }
 });
 
 test('writeUnitRuntimeRecord persists progress and recovery metadata defaults', () => {

package/src/resources/extensions/gsd/tests/auto-wrapup-inflight-guard.test.ts

@@ -136,6 +136,30 @@ describe("#3512: pauseAuto and stopAuto must flush queued follow-up messages", (
     );
   });
 
+  test("pauseAuto rebuilds STATE.md before releasing the session lock", () => {
+    // pauseAuto must persist the DB-backed state projection so resume/debugging
+    // does not see a stale STATE.md after a mid-unit interruption.
+    const start = autoSrc.indexOf("export async function pauseAuto(");
+    const end = autoSrc.indexOf("/**\n * Build a WorktreeResolverDeps", start);
+    const pauseAutoSection = autoSrc.slice(start, end);
+    assert.ok(pauseAutoSection.length > 0, "Could not locate pauseAuto function");
+
+    const rebuildIndex = pauseAutoSection.indexOf("await rebuildState(s.basePath)");
+    const releaseIndex = pauseAutoSection.indexOf("releaseSessionLock(lockBase())");
+    assert.ok(
+      rebuildIndex >= 0,
+      "pauseAuto must rebuild STATE.md from DB-backed state before pause completes",
+    );
+    assert.ok(
+      releaseIndex >= 0,
+      "pauseAuto must still release the session lock",
+    );
+    assert.ok(
+      rebuildIndex < releaseIndex,
+      "pauseAuto must rebuild state before releasing the session lock",
+    );
+  });
+
   test("run-unit.ts still has its existing clearQueue() call (baseline)", () => {
     // Verify the original clearQueue pattern in run-unit.ts hasn't been removed.
     assert.ok(
@@ -167,3 +191,35 @@ describe("#4365: tool_execution_start hook must pass toolName to markToolStart",
     );
   });
 });
+
+describe("deep setup approval questions pause immediately", () => {
+  test("register-hooks sets pending gate during message_update without aborting the stream", () => {
+    const startMarker = 'pi.on("message_update"';
+    const endMarker = 'pi.on("session_shutdown"';
+    const messageUpdateSection = registerHooksSrc.slice(
+      registerHooksSrc.indexOf(startMarker),
+      registerHooksSrc.indexOf(endMarker),
+    );
+
+    assert.ok(
+      messageUpdateSection.length > 0,
+      "Could not locate message_update approval pause handler",
+    );
+    assert.ok(
+      messageUpdateSection.includes("shouldPauseForUserApprovalQuestion"),
+      "message_update must detect approval/question boundaries",
+    );
+    assert.ok(
+      messageUpdateSection.includes("approvalGateIdForUnit") && messageUpdateSection.includes("setPendingGate"),
+      "plain-text approval questions must set the durable write gate",
+    );
+    assert.ok(
+      messageUpdateSection.includes("getDiscussionMilestoneIdFor") && messageUpdateSection.includes('"discuss-milestone"'),
+      "foreground milestone discussion questions must also set the durable write gate",
+    );
+    assert.ok(
+      !messageUpdateSection.includes("ctx.abort()"),
+      "message_update must NOT abort the stream — aborting eats the model's question text on external CLI providers; the pending gate set above blocks subsequent tool calls instead",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/bootstrap-derive-state-db-open.test.ts

@@ -32,7 +32,7 @@ describe("bootstrap deriveState DB guards (#3844)", () => {
     assert.ok(compactIdx > -1, "register-hooks should define session_before_compact");
     const compactSection = extractSourceRegion(registerHooksSrc, 'pi.on("session_before_compact"');
     const ensureIdx = compactSection.indexOf("ensureDbOpen()");
-    const deriveIdx = compactSection.indexOf("deriveState(basePath)");
+    const deriveIdx = compactSection.indexOf("deriveGsdState(basePath)");
     assert.ok(ensureIdx > -1, "session_before_compact should call ensureDbOpen()");
     assert.ok(deriveIdx > -1, "session_before_compact should derive state");
     assert.ok(ensureIdx < deriveIdx, "session_before_compact should open DB before deriveState");