gsd-pi 2.77.0-dev.c9c8932c6 → 2.77.0-dev.cfd69e714

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/double-merge-guard.test.ts

@@ -4,6 +4,7 @@ import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { AutoSession } from "../auto/session.ts";
+import { extractSourceRegion } from "./test-helpers.ts";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -20,7 +21,7 @@ describe("double mergeAndExit guard (#2645)", () => {
     const completeIdx = phasesSrc.indexOf('state.phase === "complete"');
     assert.ok(completeIdx > 0, "phases.ts should have a 'complete' phase check");
 
-    const afterComplete = phasesSrc.slice(completeIdx, completeIdx + 600);
+    const afterComplete = extractSourceRegion(phasesSrc, 'state.phase === "complete"');
     const mergeIdx = afterComplete.indexOf("deps.resolver.mergeAndExit");
     const flagIdx = afterComplete.indexOf("s.milestoneMergedInPhases = true");
 
@@ -42,7 +43,7 @@ describe("double mergeAndExit guard (#2645)", () => {
     const allCompleteIdx = phasesSrc.indexOf("incomplete.length === 0");
     assert.ok(allCompleteIdx > 0, "phases.ts should have an all-milestones-complete check");
 
-    const afterAllComplete = phasesSrc.slice(allCompleteIdx, allCompleteIdx + 800);
+    const afterAllComplete = extractSourceRegion(phasesSrc, "incomplete.length === 0");
     const mergeIdx = afterAllComplete.indexOf("deps.resolver.mergeAndExit");
     const flagIdx = afterAllComplete.indexOf("s.milestoneMergedInPhases = true");
 
@@ -64,7 +65,7 @@ describe("double mergeAndExit guard (#2645)", () => {
     const step4Idx = autoSrc.indexOf("Step 4: Auto-worktree exit");
     assert.ok(step4Idx > 0, "auto.ts should have Step 4 worktree exit");
 
-    const step4Block = autoSrc.slice(step4Idx, step4Idx + 600);
+    const step4Block = extractSourceRegion(autoSrc, "Step 4: Auto-worktree exit");
     assert.ok(
       step4Block.includes("milestoneMergedInPhases"),
       "stopAuto Step 4 must check milestoneMergedInPhases before merging",

package/src/resources/extensions/gsd/tests/empty-content-abort-loop.test.ts

@@ -13,6 +13,7 @@ import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
+import { extractSourceRegion } from "./test-helpers.ts";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const RECOVERY_PATH = join(__dirname, "..", "bootstrap", "agent-end-recovery.ts");
@@ -30,7 +31,7 @@ test("agent-end-recovery.ts does not pause on aborted messages with empty conten
   assert.ok(abortIdx > -1, "abort handler must exist in agent-end-recovery.ts");
 
   // Extract the region around the abort handler (enough to see the guard logic)
-  const abortRegion = source.slice(Math.max(0, abortIdx - 200), abortIdx + 600);
+  const abortRegion = extractSourceRegion(source, 'stopReason === "aborted"', { fromIdx: abortIdx });
 
   // Must check for empty content before pausing
   assert.ok(
@@ -48,7 +49,7 @@ test("agent-end-recovery.ts routes empty-content aborted messages to resolveAgen
   assert.ok(abortIdx > -1, "abort handler must exist");
 
   // Get the full abort handling block (from the if to the next stopReason check or success path)
-  const afterAbort = source.slice(abortIdx, abortIdx + 800);
+  const afterAbort = extractSourceRegion(source, 'stopReason === "aborted"');
 
   // The abort block must have a code path that calls resolveAgentEnd (for empty-content case)
   assert.ok(
@@ -63,7 +64,7 @@ test("agent-end-recovery.ts checks for errorMessage presence in abort handler (#
   const abortIdx = source.indexOf('stopReason === "aborted"');
   assert.ok(abortIdx > -1, "abort handler must exist");
 
-  const abortRegion = source.slice(abortIdx, abortIdx + 600);
+  const abortRegion = extractSourceRegion(source, 'stopReason === "aborted"');
 
   // Fatal aborts should have error context (errorMessage field).
   // The handler should check for this to distinguish fatal from non-fatal aborts.

package/src/resources/extensions/gsd/tests/execution-entry-missing-context-4671.test.ts

@@ -0,0 +1,173 @@
+/**
+ * Regression tests for #4671 — execution-entry phase + missing CONTEXT.md.
+ *
+ * When a milestone advances to an execution-entry phase (executing /
+ * summarizing / validating-milestone / completing-milestone) without
+ * `CONTEXT.md` on disk, the `pre-planning (no context) → discuss-milestone`
+ * rule no longer fires and the plan-v2 gate only blocks. This rule provides
+ * the recovery by redispatching to discuss-milestone.
+ *
+ * Exercises the dispatch rule from DISPATCH_RULES directly with a
+ * DispatchContext built against a real temp directory.
+ */
+import { test, describe } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { DISPATCH_RULES, type DispatchContext } from "../auto-dispatch.ts";
+import type { GSDState, Phase } from "../types.ts";
+
+const RULE_NAME_TOKEN = "execution-entry phase (no context)";
+
+function findRule() {
+  const matches = DISPATCH_RULES.filter((r) => r.name.includes(RULE_NAME_TOKEN));
+  if (matches.length !== 1) {
+    throw new Error(
+      `expected exactly one dispatch rule containing "${RULE_NAME_TOKEN}", found ${matches.length}`,
+    );
+  }
+  return matches[0];
+}
+
+function buildState(phase: Phase): GSDState {
+  return {
+    activeMilestone: { id: "M001", title: "Test milestone" },
+    activeSlice: null,
+    activeTask: null,
+    phase,
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "",
+    registry: [],
+  };
+}
+
+function makeBasePath(prefix: string): string {
+  const dir = mkdtempSync(join(tmpdir(), `gsd-4671-${prefix}-`));
+  mkdirSync(join(dir, ".gsd", "milestones", "M001"), { recursive: true });
+  return dir;
+}
+
+function buildCtx(basePath: string, state: GSDState): DispatchContext {
+  return {
+    basePath,
+    mid: "M001",
+    midTitle: "Test milestone",
+    state,
+    prefs: undefined,
+  };
+}
+
+describe("#4671 execution-entry phase missing-context recovery", () => {
+  const executionEntryPhases: Phase[] = [
+    "executing",
+    "summarizing",
+    "validating-milestone",
+    "completing-milestone",
+  ];
+
+  for (const phase of executionEntryPhases) {
+    test(`phase=${phase} with missing CONTEXT.md → dispatches discuss-milestone`, async () => {
+      const basePath = makeBasePath(`missing-${phase}`);
+      try {
+        const action = await findRule().match(buildCtx(basePath, buildState(phase)));
+        assert.ok(action, "rule must return an action when CONTEXT.md is missing");
+        assert.strictEqual(action!.action, "dispatch");
+        if (action!.action === "dispatch") {
+          assert.strictEqual(action!.unitType, "discuss-milestone");
+          assert.strictEqual(action!.unitId, "M001");
+          assert.ok(typeof action!.prompt === "string" && action!.prompt.length > 0);
+        }
+      } finally {
+        rmSync(basePath, { recursive: true, force: true });
+      }
+    });
+  }
+
+  test("phase=executing with CONTEXT.md present → falls through", async () => {
+    const basePath = makeBasePath("has-context");
+    try {
+      writeFileSync(
+        join(basePath, ".gsd", "milestones", "M001", "M001-CONTEXT.md"),
+        "# M001 Context\n\nSome real context.\n",
+      );
+      const action = await findRule().match(buildCtx(basePath, buildState("executing")));
+      assert.strictEqual(action, null, "rule must fall through when CONTEXT.md exists");
+    } finally {
+      rmSync(basePath, { recursive: true, force: true });
+    }
+  });
+
+  test("phase=executing accepts finalized CONTEXT.md from GSD_PROJECT_ROOT fallback", async () => {
+    const projectRoot = makeBasePath("project-root-context");
+    const worktreeBase = makeBasePath("worktree-context");
+    const prevProjectRoot = process.env.GSD_PROJECT_ROOT;
+    try {
+      writeFileSync(
+        join(projectRoot, ".gsd", "milestones", "M001", "M001-CONTEXT.md"),
+        "# M001 Context\n\nFinalized context at project root.\n",
+      );
+      process.env.GSD_PROJECT_ROOT = projectRoot;
+
+      const action = await findRule().match(buildCtx(worktreeBase, buildState("executing")));
+      assert.strictEqual(
+        action,
+        null,
+        "rule must align with plan-v2 project-root fallback before redispatching",
+      );
+    } finally {
+      if (prevProjectRoot === undefined) {
+        delete process.env.GSD_PROJECT_ROOT;
+      } else {
+        process.env.GSD_PROJECT_ROOT = prevProjectRoot;
+      }
+      rmSync(projectRoot, { recursive: true, force: true });
+      rmSync(worktreeBase, { recursive: true, force: true });
+    }
+  });
+
+  test("phase=pre-planning does not trigger this rule (handled by upstream rule)", async () => {
+    const basePath = makeBasePath("pre-planning");
+    try {
+      const action = await findRule().match(buildCtx(basePath, buildState("pre-planning")));
+      assert.strictEqual(
+        action,
+        null,
+        "rule must only target execution-entry phases; pre-planning is handled elsewhere",
+      );
+    } finally {
+      rmSync(basePath, { recursive: true, force: true });
+    }
+  });
+
+  test("empty CONTEXT.md (whitespace only) → rule still fires", async () => {
+    const basePath = makeBasePath("empty-context");
+    try {
+      writeFileSync(
+        join(basePath, ".gsd", "milestones", "M001", "M001-CONTEXT.md"),
+        "   \n\t\n",
+      );
+      const action = await findRule().match(buildCtx(basePath, buildState("summarizing")));
+      assert.ok(action, "rule must fire when CONTEXT.md is empty/whitespace-only");
+      if (action?.action === "dispatch") {
+        assert.strictEqual(action.unitType, "discuss-milestone");
+      }
+    } finally {
+      rmSync(basePath, { recursive: true, force: true });
+    }
+  });
+
+  test("rule ordering: fires BEFORE execution-entry phase handlers", () => {
+    const recoveryIdx = DISPATCH_RULES.findIndex((r) => r.name.includes(RULE_NAME_TOKEN));
+    const summarizingIdx = DISPATCH_RULES.findIndex((r) =>
+      r.name.startsWith("summarizing → complete-slice"),
+    );
+    assert.ok(recoveryIdx > -1, "recovery rule must exist");
+    assert.ok(summarizingIdx > -1, "summarizing rule must exist");
+    assert.ok(
+      recoveryIdx < summarizingIdx,
+      `recovery rule (idx ${recoveryIdx}) must come before summarizing rule (idx ${summarizingIdx}) so it can redispatch before the plan-v2 gate blocks`,
+    );
+  });
+});

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)}`,
     );
   });
 });