gsd-pi 2.33.0 → 2.33.1-dev.29a8268

package/dist/resources/extensions/gsd/tests/session-lock.test.ts

@@ -12,6 +12,7 @@ import {
   readSessionLockData,
   isSessionLockHeld,
   isSessionLockProcessAlive,
+  cleanupStrayLockFiles,
 } from "../session-lock.ts";
 
 // ─── acquireSessionLock ──────────────────────────────────────────────────
@@ -313,3 +314,121 @@ test("acquireSessionLock creates .gsd/ if it does not exist", () => {
   releaseSessionLock(dir);
   rmSync(dir, { recursive: true, force: true });
 });
+
+// ─── cleanupStrayLockFiles (#1315) ──────────────────────────────────────
+
+test("cleanupStrayLockFiles removes numbered lock variants but preserves auto.lock", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+  const gsdDir = join(dir, ".gsd");
+  mkdirSync(gsdDir, { recursive: true });
+
+  // Create canonical lock file + numbered variants
+  writeFileSync(join(gsdDir, "auto.lock"), '{"pid":1}');
+  writeFileSync(join(gsdDir, "auto 2.lock"), '{"pid":2}');
+  writeFileSync(join(gsdDir, "auto 3.lock"), '{"pid":3}');
+  writeFileSync(join(gsdDir, "auto 4.lock"), '{"pid":4}');
+
+  cleanupStrayLockFiles(dir);
+
+  assert.ok(existsSync(join(gsdDir, "auto.lock")), "canonical auto.lock should be preserved");
+  assert.ok(!existsSync(join(gsdDir, "auto 2.lock")), "auto 2.lock should be removed");
+  assert.ok(!existsSync(join(gsdDir, "auto 3.lock")), "auto 3.lock should be removed");
+  assert.ok(!existsSync(join(gsdDir, "auto 4.lock")), "auto 4.lock should be removed");
+
+  rmSync(dir, { recursive: true, force: true });
+});
+
+test("cleanupStrayLockFiles handles parenthesized variants", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+  const gsdDir = join(dir, ".gsd");
+  mkdirSync(gsdDir, { recursive: true });
+
+  // macOS sometimes uses parenthesized format: "auto (2).lock"
+  writeFileSync(join(gsdDir, "auto.lock"), '{"pid":1}');
+  writeFileSync(join(gsdDir, "auto (2).lock"), '{"pid":2}');
+
+  cleanupStrayLockFiles(dir);
+
+  assert.ok(existsSync(join(gsdDir, "auto.lock")), "canonical auto.lock should be preserved");
+  assert.ok(!existsSync(join(gsdDir, "auto (2).lock")), "auto (2).lock should be removed");
+
+  rmSync(dir, { recursive: true, force: true });
+});
+
+test("cleanupStrayLockFiles does not remove unrelated files", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+  const gsdDir = join(dir, ".gsd");
+  mkdirSync(gsdDir, { recursive: true });
+
+  // Create unrelated files that should NOT be removed
+  writeFileSync(join(gsdDir, "auto.lock"), '{"pid":1}');
+  writeFileSync(join(gsdDir, "config.json"), '{}');
+  writeFileSync(join(gsdDir, "other.lock"), '{}');
+
+  cleanupStrayLockFiles(dir);
+
+  assert.ok(existsSync(join(gsdDir, "auto.lock")), "auto.lock should be preserved");
+  assert.ok(existsSync(join(gsdDir, "config.json")), "config.json should be preserved");
+  assert.ok(existsSync(join(gsdDir, "other.lock")), "other.lock should be preserved");
+
+  rmSync(dir, { recursive: true, force: true });
+});
+
+test("cleanupStrayLockFiles is safe on empty directory", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+  const gsdDir = join(dir, ".gsd");
+  mkdirSync(gsdDir, { recursive: true });
+
+  // Should not throw
+  cleanupStrayLockFiles(dir);
+
+  rmSync(dir, { recursive: true, force: true });
+});
+
+test("cleanupStrayLockFiles is safe when .gsd/ does not exist", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+
+  // Should not throw even without .gsd/
+  cleanupStrayLockFiles(dir);
+
+  rmSync(dir, { recursive: true, force: true });
+});
+
+test("acquireSessionLock cleans stray lock files before acquiring", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+  const gsdDir = join(dir, ".gsd");
+  mkdirSync(gsdDir, { recursive: true });
+
+  // Plant stray lock files before acquire
+  writeFileSync(join(gsdDir, "auto 2.lock"), '{"pid":9999999}');
+  writeFileSync(join(gsdDir, "auto 3.lock"), '{"pid":9999998}');
+
+  const result = acquireSessionLock(dir);
+  assert.equal(result.acquired, true, "should acquire lock");
+
+  // Stray files should be cleaned up
+  assert.ok(!existsSync(join(gsdDir, "auto 2.lock")), "auto 2.lock should be removed during acquire");
+  assert.ok(!existsSync(join(gsdDir, "auto 3.lock")), "auto 3.lock should be removed during acquire");
+
+  releaseSessionLock(dir);
+  rmSync(dir, { recursive: true, force: true });
+});
+
+test("releaseSessionLock cleans stray lock files after releasing", () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-session-lock-"));
+  const gsdDir = join(dir, ".gsd");
+  mkdirSync(gsdDir, { recursive: true });
+
+  const result = acquireSessionLock(dir);
+  assert.equal(result.acquired, true);
+
+  // Plant stray lock files (simulating cloud sync creating them during session)
+  writeFileSync(join(gsdDir, "auto 2.lock"), '{"pid":9999999}');
+
+  releaseSessionLock(dir);
+
+  assert.ok(!existsSync(join(gsdDir, "auto 2.lock")), "auto 2.lock should be removed during release");
+  assert.ok(!existsSync(join(gsdDir, "auto.lock")), "auto.lock should also be removed");
+
+  rmSync(dir, { recursive: true, force: true });
+});

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

@@ -0,0 +1,206 @@
+/**
+ * worktree-sync-milestones.test.ts — Regression test for #1311.
+ *
+ * Verifies that syncGsdStateToWorktree copies missing milestones,
+ * milestone files, and slice directories from the main repo's .gsd/
+ * into the worktree's .gsd/.
+ *
+ * Covers:
+ *   - Entirely missing milestone directory
+ *   - Milestone exists but missing CONTEXT/ROADMAP files
+ *   - Missing slices within an existing milestone
+ *   - No-op when directories are identical (symlinked)
+ *   - Root-level files (DECISIONS, REQUIREMENTS, etc.)
+ */
+
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, readFileSync, symlinkSync, realpathSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import { syncGsdStateToWorktree } from '../auto-worktree.ts';
+import { createTestContext } from './test-helpers.ts';
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+function createBase(name: string): string {
+  const base = mkdtempSync(join(tmpdir(), `gsd-wt-sync-${name}-`));
+  mkdirSync(join(base, '.gsd', 'milestones'), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  rmSync(base, { recursive: true, force: true });
+}
+
+async function main(): Promise<void> {
+
+  // ─── 1. Missing milestone directory is synced ─────────────────────────
+  console.log('\n=== 1. missing milestone directory is copied from main ===');
+  {
+    const mainBase = createBase('main');
+    const wtBase = createBase('wt');
+
+    try {
+      // Main repo has M001 and M002
+      const m001Dir = join(mainBase, '.gsd', 'milestones', 'M001');
+      mkdirSync(m001Dir, { recursive: true });
+      writeFileSync(join(m001Dir, 'M001-CONTEXT.md'), '# M001\nDone.');
+      writeFileSync(join(m001Dir, 'M001-ROADMAP.md'), '# Roadmap');
+
+      const m002Dir = join(mainBase, '.gsd', 'milestones', 'M002');
+      mkdirSync(m002Dir, { recursive: true });
+      writeFileSync(join(m002Dir, 'M002-CONTEXT.md'), '# M002\nNew milestone.');
+      writeFileSync(join(m002Dir, 'M002-ROADMAP.md'), '# Roadmap');
+
+      // Worktree only has M001
+      const wtM001Dir = join(wtBase, '.gsd', 'milestones', 'M001');
+      mkdirSync(wtM001Dir, { recursive: true });
+      writeFileSync(join(wtM001Dir, 'M001-CONTEXT.md'), '# M001\nDone.');
+
+      // M002 is missing from worktree
+      assertTrue(!existsSync(join(wtBase, '.gsd', 'milestones', 'M002')), 'M002 missing before sync');
+
+      const result = syncGsdStateToWorktree(mainBase, wtBase);
+
+      assertTrue(existsSync(join(wtBase, '.gsd', 'milestones', 'M002')), '#1311: M002 synced to worktree');
+      assertTrue(existsSync(join(wtBase, '.gsd', 'milestones', 'M002', 'M002-CONTEXT.md')), 'M002 CONTEXT synced');
+      assertTrue(existsSync(join(wtBase, '.gsd', 'milestones', 'M002', 'M002-ROADMAP.md')), 'M002 ROADMAP synced');
+      assertTrue(result.synced.length > 0, 'sync reported files');
+    } finally {
+      cleanup(mainBase);
+      cleanup(wtBase);
+    }
+  }
+
+  // ─── 2. Missing files within existing milestone ───────────────────────
+  console.log('\n=== 2. missing files within existing milestone are synced ===');
+  {
+    const mainBase = createBase('main');
+    const wtBase = createBase('wt');
+
+    try {
+      // Main repo M001 has CONTEXT, ROADMAP, RESEARCH
+      const m001Dir = join(mainBase, '.gsd', 'milestones', 'M001');
+      mkdirSync(m001Dir, { recursive: true });
+      writeFileSync(join(m001Dir, 'M001-CONTEXT.md'), '# M001 Context');
+      writeFileSync(join(m001Dir, 'M001-ROADMAP.md'), '# M001 Roadmap');
+      writeFileSync(join(m001Dir, 'M001-RESEARCH.md'), '# M001 Research');
+
+      // Worktree M001 only has CONTEXT (stale snapshot)
+      const wtM001Dir = join(wtBase, '.gsd', 'milestones', 'M001');
+      mkdirSync(wtM001Dir, { recursive: true });
+      writeFileSync(join(wtM001Dir, 'M001-CONTEXT.md'), '# M001 Context');
+
+      const result = syncGsdStateToWorktree(mainBase, wtBase);
+
+      assertTrue(existsSync(join(wtBase, '.gsd', 'milestones', 'M001', 'M001-ROADMAP.md')), 'ROADMAP synced');
+      assertTrue(existsSync(join(wtBase, '.gsd', 'milestones', 'M001', 'M001-RESEARCH.md')), 'RESEARCH synced');
+      // Existing file should NOT be overwritten
+      assertEq(
+        readFileSync(join(wtBase, '.gsd', 'milestones', 'M001', 'M001-CONTEXT.md'), 'utf-8'),
+        '# M001 Context',
+        'existing CONTEXT not overwritten',
+      );
+    } finally {
+      cleanup(mainBase);
+      cleanup(wtBase);
+    }
+  }
+
+  // ─── 3. Missing slices directory synced ───────────────────────────────
+  console.log('\n=== 3. missing slices directory synced ===');
+  {
+    const mainBase = createBase('main');
+    const wtBase = createBase('wt');
+
+    try {
+      // Main repo has M001 with slices S01–S03
+      const m001Dir = join(mainBase, '.gsd', 'milestones', 'M001');
+      mkdirSync(join(m001Dir, 'slices', 'S01'), { recursive: true });
+      mkdirSync(join(m001Dir, 'slices', 'S02'), { recursive: true });
+      mkdirSync(join(m001Dir, 'slices', 'S03'), { recursive: true });
+      writeFileSync(join(m001Dir, 'M001-ROADMAP.md'), '# Roadmap');
+      writeFileSync(join(m001Dir, 'slices', 'S01', 'S01-PLAN.md'), '# S01 Plan');
+      writeFileSync(join(m001Dir, 'slices', 'S02', 'S02-PLAN.md'), '# S02 Plan');
+      writeFileSync(join(m001Dir, 'slices', 'S03', 'S03-PLAN.md'), '# S03 Plan');
+
+      // Worktree M001 has slices S01–S02 only (S03 missing)
+      const wtM001Dir = join(wtBase, '.gsd', 'milestones', 'M001');
+      mkdirSync(join(wtM001Dir, 'slices', 'S01'), { recursive: true });
+      mkdirSync(join(wtM001Dir, 'slices', 'S02'), { recursive: true });
+      writeFileSync(join(wtM001Dir, 'M001-ROADMAP.md'), '# Roadmap');
+      writeFileSync(join(wtM001Dir, 'slices', 'S01', 'S01-PLAN.md'), '# S01 Plan');
+      writeFileSync(join(wtM001Dir, 'slices', 'S02', 'S02-PLAN.md'), '# S02 Plan');
+
+      assertTrue(!existsSync(join(wtBase, '.gsd', 'milestones', 'M001', 'slices', 'S03')), 'S03 missing before sync');
+
+      syncGsdStateToWorktree(mainBase, wtBase);
+
+      assertTrue(existsSync(join(wtBase, '.gsd', 'milestones', 'M001', 'slices', 'S03')), '#1311: S03 synced');
+      assertTrue(existsSync(join(wtBase, '.gsd', 'milestones', 'M001', 'slices', 'S03', 'S03-PLAN.md')), 'S03 PLAN synced');
+    } finally {
+      cleanup(mainBase);
+      cleanup(wtBase);
+    }
+  }
+
+  // ─── 4. No-op when both resolve to same directory (symlink) ───────────
+  console.log('\n=== 4. no-op when .gsd/ resolves to same path (symlinked) ===');
+  {
+    const sharedDir = createBase('shared');
+    const mainBase = mkdtempSync(join(tmpdir(), 'gsd-wt-sync-main-'));
+    const wtBase = mkdtempSync(join(tmpdir(), 'gsd-wt-sync-wt-'));
+
+    try {
+      // Both main and worktree symlink to the same shared directory
+      writeFileSync(join(sharedDir, '.gsd', 'milestones', 'keep'), '');
+      symlinkSync(join(sharedDir, '.gsd'), join(mainBase, '.gsd'));
+      symlinkSync(join(sharedDir, '.gsd'), join(wtBase, '.gsd'));
+
+      const result = syncGsdStateToWorktree(mainBase, wtBase);
+      assertEq(result.synced.length, 0, 'no files synced when both point to same dir');
+    } finally {
+      cleanup(sharedDir);
+      rmSync(mainBase, { recursive: true, force: true });
+      rmSync(wtBase, { recursive: true, force: true });
+    }
+  }
+
+  // ─── 5. Root-level .gsd/ files synced ─────────────────────────────────
+  console.log('\n=== 5. root-level .gsd/ files synced ===');
+  {
+    const mainBase = createBase('main');
+    const wtBase = createBase('wt');
+
+    try {
+      writeFileSync(join(mainBase, '.gsd', 'DECISIONS.md'), '# Decisions');
+      writeFileSync(join(mainBase, '.gsd', 'REQUIREMENTS.md'), '# Requirements');
+      writeFileSync(join(mainBase, '.gsd', 'PROJECT.md'), '# Project');
+
+      // Worktree has none of these
+      const result = syncGsdStateToWorktree(mainBase, wtBase);
+
+      assertTrue(existsSync(join(wtBase, '.gsd', 'DECISIONS.md')), 'DECISIONS.md synced');
+      assertTrue(existsSync(join(wtBase, '.gsd', 'REQUIREMENTS.md')), 'REQUIREMENTS.md synced');
+      assertTrue(existsSync(join(wtBase, '.gsd', 'PROJECT.md')), 'PROJECT.md synced');
+      assertTrue(result.synced.length >= 3, 'at least 3 files synced');
+    } finally {
+      cleanup(mainBase);
+      cleanup(wtBase);
+    }
+  }
+
+  // ─── 6. Non-existent directories handled gracefully ───────────────────
+  console.log('\n=== 6. non-existent directories → no-op ===');
+  {
+    const result = syncGsdStateToWorktree('/tmp/does-not-exist-main', '/tmp/does-not-exist-wt');
+    assertEq(result.synced.length, 0, 'no crash on missing directories');
+  }
+
+  report();
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gsd-pi",
-  "version": "2.33.0",
+  "version": "2.33.1-dev.29a8268",
   "description": "GSD — Get Shit Done coding agent",
   "license": "MIT",
   "repository": {

package/packages/pi-coding-agent/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gsd/pi-coding-agent",
-  "version": "2.33.0",
+  "version": "2.33.1",
   "description": "Coding agent CLI (vendored from pi-mono)",
   "type": "module",
   "piConfig": {

package/pkg/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glittercowboy/gsd",
-  "version": "2.33.0",
+  "version": "2.33.1",
   "piConfig": {
     "name": "gsd",
     "configDir": ".gsd"

package/src/resources/extensions/gsd/auto-supervisor.ts

@@ -1,5 +1,5 @@
 /**
- * Auto-mode Supervisor — SIGTERM handling and working-tree activity detection.
+ * Auto-mode Supervisor — signal handling and working-tree activity detection.
  *
  * Pure functions — no module-level globals or AutoContext dependency.
  */
@@ -8,10 +8,10 @@ import { clearLock } from "./crash-recovery.js";
 import { releaseSessionLock } from "./session-lock.js";
 import { nativeHasChanges } from "./native-git-bridge.js";
 
-// ─── SIGTERM Handling ─────────────────────────────────────────────────────────
+// ─── Signal Handling ──────────────────────────────────────────────────────────
 
 /**
- * Register a SIGTERM handler that clears the lock file and exits cleanly.
+ * Register SIGTERM and SIGINT handlers that clear lock files and exit cleanly.
  * Captures the active base path at registration time so the handler
  * always references the correct path even if the module variable changes.
  * Removes any previously registered handler before installing the new one.
@@ -22,20 +22,25 @@ export function registerSigtermHandler(
   currentBasePath: string,
   previousHandler: (() => void) | null,
 ): () => void {
-  if (previousHandler) process.off("SIGTERM", previousHandler);
+  if (previousHandler) {
+    process.off("SIGTERM", previousHandler);
+    process.off("SIGINT", previousHandler);
+  }
   const handler = () => {
     releaseSessionLock(currentBasePath);
     clearLock(currentBasePath);
     process.exit(0);
   };
   process.on("SIGTERM", handler);
+  process.on("SIGINT", handler);
   return handler;
 }
 
-/** Deregister the SIGTERM handler (called on stop/pause). */
+/** Deregister signal handlers (called on stop/pause). */
 export function deregisterSigtermHandler(handler: (() => void) | null): void {
   if (handler) {
     process.off("SIGTERM", handler);
+    process.off("SIGINT", handler);
   }
 }
 

package/src/resources/extensions/gsd/auto-worktree.ts

@@ -6,7 +6,7 @@
  * manages create, enter, detect, and teardown for auto-mode worktrees.
  */
 
-import { existsSync, readFileSync, realpathSync, unlinkSync, statSync, rmSync } from "node:fs";
+import { existsSync, readFileSync, realpathSync, unlinkSync, statSync, rmSync, readdirSync, cpSync, lstatSync as lstatSyncFn } from "node:fs";
 import { isAbsolute, join, sep } from "node:path";
 import { GSDError, GSD_IO_ERROR, GSD_GIT_ERROR } from "./errors.js";
 import { execSync, execFileSync } from "node:child_process";
@@ -45,6 +45,122 @@ import { getErrorMessage } from "./error-utils.js";
 /** Original project root before chdir into auto-worktree. */
 let originalBase: string | null = null;
 
+// ─── Worktree ↔ Main Repo Sync (#1311) ──────────────────────────────────────
+
+/**
+ * Sync .gsd/ state from the main repo into the worktree.
+ *
+ * When .gsd/ is a symlink to the external state directory, both the main
+ * repo and worktree share the same directory — no sync needed.
+ *
+ * When .gsd/ is a real directory (e.g., git-tracked or manage_gitignore:false),
+ * the worktree has its own copy that may be stale. This function copies
+ * missing milestones, CONTEXT, ROADMAP, DECISIONS, REQUIREMENTS, and
+ * PROJECT files from the main repo's .gsd/ into the worktree's .gsd/.
+ *
+ * Only adds missing content — never overwrites existing files in the worktree
+ * (the worktree's execution state is authoritative for in-progress work).
+ */
+export function syncGsdStateToWorktree(mainBasePath: string, worktreePath_: string): { synced: string[] } {
+  const mainGsd = gsdRoot(mainBasePath);
+  const wtGsd = gsdRoot(worktreePath_);
+  const synced: string[] = [];
+
+  // If both resolve to the same directory (symlink), no sync needed
+  try {
+    const mainResolved = realpathSync(mainGsd);
+    const wtResolved = realpathSync(wtGsd);
+    if (mainResolved === wtResolved) return { synced };
+  } catch {
+    // Can't resolve — proceed with sync as a safety measure
+  }
+
+  if (!existsSync(mainGsd) || !existsSync(wtGsd)) return { synced };
+
+  // Sync root-level .gsd/ files (DECISIONS, REQUIREMENTS, PROJECT, KNOWLEDGE)
+  const rootFiles = ["DECISIONS.md", "REQUIREMENTS.md", "PROJECT.md", "KNOWLEDGE.md", "OVERRIDES.md"];
+  for (const f of rootFiles) {
+    const src = join(mainGsd, f);
+    const dst = join(wtGsd, f);
+    if (existsSync(src) && !existsSync(dst)) {
+      try {
+        cpSync(src, dst);
+        synced.push(f);
+      } catch { /* non-fatal */ }
+    }
+  }
+
+  // Sync milestones: copy entire milestone directories that are missing
+  const mainMilestonesDir = join(mainGsd, "milestones");
+  const wtMilestonesDir = join(wtGsd, "milestones");
+  if (existsSync(mainMilestonesDir) && existsSync(wtMilestonesDir)) {
+    try {
+      const mainMilestones = readdirSync(mainMilestonesDir, { withFileTypes: true })
+        .filter(d => d.isDirectory() && /^M\d{3}/.test(d.name))
+        .map(d => d.name);
+
+      for (const mid of mainMilestones) {
+        const srcDir = join(mainMilestonesDir, mid);
+        const dstDir = join(wtMilestonesDir, mid);
+
+        if (!existsSync(dstDir)) {
+          // Entire milestone missing from worktree — copy it
+          try {
+            cpSync(srcDir, dstDir, { recursive: true });
+            synced.push(`milestones/${mid}/`);
+          } catch { /* non-fatal */ }
+        } else {
+          // Milestone directory exists but may be missing files (stale snapshot).
+          // Sync individual top-level milestone files (CONTEXT, ROADMAP, RESEARCH, etc.)
+          try {
+            const srcFiles = readdirSync(srcDir).filter(f => f.endsWith(".md") || f.endsWith(".json"));
+            for (const f of srcFiles) {
+              const srcFile = join(srcDir, f);
+              const dstFile = join(dstDir, f);
+              if (!existsSync(dstFile)) {
+                try {
+                  const srcStat = lstatSyncFn(srcFile);
+                  if (srcStat.isFile()) {
+                    cpSync(srcFile, dstFile);
+                    synced.push(`milestones/${mid}/${f}`);
+                  }
+                } catch { /* non-fatal */ }
+              }
+            }
+
+            // Sync slices directory if it exists in main but not in worktree
+            const srcSlicesDir = join(srcDir, "slices");
+            const dstSlicesDir = join(dstDir, "slices");
+            if (existsSync(srcSlicesDir) && !existsSync(dstSlicesDir)) {
+              try {
+                cpSync(srcSlicesDir, dstSlicesDir, { recursive: true });
+                synced.push(`milestones/${mid}/slices/`);
+              } catch { /* non-fatal */ }
+            } else if (existsSync(srcSlicesDir) && existsSync(dstSlicesDir)) {
+              // Both exist — sync missing slice directories
+              const srcSlices = readdirSync(srcSlicesDir, { withFileTypes: true })
+                .filter(d => d.isDirectory())
+                .map(d => d.name);
+              for (const sid of srcSlices) {
+                const srcSlice = join(srcSlicesDir, sid);
+                const dstSlice = join(dstSlicesDir, sid);
+                if (!existsSync(dstSlice)) {
+                  try {
+                    cpSync(srcSlice, dstSlice, { recursive: true });
+                    synced.push(`milestones/${mid}/slices/${sid}/`);
+                  } catch { /* non-fatal */ }
+                }
+              }
+            }
+          } catch { /* non-fatal */ }
+        }
+      }
+    } catch { /* non-fatal */ }
+  }
+
+  return { synced };
+}
+
 // ─── Worktree Post-Create Hook (#597) ────────────────────────────────────────
 
 /**
@@ -125,6 +241,12 @@ export function createAutoWorktree(basePath: string, milestoneId: string): strin
   // Ensure worktree shares external state via symlink
   ensureGsdSymlink(info.path);
 
+  // Sync .gsd/ state from main repo into the worktree (#1311).
+  // Even with the symlink, the worktree may have stale git-tracked files
+  // if .gsd/ is not gitignored. And on fresh create, the milestone files
+  // created on main since the branch point won't be in the worktree.
+  syncGsdStateToWorktree(basePath, info.path);
+
   // Run user-configured post-create hook (#597) — e.g. copy .env, symlink assets
   const hookError = runWorktreePostCreateHook(basePath, info.path);
   if (hookError) {
@@ -267,6 +389,18 @@ export function enterAutoWorktree(basePath: string, milestoneId: string): string
     throw new GSDError(GSD_IO_ERROR, `Auto-worktree path ${p} exists but .git is unreadable`);
   }
 
+  // Ensure worktree shares external state via symlink (#1311).
+  // On resume (enterAutoWorktree), the symlink may be missing if it was
+  // created before ensureGsdSymlink existed, or the .gsd/ directory may be
+  // a stale git-tracked copy instead of a symlink. Refreshing here ensures
+  // the worktree sees the same milestone state as the main repo.
+  ensureGsdSymlink(p);
+
+  // Sync .gsd/ state from main repo into worktree (#1311).
+  // Covers the case where .gsd/ is a real directory (not symlinked) and
+  // milestones were created on main after the worktree was last used.
+  syncGsdStateToWorktree(basePath, p);
+
   const previousCwd = process.cwd();
 
   try {

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

@@ -52,8 +52,20 @@ import { handleStart, handleTemplates, getTemplateCompletions } from "./commands
 
 /** Resolve the effective project root, accounting for worktree paths. */
 export function projectRoot(): string {
-  const root = resolveProjectRoot(process.cwd());
-  assertSafeDirectory(root);
+  const cwd = process.cwd();
+  const root = resolveProjectRoot(cwd);
+
+  // When running inside a GSD worktree, the resolved root may be a "dangerous"
+  // directory (e.g., $HOME used as a git repo root — #1317). The safety check
+  // should validate the actual working directory, not the upstream root,
+  // because the worktree itself is a safe project subdirectory.
+  // Only skip the root check when we can confirm we're in a valid worktree.
+  if (root !== cwd) {
+    // We're in a worktree — validate the worktree path instead of the root
+    assertSafeDirectory(cwd);
+  } else {
+    assertSafeDirectory(root);
+  }
   return root;
 }
 

package/src/resources/extensions/gsd/git-service.ts

@@ -336,13 +336,17 @@ export class GitServiceImpl {
    * @param extraExclusions Additional pathspec exclusions beyond RUNTIME_EXCLUSION_PATHS.
    */
   private smartStage(extraExclusions: readonly string[] = []): void {
-    // Always exclude .gsd/ — state is managed externally (symlinked to ~/.gsd/projects/<hash>/)
-    const allExclusions = [".gsd/", ...extraExclusions];
-
     // One-time cleanup: if runtime files are already tracked in the index
     // (from older versions where the fallback bug staged them), untrack them
     // in a dedicated commit. This must happen as a separate commit because
     // the git reset HEAD step below would otherwise undo the rm --cached.
+    //
+    // SAFETY: Only untrack the specific RUNTIME paths (activity/, runtime/,
+    // auto.lock, etc.) — NOT all of .gsd/. If .gsd/milestones/ files were
+    // previously tracked, they stay tracked until the milestone completes
+    // and the worktree is torn down. This prevents a mid-execution behavioral
+    // discontinuity where the first half of a milestone has .gsd/ artifacts
+    // committed but the second half doesn't (#1326).
     if (!this._runtimeFilesCleanedUp) {
       let cleaned = false;
       for (const exclusion of RUNTIME_EXCLUSION_PATHS) {
@@ -357,17 +361,19 @@ export class GitServiceImpl {
 
     // Stage everything, then unstage excluded paths.
     //
-    // Previous approach used pathspec excludes (:(exclude)...) with git add -A,
-    // but that fails when .gsd/ is in .gitignore — git exits non-zero before
-    // evaluating the excludes. The catch fallback ran plain `git add -A`,
-    // staging all tracked runtime files unconditionally and defeating the
-    // exclusion list entirely.
+    // Exclude only RUNTIME paths from staging — not the entire .gsd/ directory.
+    // When .gsd/milestones/ files are already tracked in the index (projects
+    // where .gsd/ is not gitignored, or Windows junctions that git sees as
+    // real directories), they should continue to be committed. Excluding the
+    // entire .gsd/ directory mid-milestone causes silent commit failure where
+    // the second half of a milestone's artifacts are never committed (#1326).
     //
-    // git reset HEAD silently succeeds when the path isn't staged, so no
-    // error handling is needed per-path.
+    // If .gsd/ IS in .gitignore (the default for external state projects),
+    // git add -A already skips it and the reset is a harmless no-op.
     nativeAddAll(this.basePath);
 
-    for (const exclusion of allExclusions) {
+    const runtimeExclusions = [...RUNTIME_EXCLUSION_PATHS, ...extraExclusions];
+    for (const exclusion of runtimeExclusions) {
       try { nativeResetPaths(this.basePath, [exclusion]); } catch { /* path not staged — ignore */ }
     }
   }