gsd-pi 2.77.0-dev.58d3d4d6c → 2.77.0-dev.cfd69e714

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

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
@@ -21,6 +21,7 @@ import {
 } from "../interrupted-session.ts";
 import { gsdRoot } from "../paths.ts";
 import type { GSDState } from "../types.ts";
+import { _synthesizePausedSessionRecoveryForTest } from "../auto.ts";
 
 function makeTmpBase(): string {
   const base = join(tmpdir(), `gsd-test-${randomUUID()}`);
@@ -167,6 +168,54 @@ test("readPausedSessionMetadata reads paused-session metadata when present", ()
   }
 });
 
+test("paused session recovery consumes JSONL without deleting the evidence file", (t) => {
+  const base = makeTmpBase();
+  t.after(() => cleanup(base));
+
+  const sessionFile = join(base, "paused-session.jsonl");
+  writeFileSync(
+    sessionFile,
+    [
+      JSON.stringify({ type: "session", id: "session-1" }),
+      JSON.stringify({
+        type: "message",
+        message: {
+          role: "assistant",
+          content: [
+            {
+              type: "toolCall",
+              name: "bash",
+              id: "tool-1",
+              arguments: { command: "echo paused" },
+            },
+          ],
+        },
+      }),
+      JSON.stringify({
+        type: "message",
+        message: {
+          role: "toolResult",
+          toolCallId: "tool-1",
+          toolName: "bash",
+          isError: false,
+          content: "paused\n",
+        },
+      }),
+    ].join("\n"),
+    "utf-8",
+  );
+
+  const recovery = _synthesizePausedSessionRecoveryForTest(
+    base,
+    "execute-task",
+    "M001/S01/T01",
+    sessionFile,
+  );
+
+  assert.equal(recovery?.trace.toolCallCount, 1);
+  assert.equal(existsSync(sessionFile), true, "paused JSONL must remain available after synthesis");
+});
+
 test("readPausedSessionMetadata preserves unitType and unitId through round-trip", () => {
   const base = makeTmpBase();
   try {

package/src/resources/extensions/gsd/tests/derive-state-crossval.test.ts

@@ -351,9 +351,9 @@ skills_used: []
       const dbState = await deriveStateFromDb(base);
 
       assertStatesEqual(dbState, fileState, 'E-blocked');
-      // With partial-dep fallback, circular deps no longer block — fallback picks first eligible slice
-      assert.deepStrictEqual(dbState.phase, 'planning', 'E-blocked: phase is planning (fallback picks a slice)');
-      assert.ok(dbState.activeSlice !== null, 'E-blocked: activeSlice is set via fallback');
+      assert.deepStrictEqual(dbState.phase, 'blocked', 'E-blocked: phase is blocked when no slice deps are satisfied');
+      assert.deepStrictEqual(dbState.activeSlice, null, 'E-blocked: no activeSlice is selected through unmet deps');
+      assert.ok(dbState.blockers.some(b => b.includes('No slice eligible')), 'E-blocked: blocker explains no eligible slice');
 
       closeDatabase();
     } finally {

package/src/resources/extensions/gsd/tests/derive-state-db-disk-reconcile.test.ts

@@ -112,6 +112,46 @@ async function main(): Promise<void> {
     cleanup(base);
   }
 
+  console.log("\n=== #4974: summary-only disk milestones keep parsed title ===");
+
+  {
+    const summaryOnlyBase = createFixtureBase();
+    const summaryOnlyDbPath = join(summaryOnlyBase, ".gsd", "gsd.db");
+
+    try {
+      openDatabase(summaryOnlyDbPath);
+      insertMilestone({ id: "M001", title: "M001: Existing DB Milestone", status: "complete", depends_on: [] });
+
+      writeFile(
+        summaryOnlyBase,
+        "milestones/M002/SUMMARY.md",
+        `---\nid: M002\nstatus: complete\n---\n\n# M002: Summary-Only Milestone\n\nComplete.`,
+      );
+
+      invalidateStateCache();
+      const state = await deriveStateFromDb(summaryOnlyBase);
+      const m002Entry = state.registry.find((m) => m.id === "M002");
+
+      assertTrue(
+        m002Entry !== undefined,
+        "M002 summary-only disk milestone should appear in state.registry (#4974)",
+      );
+      assertEq(
+        m002Entry?.title,
+        "Summary-Only Milestone",
+        "M002 summary-only disk milestone should use parsed SUMMARY title (#4974)",
+      );
+      assertEq(
+        m002Entry?.status,
+        "complete",
+        "M002 summary-only disk milestone should reconcile as complete (#4974)",
+      );
+    } finally {
+      closeDatabase();
+      cleanup(summaryOnlyBase);
+    }
+  }
+
   report();
 }
 

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

@@ -14,6 +14,7 @@ import {
   getAllMilestones,
   insertSlice,
   insertTask,
+  getSliceTasks,
   updateTaskStatus,
 } from '../gsd-db.ts';
 // ─── Fixture Helpers ───────────────────────────────────────────────────────
@@ -270,6 +271,93 @@ describe('derive-state-db', async () => {
     }
   });
 
+  test('derive-state-db: partial task rows reconcile missing plan tasks before summarizing', async (t) => {
+    const base = createFixtureBase();
+    t.after(() => {
+      closeDatabase();
+      cleanup(base);
+    });
+
+    const partialTaskPlan = `# S01: First Slice
+
+**Goal:** Test partial task DB reconciliation.
+**Demo:** Tests pass.
+
+## Tasks
+
+- [x] **T01: Existing Complete** \`est:10m\`
+  Already complete in DB.
+
+- [ ] **T02: Missing Pending** \`est:10m\`
+  Missing from DB but present in the plan.
+`;
+    writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_CONTENT);
+    writeFile(base, 'milestones/M001/slices/S01/S01-PLAN.md', partialTaskPlan);
+    writeFile(base, 'milestones/M001/slices/S01/tasks/.gitkeep', '');
+    writeFile(base, 'milestones/M001/slices/S01/tasks/T01-PLAN.md', '# T01 Plan');
+    writeFile(base, 'milestones/M001/slices/S01/tasks/T02-PLAN.md', '# T02 Plan');
+
+    openDatabase(':memory:');
+    insertMilestone({ id: 'M001', title: 'Test Milestone', status: 'active' });
+    insertSlice({ id: 'S01', milestoneId: 'M001', title: 'First Slice', status: 'active', risk: 'low', depends: [] });
+    insertTask({ id: 'T01', sliceId: 'S01', milestoneId: 'M001', title: 'Existing Complete', status: 'complete' });
+
+    invalidateStateCache();
+    const state = await deriveState(base);
+
+    const dbTasks = getSliceTasks('M001', 'S01');
+    assert.deepStrictEqual(dbTasks.length, 2, 'partial-task-db: missing T02 imported from plan');
+    assert.deepStrictEqual(dbTasks.find(t => t.id === 'T01')?.status, 'complete', 'partial-task-db: existing complete T01 preserved');
+    assert.deepStrictEqual(dbTasks.find(t => t.id === 'T02')?.status, 'pending', 'partial-task-db: missing T02 inserted pending');
+    assert.deepStrictEqual(state.phase, 'executing', 'partial-task-db: phase remains executing, not summarizing');
+    assert.deepStrictEqual(state.activeTask?.id, 'T02', 'partial-task-db: activeTask is missing plan task T02');
+    assert.deepStrictEqual(state.progress?.tasks, { done: 1, total: 2 }, 'partial-task-db: task progress includes reconciled plan task');
+  });
+
+  test('derive-state-db: empty DB disk import preserves milestone completion and dependencies', async (t) => {
+    const base = createFixtureBase();
+    t.after(() => {
+      closeDatabase();
+      cleanup(base);
+    });
+
+    writeFile(base, 'milestones/M001/M001-ROADMAP.md', `# M001: Foundation
+
+**Vision:** Foundation.
+
+## Slices
+
+- [x] **S01: Done** \`risk:low\` \`depends:[]\`
+  > After this: Done.
+`);
+    writeFile(base, 'milestones/M001/M001-VALIDATION.md', '---\nverdict: pass\nremediation_round: 0\n---\n\nPassed.');
+    writeFile(base, 'milestones/M001/M001-SUMMARY.md', '# M001 Summary\n\nDone.');
+    writeFile(base, 'milestones/M002/M002-CONTEXT.md', '---\ndepends_on:\n  - M001\n---\n\n# M002: Dependent\n');
+    writeFile(base, 'milestones/M002/M002-ROADMAP.md', `# M002: Dependent
+
+**Vision:** Active work.
+
+## Slices
+
+- [ ] **S01: Work** \`risk:low\` \`depends:[]\`
+  > After this: Done.
+`);
+    writeFile(base, 'milestones/M003/M003-CONTEXT.md', '---\ndepends_on:\n  - M002\n---\n\n# M003: Blocked\n');
+
+    openDatabase(':memory:');
+
+    invalidateStateCache();
+    const state = await deriveState(base);
+
+    const milestones = getAllMilestones();
+    assert.deepStrictEqual(milestones.find(m => m.id === 'M001')?.status, 'complete', 'disk-import: terminal summary imports M001 as complete');
+    assert.deepStrictEqual(milestones.find(m => m.id === 'M002')?.depends_on, ['M001'], 'disk-import: M002 depends_on imported from CONTEXT');
+    assert.deepStrictEqual(milestones.find(m => m.id === 'M003')?.depends_on, ['M002'], 'disk-import: M003 depends_on imported from CONTEXT');
+    assert.deepStrictEqual(state.activeMilestone?.id, 'M002', 'disk-import: M002 is active because M001 completion satisfies dependency');
+    assert.deepStrictEqual(state.registry.find(e => e.id === 'M001')?.status, 'complete', 'disk-import: M001 registry status is complete');
+    assert.deepStrictEqual(state.registry.find(e => e.id === 'M003')?.status, 'pending', 'disk-import: M003 stays pending on unmet M002 dependency');
+  });
+
   // ─── Test 5: Requirements counting from disk (DB no longer used for content) ─
   test('derive-state-db: requirements from disk content', async () => {
     const base = createFixtureBase();
@@ -616,10 +704,10 @@ describe('derive-state-db', async () => {
       invalidateStateCache();
       const dbState = await deriveStateFromDb(base);
 
-      // With partial-dep fallback, circular deps no longer block — fallback picks first eligible slice
-      assert.deepStrictEqual(dbState.phase, 'planning', 'blocked-db: phase is planning (fallback picks a slice)');
+      assert.deepStrictEqual(dbState.phase, 'blocked', 'blocked-db: phase is blocked when no slice deps are satisfied');
       assert.deepStrictEqual(dbState.phase, fileState.phase, 'blocked-db: phase matches filesystem');
-      assert.ok(dbState.activeSlice !== null, 'blocked-db: activeSlice is set via fallback');
+      assert.deepStrictEqual(dbState.activeSlice, null, 'blocked-db: no activeSlice is selected through unmet deps');
+      assert.ok(dbState.blockers.some(b => b.includes('No slice eligible')), 'blocked-db: blocker explains no eligible slice');
 
       closeDatabase();
     } finally {

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

@@ -431,7 +431,7 @@ Continue from step 2.
       cleanup(base1);
     }
 
-    // Case B: S01 depends on nonexistent S99 -> fallback picks best available slice
+    // Case B: S01 depends on nonexistent S99 -> no slice is eligible
     const base2 = createFixtureBase();
     try {
       writeRoadmap(base2, 'M001', `# M001: Test Milestone
@@ -446,8 +446,9 @@ Continue from step 2.
 
       const state2 = await deriveState(base2);
 
-      assert.deepStrictEqual(state2.phase, 'planning', 'blocked-B: phase is planning (fallback picks S01)');
-      assert.deepStrictEqual(state2.activeSlice?.id, 'S01', 'blocked-B: activeSlice is S01 via fallback');
+      assert.deepStrictEqual(state2.phase, 'blocked', 'blocked-B: phase is blocked when dependency is unsatisfied');
+      assert.deepStrictEqual(state2.activeSlice, null, 'blocked-B: no activeSlice selected through unmet deps');
+      assert.ok(state2.blockers.some(b => b.includes('No slice eligible')), 'blocked-B: blocker explains no eligible slice');
     } finally {
       cleanup(base2);
     }

package/src/resources/extensions/gsd/tests/dispatcher-stuck-planning.test.ts

@@ -4,7 +4,7 @@
  * Verify that state.ts contains the disk-to-DB task reconciliation logic
  * that prevents the dispatcher from getting stuck in an infinite planning
  * loop when the planner writes a PLAN.md but never calls the persistence
- * tool, leaving the DB with zero task rows.
+ * tool, leaving the DB with zero or partial task rows.
  */
 
 import { describe, test } from "node:test";
@@ -24,7 +24,8 @@ describe("dispatcher stuck-planning reconciliation (#3656)", () => {
   });
 
   test("contains plan-file task reconciliation block", () => {
-    assert.match(source, /tasks\.length\s*===\s*0\s*&&\s*planFile/);
+    assert.match(source, /if\s*\(\s*planFile\s*\)/);
+    assert.match(source, /dbTaskIds\.has\(t\.id\)/);
   });
 
   test("calls insertTask for each disk plan task", () => {

package/src/resources/extensions/gsd/tests/extension-bootstrap-isolation.test.ts

@@ -1,154 +1,164 @@
-// Structural contracts for GSD extension bootstrap isolation.
+// Behavioural contract for GSD extension bootstrap isolation (#4168, #4172).
 //
-// The /gsd command must survive failures in the full extension bootstrap
-// (register-extension.ts). This guards against the regression where a
-// Windows-specific import failure in register-shortcuts.ts silently
-// prevented /gsd from being registered at all (#4168, #4172).
+// Guarantee: the `/gsd` slash command must be registered on pi even if the
+// full bootstrap (shortcuts, tools, hooks, ecosystem) throws during import or
+// execution. Prior regressions: a Windows-specific failure in register-
+// shortcuts.ts silently prevented /gsd from being registered at all because
+// registerGSDCommand was called inside the same try that loaded shortcuts.
+//
+// These tests exercise the real default export of index.ts (which calls
+// registerGSDCommand via dynamic import, then attempts the full bootstrap)
+// with a minimal mock ExtensionAPI and verify the observable behaviour
+// directly: /gsd is registered in both the happy path and the degraded path.
+//
+// Anti-regression proof (documented in commit):
+//   neuter index.ts to register /gsd inside the same try{} as
+//   register-extension → the degraded-path test fails (no /gsd command
+//   registered when register-extension throws). Restore → passes.
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const indexSrc = readFileSync(join(__dirname, "../index.ts"), "utf-8");
-const registerExtSrc = readFileSync(
-  join(__dirname, "../bootstrap/register-extension.ts"),
-  "utf-8",
-);
-
-// ─── index.ts: core /gsd command must be registered before full bootstrap ─────
-
-describe("index.ts bootstrap isolation", () => {
-  test("imports registerGSDCommand from commands/index.js separately", () => {
-    assert.ok(
-      indexSrc.includes('./commands/index.js"') || indexSrc.includes("./commands/index.js'"),
-      "index.ts must import registerGSDCommand from ./commands/index.js",
-    );
-  });
-
-  test("calls registerGSDCommand before importing register-extension.js", () => {
-    const gsdCommandCallPos = indexSrc.indexOf("registerGSDCommand(pi)");
-    const bootstrapImportPos = indexSrc.indexOf(
-      './bootstrap/register-extension.js"',
-    );
 
-    assert.ok(gsdCommandCallPos >= 0, "must call registerGSDCommand(pi)");
-    assert.ok(bootstrapImportPos >= 0, "must import register-extension.js");
+import registerExtension from "../index.ts";
+
+type RegisterFn = (name: string, def: unknown) => void;
+
+function makePi(overrides: Partial<Record<string, unknown>> = {}) {
+  const registered: Array<[string, unknown]> = [];
+  const registerCommand: RegisterFn = (name, def) => {
+    registered.push([name, def]);
+  };
+  const events = {
+    on: () => {},
+    off: () => {},
+    emit: () => {},
+  };
+  const pi = {
+    registerCommand,
+    registerTool: () => {},
+    registerHook: () => {},
+    registerShortcut: () => {},
+    events,
+    ...overrides,
+  };
+  return { pi, registered };
+}
+
+describe("extension bootstrap isolation (#4168, #4172)", () => {
+  test("happy path: /gsd command is registered", async () => {
+    const { pi, registered } = makePi();
+    await registerExtension(pi as any);
+    const names = registered.map(([n]) => n);
     assert.ok(
-      gsdCommandCallPos < bootstrapImportPos,
-      "registerGSDCommand(pi) must be called BEFORE importing register-extension.js",
+      names.includes("gsd"),
+      `expected 'gsd' in registered commands, got ${JSON.stringify(names)}`,
     );
   });
 
-  test("wraps register-extension.js import in try-catch", () => {
-    // The dynamic import of register-extension.js must be inside a try block
-    const tryPos = indexSrc.indexOf("try {");
-    const bootstrapImportPos = indexSrc.indexOf(
-      './bootstrap/register-extension.js"',
-    );
-    const catchPos = indexSrc.indexOf("catch (err)");
-
-    assert.ok(tryPos >= 0, "must have try block");
-    assert.ok(catchPos >= 0, "must have catch block");
+  test("degraded path: /gsd still registered when registerCommand throws for non-core commands", async () => {
+    // Simulate the Windows-style failure: pi.registerCommand throws for a
+    // specific non-core command ('kill' is a simple target registered by
+    // the full bootstrap) — the full bootstrap must fail but /gsd must
+    // already be registered before the failure occurs.
+    const registered: Array<[string, unknown]> = [];
+    const pi = {
+      registerCommand: (name: string, def: unknown) => {
+        if (name !== "gsd" && name !== "worktree" && name !== "exit") {
+          // Let /gsd, /worktree, /exit succeed (they precede the non-core
+          // loop); throw when the first non-core registration fires.
+        }
+        if (name === "kill") throw new Error("simulated windows failure");
+        registered.push([name, def]);
+      },
+      registerTool: () => {},
+      registerHook: () => {},
+      registerShortcut: () => {},
+      events: { on: () => {}, off: () => {}, emit: () => {} },
+    };
+
+    // registerExtension must not throw — the outer try/catch in index.ts
+    // swallows bootstrap failures after /gsd is already registered.
+    await registerExtension(pi as any);
+
+    const names = registered.map(([n]) => n);
     assert.ok(
-      tryPos < bootstrapImportPos && bootstrapImportPos < catchPos,
-      "register-extension.js import must be wrapped in try-catch",
+      names.includes("gsd"),
+      "expected 'gsd' to be registered even when a later command registration throws",
     );
   });
 
-  test("logs warning on bootstrap failure via workflow-logger", () => {
-    assert.ok(
-      indexSrc.includes("logWarning"),
-      "must use logWarning when bootstrap fails",
-    );
-    assert.ok(
-      indexSrc.includes("Extension setup partially failed"),
-      "warning message must indicate partial failure with /gsd still available",
+  test("degraded path: /gsd registered BEFORE any non-core command", async () => {
+    // Ordering guard: the first registerCommand call must be for 'gsd',
+    // because index.ts awaits registerGSDCommand(pi) before importing
+    // register-extension. Regression scenario: if a future refactor moves
+    // registerGSDCommand into the try block or after other registrations,
+    // a failure in those earlier registrations would take /gsd down too.
+    const calls: string[] = [];
+    const pi = {
+      registerCommand: (name: string) => {
+        calls.push(name);
+      },
+      registerTool: () => {},
+      registerHook: () => {},
+      registerShortcut: () => {},
+      events: { on: () => {}, off: () => {}, emit: () => {} },
+    };
+    await registerExtension(pi as any);
+    assert.ok(calls.length > 0, "expected at least one registerCommand call");
+    assert.equal(
+      calls[0],
+      "gsd",
+      `expected 'gsd' to be the first command registered, got ${JSON.stringify(calls)}`,
     );
   });
 });
 
-// ─── register-extension.ts: no double-registration + defensive wrapping ───────
-
-describe("register-extension.ts defensive registration", () => {
-  test("does NOT import or call registerGSDCommand (avoids double-registration)", () => {
-    // registerGSDCommand is now called by index.ts, not register-extension.ts
-    assert.ok(
-      !registerExtSrc.includes("import { registerGSDCommand }"),
-      "register-extension.ts must NOT import registerGSDCommand",
-    );
-
-    // Check the function body of registerGsdExtension doesn't call it
-    const funcBodyStart = registerExtSrc.indexOf(
-      "export function registerGsdExtension",
-    );
-    const funcBody = registerExtSrc.slice(funcBodyStart);
-    assert.ok(
-      !funcBody.includes("registerGSDCommand(pi)"),
-      "registerGsdExtension must NOT call registerGSDCommand(pi)",
-    );
-  });
-
-  test("still registers worktree, exit, and kill commands", () => {
-    const funcBodyStart = registerExtSrc.indexOf(
-      "export function registerGsdExtension",
-    );
-    const funcBody = registerExtSrc.slice(funcBodyStart);
-
-    assert.ok(
-      funcBody.includes("registerWorktreeCommand(pi)"),
-      "must register worktree command",
-    );
-    assert.ok(
-      funcBody.includes("registerExitCommand(pi)"),
-      "must register exit command",
-    );
-    assert.ok(
-      funcBody.includes('"kill"'),
-      "must register kill command",
-    );
-  });
-
-  test("wraps non-critical registrations in individual try-catch blocks", () => {
-    const funcBodyStart = registerExtSrc.indexOf(
-      "export function registerGsdExtension",
-    );
-    const funcBody = registerExtSrc.slice(funcBodyStart);
-
-    // Each non-critical registration should be wrapped with error handling
-    const registrationNames = [
-      "dynamic-tools",
-      "db-tools",
-      "journal-tools",
-      "query-tools",
-      "shortcuts",
-      "hooks",
-    ];
-
-    for (const name of registrationNames) {
-      assert.ok(
-        funcBody.includes(`"${name}"`),
-        `non-critical registration "${name}" must be present`,
-      );
-    }
-
-    // Must have try-catch inside the registration loop
+// Behavioural contract for registerGsdExtension itself: each non-core
+// registration is wrapped in its own try/catch so one failure does not
+// prevent siblings from loading.
+
+import { registerGsdExtension } from "../bootstrap/register-extension.ts";
+
+describe("registerGsdExtension defensive registration", () => {
+  test("a failing shortcut registration does not prevent kill command registration", async () => {
+    // `shortcuts` is registered via a non-critical slot that is wrapped in
+    // its own try/catch. `kill` is registered before the non-critical loop
+    // as a critical command. Simulate: registerShortcut throws. Expect:
+    // 'kill' is still registered, registerGsdExtension does not throw.
+    const registered: string[] = [];
+    const pi = {
+      registerCommand: (name: string) => {
+        registered.push(name);
+      },
+      registerTool: () => {},
+      registerHook: () => {},
+      registerShortcut: () => {
+        throw new Error("simulated platform-specific shortcut failure");
+      },
+      events: { on: () => {}, off: () => {}, emit: () => {} },
+    };
+    assert.doesNotThrow(() => registerGsdExtension(pi as any));
     assert.ok(
-      funcBody.includes("try {") && funcBody.includes("catch (err)"),
-      "must have try-catch for non-critical registrations",
+      registered.includes("kill"),
+      `expected 'kill' to be registered despite shortcut failure, got ${JSON.stringify(registered)}`,
     );
   });
 
-  test("logs warning when a non-critical registration fails", () => {
-    assert.ok(
-      registerExtSrc.includes("Failed to register"),
-      "must log descriptive warning for individual registration failures",
-    );
+  test("does NOT register /gsd (caller's responsibility, avoids double-registration)", () => {
+    const registered: string[] = [];
+    const pi = {
+      registerCommand: (name: string) => {
+        registered.push(name);
+      },
+      registerTool: () => {},
+      registerHook: () => {},
+      registerShortcut: () => {},
+      events: { on: () => {}, off: () => {}, emit: () => {} },
+    };
+    registerGsdExtension(pi as any);
     assert.ok(
-      registerExtSrc.includes("logWarning"),
-      "must use logWarning from workflow-logger",
+      !registered.includes("gsd"),
+      `registerGsdExtension must NOT register 'gsd' (it is registered separately by index.ts), got ${JSON.stringify(registered)}`,
     );
   });
 });