gsd-pi 2.82.0-dev.3709f22a5 → 2.82.0-dev.4285182e8

package/src/resources/extensions/gsd/state.ts

@@ -591,7 +591,7 @@ async function handleAllSlicesDone(
       recentDecisions: [],
       blockers: [
         `Milestone ${activeMilestone.id} validation verdict is needs-remediation but all slices are complete. ` +
-          `Add remediation slices via gsd_reassess_roadmap or override the verdict manually.`,
+          `Add remediation slices via gsd_reassess_roadmap, or run \`/gsd verdict pass --rationale "..."\` to override.`,
       ],
       nextAction: `Resolve ${activeMilestone.id} remediation before proceeding.`,
       registry, requirements,
@@ -1314,7 +1314,7 @@ export async function _deriveStateImpl(
         recentDecisions: [],
         blockers: [
           `Milestone ${activeMilestone.id} validation verdict is needs-remediation but all slices are complete. ` +
-            `Add remediation slices via gsd_reassess_roadmap or override the verdict manually.`,
+            `Add remediation slices via gsd_reassess_roadmap, or run \`/gsd verdict pass --rationale "..."\` to override.`,
         ],
         nextAction: `Resolve ${activeMilestone.id} remediation before proceeding.`,
         registry,
@@ -1441,7 +1441,7 @@ export async function _deriveStateImpl(
     const summaryPath = resolveTaskFile(basePath, activeMilestone.id, activeSlice.id, t.id, "SUMMARY");
     if (summaryPath && existsSync(summaryPath)) {
       t.done = true;
-      logWarning("reconcile", `task ${activeMilestone.id}/${activeSlice.id}/${t.id} reconciled via SUMMARY on disk (#2514)`, { mid: activeMilestone.id, sid: activeSlice.id, tid: t.id });
+      logWarning("reconcile", `task ${activeMilestone.id}/${activeSlice.id}/${t.id} reconciled via SUMMARY on disk`, { mid: activeMilestone.id, sid: activeSlice.id, tid: t.id });
     }
   }
 

package/src/resources/extensions/gsd/status-guards.ts

@@ -30,3 +30,11 @@ export function isInactiveStatus(status: string): boolean {
 export function isSkippedForDispatch(status: string): boolean {
   return isClosedStatus(status) || status === "parked" || isDeferredStatus(status);
 }
+
+/**
+ * Returns true when a milestone is future/backlog work (not currently executing).
+ * Includes legacy/project-specific alias "planned" for compatibility.
+ */
+export function isFutureMilestoneStatus(status: string): boolean {
+  return status === "pending" || status === "queued" || status === "planned";
+}

package/src/resources/extensions/gsd/templates/plan.md

@@ -132,6 +132,7 @@
   Verify field rules:
   - MUST be a mechanically executable command: `npm test`, `grep -q "pattern" file`, `test -f path`
   - MUST NOT use shell pipes, redirects, semicolons, backticks, command substitution, or output trimming
+  - MUST NOT use inline `node -e` assertions for verification; put assertions in a real test file and run it with `node --test` or a package test script
   - For content/document tasks: verify file existence, section count, YAML validity, or word count
     NOT exact phrasing, specific formulas, or "zero TBD" aspirational criteria
   - If no command can verify the output, write: "Manual review — file exists and is non-empty"

package/src/resources/extensions/gsd/templates/task-plan.md

@@ -57,6 +57,12 @@ skills_used:
 - {{howToVerifyThisTaskIsActuallyDone}}
 - {{commandToRun_OR_behaviorToCheck}}
 
+## Verify Rules
+
+- Use a real executable check, not prose.
+- If the check needs file-content assertions, write a `node:test` file and run it with `node --test` or a package test script.
+- Do not use inline `node -e` assertions for verification.
+
 ## Observability Impact
 
 <!-- OMIT THIS SECTION ENTIRELY for simple tasks that don't touch runtime boundaries,

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

@@ -129,6 +129,8 @@ function makeMockPi() {
       setModelCalls.push(args);
       return true;
     },
+    getThinkingLevel: () => "off",
+    setThinkingLevel: () => {},
     calls,
     setModelCalls,
   } as any;

package/src/resources/extensions/gsd/tests/auto-paused-ui-cleanup.test.ts

@@ -6,7 +6,7 @@ import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "nod
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
-import { cleanupAfterLoopExit, rerootCommandSession, stopAuto } from "../auto.ts";
+import { cleanupAfterLoopExit, pauseAuto, rerootCommandSession, stopAuto } from "../auto.ts";
 import { autoSession } from "../auto-runtime-state.ts";
 import { closeDatabase, insertMilestone, insertSlice, openDatabase } from "../gsd-db.ts";
 import { WorktreeLifecycle } from "../worktree-lifecycle.ts";
@@ -43,6 +43,52 @@ test("cleanupAfterLoopExit preserves paused auto badge after provider pause", as
   }
 });
 
+test("cleanupAfterLoopExit preserves paused worktree session and visible failure output", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-paused-session-preserve-"));
+  const worktree = join(base, ".gsd", "worktrees", "M001");
+  const previousCwd = process.cwd();
+  const newSessionWorkspaces: string[] = [];
+  let restoreCalls = 0;
+
+  t.mock.method(WorktreeLifecycle.prototype, "restoreToProjectRoot", function () {
+    restoreCalls += 1;
+  });
+
+  mkdirSync(worktree, { recursive: true });
+  process.chdir(worktree);
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.paused = true;
+  autoSession.basePath = worktree;
+  autoSession.originalBasePath = base;
+  autoSession.cmdCtx = {
+    newSession: async ({ workspaceRoot }: { workspaceRoot: string }) => {
+      newSessionWorkspaces.push(workspaceRoot);
+      return { cancelled: false };
+    },
+  } as any;
+
+  try {
+    await cleanupAfterLoopExit({
+      ui: {
+        setStatus: () => {},
+        setWidget: () => {},
+        notify: () => {},
+      },
+    } as any);
+
+    assert.equal(restoreCalls, 0, "paused cleanup must not restore out of the active worktree");
+    assert.deepEqual(newSessionWorkspaces, [], "paused cleanup must not start a blank rerooted session");
+    assert.equal(autoSession.basePath, worktree);
+    assert.equal(realpathSync(process.cwd()), realpathSync(worktree));
+    assert.equal(autoSession.paused, true);
+  } finally {
+    autoSession.reset();
+    process.chdir(previousCwd);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 test("cleanupAfterLoopExit clears status and progress widget without replacing outcome surface", async () => {
   const statusCalls: unknown[] = [];
   const widgetCalls: unknown[] = [];
@@ -117,6 +163,98 @@ test("cleanupAfterLoopExit clears progress widget after stopAuto reset", async (
   }
 });
 
+test("pauseAuto preserves artifact retry counts across pause/resume", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-pause-retry-count-"));
+  const previousCwd = process.cwd();
+  const retryKey = "execute-task:M001/S01/T01";
+
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.verificationRetryCount.set(retryKey, 2);
+  autoSession.pendingVerificationRetry = {
+    unitId: "M001/S01/T01",
+    failureContext: "Missing expected artifact (attempt 2/3).",
+    attempt: 2,
+  };
+
+  try {
+    process.chdir(base);
+    await pauseAuto();
+
+    assert.equal(autoSession.paused, true);
+    assert.equal(autoSession.pendingVerificationRetry, null);
+    assert.equal(autoSession.verificationRetryCount.get(retryKey), 2);
+  } finally {
+    autoSession.reset();
+    process.chdir(previousCwd);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("cleanupAfterLoopExit preserves step-mode surface and worktree session after completed step", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-step-surface-"));
+  const worktree = join(base, ".gsd", "worktrees", "M001");
+  const previousCwd = process.cwd();
+  const statusCalls: unknown[] = [];
+  const widgetCalls: unknown[] = [];
+  const newSessionWorkspaces: string[] = [];
+  let restoreCalls = 0;
+
+  t.mock.method(WorktreeLifecycle.prototype, "restoreToProjectRoot", function () {
+    restoreCalls += 1;
+  });
+
+  mkdirSync(worktree, { recursive: true });
+  process.chdir(worktree);
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.paused = false;
+  autoSession.stepMode = true;
+  autoSession.preserveStepSurfaceAfterLoopExit = true;
+  autoSession.basePath = worktree;
+  autoSession.originalBasePath = base;
+  autoSession.cmdCtx = {
+    newSession: async ({ workspaceRoot }: { workspaceRoot: string }) => {
+      newSessionWorkspaces.push(workspaceRoot);
+      return { cancelled: false };
+    },
+  } as any;
+
+  try {
+    await cleanupAfterLoopExit({
+      hasUI: true,
+      ui: {
+        setStatus: (...args: unknown[]) => statusCalls.push(args),
+        setWidget: (...args: unknown[]) => widgetCalls.push(args),
+        setHeader: () => {},
+        notify: () => {},
+      },
+    } as any);
+
+    assert.deepEqual(statusCalls, [], "step-mode cleanup must leave the NEXT badge visible");
+    assert.equal(
+      widgetCalls.some((args) => Array.isArray(args) && args[0] === "gsd-progress" && args[1] === undefined),
+      false,
+      "step-mode cleanup must not clear the completed step progress surface",
+    );
+    assert.equal(
+      widgetCalls.some((args) => Array.isArray(args) && args[0] === "gsd-health"),
+      false,
+      "step-mode cleanup must not replace the progress surface with idle health",
+    );
+    assert.deepEqual(newSessionWorkspaces, [], "step-mode cleanup must not re-root the visible command session");
+    assert.equal(restoreCalls, 0, "step-mode cleanup must not restore out of the active worktree");
+    assert.equal(autoSession.active, false);
+    assert.equal(autoSession.preserveStepSurfaceAfterLoopExit, false);
+    assert.equal(autoSession.basePath, worktree);
+    assert.equal(realpathSync(process.cwd()), realpathSync(worktree));
+  } finally {
+    autoSession.reset();
+    process.chdir(previousCwd);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 test("cleanupAfterLoopExit restores project root through lifecycle and preserves chdir", async (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-cleanup-lifecycle-"));
   const worktree = join(base, ".gsd", "worktrees", "M001");

package/src/resources/extensions/gsd/tests/auto-post-unit-step-message.test.ts

@@ -1,4 +1,5 @@
-// GSD-2 — Tests for step-mode completion messages in auto-post-unit
+// Project/App: GSD-2
+// File Purpose: Tests for step-mode completion messages in auto-post-unit.
 
 import test from "node:test";
 import assert from "node:assert/strict";
@@ -31,7 +32,7 @@ test("buildStepCompleteMessage: milestone complete surfaces review guidance", ()
   assert.doesNotMatch(msg, /Next:/);
 });
 
-test("buildStepCompleteMessage: mid-flight step includes next unit label and /clear hint", () => {
+test("buildStepCompleteMessage: mid-flight step includes next unit label and /gsd next hint", () => {
   const state = makeState({
     phase: "executing",
     activeSlice: { id: "S01", title: "Core" },
@@ -40,7 +41,7 @@ test("buildStepCompleteMessage: mid-flight step includes next unit label and /cl
   const msg = buildStepCompleteMessage(state);
   assert.match(msg, /Next: Execute T03: Wire notify/);
   assert.match(msg, /\/clear/);
-  assert.match(msg, /\/gsd to continue/);
+  assert.match(msg, /\/gsd next to continue one step/);
 });
 
 test("buildStepCompleteMessage: unknown phase falls back to generic continue label", () => {
@@ -51,9 +52,9 @@ test("buildStepCompleteMessage: unknown phase falls back to generic continue lab
   assert.match(msg, /\/clear/);
 });
 
-test("STEP_COMPLETE_FALLBACK_MESSAGE: used when deriveState throws, still points users at /clear + /gsd", () => {
+test("STEP_COMPLETE_FALLBACK_MESSAGE: used when deriveState throws, still points users at /clear + /gsd next", () => {
   assert.match(STEP_COMPLETE_FALLBACK_MESSAGE, /\/clear/);
-  assert.match(STEP_COMPLETE_FALLBACK_MESSAGE, /\/gsd/);
+  assert.match(STEP_COMPLETE_FALLBACK_MESSAGE, /\/gsd next/);
 });
 
 test("shouldReturnStepWizardAfterUnit: terminal milestone completion continues to merge-back path", () => {

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

@@ -807,6 +807,51 @@ test("hasImplementationArtifacts finds integration implementation-only commits w
   }
 });
 
+test("hasImplementationArtifacts ignores corrupted milestone/* integration metadata", () => {
+  const base = makeGitBase();
+  try {
+    mkdirSync(join(base, "src"), { recursive: true });
+    writeFileSync(join(base, "src", "feature.ts"), "export function feature() {}\n");
+    execFileSync("git", ["add", "src/feature.ts"], { cwd: base, stdio: "ignore" });
+    execFileSync("git", ["commit", "-m", "feat: add milestone feature\n\nGSD-Task: S01/T01"], { cwd: base, stdio: "ignore" });
+
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone One", status: "active" });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M001",
+      title: "Slice One",
+      status: "complete",
+      risk: "low",
+      depends: [],
+    });
+    insertTask({
+      id: "T01",
+      sliceId: "S01",
+      milestoneId: "M001",
+      title: "Task One",
+      status: "complete",
+    });
+
+    execFileSync("git", ["checkout", "-b", "milestone/M001"], { cwd: base, stdio: "ignore" });
+    mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+    writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-SUMMARY.md"), "# Milestone Summary\nDone.");
+    execFileSync("git", ["add", "."], { cwd: base, stdio: "ignore" });
+    execFileSync("git", ["commit", "-m", "chore: auto-commit after complete-milestone\n\nGSD-Unit: M001"], { cwd: base, stdio: "ignore" });
+
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "M001-META.json"),
+      JSON.stringify({ integrationBranch: "milestone/M001" }, null, 2) + "\n",
+    );
+
+    const result = hasImplementationArtifacts(base, "M001");
+    assert.equal(result, "present", "corrupted milestone integration metadata should fall back to main branch for artifact detection");
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("hasImplementationArtifacts backfills untagged main implementation commits from completed task file hints", () => {
   const base = makeGitBase();
   try {
@@ -1043,24 +1088,50 @@ test("hasImplementationArtifacts binds GSD-Task trailer to milestone via DB stat
   }
 });
 
-test("hasImplementationArtifacts does not bind GSD-Task trailer without milestone ownership evidence", () => {
+test("hasImplementationArtifacts does not claim Sxx/Tyy commit trailers across milestones when ownership points elsewhere", () => {
   const base = makeGitBase();
   try {
     writeFileSync(join(base, ".git", "info", "exclude"), ".gsd/\n");
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone One", status: "active" });
+    insertMilestone({ id: "M002", title: "Milestone Two", status: "active" });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M002",
+      title: "Slice One",
+      status: "complete",
+      risk: "low",
+      depends: [],
+    });
+    insertTask({
+      id: "T01",
+      sliceId: "S01",
+      milestoneId: "M002",
+      title: "Task One",
+      status: "complete",
+    });
+
     mkdirSync(join(base, "src"), { recursive: true });
     writeFileSync(join(base, "src", "feature.ts"), "export function feature() {}\n");
     execFileSync("git", ["add", "."], { cwd: base, stdio: "ignore" });
     execFileSync(
       "git",
-      ["commit", "-m", "feat: add feature\n\nGSD-Task: S01/T01"],
+      ["commit", "-m", "feat: add sibling feature\n\nGSD-Task: S01/T01"],
       { cwd: base, stdio: "ignore" },
     );
 
-    const result = hasImplementationArtifacts(base, "M001");
+    const m001Result = hasImplementationArtifacts(base, "M001");
+    const m002Result = hasImplementationArtifacts(base, "M002");
     assert.equal(
-      result,
+      m001Result,
       "absent",
-      "S01/T01 shape alone must not bind an implementation commit to M001",
+      "Sxx/Tyy commit trailers owned by M002 must not be attributed to M001",
+    );
+    assert.equal(
+      m002Result,
+      "present",
+      "the owning milestone should still claim the implementation-bearing commit",
     );
   } finally {
     cleanup(base);

package/src/resources/extensions/gsd/tests/checkout-branch-stash-guard.test.ts

@@ -0,0 +1,87 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { checkoutBranchWithStashGuard } from "../auto-worktree.ts";
+
+function git(args: string[], cwd: string): string {
+  return execFileSync("git", args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+  });
+}
+
+function createRepo(t: { after: (fn: () => void) => void }): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "checkout-stash-guard-")));
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+  git(["init"], dir);
+  git(["config", "user.email", "test@example.com"], dir);
+  git(["config", "user.name", "Test User"], dir);
+  writeFileSync(join(dir, "note.txt"), "base\n");
+  git(["add", "note.txt"], dir);
+  git(["commit", "-m", "init"], dir);
+  git(["branch", "-M", "main"], dir);
+  return dir;
+}
+
+describe("checkoutBranchWithStashGuard", () => {
+  test("restores dirty working tree after successful checkout", (t) => {
+    const repo = createRepo(t);
+    git(["checkout", "-b", "milestone/M001"], repo);
+    git(["checkout", "main"], repo);
+
+    writeFileSync(join(repo, "note.txt"), "dirty\n");
+
+    checkoutBranchWithStashGuard(repo, "milestone/M001", "test-success");
+
+    const branch = git(["branch", "--show-current"], repo).trim();
+    assert.equal(branch, "milestone/M001");
+    const content = git(["show", "HEAD:note.txt"], repo).trim();
+    assert.equal(content, "base");
+    const wtContent = readFileSync(join(repo, "note.txt"), "utf8");
+    assert.equal(wtContent, "dirty\n");
+    const status = git(["status", "--porcelain"], repo);
+    assert.match(status, /note\.txt/);
+  });
+
+  test("restores dirty working tree when checkout throws", (t) => {
+    const repo = createRepo(t);
+    writeFileSync(join(repo, "note.txt"), "dirty\n");
+
+    assert.throws(
+      () => checkoutBranchWithStashGuard(repo, "milestone/DOES-NOT-EXIST", "test-failure"),
+    );
+
+    const status = git(["status", "--porcelain"], repo);
+    assert.match(status, /note\.txt/);
+    const stashList = git(["stash", "list"], repo).trim();
+    assert.equal(stashList, "");
+  });
+
+  test("surfaces distinct error when checkout succeeds but stash pop conflicts", (t) => {
+    const repo = createRepo(t);
+    // Branch B has a divergent version of note.txt so popping a stash made
+    // against main will conflict after the checkout to B.
+    git(["checkout", "-b", "milestone/B"], repo);
+    writeFileSync(join(repo, "note.txt"), "B-version\n");
+    git(["add", "note.txt"], repo);
+    git(["commit", "-m", "B"], repo);
+    git(["checkout", "main"], repo);
+
+    writeFileSync(join(repo, "note.txt"), "local\n");
+
+    assert.throws(
+      () => checkoutBranchWithStashGuard(repo, "milestone/B", "test-pop-failure"),
+      /checkout to 'milestone\/B' succeeded but stash restore failed/,
+    );
+
+    const branch = git(["branch", "--show-current"], repo).trim();
+    assert.equal(branch, "milestone/B");
+    const stashList = git(["stash", "list"], repo).trim();
+    assert.match(stashList, /gsd: checkout stash/);
+  });
+});