gsd-pi 2.82.0 → 3.0.0-dev.2e8b124f7

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

@@ -20,6 +20,7 @@ import { existsSync, readFileSync, unlinkSync } from "node:fs";
 import { randomUUID } from "node:crypto";
 import { join } from "node:path";
 import { debugLog } from "./debug-logger.js";
+import { logWarning } from "./workflow-logger.js";
 import { emitJournalEvent } from "./journal.js";
 import { emitWorktreeCreated, emitWorktreeMerged } from "./worktree-telemetry.js";
 import { resolveWorktreeProjectRoot, normalizeWorktreePathForCompare, } from "./worktree-root.js";
@@ -48,6 +49,11 @@ import { nativeCheckoutBranch } from "./native-git-bridge.js";
 // is the only Module that calls them, and they live alongside the Module's
 // other primitives in `auto-worktree.ts`.
 import { autoWorktreeBranch, createAutoWorktree, enterAutoWorktree, enterBranchModeForMilestone, getAutoWorktreePath, isInAutoWorktree, teardownAutoWorktree, } from "./auto-worktree.js";
+const recentWorktreeMergeFailures = new Map();
+const MERGE_FAILURE_DEDUPE_MS = 60_000;
+export function resetRecentWorktreeMergeFailuresForTest() {
+    recentWorktreeMergeFailures.clear();
+}
 /**
  * Internal sentinel — thrown by `_mergeBranchMode` when it has already
  * emitted a user-visible error. The outer `mergeAndExit` catches the type
@@ -197,18 +203,9 @@ export function _enterMilestoneCore(s, deps, milestoneId, ctx) {
             cause: invalidMilestoneIdError(milestoneId),
         };
     }
-    if (s.isolationDegraded) {
-        debugLog("WorktreeLifecycle", {
-            action: "enterMilestone",
-            milestoneId,
-            skipped: true,
-            reason: "isolation-degraded",
-        });
-        return { ok: false, reason: "isolation-degraded" };
-    }
     // Phase B: claim a milestone lease before any worktree mutation. Two
     // workers cannot enter the same milestone concurrently. Best-effort:
-    // skip if no worker registered (single-worker fallback) or DB
+    // warn if no worker registered (single-worker fallback) or skip if DB
     // unavailable; reuse existing lease if we already hold it on this
     // milestone (re-entry within the same session).
     if (s.workerId) {
@@ -288,11 +285,43 @@ export function _enterMilestoneCore(s, deps, milestoneId, ctx) {
             }
         }
     }
+    else {
+        logWarning("worktree", `enterMilestone(${milestoneId}) ran before auto worker registration; milestone lease was not claimed.`);
+    }
     // Resolve the project root for worktree operations via shared helper.
     // Handles the case where originalBasePath is falsy and basePath is itself
     // a worktree path — prevents double-nested worktree paths (#3729).
     const basePath = resolveWorktreeProjectRoot(s.basePath, s.originalBasePath);
     const mode = getIsolationMode(basePath);
+    if (s.isolationDegraded) {
+        if (mode === "worktree") {
+            try {
+                lifecycleEnterBranchMode(deps, basePath, milestoneId);
+                s.basePath = basePath;
+                rebuildGitService(s, deps);
+                invalidateAllCaches();
+                ctx.notify(`Worktree isolation is degraded. Fell back to branch milestone/${milestoneId}.`, "warning");
+                return { ok: true, mode: "branch", path: basePath };
+            }
+            catch (err) {
+                debugLog("WorktreeLifecycle", {
+                    action: "enterMilestone",
+                    milestoneId,
+                    skipped: true,
+                    reason: "isolation-degraded",
+                    fallback: "branch-failed",
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+        debugLog("WorktreeLifecycle", {
+            action: "enterMilestone",
+            milestoneId,
+            skipped: true,
+            reason: "isolation-degraded",
+        });
+        return { ok: false, reason: "isolation-degraded" };
+    }
     if (mode === "none") {
         debugLog("WorktreeLifecycle", {
             action: "enterMilestone",
@@ -477,6 +506,28 @@ function rebuildGitService(s, deps) {
     // GitService cast.
     s.gitService = deps.gitServiceFactory(s.basePath);
 }
+function emitWorktreeMergeFailedOnce(basePath, milestoneId, err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const errorCategory = err instanceof Error ? err.name : "Error";
+    const now = Date.now();
+    const key = `${basePath}\0${milestoneId}\0${errorCategory}`;
+    const previous = recentWorktreeMergeFailures.get(key);
+    if (previous && now - previous < MERGE_FAILURE_DEDUPE_MS)
+        return;
+    for (const [candidate, ts] of recentWorktreeMergeFailures) {
+        if (now - ts >= MERGE_FAILURE_DEDUPE_MS) {
+            recentWorktreeMergeFailures.delete(candidate);
+        }
+    }
+    emitJournalEvent(basePath, {
+        ts: new Date().toISOString(),
+        flowId: randomUUID(),
+        seq: 0,
+        eventType: "worktree-merge-failed",
+        data: { milestoneId, error: msg },
+    });
+    recentWorktreeMergeFailures.set(key, now);
+}
 // ─── Session-less merge entry (ADR-016 phase 2 / A1) ─────────────────────
 /**
  * Worktree-mode merge body. Session-less — operates on a `MergeContext`.
@@ -590,13 +641,7 @@ function _mergeWorktreeModeImpl(deps, mctx) {
             error: msg,
             fallback: "chdir-to-project-root",
         });
-        emitJournalEvent(originalBasePath || worktreeBasePath, {
-            ts: new Date().toISOString(),
-            flowId: randomUUID(),
-            seq: 0,
-            eventType: "worktree-merge-failed",
-            data: { milestoneId, error: msg },
-        });
+        emitWorktreeMergeFailedOnce(originalBasePath || worktreeBasePath, milestoneId, err);
         // Surface a clear, actionable error. Worktree and milestone branch
         // are intentionally preserved — nothing has been deleted. User can
         // retry /gsd dispatch complete-milestone or merge manually once the
@@ -1198,17 +1243,36 @@ export class WorktreeLifecycle {
         }
     }
     /**
-     * Restore `s.basePath` to `s.originalBasePath` and rebuild `s.gitService`.
-     * No-op when `originalBasePath` is empty (fresh sessions).
+     * Restore `s.basePath` to `s.originalBasePath`, chdir process cwd, and
+     * rebuild `s.gitService`. No-op when `originalBasePath` is empty (fresh
+     * sessions).
      *
      * Used by error/cleanup paths that need the session to behave as if the
      * worktree was never entered. Does NOT teardown the worktree directory —
      * callers that need teardown go through `exitMilestone({ merge: false })`.
+     *
+     * ADR-016 phase 3 (#5693): chdir lives inside the verb so callers do not
+     * pair `restoreToProjectRoot()` with a redundant `process.chdir`. The
+     * chdir runs BEFORE the throwable work (`rebuildGitService`, cache
+     * invalidation) so that cleanup-path cwd is restored even if the
+     * downstream rebuild throws. The chdir itself is best-effort; failure is
+     * logged via debugLog and swallowed.
      */
     restoreToProjectRoot() {
         if (!this.s.originalBasePath)
             return;
         this.s.basePath = this.s.originalBasePath;
+        try {
+            process.chdir(this.s.basePath);
+        }
+        catch (err) {
+            debugLog("WorktreeLifecycle", {
+                action: "restoreToProjectRoot",
+                result: "chdir-failed",
+                basePath: this.s.basePath,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
         rebuildGitService(this.s, this.deps);
         invalidateAllCaches();
     }

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

@@ -177,7 +177,16 @@ export function createWorktree(basePath, name, opts = {}) {
         const gitFilePath = join(wtPath, ".git");
         if (!existsSync(gitFilePath)) {
             logWarning("reconcile", `Removing stale worktree directory (no .git file): ${wtPath}`, { worktree: name });
-            rmSync(wtPath, { recursive: true, force: true });
+            try {
+                rmSync(wtPath, { recursive: true, force: true });
+            }
+            catch (error) {
+                const code = error?.code;
+                if (code === "EPERM" || code === "EBUSY") {
+                    throw new GSDError(GSD_GIT_ERROR, `Cannot remove stale worktree directory at ${wtPath} (${code}: directory may be locked by another process). Close editors/antivirus/git tools using this path and retry.`, { cause: error });
+                }
+                throw error;
+            }
         }
         else {
             throw new GSDError(GSD_STALE_STATE, `Worktree "${name}" already exists at ${wtPath}`);
@@ -491,7 +500,7 @@ export function removeWorktree(basePath, name, opts = {}) {
             const nestedGitPath = join(nestedDir, ".git");
             try {
                 rmSync(nestedGitPath, { recursive: true, force: true });
-                logWarning("reconcile", `Removed nested .git directory from scaffolded project to prevent data loss (#2616)`, { worktree: name, nestedRepo: nestedDir });
+                logWarning("reconcile", `Removed nested .git directory from scaffolded project to prevent data loss`, { worktree: name, nestedRepo: nestedDir });
             }
             catch {
                 logWarning("reconcile", `Failed to remove nested .git directory — files may be lost as orphaned gitlink`, { worktree: name, nestedRepo: nestedDir });

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

@@ -1,6 +1,7 @@
 // Project/App: GSD-2
 // File Purpose: Worktree Safety module contract for validating source-writing Unit roots.
 import { existsSync, lstatSync } from "node:fs";
+import { execFileSync } from "node:child_process";
 import { join, resolve } from "node:path";
 import { normalizeWorktreePathForCompare } from "./worktree-root.js";
 import { listWorktrees } from "./worktree-manager.js";
@@ -17,6 +18,12 @@ const defaultDeps = {
             branch: worktree.branch,
         }));
     },
+    pruneRegisteredWorktrees(projectRoot) {
+        execFileSync("git", ["worktree", "prune"], {
+            cwd: projectRoot,
+            stdio: "pipe",
+        });
+    },
     getCurrentBranch,
 };
 function isValidMilestoneId(milestoneId) {
@@ -32,6 +39,7 @@ function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
 export function createWorktreeSafetyModule(deps = defaultDeps) {
+    const unregisteredRecoveryFailed = new Set();
     return {
         validateUnitRoot(input) {
             if (input.writeScope === "planning-only") {
@@ -79,7 +87,31 @@ export function createWorktreeSafetyModule(deps = defaultDeps) {
                 return failure("worktree-git-probe-failed", `Unable to list registered worktrees for project root ${projectRoot}.`, "Recover or recreate the milestone worktree before dispatching the source-writing Unit.", { projectRoot, error: errorMessage(error) });
             }
             if (registered && !registered.some((worktree) => samePath(worktree.path, unitRoot))) {
-                return failure("worktree-unregistered", `Worktree root ${unitRoot} is not registered with git worktree list.`, "Recreate or re-register the milestone worktree before dispatching the source-writing Unit.", { unitRoot });
+                const wasPreviouslyTracked = unregisteredRecoveryFailed.has(unitRoot);
+                let attemptedPrune = false;
+                if (!wasPreviouslyTracked && deps.pruneRegisteredWorktrees) {
+                    attemptedPrune = true;
+                    try {
+                        deps.pruneRegisteredWorktrees(projectRoot);
+                        const rechecked = deps.listRegisteredWorktrees?.(projectRoot);
+                        if (rechecked?.some((worktree) => samePath(worktree.path, unitRoot))) {
+                            unregisteredRecoveryFailed.delete(unitRoot);
+                            registered = rechecked;
+                        }
+                        else {
+                            unregisteredRecoveryFailed.add(unitRoot);
+                        }
+                    }
+                    catch (error) {
+                        unregisteredRecoveryFailed.add(unitRoot);
+                        return failure("worktree-git-probe-failed", `Unable to recover unregistered worktree root ${unitRoot}.`, "Run 'git worktree prune', then recreate the milestone worktree before dispatching the source-writing Unit.", { projectRoot, unitRoot, error: errorMessage(error) });
+                    }
+                }
+                if (!registered?.some((worktree) => samePath(worktree.path, unitRoot))) {
+                    return failure("worktree-unregistered", `Worktree root ${unitRoot} is not registered with git worktree list.`, attemptedPrune || wasPreviouslyTracked
+                        ? "Worktree recovery was attempted but the root is still unregistered. Recreate or re-register the milestone worktree before dispatching the source-writing Unit."
+                        : "Run 'git worktree prune'. If still unregistered, recreate or re-register the milestone worktree before dispatching the source-writing Unit.", { unitRoot, attemptedPrune, trackedAsFailed: unregisteredRecoveryFailed.has(unitRoot) });
+                }
             }
             if (input.emptyWorktreeWithProjectContent) {
                 return failure("empty-worktree-with-project-content", `Worktree root ${unitRoot} has no project content, but the project root does.`, "Resolve untracked project-root content or recreate the worktree so source writes stay isolated.", { unitRoot, projectRoot });

package/dist/resources/extensions/gsd/worktree-state-projection.js

@@ -100,6 +100,34 @@ function forceOverwriteAssessmentsWithVerdict(srcMilestoneDir, dstMilestoneDir)
         logWarning("worktree", `assessment sync failed: ${err instanceof Error ? err.message : String(err)}`);
     }
 }
+function syncTopLevelMilestoneArtifacts(srcMilestonesDir, dstMilestonesDir) {
+    if (!existsSync(srcMilestonesDir))
+        return;
+    try {
+        for (const milestoneEntry of readdirSync(srcMilestonesDir, { withFileTypes: true })) {
+            if (!milestoneEntry.isDirectory())
+                continue;
+            const srcMilestoneDir = join(srcMilestonesDir, milestoneEntry.name);
+            const dstMilestoneDir = join(dstMilestonesDir, milestoneEntry.name);
+            try {
+                mkdirSync(dstMilestoneDir, { recursive: true });
+                for (const fileEntry of readdirSync(srcMilestoneDir, { withFileTypes: true })) {
+                    if (!fileEntry.isFile())
+                        continue;
+                    if (!fileEntry.name.endsWith(".md") && !fileEntry.name.endsWith(".json"))
+                        continue;
+                    safeCopy(join(srcMilestoneDir, fileEntry.name), join(dstMilestoneDir, fileEntry.name), { force: false });
+                }
+            }
+            catch (err) {
+                logWarning("worktree", `milestone top-level artifact sync failed (${milestoneEntry.name}): ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
+    catch (err) {
+        logWarning("worktree", `milestone artifact scan failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
 /**
  * Root-level .gsd/ files copied from worktree back to project root for
  * post-merge diagnostics. Markdown projections are NOT in this list — DB
@@ -142,6 +170,9 @@ export function _projectRootToWorktreeImpl(projectRoot, worktreePath_, milestone
     // by validate-milestone) get clobbered by stale project root copies,
     // causing an infinite re-validation loop (#1886).
     safeCopyRecursive(join(prGsd, "milestones", milestoneId), join(wtGsd, "milestones", milestoneId), { force: false });
+    // Additively project missing top-level milestone files for all milestones
+    // so worktree-bound units can verify future-milestone context artifacts.
+    syncTopLevelMilestoneArtifacts(join(prGsd, "milestones"), join(wtGsd, "milestones"));
     // Force-sync ASSESSMENT files that have a verdict from project root (#2821).
     // The additive-only copy above preserves worktree-local files, but
     // ASSESSMENT files are special: after run-uat writes a verdict and post-unit