gsd-pi 2.82.0 → 3.0.0-dev.04f5ccf82

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

@@ -241,7 +241,19 @@ export function createWorktree(basePath: string, name: string, opts: { branch?:
     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 as NodeJS.ErrnoException)?.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 as Error },
+          );
+        }
+        throw error;
+      }
     } else {
       throw new GSDError(GSD_STALE_STATE, `Worktree "${name}" already exists at ${wtPath}`);
     }
@@ -618,7 +630,7 @@ export function removeWorktree(
       try {
         rmSync(nestedGitPath, { recursive: true, force: true });
         logWarning("reconcile",
-          `Removed nested .git directory from scaffolded project to prevent data loss (#2616)`,
+          `Removed nested .git directory from scaffolded project to prevent data loss`,
           { worktree: name, nestedRepo: nestedDir },
         );
       } catch {

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

@@ -2,6 +2,7 @@
 // File Purpose: Worktree Safety module contract for validating source-writing Unit roots.
 
 import { existsSync, lstatSync, type Stats } from "node:fs";
+import { execFileSync } from "node:child_process";
 import { join, resolve } from "node:path";
 
 import { normalizeWorktreePathForCompare } from "./worktree-root.js";
@@ -52,6 +53,7 @@ export interface WorktreeSafetyInput {
   projectRoot: string;
   unitRoot: string;
   milestoneId?: string | null;
+  isolationMode?: "none" | "branch" | "worktree";
   expectedBranch?: string | null;
   emptyWorktreeWithProjectContent?: boolean;
   lease?: {
@@ -70,6 +72,7 @@ export interface WorktreeSafetyDeps {
   existsSync(path: string): boolean;
   lstatSync(path: string): Pick<Stats, "isFile">;
   listRegisteredWorktrees?(projectRoot: string): readonly RegisteredWorktree[];
+  pruneRegisteredWorktrees?(projectRoot: string): void;
   getCurrentBranch?(unitRoot: string): string;
 }
 
@@ -90,6 +93,12 @@ const defaultDeps: WorktreeSafetyDeps = {
       branch: worktree.branch,
     }));
   },
+  pruneRegisteredWorktrees(projectRoot) {
+    execFileSync("git", ["worktree", "prune"], {
+      cwd: projectRoot,
+      stdio: "pipe",
+    });
+  },
   getCurrentBranch,
 };
 
@@ -117,6 +126,8 @@ function errorMessage(error: unknown): string {
 export function createWorktreeSafetyModule(
   deps: WorktreeSafetyDeps = defaultDeps,
 ): WorktreeSafetyModule {
+  const unregisteredRecoveryFailed = new Set<string>();
+
   return {
     validateUnitRoot(input) {
       if (input.writeScope === "planning-only") {
@@ -146,12 +157,19 @@ export function createWorktreeSafetyModule(
 
       const projectRoot = resolve(input.projectRoot);
       const unitRoot = resolve(input.unitRoot);
-      const expectedRoot = join(projectRoot, ".gsd", "worktrees", milestoneId);
+      const isolationMode = input.isolationMode ?? "worktree";
+      const expectedRoot = isolationMode === "worktree"
+        ? join(projectRoot, ".gsd", "worktrees", milestoneId)
+        : projectRoot;
       if (!samePath(unitRoot, expectedRoot)) {
         return failure(
           "invalid-root",
-          `Unit root ${unitRoot} is not the expected worktree root for ${milestoneId}.`,
-          "Prepare the Unit in its canonical milestone worktree before allowing source writes.",
+          isolationMode === "worktree"
+            ? `Unit root ${unitRoot} is not the expected worktree root for ${milestoneId}.`
+            : `Unit root ${unitRoot} is not the project root while isolation mode is ${isolationMode}.`,
+          isolationMode === "worktree"
+            ? "Prepare the Unit in its canonical milestone worktree before allowing source writes."
+            : "Run the Unit from the project root when worktree isolation is disabled.",
           { expectedRoot, unitRoot },
         );
       }
@@ -187,7 +205,7 @@ export function createWorktreeSafetyModule(
         );
       }
 
-      if (!gitMarkerStat.isFile()) {
+      if (isolationMode === "worktree" && !gitMarkerStat.isFile()) {
         return failure(
           "worktree-git-marker-not-file",
           `Worktree root ${unitRoot} has a .git directory, not a registered worktree .git file.`,
@@ -208,12 +226,41 @@ export function createWorktreeSafetyModule(
         );
       }
       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) {

package/src/resources/extensions/gsd/worktree-state-projection.ts

@@ -123,6 +123,45 @@ function forceOverwriteAssessmentsWithVerdict(
   }
 }
 
+function syncTopLevelMilestoneArtifacts(
+  srcMilestonesDir: string,
+  dstMilestonesDir: string,
+): void {
+  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
@@ -176,6 +215,10 @@ export function _projectRootToWorktreeImpl(
     { 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

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

@@ -50,10 +50,47 @@ export type AutoExitReason =
   | "merge-conflict"
   | "merge-failed"
   | "slice-merge-conflict"
+  | "provider-error"
+  | "session-failed"
+  | "stream-aborted"
+  | "unit-aborted"
+  | "verification-exhausted"
   | "all-complete"
   | "no-active-milestone"
   | "other";
 
+export function normalizeAutoExitReason(rawReason?: string): AutoExitReason {
+  const reason = rawReason ?? "stop";
+  const reasonLc = reason.toLowerCase();
+  return reasonLc.startsWith("blocked:")
+    ? "blocked"
+    : reasonLc.startsWith("merge conflict")
+      ? "merge-conflict"
+      : reasonLc.startsWith("merge error") || reasonLc.startsWith("merge failed")
+        ? "merge-failed"
+        : reasonLc.startsWith("slice-parallel dispatched")
+          ? "stop"
+          : reasonLc.startsWith("slice-merge-conflict")
+            ? "slice-merge-conflict"
+            : reasonLc.startsWith("provider error")
+              ? "provider-error"
+              : reasonLc.startsWith("session creation")
+                ? "session-failed"
+                : reasonLc.startsWith("operation aborted") || reasonLc.includes("stream aborted")
+                  ? "stream-aborted"
+                  : reasonLc.startsWith("auto-mode stopped")
+                    ? "unit-aborted"
+                    : reasonLc.includes("pausing auto-mode after") && reasonLc.includes("retries")
+                      ? "verification-exhausted"
+                      : reasonLc === "all milestones complete"
+                        ? "all-complete"
+                        : reasonLc === "no active milestone"
+                          ? "no-active-milestone"
+                          : reasonLc === "stop" || reasonLc === "pause"
+                            ? reasonLc
+                            : "other";
+}
+
 // ─── Emitters ────────────────────────────────────────────────────────────
 
 export function emitWorktreeCreated(
@@ -125,6 +162,7 @@ export function emitAutoExit(
      *  reasons (e.g. stopAuto's `reason?: string` parameter) should map to
      *  the closed set before emitting. */
     reason: AutoExitReason;
+    rawReason?: string;
     milestoneId?: string;
     milestoneMerged: boolean;
     isolationMode?: WorktreeIsolationMode;
@@ -133,6 +171,7 @@ export function emitAutoExit(
 ): void {
   emitJournalEvent(projectRoot, baseEntry("auto-exit", {
     reason: meta.reason,
+    rawReason: meta.rawReason,
     flowId: meta.flowId,
     milestoneId: meta.milestoneId,
     milestoneMerged: meta.milestoneMerged,