gsd-pi 2.82.0-dev.2841a1e44 → 2.82.0-dev.9d5798940

package/src/resources/extensions/gsd/tests/auto-deterministic-error-classification-4973.test.ts

@@ -42,6 +42,20 @@ function makeTmpBase(): string {
   return base;
 }
 
+function makeBrokenIsolatedWorktree(): string {
+  const root = mkdtempSync(join(tmpdir(), `gsd-test-5848-${randomUUID().slice(0, 8)}-`));
+  tmpDirs.push(root);
+  const base = join(root, ".gsd", "projects", "project-id", "worktrees", "M003");
+  mkdirSync(join(base, ".gsd", "milestones", "M003", "slices", "S03"), { recursive: true });
+  return base;
+}
+
+function makeBrokenIsolatedWorktreeRevParse(): string {
+  const base = makeBrokenIsolatedWorktree();
+  mkdirSync(join(base, ".git"));
+  return base;
+}
+
 function resetAutoState(): void {
   _setAutoActiveForTest(false);
 }
@@ -231,6 +245,108 @@ describe("Test 5 — postUnitPreVerification short-circuits on deterministic err
   });
 });
 
+describe("Test 5b — broken isolated worktree short-circuits artifact retry (#5848)", () => {
+  test("pauses with worktree integrity failure instead of setting pendingVerificationRetry", async () => {
+    const { postUnitPreVerification } = await import("../auto-post-unit.ts");
+
+    const base = makeBrokenIsolatedWorktree();
+    const s = new AutoSession();
+    s.active = true;
+    s.basePath = base;
+    s.currentUnit = { type: "research-slice", id: "M003/S03", startedAt: Date.now() };
+    s.verificationRetryCount.set("research-slice:M003/S03", 2);
+
+    const notifications: string[] = [];
+    let pauseCalled = false;
+    const pctx = {
+      s,
+      ctx: {
+        ui: {
+          notify: (message: string) => {
+            notifications.push(message);
+          },
+        },
+      },
+      pi: {},
+      buildSnapshotOpts: () => ({}) as any,
+      lockBase: () => base,
+      stopAuto: async () => {},
+      pauseAuto: async () => {
+        pauseCalled = true;
+      },
+      updateProgressWidget: () => {},
+    } as any;
+
+    const result = await postUnitPreVerification(pctx, {
+      skipSettleDelay: true,
+      skipWorktreeSync: true,
+    });
+
+    assert.strictEqual(result, "dispatched", "worktree integrity failure must pause instead of retrying");
+    assert.strictEqual(pauseCalled, true, "pauseAuto must be called for a broken isolated worktree");
+    assert.strictEqual(s.pendingVerificationRetry, null, "pendingVerificationRetry must NOT be set");
+    assert.strictEqual(s.verificationRetryCount.has("research-slice:M003/S03"), false, "stale retry count must be cleared");
+    assert.ok(
+      notifications.some((message) => message.includes("Worktree integrity failure") && message.includes(".git missing")),
+      `expected worktree integrity notification, got: ${notifications.join("\n")}`,
+    );
+    assert.ok(
+      notifications.every((message) => !message.includes("Artifact verification failed")),
+      `must not surface artifact retry messaging, got: ${notifications.join("\n")}`,
+    );
+  });
+
+  test("pauses when git rev-parse cannot validate an isolated worktree", async () => {
+    const { postUnitPreVerification } = await import("../auto-post-unit.ts");
+
+    const base = makeBrokenIsolatedWorktreeRevParse();
+    const s = new AutoSession();
+    s.active = true;
+    s.basePath = base;
+    s.currentUnit = { type: "research-slice", id: "M003/S03", startedAt: Date.now() };
+    s.verificationRetryCount.set("research-slice:M003/S03", 2);
+
+    const notifications: string[] = [];
+    let pauseCalled = false;
+    const pctx = {
+      s,
+      ctx: {
+        ui: {
+          notify: (message: string) => {
+            notifications.push(message);
+          },
+        },
+      },
+      pi: {},
+      buildSnapshotOpts: () => ({}) as any,
+      lockBase: () => base,
+      stopAuto: async () => {},
+      pauseAuto: async () => {
+        pauseCalled = true;
+      },
+      updateProgressWidget: () => {},
+    } as any;
+
+    const result = await postUnitPreVerification(pctx, {
+      skipSettleDelay: true,
+      skipWorktreeSync: true,
+    });
+
+    assert.strictEqual(result, "dispatched", "worktree integrity failure must pause instead of retrying");
+    assert.strictEqual(pauseCalled, true, "pauseAuto must be called for a broken isolated worktree");
+    assert.strictEqual(s.pendingVerificationRetry, null, "pendingVerificationRetry must NOT be set");
+    assert.strictEqual(s.verificationRetryCount.has("research-slice:M003/S03"), false, "stale retry count must be cleared");
+    assert.ok(
+      notifications.some((message) => message.includes("Worktree integrity failure") && message.includes("git rev-parse")),
+      `expected git rev-parse worktree integrity notification, got: ${notifications.join("\n")}`,
+    );
+    assert.ok(
+      notifications.every((message) => !message.includes("Artifact verification failed")),
+      `must not surface artifact retry messaging, got: ${notifications.join("\n")}`,
+    );
+  });
+});
+
 // ─── Test 6: Model-quality failures use standard retry path ──────────────────
 
 describe("Test 6 — non-deterministic failures use standard retry; tier escalates once (#4973)", () => {

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

@@ -3,7 +3,11 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 
-import { buildStepCompleteMessage, STEP_COMPLETE_FALLBACK_MESSAGE } from "../auto-post-unit.ts";
+import {
+  buildStepCompleteMessage,
+  shouldReturnStepWizardAfterUnit,
+  STEP_COMPLETE_FALLBACK_MESSAGE,
+} from "../auto-post-unit.ts";
 import type { GSDState } from "../types.ts";
 
 function makeState(overrides: Partial<GSDState>): GSDState {
@@ -51,3 +55,10 @@ test("STEP_COMPLETE_FALLBACK_MESSAGE: used when deriveState throws, still points
   assert.match(STEP_COMPLETE_FALLBACK_MESSAGE, /\/clear/);
   assert.match(STEP_COMPLETE_FALLBACK_MESSAGE, /\/gsd/);
 });
+
+test("shouldReturnStepWizardAfterUnit: terminal milestone completion continues to merge-back path", () => {
+  assert.equal(shouldReturnStepWizardAfterUnit("complete-milestone", "complete"), false);
+  assert.equal(shouldReturnStepWizardAfterUnit("complete-milestone", null), false);
+  assert.equal(shouldReturnStepWizardAfterUnit("execute-task", "complete"), false);
+  assert.equal(shouldReturnStepWizardAfterUnit("execute-task", "executing"), true);
+});

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

@@ -5,7 +5,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 
-import { verifyExpectedArtifact, hasImplementationArtifacts, resolveExpectedArtifactPath, diagnoseExpectedArtifact, buildLoopRemediationSteps, writeBlockerPlaceholder, refreshRecoveryDbForArtifact } from "../auto-recovery.ts";
+import { verifyExpectedArtifact, hasImplementationArtifacts, resolveExpectedArtifactPath, diagnoseExpectedArtifact, diagnoseWorktreeIntegrityFailure, buildLoopRemediationSteps, writeBlockerPlaceholder, refreshRecoveryDbForArtifact } from "../auto-recovery.ts";
 import { resolveMilestoneFile } from "../paths.ts";
 import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertGateRow, insertTask, getMilestoneCommitAttributionShas } from "../gsd-db.ts";
 import { clearParseCache } from "../files.ts";
@@ -141,6 +141,20 @@ test("resolveExpectedArtifactPath returns null for unknown type", () => {
   }
 });
 
+test("diagnoseWorktreeIntegrityFailure reports missing GSD worktree paths only", () => {
+  const missingWorktreePath = join(tmpdir(), `gsd-test-${randomUUID()}`, ".gsd", "worktrees", "M001-S01");
+  assert.equal(
+    diagnoseWorktreeIntegrityFailure(join(tmpdir(), `gsd-test-${randomUUID()}`)),
+    null,
+    "non-GSD paths should keep falling through to artifact recovery",
+  );
+  assert.equal(
+    diagnoseWorktreeIntegrityFailure(missingWorktreePath),
+    `Worktree integrity failure: ${missingWorktreePath} does not exist. Repair or recreate the worktree before retrying.`,
+    "missing GSD worktree paths should fail terminally before artifact retry",
+  );
+});
+
 test("resolveExpectedArtifactPath returns correct path for all milestone-level types", () => {
   const base = makeTmpBase();
   try {

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

@@ -2,7 +2,7 @@
 
 import { describe, test, beforeEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync, realpathSync } from "node:fs";
+import { existsSync, mkdtempSync, mkdirSync, writeFileSync, rmSync, realpathSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
@@ -13,6 +13,7 @@ import {
   _resetAutoWorktreeOriginalBaseForTests,
   createAutoWorktree,
   enterAutoWorktree,
+  mergeMilestoneToMain,
   teardownAutoWorktree,
 } from "../auto-worktree.ts";
 
@@ -173,4 +174,71 @@ describe("auto-worktree workspace registry", () => {
     teardownAutoWorktree(dir2, "M020");
     try { process.chdir(savedCwd); } catch { /* ignore */ }
   });
+
+  test("mergeMilestoneToMain cleans up when milestone branch was already regular-merged", (t) => {
+    const tempDir = createTempRepo(t);
+    const msDir = join(tempDir, ".gsd", "milestones", "M003");
+    mkdirSync(msDir, { recursive: true });
+    writeFileSync(join(msDir, "CONTEXT.md"), "# M003 Context\n");
+    git(["add", "."], tempDir);
+    git(["commit", "-m", "add milestone"], tempDir);
+
+    createAutoWorktree(tempDir, "M003");
+    const wtDir = join(tempDir, ".gsd", "worktrees", "M003");
+    writeFileSync(join(wtDir, "feature.txt"), "implemented\n");
+    git(["add", "feature.txt"], wtDir);
+    git(["commit", "-m", "feat: implement M003"], wtDir);
+
+    process.chdir(tempDir);
+    git(["merge", "--no-ff", "milestone/M003", "-m", "merge M003"], tempDir);
+
+    process.chdir(wtDir);
+    const result = mergeMilestoneToMain(tempDir, "M003", "# M003\n- [x] **S01: Done**\n");
+
+    assert.equal(result.codeFilesChanged, true);
+    assert.equal(result.pushed, false);
+    assert.equal(result.prCreated, false);
+    assert.equal(existsSync(wtDir), false, "worktree directory is removed");
+    assert.throws(
+      () => git(["rev-parse", "--verify", "milestone/M003"], tempDir),
+      /Command failed/,
+      "already-merged milestone branch is deleted",
+    );
+    try { process.chdir(savedCwd); } catch { /* ignore */ }
+  });
+
+  test("mergeMilestoneToMain cleans up already-merged milestone after main advances", (t) => {
+    const tempDir = createTempRepo(t);
+    const msDir = join(tempDir, ".gsd", "milestones", "M004");
+    mkdirSync(msDir, { recursive: true });
+    writeFileSync(join(msDir, "CONTEXT.md"), "# M004 Context\n");
+    git(["add", "."], tempDir);
+    git(["commit", "-m", "add milestone"], tempDir);
+
+    createAutoWorktree(tempDir, "M004");
+    const wtDir = join(tempDir, ".gsd", "worktrees", "M004");
+    writeFileSync(join(wtDir, "feature.txt"), "implemented\n");
+    git(["add", "feature.txt"], wtDir);
+    git(["commit", "-m", "feat: implement M004"], wtDir);
+
+    process.chdir(tempDir);
+    git(["merge", "--no-ff", "milestone/M004", "-m", "merge M004"], tempDir);
+    writeFileSync(join(tempDir, "hotfix.txt"), "later main work\n");
+    git(["add", "hotfix.txt"], tempDir);
+    git(["commit", "-m", "fix: advance main"], tempDir);
+
+    process.chdir(wtDir);
+    const result = mergeMilestoneToMain(tempDir, "M004", "# M004\n- [x] **S01: Done**\n");
+
+    assert.equal(result.codeFilesChanged, true);
+    assert.equal(result.pushed, false);
+    assert.equal(result.prCreated, false);
+    assert.equal(existsSync(wtDir), false, "worktree directory is removed");
+    assert.throws(
+      () => git(["rev-parse", "--verify", "milestone/M004"], tempDir),
+      /Command failed/,
+      "already-merged milestone branch is deleted",
+    );
+    try { process.chdir(savedCwd); } catch { /* ignore */ }
+  });
 });

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

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { existsSync, mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { chmodSync, existsSync, mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { execFileSync } from "node:child_process";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -10,7 +10,7 @@ import { runDispatch, runPreDispatch } from "../auto/phases.ts";
 import { AutoSession } from "../auto/session.ts";
 import { resolveUnitSupervisionTimeouts } from "../auto-timers.ts";
 import { bootstrapAutoSession } from "../auto-start.ts";
-import { postUnitPreVerification } from "../auto-post-unit.ts";
+import { postUnitPostVerification, postUnitPreVerification } from "../auto-post-unit.ts";
 import { resolveDispatch, setResearchProjectPromptBuilderForTest } from "../auto-dispatch.ts";
 import { resolveExpectedArtifactPath, verifyExpectedArtifact, writeBlockerPlaceholder } from "../auto-recovery.ts";
 import { finalizeProjectResearchTimeout } from "../project-research-policy.ts";
@@ -1587,6 +1587,61 @@ test("deep project setup: discuss-milestone question failure pauses instead of a
   }
 });
 
+test("verified task git closeout failure retries and continues auto-mode", async () => {
+  const base = makeBase();
+  try {
+    execFileSync("git", ["init"], { cwd: base, stdio: "ignore" });
+    execFileSync("git", ["config", "user.email", "test@example.com"], { cwd: base, stdio: "ignore" });
+    execFileSync("git", ["config", "user.name", "Test User"], { cwd: base, stdio: "ignore" });
+    const hookPath = join(base, ".git", "hooks", "pre-commit");
+    writeFileSync(
+      hookPath,
+      [
+        "#!/bin/sh",
+        "count_file=.git/pre-commit-count",
+        "count=0",
+        "if [ -f \"$count_file\" ]; then count=$(cat \"$count_file\"); fi",
+        "count=$((count + 1))",
+        "printf \"%s\" \"$count\" > \"$count_file\"",
+        "echo blocked by test hook >&2",
+        "exit 1",
+      ].join("\n"),
+    );
+    chmodSync(hookPath, 0o755);
+    writeFileSync(join(base, "work.txt"), "changed\n");
+
+    const s = new AutoSession();
+    s.active = true;
+    s.basePath = base;
+    s.originalBasePath = base;
+    s.currentUnit = { type: "execute-task", id: "M001/S01/T01", startedAt: Date.now() };
+
+    let pauseCalled = false;
+    const notifications: Array<{ message: string; severity?: string }> = [];
+    const result = await postUnitPostVerification({
+      s,
+      ctx: { ui: { notify: (message: string, severity?: string) => notifications.push({ message, severity }) } } as any,
+      pi: {} as any,
+      buildSnapshotOpts: () => ({}) as any,
+      lockBase: () => base,
+      stopAuto: async () => {},
+      pauseAuto: async () => { pauseCalled = true; },
+      updateProgressWidget: () => {},
+    });
+
+    assert.equal(result, "continue");
+    assert.equal(pauseCalled, false);
+    assert.equal(s.lastGitActionStatus, "failed");
+    assert.equal(readFileSync(join(base, ".git", "pre-commit-count"), "utf-8"), "3");
+    assert.ok(
+      notifications.some((entry) => entry.severity === "warning" && entry.message.includes("Git commit failed")),
+      "verified task git closeout failure should warn instead of stopping auto-mode",
+    );
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 test("deep project setup: approval wait wins over deterministic write-gate placeholder", async () => {
   const base = makeBase();
   try {

package/src/resources/extensions/gsd/tests/dispatch-complete-milestone-guard.test.ts

@@ -118,3 +118,42 @@ describe("complete phase dispatch guard (#5683)", () => {
     assert.equal(result?.reason, "All milestones complete.");
   });
 });
+
+describe("complete milestone context recovery guard (#5831)", () => {
+  let base = "";
+  const executionEntryRule = DISPATCH_RULES.find(
+    (candidate) => candidate.name === "execution-entry phase (no context) → discuss-milestone",
+  );
+  const prePlanningRule = DISPATCH_RULES.find(
+    (candidate) => candidate.name === "pre-planning (no context) → discuss-milestone",
+  );
+  assert.ok(executionEntryRule, "execution-entry missing-context rule should exist");
+  assert.ok(prePlanningRule, "pre-planning missing-context rule should exist");
+
+  afterEach(() => {
+    if (base) rmSync(base, { recursive: true, force: true });
+    base = "";
+  });
+
+  test("does not discuss a complete execution-entry milestone with no CONTEXT file", async () => {
+    base = makeBase();
+    const ctx = buildDispatchCtx(base);
+    ctx.state.registry = [{ id: "M001", title: "Milestone One", status: "complete" }];
+    ctx.state.phase = "completing-milestone";
+
+    const result = await executionEntryRule.match(ctx);
+
+    assert.equal(result, null);
+  });
+
+  test("does not discuss a complete pre-planning milestone with no CONTEXT file", async () => {
+    base = makeBase();
+    const ctx = buildDispatchCtx(base);
+    ctx.state.registry = [{ id: "M001", title: "Milestone One", status: "complete" }];
+    ctx.state.phase = "pre-planning";
+
+    const result = await prePlanningRule.match(ctx);
+
+    assert.equal(result, null);
+  });
+});

package/src/resources/extensions/gsd/tests/export-html-enhancements.test.ts

@@ -141,6 +141,14 @@ test("Feature 1: executive summary paragraph is rendered", () => {
   assert.ok(html.includes("$2.50 spent"), "should contain cost");
 });
 
+test("report uses the shared GSD HTML shell", () => {
+  const html = generateHtmlReport(mockData(), mockOpts());
+  assert.ok(html.includes('<span class="logo">GSD</span>'), "should render shared shell logo");
+  assert.ok(html.includes('<span class="kind-chip">Report</span>'), "should render report kind chip");
+  assert.ok(html.includes('<nav class="toc" aria-label="Report sections">'), "should render shared shell TOC");
+  assert.ok(html.includes('<main>'), "should render content inside shared shell main");
+});
+
 test("Feature 1: executive summary includes budget context when set", () => {
   const data = mockData({ health: { ...mockData().health, budgetCeiling: 10.00 } });
   const html = generateHtmlReport(data, mockOpts());

package/src/resources/extensions/gsd/tests/park-db-sync.test.ts

@@ -7,7 +7,7 @@
  */
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { existsSync, mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -48,6 +48,60 @@ test("parkMilestone updates DB status to 'parked' (#2694)", () => {
   }
 });
 
+test("parkMilestone ignores blocked SUMMARY.md when DB milestone is active (#5828)", () => {
+  const base = createBase();
+  try {
+    openDatabase(":memory:");
+    insertMilestone({ id: "M001", title: "Test", status: "active" });
+    writeFileSync(
+      join(base, ".gsd", "milestones", "M001", "M001-SUMMARY.md"),
+      [
+        "---",
+        "status: closeout_blocked",
+        "---",
+        "",
+        "# M001 Summary",
+        "",
+        "Completion was not persisted.",
+      ].join("\n"),
+      "utf-8",
+    );
+
+    const parked = parkMilestone(base, "M001", "test");
+
+    assert.ok(parked, "active DB row should allow parking despite a blocked SUMMARY.md");
+    assert.ok(
+      existsSync(join(base, ".gsd", "milestones", "M001", "M001-PARKED.md")),
+      "PARKED.md should be written",
+    );
+    assert.equal(getMilestone("M001")!.status, "parked", "DB status should be parked");
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("parkMilestone refuses DB-complete milestones (#5828)", () => {
+  const base = createBase();
+  try {
+    openDatabase(":memory:");
+    insertMilestone({ id: "M001", title: "Test", status: "complete" });
+
+    const parked = parkMilestone(base, "M001", "test");
+
+    assert.equal(parked, false, "complete DB row should not be parkable");
+    assert.equal(
+      existsSync(join(base, ".gsd", "milestones", "M001", "M001-PARKED.md")),
+      false,
+      "PARKED.md should not be written",
+    );
+    assert.equal(getMilestone("M001")!.status, "complete", "DB status should remain complete");
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 test("unparkMilestone updates DB status to 'active' (#2694)", () => {
   const base = createBase();
   try {

package/src/resources/extensions/gsd/tests/plan-slice.test.ts

@@ -125,6 +125,31 @@ test('handlePlanSlice advances DB-derived state out of planning immediately', as
   }
 });
 
+test('handlePlanSlice clears sketch flag so DB-derived state leaves refining', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    insertMilestone({ id: 'M001', title: 'Milestone', status: 'active' });
+    insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Planning slice', status: 'pending', demo: 'Rendered plans exist.', isSketch: true });
+
+    invalidateStateCache();
+    const before = await deriveState(base);
+    assert.equal(before.phase, 'refining');
+
+    const result = await handlePlanSlice(validParams(), base);
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+    assert.equal(getSlice('M001', 'S02')?.is_sketch, 0, 'planned slice must no longer be treated as a sketch');
+
+    invalidateStateCache();
+    const after = await deriveState(base);
+    assert.notEqual(after.phase, 'refining');
+    assert.equal(after.progress?.tasks?.total, 2);
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('handlePlanSlice leaves omitted enrichment fields empty instead of rendering placeholders', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));

package/src/resources/extensions/gsd/tests/post-unit-git-failure.test.ts

@@ -11,7 +11,7 @@ const source = readFileSync(
 
 test("postUnitPreVerification blocks on git action failure", () => {
   const failureBlock = extractSourceRegion(source, 'if (gitResult.status === "failed")');
-  assert.ok(failureBlock.includes('ctx.ui.notify(failureMsg, "error")'));
+  assert.ok(failureBlock.includes('ctx.ui.notify(failureMsg, opts?.softFailure ? "warning" : "error")'));
   assert.ok(failureBlock.includes("await pauseAuto(ctx, pi)"));
   assert.ok(failureBlock.includes('return "dispatched"'));
   assert.ok(!failureBlock.includes("git-action-failed-nonblocking"));

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,50 @@ 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 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/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/stuck-state-via-db.test.ts

@@ -23,9 +23,12 @@ import { registerAutoWorker } from "../db/auto-workers.ts";
 import { claimMilestoneLease } from "../db/milestone-leases.ts";
 import {
   recordDispatchClaim,
+  markCanceled,
   getRecentUnitKeysForWorker,
+  getRecentUnitKeysForProjectRoot,
 } from "../db/unit-dispatches.ts";
 import { setRuntimeKv, getRuntimeKv } from "../db/runtime-kv.ts";
+import { detectStuck } from "../auto/detect-stuck.ts";
 
 function makeBase(): string {
   const base = mkdtempSync(join(tmpdir(), "gsd-stuck-state-db-"));
@@ -67,6 +70,42 @@ test("getRecentUnitKeysForWorker reconstructs the recentUnits sliding window", (
   assert.deepEqual(window.map(w => w.key), ["U1", "U2", "U3"]);
 });
 
+test("getRecentUnitKeysForProjectRoot restores compound keys used by stuck detection", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "T", status: "active" });
+  const worker = registerAutoWorker({ projectRootRealpath: base });
+  const lease = claimMilestoneLease(worker, "M001");
+  assert.equal(lease.ok, true);
+  if (!lease.ok) return;
+
+  for (let i = 0; i < 2; i++) {
+    const claim = recordDispatchClaim({
+      traceId: `t${i}`,
+      workerId: worker,
+      milestoneLeaseToken: lease.token,
+      milestoneId: "M001",
+      sliceId: "S01",
+      unitType: "complete-slice",
+      unitId: "M001/S01",
+    });
+    assert.equal(claim.ok, true);
+    if (!claim.ok) return;
+    markCanceled(claim.dispatchId, "pause");
+  }
+
+  const window = getRecentUnitKeysForProjectRoot(base, 20);
+  assert.deepEqual(window.map(w => w.key), [
+    "complete-slice/M001/S01",
+    "complete-slice/M001/S01",
+  ]);
+
+  const result = detectStuck([...window, { key: "complete-slice/M001/S01" }]);
+  assert.equal(result?.stuck, true);
+  assert.match(result?.reason ?? "", /3 consecutive times/);
+});
+
 test("getRecentUnitKeysForWorker honors the limit parameter", (t) => {
   const base = makeBase();
   t.after(() => cleanup(base));