gsd-pi 2.82.0-dev.ed17d078d → 3.0.0-dev.04f5ccf82

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

@@ -62,7 +62,11 @@ async function runSuccessfulFinalize(s: AutoSession) {
   );
 }
 
-async function runFinalizeWithDeps(s: AutoSession, depsOverrides: Record<string, unknown>) {
+async function runFinalizeWithDeps(
+  s: AutoSession,
+  depsOverrides: Record<string, unknown>,
+  ctxOverride?: Record<string, unknown>,
+) {
   const unit = s.currentUnit;
   assert.ok(unit, "test setup must provide currentUnit");
 
@@ -86,7 +90,7 @@ async function runFinalizeWithDeps(s: AutoSession, depsOverrides: Record<string,
 
   return runFinalize(
     {
-      ctx: { ui: { notify() {} } },
+      ctx: ctxOverride ?? { ui: { notify() {} } },
       pi: {},
       s,
       deps,
@@ -223,3 +227,50 @@ test("runFinalize merges a verified complete-milestone immediately and only once
   assert.equal(lifecycleMergeCalls, 1);
   assert.equal(resolverMergeCalls, 0);
 });
+
+test("runFinalize does not render next-phase handoff for complete-milestone", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-finalize-complete-handoff-"));
+  t.after(() => {
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  const s = new AutoSession();
+  const widgetCalls: Array<[string, unknown]> = [];
+  s.basePath = base;
+  s.originalBasePath = base;
+  s.currentMilestoneId = "M001";
+  s.currentUnit = {
+    type: "complete-milestone",
+    id: "M001",
+    startedAt: Date.now(),
+  };
+
+  const result = await runFinalizeWithDeps(
+    s,
+    {
+      preflightCleanRoot: () => ({ stashPushed: false }),
+      postflightPopStash: () => ({ needsManualRecovery: false }),
+      lifecycle: {
+        exitMilestone() {
+          return { ok: true, merged: true, codeFilesChanged: false };
+        },
+      },
+    },
+    {
+      hasUI: true,
+      ui: {
+        notify() {},
+        setWidget(key: string, value: unknown) {
+          widgetCalls.push([key, value]);
+        },
+      },
+    },
+  );
+
+  assert.equal(result.action, "next");
+  assert.equal(
+    widgetCalls.some(([key]) => key === "gsd-outcome"),
+    false,
+    "complete-milestone finalize should leave terminal completion UI to stopAuto",
+  );
+});

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

@@ -1,9 +1,14 @@
-// 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";
 
-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 {
@@ -27,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" },
@@ -36,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", () => {
@@ -47,7 +52,14 @@ 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", () => {
+  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 {
@@ -225,8 +239,7 @@ test("buildLoopRemediationSteps returns steps for execute-task", () => {
   try {
     const steps = buildLoopRemediationSteps("execute-task", "M001/S01/T01", base);
     assert.ok(steps);
-    assert.ok(steps!.includes("T01"));
-    assert.ok(steps!.includes("gsd undo-task"));
+    assert.ok(steps!.includes("gsd undo-task M001/S01/T01"));
   } finally {
     cleanup(base);
   }
@@ -249,8 +262,7 @@ test("buildLoopRemediationSteps returns steps for complete-slice", () => {
   try {
     const steps = buildLoopRemediationSteps("complete-slice", "M001/S01", base);
     assert.ok(steps);
-    assert.ok(steps!.includes("S01"));
-    assert.ok(steps!.includes("gsd reset-slice"));
+    assert.ok(steps!.includes("gsd reset-slice M001/S01"));
   } finally {
     cleanup(base);
   }
@@ -447,6 +459,44 @@ test("verifyExpectedArtifact rejects complete-slice when roadmap checkbox is sti
   }
 });
 
+test("verifyExpectedArtifact rejects run-uat when ASSESSMENT has no verdict", () => {
+  const base = makeTmpBase();
+  try {
+    const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    writeFileSync(join(sliceDir, "S01-ASSESSMENT.md"), "# Reassessment\n\nNo canonical verdict field.\n");
+
+    assert.equal(
+      verifyExpectedArtifact("run-uat", "M001/S01", base),
+      false,
+      "run-uat should not verify from a pre-existing ASSESSMENT without verdict",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("verifyExpectedArtifact accepts run-uat when ASSESSMENT has verdict", () => {
+  const base = makeTmpBase();
+  try {
+    const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    writeFileSync(join(sliceDir, "S01-ASSESSMENT.md"), [
+      "---",
+      "verdict: pass",
+      "---",
+      "",
+      "# UAT Assessment",
+    ].join("\n"));
+
+    assert.equal(
+      verifyExpectedArtifact("run-uat", "M001/S01", base),
+      true,
+      "run-uat should verify when ASSESSMENT contains a canonical verdict",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
 
 // ─── verifyExpectedArtifact: plan-slice task plan check (#739) ────────────
 
@@ -793,6 +843,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 {
@@ -873,7 +968,11 @@ test("hasImplementationArtifacts does not backfill untagged commits before miles
     });
 
     const result = hasImplementationArtifacts(base, "M001");
-    assert.equal(result, "absent", "pre-milestone commits must not be attributed to the milestone");
+    assert.equal(
+      result,
+      "unknown",
+      "integration self-diff should remain unknown when pre-milestone commits cannot be attributed",
+    );
     assert.deepEqual(getMilestoneCommitAttributionShas("M001"), []);
   } finally {
     cleanup(base);
@@ -910,7 +1009,11 @@ test("hasImplementationArtifacts does not backfill unrelated untagged implementa
     execFileSync("git", ["commit", "-m", "feat: unrelated work"], { cwd: base, stdio: "ignore" });
 
     const result = hasImplementationArtifacts(base, "M001");
-    assert.equal(result, "absent", "backfill must require overlap with completed task file hints");
+    assert.equal(
+      result,
+      "unknown",
+      "integration self-diff should remain unknown when unrelated untagged commits cannot be attributed",
+    );
     assert.deepEqual(getMilestoneCommitAttributionShas("M001"), []);
   } finally {
     cleanup(base);
@@ -1029,24 +1132,44 @@ 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 returns unknown when GSD-Task trailer cannot be bound to milestone ownership evidence", () => {
   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");
     assert.equal(
       result,
-      "absent",
-      "S01/T01 shape alone must not bind an implementation commit to M001",
+      "unknown",
+      "integration self-diff should not conclude absent when S01/T01 cannot be bound to M001",
     );
   } finally {
     cleanup(base);
@@ -1070,8 +1193,8 @@ test("hasImplementationArtifacts ignores malformed milestone IDs in commit-messa
     const result = hasImplementationArtifacts(base, "M001(");
     assert.equal(
       result,
-      "absent",
-      "malformed milestone IDs must not bind implementation commits through message scanning",
+      "unknown",
+      "malformed milestone IDs must not force an absent classification when ownership cannot be proven",
     );
   } finally {
     cleanup(base);

package/src/resources/extensions/gsd/tests/auto-remote-session-lock-cleanup.test.ts

@@ -0,0 +1,64 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { checkRemoteAutoSession } from "../auto.ts";
+import { openDatabase, closeDatabase, _getAdapter } from "../gsd-db.ts";
+import { registerAutoWorker } from "../db/auto-workers.ts";
+import { normalizeRealPath } from "../paths.ts";
+import { readCrashLock } from "../crash-recovery.ts";
+
+function makeBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-remote-lock-cleanup-"));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try { closeDatabase(); } catch {}
+  try { rmSync(base, { recursive: true, force: true }); } catch {}
+}
+
+function expireWorker(workerId: string): void {
+  const db = _getAdapter()!;
+  db.prepare(
+    `UPDATE workers SET last_heartbeat_at = '1970-01-01T00:00:00.000Z' WHERE worker_id = :worker_id`,
+  ).run({ ":worker_id": workerId });
+}
+
+function setWorkerPid(workerId: string, pid: number): void {
+  const db = _getAdapter()!;
+  db.prepare(
+    `UPDATE workers SET pid = :pid WHERE worker_id = :worker_id`,
+  ).run({ ":pid": pid, ":worker_id": workerId });
+}
+
+function findDeadPidCandidate(): number {
+  const candidates = [99_999, 199_999, 299_999, 399_999];
+  for (const pid of candidates) {
+    try {
+      process.kill(pid, 0);
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code === "ESRCH") return pid;
+    }
+  }
+  throw new Error("Could not find a dead PID candidate for stale-lock test");
+}
+
+test("checkRemoteAutoSession clears stale lock state when lock PID is dead", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  const workerId = registerAutoWorker({ projectRootRealpath: normalizeRealPath(base) });
+  setWorkerPid(workerId, findDeadPidCandidate());
+  expireWorker(workerId);
+
+  assert.ok(readCrashLock(base), "precondition: stale lock exists before remote session check");
+
+  const remote = checkRemoteAutoSession(base);
+  assert.deepEqual(remote, { running: false });
+  assert.equal(readCrashLock(base), null, "stale lock should be cleared by remote session check");
+});

package/src/resources/extensions/gsd/tests/auto-retry-mcp-churn-fixes.test.ts

@@ -83,4 +83,16 @@ describe("evidence-collector: toolCallId-based matching (A-3)", () => {
     assert.equal(entries[1].kind, "edit");
     assert.equal(entries[1].toolCallId, "tc-edit");
   });
+
+  it("treats PowerShell and async_bash as execution evidence", () => {
+    recordToolCall("tc-ps", "PowerShell", { command: "Get-ChildItem" });
+    recordToolCall("tc-async", "async_bash", { command: "npm run build" });
+
+    const entries = getEvidence() as readonly BashEvidence[];
+    assert.equal(entries.length, 2);
+    assert.equal(entries[0].kind, "bash");
+    assert.equal(entries[0].command, "Get-ChildItem");
+    assert.equal(entries[1].kind, "bash");
+    assert.equal(entries[1].command, "npm run build");
+  });
 });

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

@@ -98,6 +98,7 @@ test("bootstrap aborts before starting next milestone when completed orphan merg
       {
         shouldUseWorktreeIsolation: () => true,
         registerSigtermHandler: () => {},
+        registerAutoWorkerForSession: () => {},
         lockBase: () => base,
         buildLifecycle: () => ({
           adoptSessionRoot: (sessionBase: string, originalBase?: string) => {

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

@@ -0,0 +1,20 @@
+// Project/App: GSD-2
+// File Purpose: Regression tests for auto-mode stop notification formatting.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { formatAutoStopNotification } from "../auto.ts";
+
+test("auto stop notification keeps session totals on a separate line", () => {
+  const message = formatAutoStopNotification(
+    "Auto-mode stopped",
+    { cost: 0.652, tokens: { total: 87000 } },
+    2,
+  );
+
+  assert.equal(
+    message,
+    "Auto-mode stopped.\nSession: $0.652 · 87.0k tokens · 2 units",
+  );
+});

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

@@ -13,8 +13,10 @@ import {
   heartbeatAutoWorker,
   markWorkerCrashed,
   markWorkerStopping,
+  markWorkerStoppingByPid,
   getActiveAutoWorkers,
   getAutoWorker,
+  findStaleWorkerForProject,
 } from "../db/auto-workers.ts";
 
 function makeBase(): string {
@@ -71,6 +73,18 @@ test("markWorkerStopping flips status to stopping", (t) => {
   assert.equal(row.status, "stopping");
 });
 
+test("markWorkerStoppingByPid flips matching active row to stopping", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  const id = registerAutoWorker({ projectRootRealpath: base });
+  const pid = getAutoWorker(id)!.pid;
+  markWorkerStoppingByPid(base, pid);
+  const row = getAutoWorker(id)!;
+  assert.equal(row.status, "stopping");
+});
+
 test("markWorkerCrashed flips status to crashed", (t) => {
   const base = makeBase();
   t.after(() => cleanup(base));
@@ -103,3 +117,18 @@ test("getActiveAutoWorkers filters by status and TTL", (t) => {
   assert.equal(after.length, 1);
   assert.equal(after[0].worker_id, b);
 });
+
+test("findStaleWorkerForProject returns dead PID immediately even before heartbeat TTL", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+
+  const id = registerAutoWorker({ projectRootRealpath: base });
+  _getAdapter()!.prepare(
+    `UPDATE workers SET pid = -1 WHERE worker_id = :worker_id`,
+  ).run({ ":worker_id": id });
+
+  const stale = findStaleWorkerForProject(base);
+  assert.ok(stale, "dead pid should be detected as stale immediately");
+  assert.equal(stale!.worker_id, id);
+});

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/autocomplete-regressions-1675.test.ts

@@ -120,3 +120,24 @@ test("bare /gsd skip shows usage and does not fall through to unknown-command wa
   );
 });
 
+test("direct loop verbs do not fall through to unknown-command warning", async () => {
+  const loopVerbs = [
+    "research-milestone",
+    "research-slice",
+    "plan-milestone",
+    "plan-slice",
+    "execute-task",
+    "complete-slice",
+    "validate-milestone",
+    "complete-milestone",
+  ];
+
+  for (const verb of loopVerbs) {
+    const ctx = createMockCtx();
+    await handleGSDCommand(verb, ctx as any, {} as any);
+    assert.ok(
+      !ctx.notifications.some((n) => n.message.startsWith(`Unknown: /gsd ${verb}`)),
+      `${verb} should be recognized as a valid /gsd command alias`,
+    );
+  }
+});