gsd-pi 2.77.0-dev.eaa4973bc → 2.78.0-dev.aeeb2ca00

package/src/resources/extensions/gsd/tests/pipeline-variant-dispatch.test.ts

@@ -0,0 +1,301 @@
+// GSD-2 — #4781 phase 2: dispatch-rule gates read pipeline variant from DB.
+// Behavior tests (not source-grep) — construct a real tmpdir DB, insert a
+// milestone whose planning fields classify to the target variant, exercise
+// DISPATCH_RULES.match(), assert the gate result.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { DISPATCH_RULES, type DispatchContext } from "../auto-dispatch.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  upsertMilestonePlanning,
+  insertSlice,
+} from "../gsd-db.ts";
+import { invalidateAllCaches } from "../cache.ts";
+import type { GSDState } from "../types.ts";
+
+const PARALLEL_RESEARCH_RULE = "planning (multiple slices need research) → parallel-research-slices";
+const SINGLE_RESEARCH_RULE = "planning (no research, not S01) → research-slice";
+const VALIDATE_RULE = "validating-milestone → validate-milestone";
+
+// ─── Fixture helpers ──────────────────────────────────────────────────────
+
+function makeBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-pipeline-variant-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S02", "tasks"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { closeDatabase(); } catch { /* noop */ }
+  invalidateAllCaches();
+  rmSync(base, { recursive: true, force: true });
+}
+
+interface SeedOpts {
+  title: string;
+  vision: string;
+  successCriteria: string[];
+}
+
+function seedMilestone(base: string, mid: string, opts: SeedOpts): void {
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({
+    id: mid,
+    title: opts.title,
+    status: "active",
+    depends_on: [],
+  });
+  upsertMilestonePlanning(mid, {
+    title: opts.title,
+    status: "active",
+    vision: opts.vision,
+    successCriteria: opts.successCriteria,
+    keyRisks: [],
+    proofStrategy: [],
+    verificationContract: "",
+    verificationIntegration: "",
+    verificationOperational: "",
+    verificationUat: "",
+    definitionOfDone: [],
+    requirementCoverage: "",
+    boundaryMapMarkdown: "",
+  });
+  insertSlice({
+    id: "S01",
+    milestoneId: mid,
+    title: "First",
+    status: "pending",
+    risk: "low",
+    depends: [],
+    demo: "",
+    sequence: 1,
+  });
+  insertSlice({
+    id: "S02",
+    milestoneId: mid,
+    title: "Second",
+    status: "pending",
+    risk: "low",
+    depends: ["S01"],
+    demo: "",
+    sequence: 2,
+  });
+}
+
+function findRule(name: string) {
+  const rule = DISPATCH_RULES.find(r => r.name === name);
+  assert.ok(rule, `rule "${name}" must exist`);
+  return rule!;
+}
+
+function makeCtx(params: {
+  base: string;
+  mid: string;
+  phase: GSDState["phase"];
+  activeSlice?: { id: string; title: string };
+}): DispatchContext {
+  const state: GSDState = {
+    phase: params.phase,
+    activeMilestone: { id: params.mid, title: "Test" },
+    activeSlice: params.activeSlice ?? null,
+    activeTask: null,
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "",
+    registry: [{ id: params.mid, title: "Test", status: "active" }],
+  };
+  return {
+    basePath: params.base,
+    mid: params.mid,
+    midTitle: "Test",
+    state,
+    prefs: undefined,
+  };
+}
+
+// Inputs that consistently classify.
+const TRIVIAL_INPUT: SeedOpts = {
+  title: "Static To-Do App",
+  vision: "A minimal, clean browser-based to-do app. Pure HTML/CSS/JS, no build step, no backend. Tasks persist in localStorage.",
+  successCriteria: [
+    "Open index.html in any browser without a server",
+    "Tasks survive a page reload via localStorage",
+  ],
+};
+
+const STANDARD_INPUT: SeedOpts = {
+  title: "Billing API extension",
+  vision: "Extend the billing API to charge usage-tier overages. Touch the invoice service, the entitlements cache, and the webhook handler.",
+  successCriteria: [
+    "Overage charges generate correct invoices",
+    "Integration tests cover tier rollovers",
+    "API endpoint returns structured error on webhook failure",
+  ],
+};
+
+// ─── Research-slice gate (single) ─────────────────────────────────────────
+
+test("#4781 phase 2: single research-slice rule skips dispatch for trivial variant", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+
+  seedMilestone(base, "M001", TRIVIAL_INPUT);
+  const ctx = makeCtx({
+    base,
+    mid: "M001",
+    phase: "planning",
+    activeSlice: { id: "S02", title: "Second" },
+  });
+
+  const result = await findRule(SINGLE_RESEARCH_RULE).match(ctx);
+  assert.strictEqual(result, null, "trivial variant must skip research-slice dispatch");
+});
+
+test("#4781 phase 2: single research-slice rule proceeds normally for standard variant", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+
+  seedMilestone(base, "M001", STANDARD_INPUT);
+  const ctx = makeCtx({
+    base,
+    mid: "M001",
+    phase: "planning",
+    activeSlice: { id: "S02", title: "Second" },
+  });
+
+  // No RESEARCH file exists → rule should reach the dispatch branch.
+  // We don't assert "dispatch" because the prompt builder may error with
+  // minimal fixture data; we assert "not null AND not a trivial-skip
+  // shortcut" by checking that if null was returned, it's for a known
+  // reason (research file exists). For this fixture none exists, so the
+  // result should be an action object.
+  const result = await findRule(SINGLE_RESEARCH_RULE).match(ctx);
+  assert.notStrictEqual(result, null, "standard variant must not short-circuit the research-slice gate");
+});
+
+// ─── Parallel research-slice gate ─────────────────────────────────────────
+
+test("#4781 phase 2: parallel-research-slices rule skips dispatch for trivial variant", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+
+  seedMilestone(base, "M001", TRIVIAL_INPUT);
+  // Roadmap needs to be readable for the parallel rule to enter its slice
+  // analysis. Write a minimal one.
+  const { writeFileSync } = await import("node:fs");
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+    [
+      "# M001",
+      "## Slices",
+      "- [ ] **S01: First** `risk:low` `depends:[]`",
+      "- [ ] **S02: Second** `risk:low` `depends:[]`",
+    ].join("\n"),
+  );
+
+  const ctx = makeCtx({ base, mid: "M001", phase: "planning" });
+  const result = await findRule(PARALLEL_RESEARCH_RULE).match(ctx);
+  assert.strictEqual(result, null, "trivial variant must skip parallel-research dispatch");
+});
+
+// ─── Validate-milestone gate ──────────────────────────────────────────────
+
+test("#4781 phase 2: validate-milestone rule writes pass-through VALIDATION for trivial variant", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+
+  seedMilestone(base, "M001", TRIVIAL_INPUT);
+  // findMissingSummaries checks slice SUMMARY files — write empty ones so
+  // the safety guard doesn't stop first.
+  const { writeFileSync } = await import("node:fs");
+  writeFileSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md"), "# S01\n");
+  writeFileSync(join(base, ".gsd", "milestones", "M001", "slices", "S02", "S02-SUMMARY.md"), "# S02\n");
+  // Write a roadmap so findMissingSummaries can enumerate slice IDs.
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+    [
+      "# M001",
+      "## Slices",
+      "- [x] **S01: First** `risk:low` `depends:[]`",
+      "- [x] **S02: Second** `risk:low` `depends:[]`",
+    ].join("\n"),
+  );
+
+  const ctx = makeCtx({ base, mid: "M001", phase: "validating-milestone" });
+  const result = await findRule(VALIDATE_RULE).match(ctx);
+
+  assert.ok(result, "rule must return a result, not null");
+  assert.strictEqual(result!.action, "skip", "trivial variant must return skip action");
+
+  const validationPath = join(base, ".gsd", "milestones", "M001", "M001-VALIDATION.md");
+  assert.ok(existsSync(validationPath), "pass-through VALIDATION.md must be written");
+
+  const { readFileSync } = await import("node:fs");
+  const content = readFileSync(validationPath, "utf-8");
+  assert.match(content, /verdict: pass/);
+  assert.match(content, /trivial-scope pipeline variant \(#4781\)/);
+});
+
+test("#4781 phase 2: validate-milestone rule dispatches normally for standard variant", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+
+  seedMilestone(base, "M001", STANDARD_INPUT);
+  const { writeFileSync } = await import("node:fs");
+  writeFileSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md"), "# S01\n");
+  writeFileSync(join(base, ".gsd", "milestones", "M001", "slices", "S02", "S02-SUMMARY.md"), "# S02\n");
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+    [
+      "# M001",
+      "## Slices",
+      "- [x] **S01: First** `risk:low` `depends:[]`",
+      "- [x] **S02: Second** `risk:low` `depends:[]`",
+    ].join("\n"),
+  );
+
+  const ctx = makeCtx({ base, mid: "M001", phase: "validating-milestone" });
+  const result = await findRule(VALIDATE_RULE).match(ctx);
+
+  assert.ok(result, "standard variant must produce a result");
+  assert.strictEqual(result!.action, "dispatch", "standard variant must dispatch validate-milestone");
+  if (result!.action === "dispatch") {
+    assert.strictEqual(result!.unitType, "validate-milestone");
+  }
+});
+
+// ─── Fallback safety: no DB, missing milestone ────────────────────────────
+
+test("#4781 phase 2: null variant (no milestone row) does NOT gate dispatch — safe fallback", async (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+
+  // Open DB but do NOT seed any milestone — getMilestone returns null,
+  // which makes getMilestonePipelineVariant return null. Rules must NOT
+  // short-circuit on null (silent downshift is the hazard we're guarding
+  // against).
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  const ctx = makeCtx({
+    base,
+    mid: "M999",
+    phase: "planning",
+    activeSlice: { id: "S02", title: "Second" },
+  });
+
+  // Rule should NOT return null from the variant gate. It may still return
+  // null for other reasons (e.g. missing active slice), but our assertion
+  // is specifically about the variant-gate not short-circuiting.
+  const result = await findRule(SINGLE_RESEARCH_RULE).match(ctx);
+  // Rule reaches its normal logic; with an active slice and no RESEARCH file,
+  // it should produce a dispatch action, not null from the variant gate.
+  assert.notStrictEqual(result, null, "null variant must not cause the research-slice gate to short-circuit");
+});

package/src/resources/extensions/gsd/tests/pre-execution-pause-wiring.test.ts

@@ -191,7 +191,12 @@ function createFailingTasks(): void {
       estimate: "1h",
       files: [],
       verify: "npm test",
-      inputs: ["nonexistent-file-that-does-not-exist.ts"],
+      inputs: [
+        "nonexistent-file-that-does-not-exist.ts",
+        "missing-second-file.ts",
+        "missing-third-file.ts",
+        "missing-fourth-file.ts",
+      ],
       expectedOutput: [],
       observabilityImpact: "",
     },
@@ -308,6 +313,32 @@ describe("Pre-execution checks → pauseAuto wiring", () => {
         String(call.arguments[0]).includes("Pre-execution checks failed")
     );
     assert.ok(errorNotify, "Should show error notification about pre-execution check failure");
+    const errorMessage = String(errorNotify.arguments[0]);
+    assert.match(
+      errorMessage,
+      /Pre-execution checks failed: \d+ blocking issue/,
+      "failure notification should include the blocking issue count",
+    );
+    assert.ok(
+      errorMessage.includes("[file] nonexistent-file-that-does-not-exist.ts: Task T01 references"),
+      "failure notification should include category, target, and message details",
+    );
+    assert.ok(
+      errorMessage.includes("[file] missing-third-file.ts: Task T01 references"),
+      "failure notification should include up to three actionable check details",
+    );
+    assert.ok(
+      !errorMessage.includes("missing-fourth-file.ts"),
+      "failure notification should truncate details beyond the display limit",
+    );
+    assert.ok(
+      errorMessage.includes("...and 1 more"),
+      "failure notification should summarize truncated blocking checks",
+    );
+    assert.ok(
+      errorMessage.includes(join(".gsd", "milestones", "M001", "slices", "S01", "S01-PRE-EXEC-VERIFY.json")),
+      "failure notification should point to the relative pre-exec evidence file path",
+    );
   });
 
   test("pauseAuto is called when enhanced_verification_strict: true and pre-execution returns warn", async () => {

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

@@ -13,7 +13,12 @@ import { fileURLToPath } from "node:url";
 import { classifyError, isTransient, isTransientNetworkError } from "../error-classifier.ts";
 import { pauseAutoForProviderError } from "../provider-error-pause.ts";
 import { resumeAutoAfterProviderDelay } from "../bootstrap/provider-error-resume.ts";
+import { MAX_TRANSIENT_AUTO_RESUMES } from "../bootstrap/agent-end-recovery.ts";
 import { getNextFallbackModel } from "../preferences.ts";
+// Zero-import module — imported by path rather than through the package
+// barrel to avoid pulling the full AgentSession / @gsd/pi-ai dep graph into
+// this unit test (see #4837).
+import { RETRYABLE_ERROR_RE } from "../../../../../packages/pi-coding-agent/src/core/retryable-error-regex.ts";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -405,7 +410,6 @@ test("resumeAutoAfterProviderDelay restarts paused auto-mode from the recorded b
         basePath: "/tmp/project",
       }),
       resetTransientRetryState: () => {},
-      resetSessionTimeoutState: () => {},
       startAuto: async (_ctx, _pi, base, verboseMode, options) => {
         startCalls.push({ base, verboseMode, step: options?.step });
       },
@@ -431,7 +435,6 @@ test("resumeAutoAfterProviderDelay does not double-start when auto-mode is alrea
         basePath: "/tmp/project",
       }),
       resetTransientRetryState: () => {},
-      resetSessionTimeoutState: () => {},
       startAuto: async () => {
         startCalls += 1;
       },
@@ -463,7 +466,6 @@ test("resumeAutoAfterProviderDelay leaves auto paused when no base path is avail
         basePath: "",
       }),
       resetTransientRetryState: () => {},
-      resetSessionTimeoutState: () => {},
       startAuto: async () => {
         startCalls += 1;
       },
@@ -480,7 +482,7 @@ test("resumeAutoAfterProviderDelay leaves auto paused when no base path is avail
   ]);
 });
 
-test("resumeAutoAfterProviderDelay resets provider retry state before restarting auto-mode", async () => {
+test("resumeAutoAfterProviderDelay resets provider retry state without clearing session-timeout attempts", async () => {
   const calls: string[] = [];
 
   const result = await resumeAutoAfterProviderDelay(
@@ -496,9 +498,6 @@ test("resumeAutoAfterProviderDelay resets provider retry state before restarting
       resetTransientRetryState: () => {
         calls.push("reset-transient");
       },
-      resetSessionTimeoutState: () => {
-        calls.push("reset-session-timeout");
-      },
       startAuto: async () => {
         calls.push("start-auto");
       },
@@ -508,7 +507,6 @@ test("resumeAutoAfterProviderDelay resets provider retry state before restarting
   assert.equal(result, "resumed");
   assert.deepEqual(calls, [
     "reset-transient",
-    "reset-session-timeout",
     "start-auto",
   ]);
 });
@@ -684,13 +682,12 @@ test("phases.ts resets session timeout counter on successful unit completion", (
 // ── Fix 3: MAX_TRANSIENT_AUTO_RESUMES raised to 8 ───────────────────────────
 
 test("MAX_TRANSIENT_AUTO_RESUMES is at least 8 for sustained overload resilience", () => {
-  const src = readFileSync(join(__dirname, "..", "bootstrap", "agent-end-recovery.ts"), "utf-8");
-  const match = src.match(/MAX_TRANSIENT_AUTO_RESUMES\s*=\s*(\d+)/);
-  assert.ok(match, "MAX_TRANSIENT_AUTO_RESUMES must be defined");
-  const value = Number(match![1]);
+  // Import the real constant rather than regex-scraping the source literal —
+  // this way the assertion cannot silently drift if the symbol is renamed or
+  // the value is moved. See #4837.
   assert.ok(
-    value >= 8,
-    `MAX_TRANSIENT_AUTO_RESUMES must be >= 8 for sustained overload resilience, got ${value}`,
+    MAX_TRANSIENT_AUTO_RESUMES >= 8,
+    `MAX_TRANSIENT_AUTO_RESUMES must be >= 8 for sustained overload resilience, got ${MAX_TRANSIENT_AUTO_RESUMES}`,
   );
 });
 
@@ -738,20 +735,22 @@ test("classifyError: 'context window' with 'exceed' is transient server", () =>
 // ── agent-session retryable regex handles server_error (#1166) ──────────────
 
 test("agent-session retryable error regex matches server_error (underscore)", () => {
-  // This regex is extracted from _isRetryableError in agent-session.ts.
-  // It must match both "server error" (space) and "server_error" (underscore)
-  // to properly classify Codex streaming errors as retryable.
-  // "temporarily backed off" intentionally excluded — see #3429
-  const retryableRegex = /overloaded|rate.?limit|too many requests|429|500|502|503|504|service.?unavailable|server.?error|internal.?error|connection.?error|connection.?refused|other side closed|fetch failed|upstream.?connect|reset before headers|terminated|retry delay|network.?(?:is\s+)?unavailable|credentials.*expired|extra usage is required/i;
+  // Import the real regex from the retry-handler so this test can never
+  // silently drift from runtime behaviour. The regex must match both
+  // "server error" (space) and "server_error" (underscore) to properly
+  // classify Codex streaming errors as retryable.
+  // "temporarily backed off" is intentionally excluded — see #3429 / #4837.
 
   // server_error (with underscore — Codex streaming error format)
-  assert.ok(retryableRegex.test("Codex server_error: An error occurred"));
+  assert.ok(RETRYABLE_ERROR_RE.test("Codex server_error: An error occurred"));
   // server error (with space — traditional HTTP error format)
-  assert.ok(retryableRegex.test("server error occurred"));
+  assert.ok(RETRYABLE_ERROR_RE.test("server error occurred"));
   // internal_error (with underscore)
-  assert.ok(retryableRegex.test("internal_error: something went wrong"));
+  assert.ok(RETRYABLE_ERROR_RE.test("internal_error: something went wrong"));
   // internal error (with space)
-  assert.ok(retryableRegex.test("internal error"));
+  assert.ok(RETRYABLE_ERROR_RE.test("internal error"));
   // non-retryable errors must not match
-  assert.ok(!retryableRegex.test("model not found"));
+  assert.ok(!RETRYABLE_ERROR_RE.test("model not found"));
+  // "temporarily backed off" must NOT be matched (intentional exclusion #3429)
+  assert.ok(!RETRYABLE_ERROR_RE.test("temporarily backed off"));
 });

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

@@ -178,4 +178,36 @@ describe("Windows pre-merge DB release (#4704)", () => {
       "openDatabase() called after the pre-merge stash",
     );
   });
+
+  it("pre-merge stash targets entries by marker instead of refs/stash or stash@{0}", () => {
+    const src = readFileSync(
+      join(import.meta.dirname, "..", "auto-worktree.ts"),
+      "utf-8",
+    );
+
+    assert.ok(src.includes("stashMarker"), "stash marker is tracked");
+    assert.ok(
+      src.includes('"stash", "list", "--format=%gd%x00%s"'),
+      "stash lookup reads ref and message together",
+    );
+    assert.ok(!src.includes('"rev-parse", "refs/stash"'), "refs/stash is not used for identity");
+    assert.ok(!src.includes('["stash", "pop"]'), "stash pop is never unqualified");
+    assert.ok(!src.includes('["stash", "drop"]'), "stash drop is never unqualified");
+  });
+
+  it("stash drop after pop failure requires auto-resolved .gsd conflicts", () => {
+    const src = readFileSync(
+      join(import.meta.dirname, "..", "auto-worktree.ts"),
+      "utf-8",
+    );
+
+    assert.ok(
+      src.includes("gsdUU.length > 0 && nonGsdUU.length === 0"),
+      "stash drop must only run after detected .gsd conflicts were auto-resolved",
+    );
+    assert.ok(
+      src.includes("git stash pop failed without resolvable conflict files; leaving stash for manual recovery"),
+      "non-conflict stash pop failures must leave the stash for manual recovery",
+    );
+  });
 });

package/src/resources/extensions/gsd/tests/queue-draft-detection.test.ts

@@ -6,6 +6,7 @@ import { tmpdir } from "node:os";
 
 import { deriveState } from "../state.js";
 import { buildExistingMilestonesContext } from "../guided-flow.js";
+import { extractSourceRegion } from "./test-helpers.ts";
 
 describe('queue-draft-detection', () => {
   test('draft and context milestone detection', async () => {
@@ -68,7 +69,7 @@ describe('queue-draft-detection', () => {
 
       // both files: CONTEXT.md wins, no draft label
       const m003Idx = context.indexOf("M003:");
-      const m003Section = context.slice(m003Idx, m003Idx + 500);
+      const m003Section = extractSourceRegion(context, "M003:");
       assert.ok(
         m003Section.includes("**Context:**"),
         "M003 (both files) should use 'Context:' label (CONTEXT.md wins)",
@@ -84,7 +85,7 @@ describe('queue-draft-detection', () => {
 
       // neither file: no context section
       const m004Idx = context.indexOf("M004:");
-      const m004Section = context.slice(m004Idx, m004Idx + 500);
+      const m004Section = extractSourceRegion(context, "M004:");
       assert.ok(
         !m004Section.includes("**Context:**"),
         "M004 (neither file) should not have Context: label",

package/src/resources/extensions/gsd/tests/queued-discuss-fast-path.test.ts

@@ -3,6 +3,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));
 
@@ -28,7 +29,7 @@ describe("queued-discuss-fast-path", () => {
     const fnStart = source.indexOf("async function dispatchDiscussForMilestone(");
     assert.ok(fnStart > 0, "dispatchDiscussForMilestone must exist");
     const fnEnd = source.indexOf("\nasync function ", fnStart + 1);
-    const fnBody = fnEnd > 0 ? source.slice(fnStart, fnEnd) : source.slice(fnStart, fnStart + 2000);
+    const fnBody = extractSourceRegion(source, "async function dispatchDiscussForMilestone(");
     assert.ok(
       fnBody.includes("fastPathInstruction"),
       "dispatchDiscussForMilestone must compute fastPathInstruction",
@@ -61,8 +62,7 @@ describe("queued-discuss-fast-path", () => {
     const source = guidedFlowSrc();
     const fnStart = source.indexOf("async function showDiscussQueuedMilestone(");
     assert.ok(fnStart > 0, "showDiscussQueuedMilestone must exist");
-    const fnEnd = source.indexOf("\nasync function ", fnStart + 1);
-    const fnBody = fnEnd > 0 ? source.slice(fnStart, fnEnd) : source.slice(fnStart, fnStart + 3000);
+    const fnBody = extractSourceRegion(source, "async function showDiscussQueuedMilestone(", "\nasync function ");
     assert.ok(
       fnBody.includes("hasDraft"),
       "showDiscussQueuedMilestone must check hasDraft",
@@ -81,8 +81,7 @@ describe("queued-discuss-fast-path", () => {
     const source = guidedFlowSrc();
     const fnStart = source.indexOf("async function showDiscussQueuedMilestone(");
     assert.ok(fnStart > 0, "showDiscussQueuedMilestone must exist");
-    const fnEnd = source.indexOf("\nasync function ", fnStart + 1);
-    const fnBody = fnEnd > 0 ? source.slice(fnStart, fnEnd) : source.slice(fnStart, fnStart + 3000);
+    const fnBody = extractSourceRegion(source, "async function showDiscussQueuedMilestone(", "\nasync function ");
     assert.ok(
       fnBody.includes("let fastPath = hasDraft"),
       "showDiscussQueuedMilestone must set fastPath = hasDraft so draft presence auto-enables fast path",