gsd-pi 2.33.1-dev.9bafd68 → 2.33.1-dev.b1c6556

package/dist/resources/extensions/gsd/auto-worktree.js

@@ -140,6 +140,77 @@ export function syncGsdStateToWorktree(mainBasePath, worktreePath_) {
     }
     return { synced };
 }
+/**
+ * Sync milestone artifacts from worktree back to the main external state directory.
+ * Called before milestone merge to ensure completion artifacts (SUMMARY, VALIDATION,
+ * updated ROADMAP) are visible from the project root (#1412).
+ *
+ * Only syncs .gsd/milestones/ content — root-level files (DECISIONS, REQUIREMENTS, etc.)
+ * are handled by the merge itself.
+ */
+export function syncWorktreeStateBack(mainBasePath, worktreePath, milestoneId) {
+    const mainGsd = gsdRoot(mainBasePath);
+    const wtGsd = gsdRoot(worktreePath);
+    const synced = [];
+    // 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
+    }
+    const wtMilestoneDir = join(wtGsd, "milestones", milestoneId);
+    const mainMilestoneDir = join(mainGsd, "milestones", milestoneId);
+    if (!existsSync(wtMilestoneDir))
+        return { synced };
+    mkdirSync(mainMilestoneDir, { recursive: true });
+    // Sync milestone-level files (SUMMARY, VALIDATION, ROADMAP, CONTEXT)
+    try {
+        for (const entry of readdirSync(wtMilestoneDir, { withFileTypes: true })) {
+            if (entry.isFile() && entry.name.endsWith(".md")) {
+                const src = join(wtMilestoneDir, entry.name);
+                const dst = join(mainMilestoneDir, entry.name);
+                try {
+                    cpSync(src, dst, { force: true });
+                    synced.push(`milestones/${milestoneId}/${entry.name}`);
+                }
+                catch { /* non-fatal */ }
+            }
+        }
+    }
+    catch { /* non-fatal */ }
+    // Sync slice-level files (summaries, UATs)
+    const wtSlicesDir = join(wtMilestoneDir, "slices");
+    const mainSlicesDir = join(mainMilestoneDir, "slices");
+    if (existsSync(wtSlicesDir)) {
+        try {
+            for (const sliceEntry of readdirSync(wtSlicesDir, { withFileTypes: true })) {
+                if (!sliceEntry.isDirectory())
+                    continue;
+                const sid = sliceEntry.name;
+                const wtSliceDir = join(wtSlicesDir, sid);
+                const mainSliceDir = join(mainSlicesDir, sid);
+                mkdirSync(mainSliceDir, { recursive: true });
+                for (const fileEntry of readdirSync(wtSliceDir, { withFileTypes: true })) {
+                    if (fileEntry.isFile() && fileEntry.name.endsWith(".md")) {
+                        const src = join(wtSliceDir, fileEntry.name);
+                        const dst = join(mainSliceDir, fileEntry.name);
+                        try {
+                            cpSync(src, dst, { force: true });
+                            synced.push(`milestones/${milestoneId}/slices/${sid}/${fileEntry.name}`);
+                        }
+                        catch { /* non-fatal */ }
+                    }
+                }
+            }
+        }
+        catch { /* non-fatal */ }
+    }
+    return { synced };
+}
 // ─── Worktree Post-Create Hook (#597) ────────────────────────────────────────
 /**
  * Run the user-configured post-create hook script after worktree creation.

package/dist/resources/extensions/gsd/auto.js

@@ -41,7 +41,7 @@ import { atomicWriteSync } from "./atomic-write.js";
 import { autoCommitCurrentBranch, captureIntegrationBranch, detectWorktreeName, getCurrentBranch, getMainBranch, setActiveMilestoneId, } from "./worktree.js";
 import { createGitService } from "./git-service.js";
 import { getPriorSliceCompletionBlocker } from "./dispatch-guard.js";
-import { createAutoWorktree, enterAutoWorktree, teardownAutoWorktree, isInAutoWorktree, getAutoWorktreePath, mergeMilestoneToMain, autoWorktreeBranch, } from "./auto-worktree.js";
+import { createAutoWorktree, enterAutoWorktree, teardownAutoWorktree, isInAutoWorktree, getAutoWorktreePath, mergeMilestoneToMain, autoWorktreeBranch, syncWorktreeStateBack, } from "./auto-worktree.js";
 import { pruneQueueOrder } from "./queue-order.js";
 import { showNextAction } from "../shared/mod.js";
 import { debugLog, debugTime, isDebugEnabled, writeDebugSummary } from "./debug-logger.js";
@@ -228,6 +228,16 @@ function tryMergeMilestone(ctx, milestoneId, mode) {
     // Worktree merge path
     if (isInAutoWorktree(s.basePath) && s.originalBasePath) {
         try {
+            // Sync completion artifacts from worktree → external state before merge (#1412)
+            try {
+                const { synced } = syncWorktreeStateBack(s.originalBasePath, s.basePath, milestoneId);
+                if (synced.length > 0) {
+                    debugLog("worktree-reverse-sync", { milestoneId, synced: synced.length });
+                }
+            }
+            catch (syncErr) {
+                debugLog("worktree-reverse-sync-failed", { milestoneId, error: getErrorMessage(syncErr) });
+            }
             const roadmapPath = resolveMilestoneFile(s.originalBasePath, milestoneId, "ROADMAP");
             if (!roadmapPath) {
                 teardownAutoWorktree(s.originalBasePath, milestoneId);

package/dist/resources/extensions/gsd/session-lock.js

@@ -129,6 +129,18 @@ function ensureExitHandler(gsdDir) {
  */
 export function acquireSessionLock(basePath) {
     const lp = lockPath(basePath);
+    // Re-entrant acquire on the same path: release our current OS lock first so
+    // proper-lockfile clears its update timer before we acquire a fresh lock.
+    if (_releaseFunction && _lockedPath === basePath) {
+        try {
+            _releaseFunction();
+        }
+        catch { /* may already be released */ }
+        _releaseFunction = null;
+        _lockedPath = null;
+        _lockPid = 0;
+        _lockCompromised = false;
+    }
     // Ensure the directory exists
     mkdirSync(dirname(lp), { recursive: true });
     // Clean up numbered lock file variants from cloud sync conflicts (#1315)
@@ -206,6 +218,7 @@ export function acquireSessionLock(basePath) {
                 _releaseFunction = release;
                 _lockedPath = basePath;
                 _lockPid = process.pid;
+                _lockCompromised = false;
                 // Safety net — uses centralized handler to avoid double-registration
                 ensureExitHandler(gsdDir);
                 atomicWriteSync(lp, JSON.stringify(lockData, null, 2));

package/package.json

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