gsd-pi 2.41.0-dev.9446b20 → 2.41.0-dev.97349b1

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

@@ -1,4 +1,6 @@
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync, readFileSync } from "node:fs";
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
@@ -13,82 +15,42 @@ import {
   worktreeBranchName,
   worktreePath,
 } from "../worktree-manager.ts";
-import { createTestContext } from './test-helpers.ts';
 
-const { assertEq, assertTrue, report } = createTestContext();
 function run(command: string, cwd: string): string {
   return execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
 }
 
-// Set up a test repo
-const base = mkdtempSync(join(tmpdir(), "gsd-worktree-mgr-test-"));
-run("git init -b main", base);
-run('git config user.name "Pi Test"', base);
-run('git config user.email "pi@example.com"', base);
-
-// Create initial project structure
-mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
-writeFileSync(join(base, "README.md"), "# Test Project\n", "utf-8");
-writeFileSync(
-  join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
-  "# M001: Demo\n\n## Slices\n- [ ] **S01: First** `risk:low` `depends:[]`\n  > After this: it works\n",
-  "utf-8",
-);
-run("git add .", base);
-run('git commit -m "chore: init"', base);
-
-async function main(): Promise<void> {
-  console.log("\n=== worktreeBranchName ===");
-  assertEq(worktreeBranchName("feature-x"), "worktree/feature-x", "branch name format");
-
-  console.log("\n=== createWorktree ===");
-  const info = createWorktree(base, "feature-x");
-  assertTrue(info.name === "feature-x", "name matches");
-  assertTrue(info.branch === "worktree/feature-x", "branch matches");
-  assertTrue(info.exists, "worktree exists");
-  assertTrue(existsSync(info.path), "worktree path exists on disk");
-  assertTrue(existsSync(join(info.path, "README.md")), "README.md copied to worktree");
-  assertTrue(existsSync(join(info.path, ".gsd", "milestones", "M001", "M001-ROADMAP.md")), ".gsd files copied");
-
-  // Branch was created
-  const branches = run("git branch", base);
-  assertTrue(branches.includes("worktree/feature-x"), "branch was created");
-
-  console.log("\n=== createWorktree — duplicate ===");
-  let duplicateError = "";
-  try {
-    createWorktree(base, "feature-x");
-  } catch (e) {
-    duplicateError = (e as Error).message;
-  }
-  assertTrue(duplicateError.includes("already exists"), "duplicate creation fails");
+function makeBaseRepo(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-wt-test-"));
+  run("git init -b main", base);
+  run('git config user.name "Test User"', base);
+  run('git config user.email "test@example.com"', base);
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  writeFileSync(join(base, "README.md"), "# Test Project\n", "utf-8");
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+    "# M001: Demo\n\n## Slices\n- [ ] **S01: First** `risk:low` `depends:[]`\n  > After this: it works\n",
+    "utf-8",
+  );
+  run("git add .", base);
+  run('git commit -m "chore: init"', base);
+  return base;
+}
 
-  console.log("\n=== createWorktree — invalid name ===");
-  let invalidError = "";
-  try {
-    createWorktree(base, "bad name!");
-  } catch (e) {
-    invalidError = (e as Error).message;
-  }
-  assertTrue(invalidError.includes("Invalid worktree name"), "invalid name rejected");
-
-  console.log("\n=== listWorktrees ===");
-  const list = listWorktrees(base);
-  assertEq(list.length, 1, "one worktree listed");
-  assertEq(list[0]!.name, "feature-x", "correct name");
-  assertEq(list[0]!.branch, "worktree/feature-x", "correct branch");
-  assertTrue(list[0]!.exists, "exists flag is true");
-
-  console.log("\n=== make changes in worktree ===");
-  const wtPath = worktreePath(base, "feature-x");
-  // Add a new GSD artifact in the worktree
+function makeRepoWithWorktree(worktreeName: string): { base: string; wtPath: string } {
+  const base = makeBaseRepo();
+  createWorktree(base, worktreeName);
+  return { base, wtPath: worktreePath(base, worktreeName) };
+}
+
+function makeRepoWithChanges(worktreeName: string): { base: string; wtPath: string } {
+  const { base, wtPath } = makeRepoWithWorktree(worktreeName);
   mkdirSync(join(wtPath, ".gsd", "milestones", "M002"), { recursive: true });
   writeFileSync(
     join(wtPath, ".gsd", "milestones", "M002", "M002-ROADMAP.md"),
     "# M002: New Feature\n\n## Slices\n- [ ] **S01: Setup** `risk:low` `depends:[]`\n  > After this: new feature ready\n",
     "utf-8",
   );
-  // Modify an existing artifact
   writeFileSync(
     join(wtPath, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
     "# M001: Demo (updated)\n\n## Slices\n- [x] **S01: First** `risk:low` `depends:[]`\n  > Done\n",
@@ -96,46 +58,174 @@ async function main(): Promise<void> {
   );
   run("git add .", wtPath);
   run('git commit -m "feat: add M002 and update M001"', wtPath);
-
-  console.log("\n=== diffWorktreeGSD ===");
-  const diff = diffWorktreeGSD(base, "feature-x");
-  assertTrue(diff.added.length > 0, "has added files");
-  assertTrue(diff.added.some(f => f.includes("M002")), "M002 roadmap is in added");
-  assertTrue(diff.modified.length > 0, "has modified files");
-  assertTrue(diff.modified.some(f => f.includes("M001")), "M001 roadmap is in modified");
-  assertEq(diff.removed.length, 0, "no removed files");
-
-  console.log("\n=== getWorktreeGSDDiff ===");
-  const fullDiff = getWorktreeGSDDiff(base, "feature-x");
-  assertTrue(fullDiff.includes("M002"), "full diff mentions M002");
-  assertTrue(fullDiff.includes("updated"), "full diff mentions update");
-
-  console.log("\n=== getWorktreeLog ===");
-  const log = getWorktreeLog(base, "feature-x");
-  assertTrue(log.includes("add M002"), "log shows commit message");
-
-  console.log("\n=== removeWorktree ===");
-  removeWorktree(base, "feature-x", { deleteBranch: true });
-  assertTrue(!existsSync(wtPath), "worktree directory removed");
-  const branchesAfter = run("git branch", base);
-  assertTrue(!branchesAfter.includes("worktree/feature-x"), "branch deleted");
-
-  console.log("\n=== listWorktrees after removal ===");
-  const listAfter = listWorktrees(base);
-  assertEq(listAfter.length, 0, "no worktrees after removal");
-
-  console.log("\n=== removeWorktree — already gone ===");
-  // Should not throw
-  removeWorktree(base, "feature-x", { deleteBranch: true });
-  assertTrue(true, "removeWorktree on missing worktree does not throw");
-
-  // Cleanup
-  rmSync(base, { recursive: true, force: true });
-
-  report();
+  return { base, wtPath };
 }
 
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
+// ─── worktreeBranchName ───────────────────────────────────────────────────────
+
+test("worktreeBranchName formats branch name", () => {
+  assert.strictEqual(
+    worktreeBranchName("feature-x"),
+    "worktree/feature-x",
+    "should prefix with worktree/",
+  );
+});
+
+// ─── createWorktree ───────────────────────────────────────────────────────────
+
+test("createWorktree creates worktree with correct metadata", () => {
+  const base = makeBaseRepo();
+  try {
+    const info = createWorktree(base, "feature-x");
+    assert.strictEqual(info.name, "feature-x", "name should match");
+    assert.strictEqual(info.branch, "worktree/feature-x", "branch should be prefixed");
+    assert.ok(info.exists, "exists flag should be true");
+    assert.ok(existsSync(info.path), "worktree path should exist on disk");
+    assert.ok(existsSync(join(info.path, "README.md")), "README.md should be in worktree");
+    assert.ok(
+      existsSync(join(info.path, ".gsd", "milestones", "M001", "M001-ROADMAP.md")),
+      ".gsd files should be in worktree",
+    );
+    const branches = run("git branch", base);
+    assert.ok(branches.includes("worktree/feature-x"), "branch should be created in base repo");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("createWorktree rejects duplicate name", () => {
+  const { base } = makeRepoWithWorktree("feature-x");
+  try {
+    assert.throws(
+      () => createWorktree(base, "feature-x"),
+      (err: Error) => {
+        assert.ok(
+          err.message.includes("already exists"),
+          `expected "already exists" in error, got: ${err.message}`,
+        );
+        return true;
+      },
+      "should throw on duplicate worktree name",
+    );
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("createWorktree rejects invalid name", () => {
+  const base = makeBaseRepo();
+  try {
+    assert.throws(
+      () => createWorktree(base, "bad name!"),
+      (err: Error) => {
+        assert.ok(
+          err.message.includes("Invalid worktree name"),
+          `expected "Invalid worktree name" in error, got: ${err.message}`,
+        );
+        return true;
+      },
+      "should throw on invalid worktree name",
+    );
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+// ─── listWorktrees ────────────────────────────────────────────────────────────
+
+test("listWorktrees returns active worktrees", () => {
+  const { base } = makeRepoWithWorktree("feature-x");
+  try {
+    const list = listWorktrees(base);
+    assert.strictEqual(list.length, 1, "should list exactly one worktree");
+    assert.strictEqual(list[0]!.name, "feature-x", "name should match");
+    assert.strictEqual(list[0]!.branch, "worktree/feature-x", "branch should match");
+    assert.ok(list[0]!.exists, "exists flag should be true");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("listWorktrees returns empty after removal", () => {
+  const { base } = makeRepoWithWorktree("feature-x");
+  try {
+    removeWorktree(base, "feature-x");
+    const list = listWorktrees(base);
+    assert.strictEqual(list.length, 0, "should have no worktrees after removal");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+// ─── diffWorktreeGSD ─────────────────────────────────────────────────────────
+
+test("diffWorktreeGSD detects added and modified GSD files", () => {
+  const { base } = makeRepoWithChanges("feature-x");
+  try {
+    const diff = diffWorktreeGSD(base, "feature-x");
+    assert.ok(diff.added.length > 0, "should have added files");
+    assert.ok(
+      diff.added.some((f) => f.includes("M002")),
+      "M002 roadmap should be in added files",
+    );
+    assert.ok(diff.modified.length > 0, "should have modified files");
+    assert.ok(
+      diff.modified.some((f) => f.includes("M001")),
+      "M001 roadmap should be in modified files",
+    );
+    assert.strictEqual(diff.removed.length, 0, "should have no removed files");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+// ─── getWorktreeGSDDiff ───────────────────────────────────────────────────────
+
+test("getWorktreeGSDDiff returns patch content", () => {
+  const { base } = makeRepoWithChanges("feature-x");
+  try {
+    const fullDiff = getWorktreeGSDDiff(base, "feature-x");
+    assert.ok(fullDiff.includes("M002"), "diff should mention M002");
+    assert.ok(fullDiff.includes("updated"), "diff should mention the update");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+// ─── getWorktreeLog ───────────────────────────────────────────────────────────
+
+test("getWorktreeLog shows commits", () => {
+  const { base } = makeRepoWithChanges("feature-x");
+  try {
+    const log = getWorktreeLog(base, "feature-x");
+    assert.ok(log.includes("add M002"), "log should include the commit message");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+// ─── removeWorktree ───────────────────────────────────────────────────────────
+
+test("removeWorktree removes directory and branch", () => {
+  const { base, wtPath } = makeRepoWithWorktree("feature-x");
+  try {
+    removeWorktree(base, "feature-x", { deleteBranch: true });
+    assert.ok(!existsSync(wtPath), "worktree directory should be gone");
+    const branches = run("git branch", base);
+    assert.ok(!branches.includes("worktree/feature-x"), "branch should be deleted");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("removeWorktree on missing worktree does not throw", () => {
+  const base = makeBaseRepo();
+  try {
+    assert.doesNotThrow(
+      () => removeWorktree(base, "nonexistent"),
+      "should not throw when worktree does not exist",
+    );
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
 });

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

@@ -52,7 +52,7 @@ function makeDeps(
         fn: "mergeMilestoneToMain",
         args: [basePath, milestoneId, roadmapContent],
       });
-      return { pushed: false };
+      return { pushed: false, codeFilesChanged: true };
     },
     syncWorktreeStateBack: (
       mainBasePath: string,
@@ -424,7 +424,7 @@ test("mergeAndExit in worktree mode shows pushed status", () => {
   const deps = makeDeps({
     isInAutoWorktree: () => true,
     getIsolationMode: () => "worktree",
-    mergeMilestoneToMain: () => ({ pushed: true }),
+    mergeMilestoneToMain: () => ({ pushed: true, codeFilesChanged: true }),
   });
   const ctx = makeNotifyCtx();
   const resolver = new WorktreeResolver(s, deps);
@@ -659,6 +659,81 @@ test("mergeAndExit in none mode is a no-op", () => {
   assert.equal(ctx.messages.length, 0);
 });
 
+// ─── #1906 — metadata-only merge warning ────────────────────────────────────
+
+test("mergeAndExit warns when merge contains no code changes (#1906)", () => {
+  const s = makeSession({
+    basePath: "/project/.gsd/worktrees/M001",
+    originalBasePath: "/project",
+  });
+  const deps = makeDeps({
+    isInAutoWorktree: () => true,
+    getIsolationMode: () => "worktree",
+    mergeMilestoneToMain: () => ({ pushed: false, codeFilesChanged: false }),
+  });
+  const ctx = makeNotifyCtx();
+  const resolver = new WorktreeResolver(s, deps);
+
+  resolver.mergeAndExit("M001", ctx);
+
+  assert.ok(
+    ctx.messages.some((m) => m.msg.includes("NO code changes") && m.level === "warning"),
+    "must emit warning when only .gsd/ metadata was merged",
+  );
+  assert.ok(
+    !ctx.messages.some((m) => m.msg.includes("merged to main") && m.level === "info"),
+    "must NOT emit success-style info notification for metadata-only merge",
+  );
+});
+
+test("mergeAndExit emits info when merge contains code changes (#1906)", () => {
+  const s = makeSession({
+    basePath: "/project/.gsd/worktrees/M001",
+    originalBasePath: "/project",
+  });
+  const deps = makeDeps({
+    isInAutoWorktree: () => true,
+    getIsolationMode: () => "worktree",
+    mergeMilestoneToMain: () => ({ pushed: false, codeFilesChanged: true }),
+  });
+  const ctx = makeNotifyCtx();
+  const resolver = new WorktreeResolver(s, deps);
+
+  resolver.mergeAndExit("M001", ctx);
+
+  assert.ok(
+    ctx.messages.some((m) => m.msg.includes("merged to main") && m.level === "info"),
+    "must emit info notification when code files were merged",
+  );
+  assert.ok(
+    !ctx.messages.some((m) => m.msg.includes("NO code changes")),
+    "must NOT emit metadata-only warning when code files were merged",
+  );
+});
+
+test("mergeAndExit branch mode warns when merge contains no code changes (#1906)", () => {
+  const s = makeSession({
+    basePath: "/project",
+    originalBasePath: "/project",
+  });
+  const deps = makeDeps({
+    isInAutoWorktree: () => false,
+    getIsolationMode: () => "branch",
+    getCurrentBranch: () => "milestone/M001",
+    autoWorktreeBranch: () => "milestone/M001",
+    mergeMilestoneToMain: () => ({ pushed: false, codeFilesChanged: false }),
+  });
+  const ctx = makeNotifyCtx();
+  const resolver = new WorktreeResolver(s, deps);
+
+  resolver.mergeAndExit("M001", ctx);
+
+  assert.ok(
+    ctx.messages.some((m) => m.msg.includes("NO code changes") && m.level === "warning"),
+    "branch mode must emit warning when only .gsd/ metadata was merged",
+  );
+});
+
 // ─── mergeAndEnterNext Tests ─────────────────────────────────────────────────
 
 test("mergeAndEnterNext calls mergeAndExit then enterMilestone", () => {
@@ -677,7 +752,7 @@ test("mergeAndEnterNext calls mergeAndExit then enterMilestone", () => {
       _roadmap: string,
     ) => {
       callOrder.push(`merge:${milestoneId}`);
-      return { pushed: false };
+      return { pushed: false, codeFilesChanged: true };
     },
     getAutoWorktreePath: () => null,
     createAutoWorktree: (basePath: string, milestoneId: string) => {

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

@@ -0,0 +1,140 @@
+/**
+ * Regression test for #1852: removeWorktree targets wrong path when .gsd/ is a symlink.
+ *
+ * When .gsd/ is a symlink to an external state directory, git registers
+ * the worktree at the resolved (real) path. But removeWorktree recomputes
+ * the path via worktreePath() which uses the unresolved symlink, causing
+ * a mismatch — the removal silently fails.
+ *
+ * Fix: removeWorktree should query `git worktree list` to find the actual
+ * registered path when the computed path doesn't match.
+ */
+import { mkdtempSync, mkdirSync, rmSync, symlinkSync, unlinkSync, writeFileSync, existsSync, realpathSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execSync } from "node:child_process";
+
+import {
+  createWorktree,
+  removeWorktree,
+  listWorktrees,
+  worktreePath,
+} from "../worktree-manager.ts";
+import { createTestContext } from './test-helpers.ts';
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+function run(command: string, cwd: string): string {
+  return execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+// Set up a test repo with .gsd/ as a symlink to an external directory,
+// mimicking the external state directory layout (~/.gsd/projects/<hash>/).
+// Resolve tmpdir to handle macOS /tmp -> /private/var/... symlink.
+const realTmp = realpathSync(tmpdir());
+const base = mkdtempSync(join(realTmp, "gsd-wt-symlink-test-"));
+const externalState = mkdtempSync(join(realTmp, "gsd-wt-symlink-ext-"));
+
+run("git init -b main", base);
+run('git config user.name "Test"', base);
+run('git config user.email "test@example.com"', base);
+
+// Create external state directory structure
+mkdirSync(join(externalState, "worktrees"), { recursive: true });
+
+// Create .gsd as a symlink to the external state directory
+symlinkSync(externalState, join(base, ".gsd"));
+
+// Verify the symlink is in place
+assertTrue(existsSync(join(base, ".gsd")), ".gsd symlink exists");
+assertTrue(
+  realpathSync(join(base, ".gsd")) === externalState,
+  ".gsd resolves to external state dir",
+);
+
+// Create initial commit so we have a valid repo
+writeFileSync(join(base, "README.md"), "# Test\n", "utf-8");
+run("git add .", base);
+run('git commit -m "init"', base);
+
+async function main(): Promise<void> {
+  console.log("\n=== #1852: removeWorktree with symlinked .gsd/ ===");
+
+  // Create a worktree — git will resolve the symlink and register
+  // the worktree at the external path
+  const info = createWorktree(base, "M002", { branch: "milestone/M002" });
+  assertTrue(info.exists, "worktree created");
+
+  // Verify worktree was created at the resolved (external) path
+  const realWtPath = realpathSync(info.path);
+  assertTrue(
+    realWtPath.startsWith(externalState),
+    `worktree real path (${realWtPath}) is under external state dir`,
+  );
+
+  // Verify git registered the worktree
+  const gitList = run("git worktree list", base);
+  assertTrue(gitList.includes("M002"), "git worktree list shows M002");
+
+  // The computed path via worktreePath uses the symlink path
+  const computedPath = worktreePath(base, "M002");
+  assertTrue(existsSync(computedPath), "computed path exists (via symlink)");
+
+  // Simulate what syncStateToProjectRoot does: replace the .gsd symlink with
+  // a real directory containing stale worktree data. This causes worktreePath()
+  // to compute a LOCAL path that differs from git's REGISTERED path (the
+  // resolved external path). The stale local dir passes existsSync but is not
+  // a real git worktree, so nativeWorktreeRemove fails silently.
+  unlinkSync(join(base, ".gsd"));  // remove the symlink
+  mkdirSync(join(base, ".gsd", "worktrees", "M002"), { recursive: true });
+  // Write a dummy file so the stale directory is non-empty
+  writeFileSync(join(base, ".gsd", "worktrees", "M002", "stale.txt"), "stale sync artifact", "utf-8");
+
+  // Now worktreePath(base, "M002") points to the LOCAL stale dir, not the
+  // external path where git actually registered the worktree.
+  const stalePath = worktreePath(base, "M002");
+  assertTrue(existsSync(stalePath), "stale local worktree dir exists");
+  assertTrue(
+    stalePath !== realWtPath,
+    `computed path (${stalePath}) differs from git-registered path (${realWtPath})`,
+  );
+
+  // THE ACTUAL TEST: removeWorktree must find the git-registered path and
+  // remove the real worktree, not just operate on the stale local directory.
+  removeWorktree(base, "M002", { branch: "milestone/M002", deleteBranch: true });
+
+  // After removal, the worktree should be gone from git's list
+  const gitListAfter = run("git worktree list", base);
+  assertTrue(
+    !gitListAfter.includes("M002"),
+    "worktree removed from git worktree list after removeWorktree",
+  );
+
+  // The branch should be deleted
+  const branches = run("git branch", base);
+  assertTrue(
+    !branches.includes("milestone/M002"),
+    "milestone/M002 branch deleted after removeWorktree",
+  );
+
+  // The worktree directory should be gone
+  assertTrue(
+    !existsSync(realWtPath),
+    "worktree directory removed from disk",
+  );
+
+  // List should be empty
+  const listed = listWorktrees(base);
+  assertEq(listed.length, 0, "no worktrees listed after removal");
+
+  // Cleanup
+  rmSync(base, { recursive: true, force: true });
+  rmSync(externalState, { recursive: true, force: true });
+
+  report();
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

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

@@ -19,6 +19,8 @@
  *   - syncWorktreeStateBack syncs root-level .gsd/ files (REQUIREMENTS, PROJECT, etc.)
  *   - syncWorktreeStateBack syncs ALL milestone directories, not just the current one
  *   - syncWorktreeStateBack handles next-milestone artifacts created during completion
+ *   - syncGsdStateToWorktree syncs non-standard milestone dir names (#1547)
+ *   - syncWorktreeStateBack syncs non-standard milestone dir names (#1547)
  */
 
 import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, readFileSync } from 'node:fs';
@@ -517,6 +519,78 @@ async function main(): Promise<void> {
     }
   }
 
+  // ─── 14. syncGsdStateToWorktree syncs non-standard milestone dir names (#1547) ──
+  console.log('\n=== 14. syncGsdStateToWorktree syncs non-standard milestone dir names (#1547) ===');
+  {
+    const mainBase = createBase('main');
+    const wtBase = createBase('wt');
+
+    try {
+      // Main has milestone dirs with non-standard names
+      const customDir = join(mainBase, '.gsd', 'milestones', 'sprint-alpha');
+      mkdirSync(customDir, { recursive: true });
+      writeFileSync(join(customDir, 'CONTEXT.md'), '# Sprint Alpha Context');
+
+      const suffixDir = join(mainBase, '.gsd', 'milestones', 'M001-abc123');
+      mkdirSync(suffixDir, { recursive: true });
+      writeFileSync(join(suffixDir, 'M001-abc123-CONTEXT.md'), '# M001 Context');
+
+      assertTrue(!existsSync(join(wtBase, '.gsd', 'milestones', 'sprint-alpha')), 'sprint-alpha missing before sync');
+      assertTrue(!existsSync(join(wtBase, '.gsd', 'milestones', 'M001-abc123')), 'M001-abc123 missing before sync');
+
+      const result = syncGsdStateToWorktree(mainBase, wtBase);
+
+      assertTrue(
+        existsSync(join(wtBase, '.gsd', 'milestones', 'sprint-alpha', 'CONTEXT.md')),
+        '#1547: non-standard milestone dir "sprint-alpha" synced to worktree',
+      );
+      assertTrue(
+        existsSync(join(wtBase, '.gsd', 'milestones', 'M001-abc123', 'M001-abc123-CONTEXT.md')),
+        '#1547: suffixed milestone dir "M001-abc123" synced to worktree',
+      );
+      assertTrue(result.synced.length > 0, 'sync reported files');
+    } finally {
+      cleanup(mainBase);
+      cleanup(wtBase);
+    }
+  }
+
+  // ─── 15. syncWorktreeStateBack syncs non-standard milestone dir names (#1547) ──
+  console.log('\n=== 15. syncWorktreeStateBack syncs non-standard milestone dir names (#1547) ===');
+  {
+    const mainBase = mkdtempSync(join(tmpdir(), 'gsd-wt-back-custom-main-'));
+    const wtBase = mkdtempSync(join(tmpdir(), 'gsd-wt-back-custom-wt-'));
+
+    try {
+      mkdirSync(join(mainBase, '.gsd', 'milestones'), { recursive: true });
+      mkdirSync(join(wtBase, '.gsd', 'milestones'), { recursive: true });
+
+      // Worktree has a non-standard milestone dir
+      const wtCustomDir = join(wtBase, '.gsd', 'milestones', 'sprint-beta');
+      mkdirSync(wtCustomDir, { recursive: true });
+      writeFileSync(join(wtCustomDir, 'SUMMARY.md'), '# Sprint Beta Summary');
+
+      assertTrue(
+        !existsSync(join(mainBase, '.gsd', 'milestones', 'sprint-beta')),
+        'sprint-beta missing in main before sync',
+      );
+
+      const { synced } = syncWorktreeStateBack(mainBase, wtBase, 'M001');
+
+      assertTrue(
+        existsSync(join(mainBase, '.gsd', 'milestones', 'sprint-beta', 'SUMMARY.md')),
+        '#1547: non-standard milestone dir "sprint-beta" synced back to main',
+      );
+      assertTrue(
+        synced.some((p) => p.includes('sprint-beta')),
+        '#1547: sprint-beta appears in synced list',
+      );
+    } finally {
+      rmSync(mainBase, { recursive: true, force: true });
+      rmSync(wtBase, { recursive: true, force: true });
+    }
+  }
+
   report();
 }