gsd-pi 2.77.0 → 2.78.0

package/src/resources/extensions/gsd/tests/google-search-stub.test.ts

@@ -0,0 +1,131 @@
+// GSD-2 — Tests for google-search deprecation stub (STUB-01, STUB-02)
+import test from "node:test";
+import assert from "node:assert/strict";
+
+// ─── Tests ────────────────────────────────────────────────────────────────────
+
+test("google-search stub: default export is a function", async (_t) => {
+  // STUB-01: stub has a default export function accepting ExtensionAPI
+  const mod = await import("../../google-search/index.ts");
+  const stubFn = mod.default;
+  assert.equal(typeof stubFn, "function");
+});
+
+test("google-search stub: registers session_start handler", async (_t) => {
+  // STUB-01: stub calls pi.on("session_start", ...)
+  const mod = await import("../../google-search/index.ts");
+  const stubFn = mod.default;
+
+  let capturedEvent: string | undefined;
+  let capturedHandler: unknown;
+
+  const mockPi = {
+    on(event: string, handler: unknown) {
+      capturedEvent = event;
+      capturedHandler = handler;
+    },
+    registerTool: () => {},
+  };
+
+  stubFn(mockPi as never);
+
+  assert.equal(capturedEvent, "session_start");
+  assert.equal(typeof capturedHandler, "function");
+});
+
+test("google-search stub: does NOT call registerTool", async (_t) => {
+  // STUB-02: stub is a no-op for tools
+  const mod = await import("../../google-search/index.ts");
+  const stubFn = mod.default;
+
+  let registerToolCalled = false;
+
+  const mockPi = {
+    on: (_event: string, _handler: unknown) => {},
+    registerTool: () => { registerToolCalled = true; },
+  };
+
+  stubFn(mockPi as never);
+
+  assert.equal(registerToolCalled, false);
+});
+
+test("google-search stub: session_start warning contains package name", async (_t) => {
+  // STUB-01: warning includes @gsd-extensions/google-search
+  const mod = await import("../../google-search/index.ts");
+  const stubFn = mod.default;
+
+  let capturedHandler: ((event: unknown, ctx: unknown) => Promise<void>) | undefined;
+
+  const mockPi = {
+    on(_event: string, handler: (event: unknown, ctx: unknown) => Promise<void>) {
+      capturedHandler = handler;
+    },
+    registerTool: () => {},
+  };
+
+  stubFn(mockPi as never);
+
+  assert.ok(capturedHandler, "session_start handler should have been registered");
+
+  let capturedMessage: string | undefined;
+  const mockCtx = {
+    ui: {
+      notify(message: string, _level: string) {
+        capturedMessage = message;
+      },
+    },
+  };
+
+  await capturedHandler!({}, mockCtx);
+
+  assert.ok(
+    capturedMessage?.includes("@gsd-extensions/google-search"),
+    `Expected message to include "@gsd-extensions/google-search", got: "${capturedMessage}"`,
+  );
+});
+
+test("google-search stub: session_start warning explains package is not yet published", async (_t) => {
+  // STUB-01: stub must NOT advise `gsd extensions install` — the replacement
+  // package is not yet on npm, so that command would 404. The message must
+  // explain the extraction is in progress and no user action is required.
+  const mod = await import("../../google-search/index.ts");
+  const stubFn = mod.default;
+
+  let capturedHandler: ((event: unknown, ctx: unknown) => Promise<void>) | undefined;
+
+  const mockPi = {
+    on(_event: string, handler: (event: unknown, ctx: unknown) => Promise<void>) {
+      capturedHandler = handler;
+    },
+    registerTool: () => {},
+  };
+
+  stubFn(mockPi as never);
+
+  assert.ok(capturedHandler, "session_start handler should have been registered");
+
+  let capturedMessage: string | undefined;
+  const mockCtx = {
+    ui: {
+      notify(message: string, _level: string) {
+        capturedMessage = message;
+      },
+    },
+  };
+
+  await capturedHandler!({}, mockCtx);
+
+  assert.ok(
+    !capturedMessage?.includes("gsd extensions install"),
+    `Expected message NOT to include unpublished install command, got: "${capturedMessage}"`,
+  );
+  assert.ok(
+    capturedMessage?.includes("not yet published"),
+    `Expected message to include "not yet published", got: "${capturedMessage}"`,
+  );
+  assert.ok(
+    capturedMessage?.includes("No action needed"),
+    `Expected message to include "No action needed", got: "${capturedMessage}"`,
+  );
+});

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

@@ -0,0 +1,117 @@
+/**
+ * Regression tests for the headless vs interactive milestone-bootstrap divergence.
+ *
+ * Two defects were covered here:
+ *   1. `showHeadlessMilestoneCreation` dispatched with `unitType: "plan-milestone"`
+ *      instead of `"discuss-milestone"`. The `discuss-` prefix drives tool
+ *      scoping (`guided-flow.ts:583`) and enables the `checkAutoStartAfterDiscuss`
+ *      guardrails — routing through `plan-milestone` bypassed them even
+ *      though headless is semantically a discuss flow.
+ *   2. The `discuss-headless.md` ready-phrase pre-condition was a prose
+ *      sentence, so models that treated it as advisory could skip ahead to
+ *      the ready phrase without actually writing the artifacts. The checkbox
+ *      format from `discuss.md` has lower abstraction cost and is harder to
+ *      rationalize past.
+ */
+
+import { test, describe } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const GUIDED_FLOW_PATH = join(__dirname, "..", "guided-flow.ts");
+const DISCUSS_HEADLESS_PATH = join(__dirname, "..", "prompts", "discuss-headless.md");
+
+function getGuidedFlowSource(): string {
+  return readFileSync(GUIDED_FLOW_PATH, "utf-8");
+}
+
+function getHeadlessPromptSource(): string {
+  return readFileSync(DISCUSS_HEADLESS_PATH, "utf-8");
+}
+
+describe("headless milestone bootstrap — parity with interactive flow", () => {
+  test("showHeadlessMilestoneCreation dispatches as discuss-milestone, not plan-milestone", () => {
+    const source = getGuidedFlowSource();
+    const fnStart = source.indexOf("export async function showHeadlessMilestoneCreation");
+    assert.ok(fnStart > -1, "showHeadlessMilestoneCreation must exist");
+
+    // Scope: from the function start to the next top-level export (or EOF).
+    const nextExport = source.indexOf("\nexport ", fnStart + 1);
+    const fnBody = source.slice(fnStart, nextExport === -1 ? source.length : nextExport);
+
+    // Match only the actual dispatchWorkflow call — comments in the body
+    // may mention "plan-milestone" as part of the fix rationale.
+    const dispatchMatches = [...fnBody.matchAll(/dispatchWorkflow\([^)]*,\s*"([^"]+)"\s*\)/g)];
+    assert.strictEqual(
+      dispatchMatches.length,
+      1,
+      `expected exactly one dispatchWorkflow call, found ${dispatchMatches.length}`,
+    );
+    assert.strictEqual(
+      dispatchMatches[0][1],
+      "discuss-milestone",
+      `showHeadlessMilestoneCreation must dispatch as "discuss-milestone" so tool scoping and discuss-flow guardrails apply; got "${dispatchMatches[0][1]}"`,
+    );
+  });
+
+  test("discuss-headless single-milestone pre-condition uses the non-bypassable checkbox format", () => {
+    const source = getHeadlessPromptSource();
+    const section = source.split("### Multi-Milestone")[0];
+    assert.ok(
+      /### Ready-phrase pre-condition \(NON-BYPASSABLE\)/.test(section),
+      "single-milestone ready-phrase section must be present",
+    );
+    // All four required artifacts must appear as checkboxes, not a prose list.
+    for (const artifact of [
+      "`.gsd/PROJECT.md`",
+      "`.gsd/REQUIREMENTS.md`",
+      "`{{contextPath}}`",
+      "`gsd_plan_milestone`",
+    ]) {
+      assert.ok(
+        new RegExp(`- \\[ \\] [A-Za-z]+ ${artifact.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`).test(section),
+        `single-milestone pre-condition must include a checkbox for ${artifact}`,
+      );
+    }
+    assert.ok(
+      /If ANY box is unchecked, \*\*STOP\*\*/.test(section),
+      "single-milestone pre-condition must include the 'If ANY box is unchecked, STOP' sentinel",
+    );
+    assert.ok(
+      /Do not announce the ready phrase as something you are "about to" do/.test(section),
+      "single-milestone pre-condition must include the 'do not announce intent' guard",
+    );
+  });
+
+  test("discuss-headless multi-milestone pre-condition uses the non-bypassable checkbox format", () => {
+    const source = getHeadlessPromptSource();
+    const multiIdx = source.indexOf("### Multi-Milestone");
+    assert.ok(multiIdx > -1, "multi-milestone section must be present");
+    const multiSection = source.slice(multiIdx);
+
+    assert.ok(
+      /### Ready-phrase pre-condition \(NON-BYPASSABLE\)/.test(multiSection),
+      "multi-milestone ready-phrase section must be present",
+    );
+    for (const artifact of [
+      "`.gsd/PROJECT.md`",
+      "`.gsd/REQUIREMENTS.md`",
+      "`gsd_plan_milestone`",
+      "`.gsd/DISCUSSION-MANIFEST.json`",
+    ]) {
+      const escaped = artifact.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      assert.ok(
+        new RegExp(`- \\[ \\] [\\s\\S]*?${escaped}`).test(multiSection),
+        `multi-milestone pre-condition must include a checkbox referencing ${artifact}`,
+      );
+    }
+    assert.ok(
+      /gates_completed === total/.test(multiSection),
+      "multi-milestone pre-condition must still enforce gates_completed === total",
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/hook-key-parsing.test.ts

@@ -1,11 +1,5 @@
 import { describe, it } 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 gsdDir = join(__dirname, "..");
 
 /**
  * Regression tests for #2826: hook/* completed-unit keys were parsed
@@ -15,17 +9,13 @@ const gsdDir = join(__dirname, "..");
  * The root cause: `key.indexOf("/")` splits "hook/telegram-progress/M007/S01"
  * into unitType="hook" + unitId="telegram-progress/M007/S01" instead of
  * unitType="hook/telegram-progress" + unitId="M007/S01".
+ *
+ * These tests exercise the real `splitCompletedKey` helper — the previous
+ * source-grep "does not use indexOf" blocks were dropped under #4825 as
+ * they over-specified implementation shape.
  */
 
 describe("splitCompletedKey (#2826)", () => {
-  it("is exported from forensics.ts", () => {
-    const source = readFileSync(join(gsdDir, "forensics.ts"), "utf-8");
-    assert.ok(
-      source.includes("export function splitCompletedKey"),
-      "forensics.ts must export splitCompletedKey helper",
-    );
-  });
-
   it("splits simple unit types correctly", async () => {
     const { splitCompletedKey } = await import("../forensics.ts");
     const result = splitCompletedKey("execute-task/M007/S01/T01");
@@ -64,44 +54,3 @@ describe("splitCompletedKey (#2826)", () => {
     assert.strictEqual(splitCompletedKey("hook/someName"), null);
   });
 });
-
-describe("forensics detectMissingArtifacts uses splitCompletedKey (#2826)", () => {
-  it("does not use indexOf for key splitting", () => {
-    const source = readFileSync(join(gsdDir, "forensics.ts"), "utf-8");
-    // Extract only the detectMissingArtifacts function body
-    const fnStart = source.indexOf("function detectMissingArtifacts");
-    assert.ok(fnStart !== -1, "detectMissingArtifacts must exist");
-    const fnBody = source.slice(fnStart, source.indexOf("\n}\n", fnStart) + 3);
-
-    assert.ok(
-      !fnBody.includes('key.indexOf("/")'),
-      "detectMissingArtifacts must not use key.indexOf('/') — use splitCompletedKey instead",
-    );
-    assert.ok(
-      fnBody.includes("splitCompletedKey"),
-      "detectMissingArtifacts must use splitCompletedKey helper",
-    );
-  });
-});
-
-describe("doctor-runtime-checks uses splitCompletedKey (#2826)", () => {
-  it("does not use indexOf for key splitting in orphaned-key check", () => {
-    const source = readFileSync(
-      join(gsdDir, "doctor-runtime-checks.ts"),
-      "utf-8",
-    );
-    // Find the orphaned completed-units section
-    const sectionStart = source.indexOf("Orphaned completed-units");
-    assert.ok(sectionStart !== -1, "orphaned completed-units section must exist");
-    const sectionBody = source.slice(sectionStart, source.indexOf("} catch", sectionStart));
-
-    assert.ok(
-      !sectionBody.includes('key.indexOf("/")'),
-      "doctor orphaned-key check must not use key.indexOf('/') — use splitCompletedKey instead",
-    );
-    assert.ok(
-      sectionBody.includes("splitCompletedKey"),
-      "doctor orphaned-key check must use splitCompletedKey helper",
-    );
-  });
-});

package/src/resources/extensions/gsd/tests/integration/all-milestones-complete-merge.test.ts

@@ -21,10 +21,9 @@ import {
   realpathSync,
   readFileSync,
 } from "node:fs";
-import { join, dirname } from "node:path";
+import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
-import { fileURLToPath } from "node:url";
 
 import {
   createAutoWorktree,
@@ -33,8 +32,6 @@ import {
   mergeMilestoneToMain,
 } from "../../auto-worktree.ts";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
 function run(command: string, cwd: string): string {
   return execSync(command, {
     cwd,
@@ -75,58 +72,12 @@ function createMilestoneArtifacts(dir: string, mid: string): void {
   writeFileSync(join(msDir, `${mid}-ROADMAP.md`), roadmap);
 }
 
-// ─── Source-level: verify the merge code exists in the "all complete" path ────
-
-test("auto-loop 'all milestones complete' path merges before stopping (#962)", () => {
-  const loopSrc = readFileSync(join(__dirname, "../..", "auto", "phases.ts"), "utf-8");
-  const resolverSrc = readFileSync(
-    join(__dirname, "../..", "worktree-resolver.ts"),
-    "utf-8",
-  );
-
-  // Find the "incomplete.length === 0" block
-  const incompleteIdx = loopSrc.indexOf("incomplete.length === 0");
-  assert.ok(
-    incompleteIdx > -1,
-    "auto/phases.ts should have 'incomplete.length === 0' check",
-  );
-
-  // The merge call must appear BETWEEN the incomplete check and the stopAuto call.
-  const blockAfterIncomplete = loopSrc.slice(
-    incompleteIdx,
-    incompleteIdx + 3000,
-  );
-
-  assert.ok(
-    blockAfterIncomplete.includes("deps.resolver.mergeAndExit"),
-    "auto/phases.ts should call resolver.mergeAndExit in the 'all milestones complete' path",
-  );
-
-  // The merge should come before stopAuto in this block
-  const mergePos = blockAfterIncomplete.indexOf("deps.resolver.mergeAndExit");
-  const stopPos = blockAfterIncomplete.indexOf("stopAuto");
-  assert.ok(
-    mergePos < stopPos,
-    "resolver.mergeAndExit should be called before stopAuto in the 'all complete' path",
-  );
-
-  const helperIdx = resolverSrc.indexOf("mergeAndExit(milestoneId");
-  assert.ok(
-    helperIdx > -1,
-    "WorktreeResolver.mergeAndExit helper should exist",
-  );
-  const helperBlock = resolverSrc.slice(helperIdx, helperIdx + 2600);
-  assert.ok(
-    helperBlock.includes('mode === "worktree"') ||
-      helperBlock.includes('mode: "worktree"'),
-    "WorktreeResolver.mergeAndExit should handle worktree mode",
-  );
-  assert.ok(
-    helperBlock.includes('mode === "branch"') ||
-      helperBlock.includes('mode: "branch"'),
-    "WorktreeResolver.mergeAndExit should handle branch mode",
-  );
-});
+// Note: the prior phases.ts / worktree-resolver.ts source-grep block was
+// removed under #4825 — it asserted `deps.resolver.mergeAndExit` appears
+// before `stopAuto` via indexOf positions in the source text, which broke
+// on any helper refactor without catching a real regression. The two
+// integration tests below exercise the merge-before-stop behaviour end
+// to end through real git worktrees.
 
 // ─── Integration: single milestone completes → merged to main ────────────────
 

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

@@ -717,6 +717,26 @@ test("hasImplementationArtifacts returns 'present' when implementation files com
   assert.equal(result, "present", "should return 'present' when implementation files are present");
 });
 
+test("hasImplementationArtifacts finds production execute-task commits after retry resumes on main (#4699)", (t) => {
+  const base = makeGitBase();
+  t.after(() => cleanup(base));
+
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "# Roadmap");
+  execFileSync("git", ["add", "."], { cwd: base, stdio: "ignore" });
+  execFileSync("git", ["commit", "-m", "chore: auto-commit after plan-milestone\n\nGSD-Unit: M001"], { cwd: base, stdio: "ignore" });
+
+  mkdirSync(join(base, "src"), { recursive: true });
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+  writeFileSync(join(base, "src", "feature.ts"), "export function feature() {}");
+  writeFileSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks", "T01-SUMMARY.md"), "# Summary");
+  execFileSync("git", ["add", "."], { cwd: base, stdio: "ignore" });
+  execFileSync("git", ["commit", "-m", "feat: add milestone feature\n\nGSD-Task: S01/T01"], { cwd: base, stdio: "ignore" });
+
+  const result = hasImplementationArtifacts(base, "M001");
+  assert.equal(result, "present", "main self-diff retry should find production execute-task commits");
+});
+
 test("hasImplementationArtifacts returns 'unknown' on non-git directory (fail-open)", (t) => {
   const base = join(tmpdir(), `gsd-test-nogit-${randomUUID()}`);
   mkdirSync(base, { recursive: true });

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

@@ -854,4 +854,34 @@ describe("auto-worktree-milestone-merge", { timeout: 300_000 }, () => {
       "#1906: codeFilesChanged must be true when real code files were merged");
     assert.ok(existsSync(join(repo, "real-code.ts")), "real-code.ts merged to main");
   });
+
+  // #2505 regression: when a per-entry restore of the milestone shelter fails,
+  // the shelter must be retained so the queued milestone files (whose sources
+  // were deleted during the shelter step) remain recoverable. Deleting the
+  // shelter unconditionally would permanently lose that data.
+  test("#2505: shelter retained when restore fails; cleaned up on success", () => {
+    const repo = freshRepo();
+    const wtPath = createAutoWorktree(repo, "M200");
+
+    addSliceToMilestone(repo, wtPath, "M200", "S01", "Feature", [
+      { file: "feature.ts", content: "export const f = 1;\n", message: "add feature" },
+    ]);
+
+    // Seed a queued (non-target) milestone in .gsd/milestones/ that will be
+    // sheltered during the merge and restored afterwards.
+    const queuedDir = join(repo, ".gsd", "milestones", "M201");
+    mkdirSync(queuedDir, { recursive: true });
+    writeFileSync(join(queuedDir, "CONTEXT.md"), "# queued\n");
+
+    const roadmap = makeRoadmap("M200", "Milestone w/ queued sibling", [
+      { id: "S01", title: "Feature" },
+    ]);
+
+    const result = mergeMilestoneToMain(repo, "M200", roadmap);
+
+    // Normal success path: queued milestone restored, shelter cleaned up.
+    assert.ok(existsSync(join(queuedDir, "CONTEXT.md")), "queued milestone restored from shelter");
+    assert.ok(!existsSync(join(repo, ".gsd", ".milestone-shelter")), "shelter removed on successful restore");
+    assert.ok(result.commitMessage.length > 0, "merge completed");
+  });
 });

package/src/resources/extensions/gsd/tests/integration/doctor-proactive.test.ts

@@ -161,11 +161,27 @@ describe('doctor-proactive', async () => {
     });
 
     test('escalation: no double escalation', () => {
-      // Don't reset — should already be escalated from previous test
+      // Self-contained: drive the escalated state from scratch in this test.
+      // Previously this relied on module-singleton state left over from the
+      // preceding 'escalation: at threshold' test, which silently broke under
+      // filtered/parallel/reordered runs (the fallback `shouldEscalate: false`
+      // path was satisfied by the wrong reason — see #4828).
+      resetProactiveHealing();
+      for (let i = 0; i < 5; i++) {
+        recordHealthSnapshot(0, 0, 0); // older clean snapshots
+      }
+      for (let i = 0; i < 5; i++) {
+        recordHealthSnapshot(2, 1, 0); // recent error snapshots → degrading trend
+      }
+      // First check: trigger escalation.
+      const first = checkHealEscalation(2, [{ code: "test", message: "test error", unitId: "M001/S01" }]);
+      assert.deepStrictEqual(first.shouldEscalate, true, "precondition: first call escalates");
+
+      // Second check: same session, must NOT double-escalate.
       recordHealthSnapshot(2, 0, 0);
       const result = checkHealEscalation(2, [{ code: "test", message: "test error", unitId: "M001/S01" }]);
       assert.deepStrictEqual(result.shouldEscalate, false, "no double escalation in same session");
-      assert.ok(result.reason.includes("already escalated"), "reason explains why no escalation");
+      assert.ok(result.reason.includes("already escalated"), `reason must explain no-re-escalation (got: ${result.reason})`);
     });
 
     test('escalation: deferred when improving', () => {

package/src/resources/extensions/gsd/tests/integration/git-service.test.ts

@@ -248,12 +248,13 @@ describe('git-service', async () => {
 
   assert.deepStrictEqual(
     RUNTIME_EXCLUSION_PATHS.length,
-    15,
-    "exactly 15 runtime exclusion paths"
+    16,
+    "exactly 16 runtime exclusion paths"
   );
 
   const expectedPaths = [
     ".gsd/activity/",
+    ".gsd/audit/",
     ".gsd/forensics/",
     ".gsd/runtime/",
     ".gsd/worktrees/",

package/src/resources/extensions/gsd/tests/integration/queue-completed-milestone-perf.test.ts

@@ -140,12 +140,18 @@ for (let i = 1; i <= COMPLETED_COUNT; i++) {
 
 // ─── Test: the overall context should be reasonable in size ──────────────
 
-// With 25 completed milestones NOT loading files, the context should be
-// significantly smaller than if all files were loaded
+// Invariant (not absolute budget): the per-completed-milestone line
+// contribution should stay small and CONSTANT (not proportional to the
+// size of its CONTEXT.md / SUMMARY.md). With 50 lines of fixture text
+// per completed CONTEXT.md, a naive loader would produce >=50 lines per
+// completed milestone (>1250 lines for 25 milestones). The fix emits a
+// short summary section plus separator per completed milestone, which
+// stays well under 10 lines/milestone regardless of CONTEXT.md size.
 const contextLines = context.split("\n").length;
+const avgLinesPerCompletedMilestone = contextLines / COMPLETED_COUNT;
 assertTrue(
-  contextLines < 200,
-  `Context should be concise (got ${contextLines} lines); completed milestones should not inflate it`,
+  avgLinesPerCompletedMilestone < 10,
+  `Completed milestones should not inflate the context: got ${contextLines} lines across ${COMPLETED_COUNT} completed milestones (~${avgLinesPerCompletedMilestone.toFixed(1)}/milestone)`,
 );
 
 // ─── Cleanup ──────────────────────────────────────────────────────────────