gsd-pi 2.77.0-dev.538325aea → 2.77.0-dev.58d3d4d6c

package/src/resources/extensions/gsd/tests/merge-conflict-stops-loop.test.ts

@@ -10,7 +10,7 @@
 
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
-import { createTestContext } from "./test-helpers.ts";
+import {createTestContext, extractSourceRegion } from "./test-helpers.ts";
 
 const { assertTrue, report } = createTestContext();
 
@@ -27,7 +27,14 @@ console.log("\n=== #2330: Merge conflict stops auto loop ===");
 const methodStart = resolverSrc.indexOf("Worktree-mode merge:");
 assertTrue(methodStart > 0, "worktree-resolver has _mergeWorktreeMode method");
 
-const methodBody = resolverSrc.slice(methodStart, methodStart + 6000);
+// Slice from the _mergeWorktreeMode docblock to the next method boundary
+// (Branch-mode merge:) so that docblock/body growth doesn't silently drop
+// the `throw err` out of the search window.
+const methodEnd = resolverSrc.indexOf("Branch-mode merge:", methodStart);
+const methodBody = resolverSrc.slice(
+  methodStart,
+  methodEnd > 0 ? methodEnd : methodStart + 8000,
+);
 const rethrowsConflict =
   methodBody.includes("MergeConflictError") &&
   methodBody.includes("throw err");
@@ -51,7 +58,7 @@ const instanceofIdx = phasesSrc.indexOf("instanceof MergeConflictError");
 assertTrue(instanceofIdx > 0, "auto/phases.ts has instanceof MergeConflictError check");
 
 if (instanceofIdx > 0) {
-  const afterHandler = phasesSrc.slice(instanceofIdx, instanceofIdx + 500);
+  const afterHandler = extractSourceRegion(phasesSrc, "instanceof MergeConflictError");
   const stopsLoop =
     afterHandler.includes("stopAuto") ||
     afterHandler.includes('action: "break"') ||

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

@@ -0,0 +1,30 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { classifyMilestoneSummaryContent } from "../milestone-summary-classifier.ts";
+
+test("milestone SUMMARY classifier treats explicit failed status as failure", () => {
+  assert.equal(
+    classifyMilestoneSummaryContent([
+      "---",
+      "status: failed",
+      "---",
+      "",
+      "# M001 Summary",
+      "Recovery stopped.",
+    ].join("\n")),
+    "failure",
+  );
+});
+
+test("milestone SUMMARY classifier does not treat historical not-complete prose as failure", () => {
+  assert.equal(
+    classifyMilestoneSummaryContent([
+      "# M001 Summary",
+      "",
+      "This milestone was previously not complete, now resolved.",
+    ].join("\n")),
+    "unknown",
+  );
+});
+

package/src/resources/extensions/gsd/tests/milestone-transition-state-rebuild.test.ts

@@ -85,8 +85,10 @@ test("auto.ts buildLoopDeps wires rebuildState", () => {
     "utf-8",
   );
 
-  // rebuildState should be in the LoopDeps object literal
-  const buildLoopDepsIdx = autoSrc.indexOf("function buildLoopDeps()");
+  // rebuildState should be in the LoopDeps object literal.
+  // Match the signature prefix so the test survives future param changes
+  // (e.g. the DECOUPLE-02 change from `()` to `(pi: ExtensionAPI)`).
+  const buildLoopDepsIdx = autoSrc.indexOf("function buildLoopDeps(");
   assert.ok(buildLoopDepsIdx > 0, "buildLoopDeps function should exist");
 
   const afterBuild = autoSrc.slice(buildLoopDepsIdx);

package/src/resources/extensions/gsd/tests/native-git-bridge-exec-fallback.test.ts

@@ -17,6 +17,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
 import { nativeIsRepo, nativeCommit, nativeResetHard } from "../native-git-bridge.js";
+import { extractSourceRegion } from "./test-helpers.ts";
 
 // ─── Static analysis ──────────────────────────────────────────────────────
 // Verify the fallback paths of the three affected functions do not call the
@@ -28,7 +29,7 @@ const SRC_PATH = join(import.meta.dirname, "..", "native-git-bridge.ts");
 function extractFunctionBody(src: string, fnName: string): string {
   const idx = src.indexOf(`export function ${fnName}`);
   if (idx === -1) throw new Error(`${fnName} not found in source`);
-  return src.slice(idx, idx + 1500);
+  return extractSourceRegion(src, `export function ${fnName}`);
 }
 
 function hasRawExecSync(body: string): boolean {

package/src/resources/extensions/gsd/tests/orphaned-worktree-audit.test.ts

@@ -107,7 +107,8 @@ describe("auditOrphanedMilestoneBranches", () => {
     assert.ok(branches.includes("milestone/M001"), "unmerged branch must be preserved");
   });
 
-  test("skips active (non-complete) milestone branches", () => {
+  test("skips active milestone branch with no commits ahead of main (nothing to recover)", () => {
+    // Branch created from main with zero divergence — no live work, nothing to warn about.
     run("git branch milestone/M001", dir);
     insertMilestone({ id: "M001", title: "Test", status: "active" });
 
@@ -116,11 +117,67 @@ describe("auditOrphanedMilestoneBranches", () => {
     assert.deepStrictEqual(result.recovered, []);
     assert.deepStrictEqual(result.warnings, []);
 
-    // Branch should still exist
+    // Branch should still exist (data safety — user may intend to use it)
     const branches = run("git branch --list milestone/M001", dir);
     assert.ok(branches.includes("milestone/M001"), "active milestone branch should be preserved");
   });
 
+  test("#4762 — warns about in-progress milestone with unmerged commits ahead of main", () => {
+    // Simulates the primary #4761 scenario: auto-mode was interrupted mid-milestone.
+    // DB status = active/in_progress, branch has real work, main is behind.
+    run("git checkout -b milestone/M001", dir);
+    writeFileSync(join(dir, "feature.txt"), "in-progress work\n");
+    run("git add feature.txt", dir);
+    run("git commit -m \"in-progress work on M001\"", dir);
+    run("git checkout main", dir);
+
+    insertMilestone({ id: "M001", title: "Test", status: "active" });
+
+    const result = auditOrphanedMilestoneBranches(dir, "worktree");
+
+    // Must NOT recover/delete (data safety — work is live)
+    assert.deepStrictEqual(result.recovered, [], "must not delete a branch with live in-progress work");
+
+    // Must surface a warning so the user knows the worktree holds uncollapsed work
+    assert.ok(result.warnings.length > 0, "should warn about in-progress orphan");
+    assert.ok(
+      result.warnings.some(w => w.includes("milestone/M001") && w.includes("in-progress")),
+      `warning should mention milestone/M001 and in-progress state; got: ${JSON.stringify(result.warnings)}`,
+    );
+
+    // Branch must still exist
+    const branches = run("git branch --list milestone/M001", dir);
+    assert.ok(branches.includes("milestone/M001"), "in-progress branch must be preserved");
+  });
+
+  test("#4762 — also surfaces worktree directory for in-progress orphan when present", () => {
+    // In-progress + unmerged + physical worktree directory — the full primary scenario.
+    run("git checkout -b milestone/M001", dir);
+    writeFileSync(join(dir, "feature.txt"), "in-progress work\n");
+    run("git add feature.txt", dir);
+    run("git commit -m \"in-progress work on M001\"", dir);
+    run("git checkout main", dir);
+
+    // Simulate a leftover worktree directory
+    const wtDir = join(dir, ".gsd", "worktrees", "M001");
+    mkdirSync(wtDir, { recursive: true });
+    writeFileSync(join(wtDir, ".git"), `gitdir: ${join(dir, ".git", "worktrees", "M001")}\n`);
+
+    insertMilestone({ id: "M001", title: "Test", status: "active" });
+
+    const result = auditOrphanedMilestoneBranches(dir, "worktree");
+
+    // Must preserve everything for data safety
+    assert.deepStrictEqual(result.recovered, [], "must not touch worktree or branch with live work");
+    assert.ok(existsSync(wtDir), "worktree directory must be preserved");
+
+    // Warning should mention the worktree path so the user can find the work
+    assert.ok(
+      result.warnings.some(w => w.includes(".gsd/worktrees/M001") || w.includes("worktree")),
+      `warning should reference the worktree location; got: ${JSON.stringify(result.warnings)}`,
+    );
+  });
+
   test("cleans up orphaned worktree directory for merged milestone", () => {
     // Create milestone branch (merged — same as main)
     run("git branch milestone/M001", dir);

package/src/resources/extensions/gsd/tests/parallel-commit-scope.test.ts

@@ -45,6 +45,11 @@ function initTempRepo(): string {
   gitRun(["init", "-b", "main"], dir);
   gitRun(["config", "user.name", "Test"], dir);
   gitRun(["config", "user.email", "test@test.com"], dir);
+  // Disable commit/tag signing so the test is hermetic in environments where
+  // the user's global git config enables GPG/SSH signing (e.g. Claude Code
+  // sandboxes that proxy signing through an external service).
+  gitRun(["config", "commit.gpgsign", "false"], dir);
+  gitRun(["config", "tag.gpgsign", "false"], dir);
   createFile(dir, ".gitkeep", "");
   gitRun(["add", "-A"], dir);
   gitRun(["commit", "-m", "init"], dir);

package/src/resources/extensions/gsd/tests/parallel-research-dispatch.test.ts

@@ -12,6 +12,7 @@ import { tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
 
 import { resolveDispatch } from "../auto-dispatch.ts";
+import { extractSourceRegion } from "./test-helpers.ts";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -79,7 +80,9 @@ test("dispatch: parallel-research-slices requires 2+ slices", () => {
 
 test("dispatch: parallel-research-slices respects skip_research", () => {
   const ruleIdx = dispatchSrc.indexOf("parallel-research-slices");
-  const ruleBlock = dispatchSrc.slice(ruleIdx, ruleIdx + 500);
+  // Pin to the located occurrence — if "parallel-research-slices" appears
+  // more than once in the source, fromIdx keeps the anchor deterministic.
+  const ruleBlock = extractSourceRegion(dispatchSrc, "parallel-research-slices", { fromIdx: ruleIdx });
   assert.ok(
     ruleBlock.includes("skip_research") || dispatchSrc.slice(ruleIdx - 300, ruleIdx).includes("skip_research"),
     "rule should check skip_research preference",

package/src/resources/extensions/gsd/tests/parallel-skill-prompt-integration.test.ts

@@ -0,0 +1,150 @@
+/**
+ * Worker × Skill × Subagent — prompt composition integration test.
+ *
+ * Covers two previously-untested seams:
+ *
+ *  P1. Worker × Skill — when a parallel worker's auto loop reaches a
+ *      research/plan/execute unit, the prompt it receives must include the
+ *      `<skill_activation>` block derived from the project's PREFERENCES.md.
+ *      `buildSkillActivationBlock` is unit-tested in isolation; here we
+ *      verify a dispatch-level builder actually plumbs it through.
+ *
+ *  P2. Subagent × Skill — when `buildParallelResearchSlicesPrompt` composes
+ *      per-slice subagent prompts, each embedded prompt must also carry the
+ *      `<skill_activation>` block so the dispatched subagent inherits it.
+ */
+
+import test, { afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { loadSkills } from "@gsd/pi-coding-agent";
+import {
+  buildResearchSlicePrompt,
+  buildParallelResearchSlicesPrompt,
+} from "../auto-prompts.ts";
+
+const SKILL_NAME = "testskill";
+const SKILL_ACTIVATION_SUBSTRING = `Call Skill({ skill: '${SKILL_NAME}' })`;
+
+const tmpDirs: string[] = [];
+let savedCwd: string | undefined;
+
+function setupProjectWithSkill(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-worker-skill-int-"));
+  tmpDirs.push(base);
+
+  // Milestone roadmap — buildResearchSlicePrompt inlines the roadmap excerpt.
+  const milestoneDir = join(base, ".gsd", "milestones", "M001");
+  mkdirSync(join(milestoneDir, "slices", "S01"), { recursive: true });
+  mkdirSync(join(milestoneDir, "slices", "S02"), { recursive: true });
+  writeFileSync(
+    join(milestoneDir, "M001-ROADMAP.md"),
+    [
+      "# M001: Test Milestone",
+      "",
+      "**Vision:** Verify worker × skill prompt plumbing.",
+      "",
+      "## Slices",
+      "",
+      "- [ ] **S01: Alpha** `risk:low` `depends:[]`",
+      "- [ ] **S02: Beta** `risk:low` `depends:[]`",
+      "",
+    ].join("\n"),
+    "utf-8",
+  );
+
+  // Project preferences — buildSkillActivationBlock picks these up via
+  // loadEffectiveGSDPreferences(), which reads from `${cwd}/.gsd/PREFERENCES.md`.
+  writeFileSync(
+    join(base, ".gsd", "PREFERENCES.md"),
+    ["---", `always_use_skills:`, `  - ${SKILL_NAME}`, "---", ""].join("\n"),
+    "utf-8",
+  );
+
+  // Project-scoped skill — resolveSkillReference scans `${cwd}/.agents/skills/`.
+  const skillDir = join(base, ".agents", "skills", SKILL_NAME);
+  mkdirSync(skillDir, { recursive: true });
+  writeFileSync(
+    join(skillDir, "SKILL.md"),
+    [
+      "---",
+      `name: ${SKILL_NAME}`,
+      `description: Integration-test skill for worker × skill prompt plumbing.`,
+      "---",
+      "",
+      `# ${SKILL_NAME}`,
+      "",
+      "Test skill body.",
+    ].join("\n"),
+    "utf-8",
+  );
+
+  // Load this skill into the in-process skill registry so
+  // buildSkillActivationBlock treats it as "installed".
+  loadSkills({
+    cwd: base,
+    includeDefaults: false,
+    skillPaths: [join(base, ".agents", "skills")],
+  });
+
+  return base;
+}
+
+afterEach(() => {
+  if (savedCwd !== undefined) {
+    try { process.chdir(savedCwd); } catch { /* best-effort */ }
+    savedCwd = undefined;
+  }
+  for (const dir of tmpDirs) {
+    try { rmSync(dir, { recursive: true, force: true }); } catch { /* best-effort */ }
+  }
+  tmpDirs.length = 0;
+});
+
+test("worker prompt (buildResearchSlicePrompt) includes <skill_activation> from PREFERENCES.md", async () => {
+  const base = setupProjectWithSkill();
+  savedCwd = process.cwd();
+  process.chdir(base);
+
+  const prompt = await buildResearchSlicePrompt("M001", "Test Milestone", "S01", "Alpha", base);
+
+  assert.ok(
+    prompt.includes("<skill_activation>"),
+    "research-slice prompt should contain a <skill_activation> block",
+  );
+  assert.ok(
+    prompt.includes(SKILL_ACTIVATION_SUBSTRING),
+    `research-slice prompt should reference the always-used skill '${SKILL_NAME}'`,
+  );
+});
+
+test("subagent dispatch prompt (buildParallelResearchSlicesPrompt) carries <skill_activation> into each embedded per-slice section", async () => {
+  const base = setupProjectWithSkill();
+  savedCwd = process.cwd();
+  process.chdir(base);
+
+  const prompt = await buildParallelResearchSlicesPrompt(
+    "M001",
+    "Test Milestone",
+    [
+      { id: "S01", title: "Alpha" },
+      { id: "S02", title: "Beta" },
+    ],
+    base,
+  );
+
+  // The parallel dispatch prompt concatenates per-slice subagent prompts inside
+  // fenced code blocks. Each block should carry the same skill activation.
+  const blockCount = (prompt.match(/<skill_activation>/g) ?? []).length;
+  assert.ok(
+    blockCount >= 2,
+    `expected at least 2 <skill_activation> blocks (one per slice), got ${blockCount}`,
+  );
+  assert.ok(
+    prompt.includes(SKILL_ACTIVATION_SUBSTRING),
+    `parallel-research-slices prompt should reference the always-used skill '${SKILL_NAME}'`,
+  );
+});

package/src/resources/extensions/gsd/tests/preferences-worktree-sync.test.ts

@@ -12,6 +12,7 @@ import assert from "node:assert/strict";
 import { readFileSync, mkdtempSync, mkdirSync, writeFileSync, existsSync, readdirSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
+import { extractSourceRegion } from "./test-helpers.ts";
 
 test("#2684: preferences files are NOT in ROOT_STATE_FILES (forward-only sync)", () => {
   const srcPath = join(import.meta.dirname, "..", "auto-worktree.ts");
@@ -49,7 +50,7 @@ test("copyPlanningArtifacts prefers canonical PREFERENCES.md with lowercase fall
   assert.ok(fnIdx !== -1, "copyPlanningArtifacts function exists");
 
   // Extract function body (up to the next top-level function)
-  const fnBody = src.slice(fnIdx, fnIdx + 2200);
+  const fnBody = extractSourceRegion(src, "function copyPlanningArtifacts");
 
   assert.ok(
     fnBody.includes("PROJECT_PREFERENCES_FILE") && fnBody.includes("LEGACY_PROJECT_PREFERENCES_FILE"),

package/src/resources/extensions/gsd/tests/prompt-cache-optimizer.test.ts

@@ -64,6 +64,18 @@ describe("prompt-cache-optimizer: classifySection", () => {
     assert.equal(classifySection("overrides"), "semi-static");
   });
 
+  // Regression: issue #4719 — KNOWLEDGE falls through to dynamic default.
+  // Knowledge content is reused across all tasks within a milestone, so it
+  // must be classified as semi-static to qualify for prefix caching when the
+  // cache optimizer is wired into the prompt path.
+  it("classifies knowledge as semi-static (issue #4719)", () => {
+    assert.equal(classifySection("knowledge"), "semi-static");
+  });
+
+  it("classifies project-knowledge as semi-static (issue #4719)", () => {
+    assert.equal(classifySection("project-knowledge"), "semi-static");
+  });
+
   it("classifies task-plan as dynamic", () => {
     assert.equal(classifySection("task-plan"), "dynamic");
   });

package/src/resources/extensions/gsd/tests/prompt-step-ordering.test.ts

@@ -13,6 +13,7 @@ import assert from 'node:assert/strict';
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
+import { extractSourceRegion } from "./test-helpers.ts";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -69,11 +70,21 @@ describe('register-extension _gsdEpipeGuard (#3696)', () => {
 
 describe('register-hooks session_before_compact (#3696)', () => {
   test('session_before_compact only checks isAutoActive', () => {
-    // Extract the session_before_compact handler
-    const compactIdx = registerHooksSrc.indexOf('session_before_compact');
+    // Anchor on the full registration token rather than the bare event name —
+    // prevents matching unrelated substring occurrences.
+    const compactIdx = registerHooksSrc.indexOf('pi.on("session_before_compact"');
     assert.ok(compactIdx > -1, 'session_before_compact hook should exist');
-    // The first check in the handler should be isAutoActive(), not isAutoPaused()
-    const afterCompact = registerHooksSrc.slice(compactIdx, compactIdx + 300);
+    // The first check in the handler should be isAutoActive(), not isAutoPaused().
+    // Bound the region to this single handler — register-hooks.ts contains
+    // multiple pi.on("session_before_compact") handlers and a later handler
+    // legitimately references isAutoPaused.
+    const afterCompact = extractSourceRegion(
+      registerHooksSrc,
+      'pi.on("session_before_compact"',
+      'pi.on("',
+      // NB: endAnchor search starts AFTER the startAnchor, so the next
+      // pi.on("... matches the subsequent handler rather than this one.
+    );
     assert.match(afterCompact, /isAutoActive\(\)/,
       'session_before_compact should check isAutoActive()');
     // Should NOT block compaction when paused

package/src/resources/extensions/gsd/tests/provider-errors.test.ts

@@ -404,6 +404,8 @@ test("resumeAutoAfterProviderDelay restarts paused auto-mode from the recorded b
         stepMode: true,
         basePath: "/tmp/project",
       }),
+      resetTransientRetryState: () => {},
+      resetSessionTimeoutState: () => {},
       startAuto: async (_ctx, _pi, base, verboseMode, options) => {
         startCalls.push({ base, verboseMode, step: options?.step });
       },
@@ -428,6 +430,8 @@ test("resumeAutoAfterProviderDelay does not double-start when auto-mode is alrea
         stepMode: false,
         basePath: "/tmp/project",
       }),
+      resetTransientRetryState: () => {},
+      resetSessionTimeoutState: () => {},
       startAuto: async () => {
         startCalls += 1;
       },
@@ -458,6 +462,8 @@ test("resumeAutoAfterProviderDelay leaves auto paused when no base path is avail
         stepMode: false,
         basePath: "",
       }),
+      resetTransientRetryState: () => {},
+      resetSessionTimeoutState: () => {},
       startAuto: async () => {
         startCalls += 1;
       },
@@ -474,6 +480,39 @@ test("resumeAutoAfterProviderDelay leaves auto paused when no base path is avail
   ]);
 });
 
+test("resumeAutoAfterProviderDelay resets provider retry state before restarting auto-mode", async () => {
+  const calls: string[] = [];
+
+  const result = await resumeAutoAfterProviderDelay(
+    {} as any,
+    { ui: { notify() {} } } as any,
+    {
+      getSnapshot: () => ({
+        active: false,
+        paused: true,
+        stepMode: false,
+        basePath: "/tmp/project",
+      }),
+      resetTransientRetryState: () => {
+        calls.push("reset-transient");
+      },
+      resetSessionTimeoutState: () => {
+        calls.push("reset-session-timeout");
+      },
+      startAuto: async () => {
+        calls.push("start-auto");
+      },
+    },
+  );
+
+  assert.equal(result, "resumed");
+  assert.deepEqual(calls, [
+    "reset-transient",
+    "reset-session-timeout",
+    "start-auto",
+  ]);
+});
+
 // ── Escalating backoff for transient errors (#1166) ─────────────────────────
 
 test("agent-end-recovery.ts tracks consecutive transient errors for escalating backoff", () => {
@@ -567,31 +606,6 @@ test("resetTransientRetryState is exported from agent-end-recovery.ts", () => {
   );
 });
 
-test("provider-error-resume.ts calls resetTransientRetryState before startAuto", () => {
-  const src = readFileSync(join(__dirname, "..", "bootstrap", "provider-error-resume.ts"), "utf-8");
-  assert.ok(
-    src.includes("resetTransientRetryState"),
-    "provider-error-resume.ts must import and call resetTransientRetryState",
-  );
-  // Ensure reset is called BEFORE startAuto — order matters
-  const resetIdx = src.indexOf("resetTransientRetryState()");
-  const startIdx = src.indexOf("await deps.startAuto(");
-  assert.ok(
-    resetIdx !== -1 && startIdx !== -1 && resetIdx < startIdx,
-    "resetTransientRetryState() must be called before deps.startAuto()",
-  );
-  // Session timeout counter must also be reset before startAuto
-  assert.ok(
-    src.includes("resetSessionTimeoutState"),
-    "provider-error-resume.ts must import and call resetSessionTimeoutState",
-  );
-  const sessionResetIdx = src.indexOf("resetSessionTimeoutState()");
-  assert.ok(
-    sessionResetIdx !== -1 && startIdx !== -1 && sessionResetIdx < startIdx,
-    "resetSessionTimeoutState() must be called before deps.startAuto()",
-  );
-});
-
 // ── Fix 2: Session creation timeout treated as transient in phases.ts ───────
 
 test("phases.ts handles timeout session-creation failures with pause instead of stopAuto", () => {