gsd-pi 2.82.0-dev.2841a1e44 → 2.82.0-dev.3a3c6509d

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

@@ -0,0 +1,23 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { loadPrompt } from "../prompt-loader.ts";
+
+test("loadPrompt reports missing template variables with balanced braces", () => {
+  assert.throws(
+    () => loadPrompt("guided-discuss-milestone", {
+      milestoneId: "M001",
+      milestoneTitle: "Missing working directory",
+      structuredQuestionsAvailable: "false",
+      fastPathInstruction: "",
+      inlinedTemplates: "context template",
+      commitInstruction: "Do not commit during this test.",
+    }),
+    (error) => {
+      assert.ok(error instanceof Error);
+      assert.match(error.message, /template declares \{\{workingDirectory\}\} but no value was provided/);
+      assert.doesNotMatch(error.message, /\{\{workingDirectory\}\}\}/);
+      return true;
+    },
+  );
+});

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

@@ -10,7 +10,12 @@ import assert from "node:assert/strict";
 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, resetTransientRetryState } from "../bootstrap/agent-end-recovery.ts";
+import {
+  MAX_TRANSIENT_AUTO_RESUMES,
+  isTerminalDeletedWorktreeProviderError,
+  resetTransientRetryState,
+  shouldDeferTransientErrorToCoreRetry,
+} from "../bootstrap/agent-end-recovery.ts";
 import { _buildCancelledUnitStopReason } from "../auto/phases.ts";
 import { getNextFallbackModel } from "../preferences.ts";
 // Zero-import module — imported by path rather than through the package
@@ -399,6 +404,25 @@ test("pauseAutoForProviderError falls back to indefinite pause when not rate lim
   ]);
 });
 
+test("isTerminalDeletedWorktreeProviderError matches removed auto-worktree paths only", () => {
+  assert.equal(
+    isTerminalDeletedWorktreeProviderError('Path "/Users/dev/.gsd/projects/abc123/worktrees/M005" does not exist'),
+    true,
+  );
+  assert.equal(
+    isTerminalDeletedWorktreeProviderError('Path "/Users/dev/app/.gsd/worktrees/M005" does not exist'),
+    true,
+  );
+  assert.equal(
+    isTerminalDeletedWorktreeProviderError('Path "/Users/dev/app/src/file.ts" does not exist'),
+    false,
+  );
+  assert.equal(
+    isTerminalDeletedWorktreeProviderError('Path "/Users/dev/.gsd/projects/abc123/worktrees/M005" failed with EACCES'),
+    false,
+  );
+});
+
 // ── resumeAutoAfterProviderDelay ────────────────────────────────────────────
 
 test("resumeAutoAfterProviderDelay restarts paused auto-mode from the recorded base path", async () => {
@@ -659,3 +683,15 @@ test("agent-session retryable error regex matches server_error (underscore)", ()
   // "temporarily backed off" must NOT be matched (intentional exclusion #3429)
   assert.ok(!RETRYABLE_ERROR_RE.test("temporarily backed off"));
 });
+
+test("exhausted retry errors are not deferred back to core retry handling", () => {
+  const cls = classifyError("Retry failed after 3 attempts: 500 empty_stream: upstream stream closed before first payload");
+  assert.equal(cls.kind, "server");
+  assert.equal(
+    shouldDeferTransientErrorToCoreRetry(
+      cls,
+      "Retry failed after 3 attempts: 500 empty_stream: upstream stream closed before first payload",
+    ),
+    false,
+  );
+});

package/src/resources/extensions/gsd/tests/queue-reorder-ui.test.ts

@@ -0,0 +1,54 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+import { showQueueReorder } from "../queue-reorder-ui.ts";
+
+const fakeTheme = {
+  fg: (_color: string, text: string) => text,
+  bold: (text: string) => text,
+};
+
+describe("queue-reorder-ui", () => {
+  test("keeps cursor visible while scrolling long queue with arrow keys (#4656)", async () => {
+    const originalRowsDescriptor = Object.getOwnPropertyDescriptor(process.stdout, "rows");
+    Object.defineProperty(process.stdout, "rows", { value: 20, configurable: true });
+
+    try {
+      const pending = Array.from({ length: 20 }, (_, idx) => ({
+        id: `M${String(idx + 1).padStart(3, "0")}`,
+        title: `Milestone ${idx + 1}`,
+      }));
+
+      let resolved: { order: string[]; depsToRemove: Array<{ milestone: string; dep: string }> } | null = null;
+      let lastRender: string[] = [];
+
+      const ctx = {
+        hasUI: true,
+        ui: {
+          custom: async (factory: any) => {
+            const component = factory({ requestRender() {} }, fakeTheme, null, (value: any) => {
+              resolved = value;
+            });
+
+            for (let i = 0; i < 15; i++) component.handleInput("\u001b[B");
+            lastRender = component.render(100);
+            component.handleInput("\r");
+            return resolved;
+          },
+        },
+      } as any;
+
+      await showQueueReorder(ctx, [], pending);
+
+      const joined = lastRender.join("\n");
+      assert.ok(joined.includes("M016"), "selected item should stay visible after scrolling");
+      assert.ok(lastRender.length <= 16, `overlay should fit terminal max-height, got ${lastRender.length}`);
+    } finally {
+      if (originalRowsDescriptor) {
+        Object.defineProperty(process.stdout, "rows", originalRowsDescriptor);
+      } else {
+        delete (process.stdout as { rows?: number }).rows;
+      }
+    }
+  });
+});

package/src/resources/extensions/gsd/tests/remediation-completion-guard.test.ts

@@ -1,6 +1,6 @@
 /**
- * Regression test for #2675: completing-milestone dispatch rule must
- * block completion when VALIDATION verdict is "needs-remediation".
+ * Regression tests for non-passing VALIDATION verdicts: completing-milestone
+ * dispatch must block completion when VALIDATION needs remediation or attention.
  *
  * Without this guard, needs-remediation + allSlicesDone causes a loop:
  * complete-milestone dispatched → agent refuses (correct) → no SUMMARY
@@ -66,6 +66,93 @@ test("completing-milestone blocks when VALIDATION verdict is needs-remediation (
   }
 });
 
+test("completing-milestone blocks when VALIDATION verdict is needs-attention (#5747)", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-attention-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+
+  try {
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "M001-VALIDATION.md"),
+      [
+        "---",
+        "verdict: needs-attention",
+        "remediation_round: 0",
+        "---",
+        "",
+        "# Validation Report",
+        "",
+        "Acceptance proof is incomplete and needs human attention.",
+      ].join("\n"),
+    );
+
+    const ctx = {
+      mid: "M001",
+      midTitle: "Test Milestone",
+      basePath: base,
+      state: { phase: "completing-milestone" } as any,
+      prefs: {} as any,
+      session: undefined,
+    };
+
+    const result = await completingRule!.match(ctx);
+
+    assert.ok(result !== null, "rule should match");
+    assert.equal(result!.action, "stop", "should return stop action");
+    if (result!.action === "stop") {
+      assert.equal(result!.level, "warning", "should be warning level (pausable)");
+      assert.ok(
+        result!.reason.includes("needs-attention"),
+        "reason should mention needs-attention",
+      );
+    }
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("completing-milestone blocks when VALIDATION verdict is fail (#5920)", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-fail-verdict-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+
+  try {
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "M001-VALIDATION.md"),
+      [
+        "---",
+        "verdict: fail",
+        "---",
+        "",
+        "# Validation Report",
+        "",
+        "Blocking failures remain unresolved.",
+      ].join("\n"),
+    );
+
+    const ctx = {
+      mid: "M001",
+      midTitle: "Test Milestone",
+      basePath: base,
+      state: { phase: "completing-milestone" } as any,
+      prefs: {} as any,
+      session: undefined,
+    };
+
+    const result = await completingRule!.match(ctx);
+
+    assert.ok(result !== null, "rule should match");
+    assert.equal(result!.action, "stop", "should return stop action");
+    if (result!.action === "stop") {
+      assert.equal(result!.level, "warning", "should be warning level (pausable)");
+      assert.ok(
+        result!.reason.includes('verdict is "fail"'),
+        "reason should mention fail verdict",
+      );
+    }
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 test("completing-milestone proceeds normally when VALIDATION verdict is pass (#2675 guard)", async () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-remediation-"));
   mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });

package/src/resources/extensions/gsd/tests/run-uat-replay-cap.test.ts

@@ -36,7 +36,7 @@ function makeUatProject(): string {
   return base;
 }
 
-test("run-uat dispatch stops after three attempts without a verdict", async () => {
+test("run-uat dispatch skips after three attempts without a verdict", async () => {
   const basePath = makeUatProject();
   const rule = DISPATCH_RULES.find((r) => r.name === "run-uat (post-completion)");
   assert.ok(rule, "run-uat dispatch rule is registered");
@@ -58,8 +58,7 @@ test("run-uat dispatch stops after three attempts without a verdict", async () =
     }
 
     const capped = await rule.match(ctx as any);
-    assert.equal(capped?.action, "stop");
-    assert.match(capped?.reason ?? "", /dispatched 3 times/);
+    assert.equal(capped?.action, "skip");
     assert.equal(getUatCount(basePath, "M001", "S01"), 4);
   } finally {
     rmSync(basePath, { recursive: true, force: true });

package/src/resources/extensions/gsd/tests/session-switch-abort-misclassification.test.ts

@@ -5,6 +5,7 @@ import test from "node:test";
 import assert from "node:assert/strict";
 
 import {
+  _hasEmptyAgentEndContent,
   _handleSessionSwitchAgentEnd,
   isBareClaudeCodeStreamAbortPlaceholder,
   isClaudeCodeSessionSwitchAbortMessage,
@@ -188,6 +189,15 @@ test("empty-content aborted during session-switch is silently ignored", () => {
   assert.equal(cancelledWith, null);
 });
 
+test("missing agent_end content is classified as empty abort content", () => {
+  // Providers may omit content entirely for a late aborted agent_end. That is
+  // equivalent to empty content and must not pause/cancel the next unit.
+  assert.equal(_hasEmptyAgentEndContent(undefined), true);
+  assert.equal(_hasEmptyAgentEndContent(null), true);
+  assert.equal(_hasEmptyAgentEndContent([]), true);
+  assert.equal(_hasEmptyAgentEndContent([{ type: "text", text: "partial" }]), false);
+});
+
 test("completed assistant content with aborted stopReason during session-switch is ignored", () => {
   // newSession() can abort the just-finished provider stream while the last
   // assistant message still carries the completed unit summary. That is a

package/src/resources/extensions/gsd/tests/smart-entry-routing.test.ts

@@ -0,0 +1,113 @@
+// GSD-2 — Smart entry routing behavior tests.
+// Verifies guided wizard choices resolve to the correct execution path.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  resolveActiveTaskChoiceRoute,
+  resolveGuidedExecuteLaunchMode,
+  type ActiveTaskChoice,
+  type ActiveTaskRoute,
+  type SmartEntryIsolationMode,
+} from "../smart-entry-routing.ts";
+
+test("guided execute route enters auto step bootstrap only for worktree isolation", () => {
+  const cases: Array<{
+    isolationMode: SmartEntryIsolationMode;
+    expectedRoute: ActiveTaskRoute;
+  }> = [
+    {
+      isolationMode: "worktree",
+      expectedRoute: {
+        kind: "auto-bootstrap",
+        verboseMode: false,
+        options: {
+          step: true,
+          milestoneLock: "M001",
+        },
+      },
+    },
+    {
+      isolationMode: "none",
+      expectedRoute: {
+        kind: "guided-dispatch",
+        unitType: "execute-task",
+      },
+    },
+    {
+      isolationMode: "branch",
+      expectedRoute: {
+        kind: "guided-dispatch",
+        unitType: "execute-task",
+      },
+    },
+  ];
+
+  for (const testCase of cases) {
+    assert.deepEqual(
+      resolveActiveTaskChoiceRoute({
+        choice: "execute",
+        isolationMode: testCase.isolationMode,
+        milestoneId: "M001",
+      }),
+      testCase.expectedRoute,
+    );
+  }
+});
+
+test("active task smart entry choices resolve to explicit routes", () => {
+  const cases: Array<{
+    choice: ActiveTaskChoice;
+    expectedRoute: ActiveTaskRoute;
+  }> = [
+    {
+      choice: "auto",
+      expectedRoute: {
+        kind: "auto-bootstrap",
+        verboseMode: false,
+      },
+    },
+    {
+      choice: "status",
+      expectedRoute: {
+        kind: "status",
+      },
+    },
+    {
+      choice: "milestone_actions",
+      expectedRoute: {
+        kind: "milestone-actions",
+      },
+    },
+  ];
+
+  for (const testCase of cases) {
+    assert.deepEqual(
+      resolveActiveTaskChoiceRoute({
+        choice: testCase.choice,
+        isolationMode: "worktree",
+        milestoneId: "M001",
+      }),
+      testCase.expectedRoute,
+    );
+  }
+});
+
+test("active task route rejects invalid choices from untyped callers", () => {
+  assert.throws(
+    () =>
+      resolveActiveTaskChoiceRoute({
+        choice: "not_yet" as ActiveTaskChoice,
+        isolationMode: "worktree",
+        milestoneId: "M001",
+      }),
+    /Invalid ActiveTaskChoice: not_yet/,
+  );
+});
+
+test("guided execute launch mode remains a small compatibility helper", () => {
+  assert.equal(resolveGuidedExecuteLaunchMode("worktree"), "auto-step");
+  assert.equal(resolveGuidedExecuteLaunchMode("none"), "guided-dispatch");
+  assert.equal(resolveGuidedExecuteLaunchMode("branch"), "guided-dispatch");
+});

package/src/resources/extensions/gsd/tests/start-auto-detached.test.ts

@@ -4,7 +4,10 @@ import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
 
 import { _withDetachedAutoKeepaliveForTest } from "../auto.ts";
-import { _scheduleAutoStartAfterIdleForTest } from "../guided-flow.ts";
+import {
+  _scheduleAutoStartAfterIdleForTest,
+  resolveGuidedExecuteLaunchMode,
+} from "../guided-flow.ts";
 
 const gsdDir = resolve(import.meta.dirname, "..");
 
@@ -64,6 +67,24 @@ test("bare /gsd stays in the foreground smart-entry flow (#5125 regression)", ()
   );
 });
 
+test("guided execute uses auto step bootstrap when worktree isolation is enabled", () => {
+  assert.equal(
+    resolveGuidedExecuteLaunchMode("worktree"),
+    "auto-step",
+    "guided execute must enter auto bootstrap so the milestone worktree is created before execution",
+  );
+  assert.equal(
+    resolveGuidedExecuteLaunchMode("none"),
+    "guided-dispatch",
+    "non-isolated projects can keep the foreground guided dispatch path",
+  );
+  assert.equal(
+    resolveGuidedExecuteLaunchMode("branch"),
+    "guided-dispatch",
+    "this regression fix is scoped to worktree isolation",
+  );
+});
+
 test("auto bootstrap validates blocked directories before touching .gsd migration state", () => {
   const autoSrc = readGsdFile("auto.ts");
   const autoStartSrc = readGsdFile("auto-start.ts");
@@ -99,19 +120,49 @@ test("auto bootstrap validates blocked directories before touching .gsd migratio
 
 test("fresh start registers the auto worker before bootstrap enters worktree flow (#5405)", () => {
   const autoSrc = readGsdFile("auto.ts");
+  const autoStartSrc = readGsdFile("auto-start.ts");
   const startAutoIdx = autoSrc.indexOf("export async function startAuto(");
   const startAutoBody = autoSrc.slice(startAutoIdx);
+  const bootstrapIdx = autoStartSrc.indexOf("export async function bootstrapAutoSession(");
+  const bootstrapBody = autoStartSrc.slice(bootstrapIdx);
 
-  const preBootstrapRegisterIdx = startAutoBody.indexOf("registerAutoWorkerForSession(s, base);");
   const bootstrapCallIdx = startAutoBody.indexOf("const ready = await bootstrapAutoSession(");
+  const preBootstrapBody = startAutoBody.slice(0, bootstrapCallIdx);
+  const preBootstrapRegisterIdx = preBootstrapBody.lastIndexOf("registerAutoWorkerForSession(s, base);");
+  const resumeSectionIdx = startAutoBody.indexOf("if (s.paused) {");
+  const freshStartSectionIdx = startAutoBody.indexOf("// ── Fresh start path — delegated to auto-start.ts ──");
+  const resumeBody = startAutoBody.slice(resumeSectionIdx, freshStartSectionIdx);
+  const resumeDbOpenIdx = resumeBody.indexOf("await openProjectDbIfPresent(base);");
+  const resumeRegisterIdx = resumeBody.indexOf("registerAutoWorkerForSession(s, base);");
+  const resumeEnterMilestoneIdx = resumeBody.indexOf("buildLifecycle().enterMilestone");
+  const dbOpenIdx = bootstrapBody.indexOf("await openProjectDbIfPresent(base);");
+  const bootstrapRegisterIdx = bootstrapBody.indexOf("registerAutoWorkerForSession(base);");
+  const enterMilestoneIdx = bootstrapBody.indexOf("buildLifecycle().enterMilestone");
 
   assert.ok(startAutoIdx > -1, "startAuto should exist");
   assert.ok(preBootstrapRegisterIdx > -1, "startAuto should register worker before bootstrap");
   assert.ok(bootstrapCallIdx > -1, "startAuto should call bootstrapAutoSession");
+  assert.ok(resumeSectionIdx > -1, "startAuto should have resume milestone entry flow");
+  assert.ok(freshStartSectionIdx > resumeSectionIdx, "resume assertions should be scoped before fresh start");
+  assert.ok(resumeDbOpenIdx > -1, "resume should open DB before milestone entry");
+  assert.ok(resumeRegisterIdx > -1, "resume should register worker before milestone entry");
+  assert.ok(resumeEnterMilestoneIdx > -1, "resume should enter milestones through lifecycle");
+  assert.ok(bootstrapIdx > -1, "bootstrapAutoSession should exist");
+  assert.ok(dbOpenIdx > -1, "bootstrap should open the project DB");
+  assert.ok(bootstrapRegisterIdx > -1, "bootstrap should register worker after DB open");
+  assert.ok(enterMilestoneIdx > -1, "bootstrap should enter milestones through lifecycle");
   assert.ok(
     preBootstrapRegisterIdx < bootstrapCallIdx,
     "worker registration must happen before bootstrap so enterMilestone can claim milestone leases on first entry",
   );
+  assert.ok(
+    dbOpenIdx < bootstrapRegisterIdx && bootstrapRegisterIdx < enterMilestoneIdx,
+    "bootstrap must open DB and register worker before first enterMilestone",
+  );
+  assert.ok(
+    resumeDbOpenIdx < resumeRegisterIdx && resumeRegisterIdx < resumeEnterMilestoneIdx,
+    "resume must open DB and register worker before first enterMilestone",
+  );
 });
 
 test("startAutoDetached reports failures asynchronously (#3733)", () => {