@opengsd/gsd-pi 1.3.0 → 1.4.0

package/src/resources/extensions/gsd/tests/workflow-tool-executors.test.ts

@@ -12,6 +12,7 @@ import {
   getArtifact,
   getAssessment,
   insertAssessment,
+  insertMilestone,
   upsertRequirement,
   getAllMilestones,
 } from "../gsd-db.ts";
@@ -153,9 +154,9 @@ test("executeSummarySave persists artifact and returns computed path", async ()
     }, base));
 
     assert.equal(result.details.operation, "save_summary");
-    assert.equal(result.details.path, "milestones/M001/slices/S01/S01-SUMMARY.md");
+    assert.equal(result.details.path, "phases/01-m001/01-01-SUMMARY.md");
 
-    const filePath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-SUMMARY.md");
+    const filePath = join(base, ".gsd", "phases", "01-m001", "01-01-SUMMARY.md");
     assert.ok(existsSync(filePath), "summary artifact should be written to disk");
     assert.match(readFileSync(filePath, "utf-8"), /# Summary/);
   } finally {
@@ -180,7 +181,7 @@ test("executeSummarySave mirrors milestone artifacts into the active worktree pr
     }, worktree));
 
     assert.equal(result.details.operation, "save_summary");
-    const relPath = "milestones/M001/slices/S02/S02-RESEARCH.md";
+    const relPath = "phases/01-m001/01-02-RESEARCH.md";
     const projectPath = join(base, ".gsd", relPath);
     const worktreePath = join(worktree, ".gsd", relPath);
     assert.equal(existsSync(projectPath), true, "canonical artifact should be written");
@@ -780,22 +781,23 @@ test("executePlanSlice writes task planning state and rendered plan artifacts",
   }
 });
 
-test("executePlanSlice marks validation failures with isError", async () => {
+test("executePlanSlice accepts metadata-only incremental planning payloads", async () => {
   const base = makeTmpBase();
   try {
     openTestDb(base);
+    await inProjectDir(base, () => executePlanMilestone(validMilestonePlan(), base));
 
     const result = await inProjectDir(base, () => executePlanSlice({
       milestoneId: "M001",
       sliceId: "S01",
-      goal: "Trigger validation failure for empty tasks.",
+      goal: "Persist slice metadata before tasks.",
       tasks: [],
     }, base));
 
-    assert.equal(result.isError, true);
     assert.equal(result.details.operation, "plan_slice");
-    assert.match(String(result.details.error), /validation failed: tasks must be a non-empty array/);
-    assert.match(result.content[0].text, /Error planning slice:/);
+    assert.equal(result.details.sliceId, "S01");
+    assert.equal(result.isError, undefined);
+    assert.match(result.content[0].text, /Planned slice S01/);
   } finally {
     closeDatabase();
     cleanup(base);
@@ -889,7 +891,7 @@ test("executeUatResultSave accepts gsd_uat_exec evidence written in a milestone
     assert.equal(attempt.browserToolsPresented, false);
     assert.deepEqual(attempt.modePolicy?.requiredAnyModes, ["runtime"]);
     const assessment = readFileSync(
-      join(base, ".gsd", "milestones", "M001", "slices", "S02", "S02-ASSESSMENT.md"),
+      join(base, ".gsd", "phases", "01-m001", "01-02-ASSESSMENT.md"),
       "utf-8",
     );
     assert.match(assessment, /runId: uat:M001:S02:attempt-1/);
@@ -897,7 +899,7 @@ test("executeUatResultSave accepts gsd_uat_exec evidence written in a milestone
     assert.match(assessment, /Runtime path C:\\\\tmp\\\|uat evidence/);
     assert.match(assessment, /backslash \\\\ and pipe \\\|/);
 
-    const artifactPath = "milestones/M001/slices/S02/S02-ASSESSMENT.md";
+    const artifactPath = "phases/01-m001/01-02-ASSESSMENT.md";
     const assessmentPath = `.gsd/${artifactPath}`;
     assert.equal(getArtifact(artifactPath)?.artifact_type, "ASSESSMENT");
     assert.equal(getAssessment(assessmentPath)?.scope, "run-uat");
@@ -1158,7 +1160,7 @@ test("executeUatResultSave surfaces the worktree validation path for NEEDS-HUMAN
     assert.ok(returnedText.includes(worktree), "tool return should include the worktree path");
 
     const assessment = readFileSync(
-      join(base, ".gsd", "milestones", "M001", "slices", "S07", "S07-ASSESSMENT.md"),
+      join(base, ".gsd", "phases", "01-m001", "01-07-ASSESSMENT.md"),
       "utf-8",
     );
     assert.match(assessment, /## Manual Validation/);
@@ -1217,7 +1219,7 @@ test("executeUatResultSave omits manual-validation guidance when no human checks
     assert.equal(returnedText.includes("Manual validation needed"), false);
 
     const assessment = readFileSync(
-      join(base, ".gsd", "milestones", "M001", "slices", "S08", "S08-ASSESSMENT.md"),
+      join(base, ".gsd", "phases", "01-m001", "01-08-ASSESSMENT.md"),
       "utf-8",
     );
     assert.equal(assessment.includes("## Manual Validation"), false);
@@ -1746,7 +1748,8 @@ test("executeSaveGateResult validates inputs and persists verdicts", async () =>
     assert.equal(row?.status, "complete");
     assert.equal(row?.verdict, "pass");
     assert.equal(row?.rationale, "Looks good.");
-    const planPath = join(base, ".gsd", "milestones", "M005", "slices", "S05", "S05-PLAN.md");
+    // Flat-phase: M005 title "Milestone Five" → phases/05-milestone-five/05-05-PLAN.md
+    const planPath = join(base, ".gsd", "phases", "05-milestone-five", "05-05-PLAN.md");
     assert.match(readFileSync(planPath, "utf-8"), /No issues found\./);
   } finally {
     closeDatabase();
@@ -2047,6 +2050,60 @@ test("executeSummarySave registers PROJECT milestone sequence for the next run",
   }
 });
 
+test("executeSummarySave reconciles bare PROJECT milestone IDs onto existing unique-ID rows (no phantom row) (#807)", async () => {
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+
+    // Planner already minted a unique-ID milestone for sequence 1.
+    insertMilestone({ id: "M001-b1nole", title: "Foundation", status: "active" });
+
+    // A faithfully-authored PROJECT.md uses the template's bare sequence IDs.
+    const result = await inProjectDir(base, () => executeSummarySave({
+      artifact_type: "PROJECT",
+      content: [
+        "# Project",
+        "",
+        "## What This Is",
+        "",
+        "Deep project setup output.",
+        "",
+        "## Project Shape",
+        "",
+        "**Complexity:** complex",
+        "**Why:** It spans multiple delivery steps.",
+        "",
+        "## Capability Contract",
+        "",
+        "See .gsd/REQUIREMENTS.md.",
+        "",
+        "## Milestone Sequence",
+        "",
+        "- [ ] M001: Foundation - Establish the first runnable slice.",
+        "- [ ] M002: Polish - Follow-up experience work.",
+        "",
+      ].join("\n"),
+    }, base));
+
+    assert.equal(result.isError, undefined);
+    // Bare M001 maps onto the planner's canonical row; M002 is genuinely new.
+    assert.deepEqual(result.details.registeredMilestones, ["M001-b1nole", "M002"]);
+
+    const milestones = getAllMilestones();
+    // No phantom bare "M001" row — the unique-ID row is preserved and not demoted.
+    assert.deepEqual(
+      milestones.map((m) => [m.id, m.title, m.status]).sort(),
+      [
+        ["M001-b1nole", "Foundation", "active"],
+        ["M002", "Polish", "queued"],
+      ].sort(),
+    );
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
 test("executeSummarySave hard-fails when milestone registration throws so silent No-Active-Milestone is impossible", async () => {
   const base = makeTmpBase();
   try {

package/src/resources/extensions/gsd/tests/workspace-git-preflight.test.ts

@@ -3,9 +3,10 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdirSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { delimiter, join } from "node:path";
 
+import { GIT_NO_PROMPT_ENV } from "../git-constants.js";
 import { probeGitConflictState } from "../git-conflict-state.js";
 import { ensureWorkspaceGitReadyForPath } from "../workspace-git-preflight.js";
 import { isWorkspaceGitAllowedCommand } from "../workspace-git-guard.js";
@@ -50,6 +51,38 @@ function seedProductConflict(base: string): void {
   }
 }
 
+function installCountingGitShim(binDir: string, logPath: string): void {
+  const posixShim = join(binDir, "git");
+  writeFileSync(
+    posixShim,
+    [
+      "#!/bin/sh",
+      'printf "%s\\n" "$*" >> "$GSD_GIT_LOG"',
+      'PATH="$GSD_REAL_PATH"',
+      "export PATH",
+      'exec git "$@"',
+      "",
+    ].join("\n"),
+  );
+  chmodSync(posixShim, 0o755);
+
+  writeFileSync(
+    join(binDir, "git.cmd"),
+    [
+      "@echo off",
+      'echo %*>>"%GSD_GIT_LOG%"',
+      'set "PATH=%GSD_REAL_PATH%"',
+      "git %*",
+      "",
+    ].join("\r\n"),
+  );
+}
+
+function countGitShimInvocations(logPath: string): number {
+  if (!existsSync(logPath)) return 0;
+  return readFileSync(logPath, "utf-8").split(/\r?\n/).filter(Boolean).length;
+}
+
 test("probeGitConflictState reports clean repo", () => {
   const base = makeTempRepo("gsd-ws-git-clean-");
   try {
@@ -60,6 +93,122 @@ test("probeGitConflictState reports clean repo", () => {
   }
 });
 
+test("ensureWorkspaceGitReadyForPath caches clean target probes briefly", async () => {
+  const base = makeTempRepo("gsd-ws-git-clean-cache-");
+  const binDir = makeTempDir("gsd-ws-git-shim-");
+  const logPath = join(binDir, "git.log");
+  const originalProcessPath = process.env.PATH;
+  const originalEnvPath = GIT_NO_PROMPT_ENV.PATH;
+  const originalEnvGitLog = GIT_NO_PROMPT_ENV.GSD_GIT_LOG;
+  const originalEnvRealPath = GIT_NO_PROMPT_ENV.GSD_REAL_PATH;
+
+  try {
+    installCountingGitShim(binDir, logPath);
+    const shimmedPath = `${binDir}${delimiter}${originalProcessPath ?? ""}`;
+    process.env.PATH = shimmedPath;
+    GIT_NO_PROMPT_ENV.PATH = shimmedPath;
+    GIT_NO_PROMPT_ENV.GSD_GIT_LOG = logPath;
+    GIT_NO_PROMPT_ENV.GSD_REAL_PATH = originalProcessPath ?? "";
+
+    const first = await ensureWorkspaceGitReadyForPath(base);
+    assert.equal(first.ok, true);
+    const firstCount = countGitShimInvocations(logPath);
+    assert.equal(firstCount, 3, "first clean probe should run the existing conflict checks");
+
+    const second = await ensureWorkspaceGitReadyForPath(base);
+    assert.equal(second.ok, true);
+    assert.equal(
+      countGitShimInvocations(logPath),
+      firstCount,
+      "second clean probe within the cache window must not spawn git again",
+    );
+  } finally {
+    if (originalProcessPath === undefined) delete process.env.PATH;
+    else process.env.PATH = originalProcessPath;
+    if (originalEnvPath === undefined) delete GIT_NO_PROMPT_ENV.PATH;
+    else GIT_NO_PROMPT_ENV.PATH = originalEnvPath;
+    if (originalEnvGitLog === undefined) delete GIT_NO_PROMPT_ENV.GSD_GIT_LOG;
+    else GIT_NO_PROMPT_ENV.GSD_GIT_LOG = originalEnvGitLog;
+    if (originalEnvRealPath === undefined) delete GIT_NO_PROMPT_ENV.GSD_REAL_PATH;
+    else GIT_NO_PROMPT_ENV.GSD_REAL_PATH = originalEnvRealPath;
+    cleanup(binDir);
+    cleanup(base);
+  }
+});
+
+test("ensureWorkspaceGitReadyForPath detects merge state that appears after a clean probe", async () => {
+  const base = makeTempRepo("gsd-ws-git-cache-stale-");
+  const binDir = makeTempDir("gsd-ws-git-shim2-");
+  const logPath = join(binDir, "git2.log");
+  const originalProcessPath = process.env.PATH;
+  const originalEnvPath = GIT_NO_PROMPT_ENV.PATH;
+  const originalEnvGitLog = GIT_NO_PROMPT_ENV.GSD_GIT_LOG;
+  const originalEnvRealPath = GIT_NO_PROMPT_ENV.GSD_REAL_PATH;
+
+  try {
+    installCountingGitShim(binDir, logPath);
+    const shimmedPath = `${binDir}${delimiter}${originalProcessPath ?? ""}`;
+    process.env.PATH = shimmedPath;
+    GIT_NO_PROMPT_ENV.PATH = shimmedPath;
+    GIT_NO_PROMPT_ENV.GSD_GIT_LOG = logPath;
+    GIT_NO_PROMPT_ENV.GSD_REAL_PATH = originalProcessPath ?? "";
+
+    // First call — repo is clean, cache is populated.
+    const first = await ensureWorkspaceGitReadyForPath(base);
+    assert.equal(first.ok, true);
+    const afterFirstCount = countGitShimInvocations(logPath);
+    assert.ok(afterFirstCount > 0, "first probe must have called git");
+
+    // Introduce MERGE_HEAD to simulate merge state appearing mid-TTL window.
+    writeFileSync(join(base, ".git", "MERGE_HEAD"), "0000000000000000000000000000000000000000\n");
+
+    // Second call — cache should be bypassed because merge state markers are present.
+    await ensureWorkspaceGitReadyForPath(base);
+    const afterSecondCount = countGitShimInvocations(logPath);
+    assert.ok(
+      afterSecondCount > afterFirstCount,
+      "cache must be invalidated when merge state appears, causing a fresh git probe",
+    );
+  } finally {
+    if (originalProcessPath === undefined) delete process.env.PATH;
+    else process.env.PATH = originalProcessPath;
+    if (originalEnvPath === undefined) delete GIT_NO_PROMPT_ENV.PATH;
+    else GIT_NO_PROMPT_ENV.PATH = originalEnvPath;
+    if (originalEnvGitLog === undefined) delete GIT_NO_PROMPT_ENV.GSD_GIT_LOG;
+    else GIT_NO_PROMPT_ENV.GSD_GIT_LOG = originalEnvGitLog;
+    if (originalEnvRealPath === undefined) delete GIT_NO_PROMPT_ENV.GSD_REAL_PATH;
+    else GIT_NO_PROMPT_ENV.GSD_REAL_PATH = originalEnvRealPath;
+    cleanup(binDir);
+    cleanup(base);
+  }
+});
+
+test("ensureWorkspaceGitReadyForPath detects conflicts after a non-git folder becomes a repo", async () => {
+  const base = makeTempDir("gsd-ws-git-non-repo-cache-");
+  try {
+    const first = await ensureWorkspaceGitReadyForPath(base);
+    assert.equal(first.ok, true);
+
+    git(base, "init");
+    git(base, "config", "user.email", "test@test.com");
+    git(base, "config", "user.name", "Test");
+    git(base, "config", "core.autocrlf", "false");
+    writeFileSync(join(base, "README.md"), "# init\n");
+    git(base, "add", "-A");
+    git(base, "commit", "-m", "init");
+    git(base, "branch", "-M", "main");
+    seedProductConflict(base);
+
+    const second = await ensureWorkspaceGitReadyForPath(base);
+    assert.equal(second.ok, false);
+    if (second.ok) return;
+    assert.equal(second.severity, "product-conflicts");
+    assert.ok(second.conflictedPaths.includes("app.ts"));
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("ensureWorkspaceGitReadyForPath allows fresh non-git project setup folders", async () => {
   const base = makeTempDir("gsd-ws-git-non-repo-");
   try {

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

@@ -5,13 +5,14 @@
  * that getWorktreeHealth and formatWorktreeStatusLine return correct results.
  */
 
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, realpathSync } from "node:fs";
-import { join } from "node:path";
+import { chmodSync, mkdtempSync, mkdirSync, readFileSync, writeFileSync, rmSync, realpathSync } from "node:fs";
+import { delimiter, join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 
-import { getWorktreeHealth, formatWorktreeStatusLine } from "../worktree-health.ts";
+import { getAllWorktreeHealth, getWorktreeHealth, formatWorktreeStatusLine } from "../worktree-health.ts";
 import { listWorktrees } from "../worktree-manager.ts";
+import { GIT_NO_PROMPT_ENV } from "../git-constants.ts";
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
 
@@ -173,6 +174,45 @@ describe('worktree-health', async () => {
       assert.ok(line.includes("last commit"), "shows last commit age for active worktree");
     }
 
+    // ─── Test: batch health detects main branch once ───────────────────
+    console.log("\n=== worktree health: batch main branch detection ===");
+    {
+      const dir = createBaseRepo();
+      cleanups.push(dir);
+
+      mkdirSync(join(dir, ".gsd", "worktrees"), { recursive: true });
+      run("git worktree add -b worktree/batch-a .gsd/worktrees/batch-a", dir);
+      run("git worktree add -b worktree/batch-b .gsd/worktrees/batch-b", dir);
+
+      const bin = mkdtempSync(join(tmpdir(), "wt-health-git-shim-"));
+      cleanups.push(bin);
+      const logPath = join(bin, "git.log");
+      const realGit = execSync("command -v git", { encoding: "utf-8" }).trim();
+      const shim = join(bin, "git");
+      writeFileSync(shim, `#!/bin/sh\nprintf '%s\\n' "$*" >> ${JSON.stringify(logPath)}\nexec ${JSON.stringify(realGit)} "$@"\n`, "utf-8");
+      chmodSync(shim, 0o755);
+
+      const originalPath = process.env.PATH ?? "";
+      const originalGitEnvPath = GIT_NO_PROMPT_ENV.PATH;
+      try {
+        process.env.PATH = `${bin}${delimiter}${originalPath}`;
+        GIT_NO_PROMPT_ENV.PATH = process.env.PATH;
+
+        const health = getAllWorktreeHealth(dir);
+        assert.equal(health.length, 2, "both worktrees have health entries");
+      } finally {
+        process.env.PATH = originalPath;
+        GIT_NO_PROMPT_ENV.PATH = originalGitEnvPath;
+      }
+
+      const invocations = readFileSync(logPath, "utf-8")
+        .trim()
+        .split("\n")
+        .filter(Boolean);
+      const mainBranchDetections = invocations.filter(line => line === "symbolic-ref refs/remotes/origin/HEAD");
+      assert.equal(mainBranchDetections.length, 1, "batch health detects main branch once");
+    }
+
   } finally {
     for (const dir of cleanups) {
       try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }

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

@@ -10,8 +10,10 @@ import {
   listWorktrees,
   removeWorktree,
   diffWorktreeGSD,
+  diffWorktreeNumstat,
   getWorktreeGSDDiff,
   getWorktreeLog,
+  mergeWorktreeToMain,
   worktreeBranchName,
   worktreePath,
   pruneEphemeralGhostWorktreeDirectories,
@@ -291,6 +293,31 @@ describe("diffWorktreeGSD and getWorktreeGSDDiff", () => {
   });
 });
 
+describe("worktree diff target branch override", () => {
+  let base: string;
+  beforeEach(() => {
+    const repo = makeRepoWithChanges("feature-x");
+    base = repo.base;
+
+    run("git checkout -b integration main", base);
+    writeFileSync(join(base, "TARGET_ONLY.md"), "target branch only\n", "utf-8");
+    run("git add TARGET_ONLY.md", base);
+    run('git commit -m "chore: target branch only"', base);
+    run("git checkout main", base);
+  });
+  afterEach(() => { rmSync(base, { recursive: true, force: true }); });
+
+  test("uses supplied main branch for merge preview helper overrides", () => {
+    const defaultStats = diffWorktreeNumstat(base, "feature-x", undefined, "main");
+    const overrideStats = diffWorktreeNumstat(base, "feature-x", undefined, "integration");
+    const selfLog = getWorktreeLog(base, "feature-x", worktreeBranchName("feature-x"));
+
+    assert.ok(!defaultStats.some(s => s.file === "TARGET_ONLY.md"), "default main stats should not include target-only file");
+    assert.ok(overrideStats.some(s => s.file === "TARGET_ONLY.md"), "override stats should use the supplied target branch");
+    assert.strictEqual(selfLog, "", "override log should use the supplied branch");
+  });
+});
+
 // ─── getWorktreeLog ───────────────────────────────────────────────────────────
 
 describe("getWorktreeLog", () => {
@@ -307,6 +334,44 @@ describe("getWorktreeLog", () => {
   });
 });
 
+// ─── mergeWorktreeToMain ─────────────────────────────────────────────────────
+
+describe("mergeWorktreeToMain", () => {
+  let base: string;
+  let wtPath: string;
+
+  beforeEach(() => {
+    base = makeBaseRepo();
+    wtPath = worktreePath(base, "M900");
+    mkdirSync(join(base, ".gsd-worktrees"), { recursive: true });
+    run(`git worktree add -b milestone/M900 "${wtPath}"`, base);
+  });
+
+  afterEach(() => { rmSync(base, { recursive: true, force: true }); });
+
+  test("cleans failed milestone squash state and deletes orphan branch", () => {
+    writeFileSync(join(wtPath, "README.md"), "# Milestone change\n", "utf-8");
+    run("git add README.md", wtPath);
+    run('git commit -m "feat: milestone change"', wtPath);
+
+    writeFileSync(join(base, "README.md"), "# Main change\n", "utf-8");
+    run("git add README.md", base);
+    run('git commit -m "feat: main change"', base);
+
+    assert.throws(
+      () => mergeWorktreeToMain(base, "M900", "feat: merge M900", "milestone/M900"),
+      /Merge conflicts detected/,
+    );
+
+    assert.equal(run("git status --porcelain", base), "", "failed squash cleanup should leave main clean");
+    assert.ok(!existsSync(wtPath), "failed milestone worktree should be removed");
+    assert.ok(
+      !run("git branch", base).includes("milestone/M900"),
+      "failed milestone branch should be deleted after worktree removal",
+    );
+  });
+});
+
 // ─── removeWorktree ───────────────────────────────────────────────────────────
 
 describe("removeWorktree", () => {

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

@@ -307,22 +307,26 @@ describe("Worktree Safety module", () => {
     assert.equal(result.kind, "worktree-unregistered");
   });
 
-  test("attempts prune recovery once for unregistered worktrees and tracks failed roots", () => {
+  test("removes an orphaned worktree directory when prune cannot recover it", () => {
     let pruneCalls = 0;
-    let listCalls = 0;
+    let removeCalls = 0;
+    let removedUnitRoot: string | undefined;
+    let removedMilestoneId: string | undefined;
     const safety = createWorktreeSafetyModule({
       existsSync: () => true,
       lstatSync: () => ({ isFile: () => true }),
       pruneRegisteredWorktrees: () => {
         pruneCalls += 1;
       },
-      listRegisteredWorktrees: () => {
-        listCalls += 1;
-        return [];
+      listRegisteredWorktrees: () => [],
+      removeStaleWorktreeDirectory: (root, milestoneId) => {
+        removeCalls += 1;
+        removedUnitRoot = root;
+        removedMilestoneId = milestoneId;
       },
     });
 
-    const first = safety.validateUnitRoot({
+    const result = safety.validateUnitRoot({
       unitType: "execute-task",
       unitId: "M001/S01/T01",
       writeScope: "source-writing",
@@ -330,14 +334,32 @@ describe("Worktree Safety module", () => {
       unitRoot,
       milestoneId: "M001",
     });
-    assert.equal(first.ok, false);
-    assert.equal(first.kind, "worktree-unregistered");
-    assert.equal(first.details?.attemptedPrune, true);
-    assert.equal(first.details?.trackedAsFailed, true);
+
+    // Orphaned directory is cleaned up and the failure degrades to the
+    // recoverable worktree-missing kind so the next dispatch can recreate it,
+    // instead of looping forever on worktree-unregistered (#803).
+    assert.equal(result.ok, false);
+    assert.equal(result.kind, "worktree-missing");
+    assert.equal(result.details?.removedStaleDirectory, true);
+    assert.equal(result.details?.attemptedPrune, true);
     assert.equal(pruneCalls, 1);
-    assert.equal(listCalls, 2);
+    assert.equal(removeCalls, 1);
+    assert.equal(removedUnitRoot, unitRoot);
+    assert.equal(removedMilestoneId, "M001");
+  });
 
-    const second = safety.validateUnitRoot({
+  test("keeps worktree-unregistered when the orphaned directory cannot be removed", () => {
+    const safety = createWorktreeSafetyModule({
+      existsSync: () => true,
+      lstatSync: () => ({ isFile: () => true }),
+      pruneRegisteredWorktrees: () => {},
+      listRegisteredWorktrees: () => [],
+      removeStaleWorktreeDirectory: () => {
+        throw new Error("directory may be locked by another process");
+      },
+    });
+
+    const result = safety.validateUnitRoot({
       unitType: "execute-task",
       unitId: "M001/S01/T01",
       writeScope: "source-writing",
@@ -345,12 +367,11 @@ describe("Worktree Safety module", () => {
       unitRoot,
       milestoneId: "M001",
     });
-    assert.equal(second.ok, false);
-    assert.equal(second.kind, "worktree-unregistered");
-    assert.equal(second.details?.attemptedPrune, false);
-    assert.equal(second.details?.trackedAsFailed, true);
-    assert.equal(pruneCalls, 1);
-    assert.equal(listCalls, 3);
+
+    assert.equal(result.ok, false);
+    assert.equal(result.kind, "worktree-unregistered");
+    assert.equal(result.details?.removedStaleDirectory, false);
+    assert.match(String(result.details?.error), /locked by another process/);
   });
 
   test("converts registered worktree list failures into typed failures", () => {

package/src/resources/extensions/gsd/tests/write-gate-planning-unit.test.ts

@@ -431,7 +431,10 @@ test('auto-unit scope: execute-task blocks slice and milestone lifecycle aliases
   assert.match(reopen.reason!, /gsd_milestone_reopen/);
 });
 
-test('auto-unit scope: complete-slice blocks milestone validation and native Workflow', () => {
+test('auto-unit scope: complete-slice allows milestone status but blocks milestone validation and native Workflow', () => {
+  const status = shouldBlockPlanningUnit('gsd_milestone_status', '', BASE, 'complete-slice', ALL);
+  assert.strictEqual(status.block, false);
+
   const closeSlice = shouldBlockPlanningUnit('gsd_slice_complete', '', BASE, 'complete-slice', ALL);
   assert.strictEqual(closeSlice.block, false);