@opengsd/gsd-pi 1.4.0-dev.5fc22c6f → 1.4.0-dev.c18009cd

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

@@ -102,6 +102,51 @@ class UserNotifiedError extends Error {
 function isSamePathPhysical(a, b) {
     return normalizeWorktreePathForCompare(a) === normalizeWorktreePathForCompare(b);
 }
+function preflightBlockedMergeReason(blockedReason) {
+    if (blockedReason?.startsWith("unmerged-conflicts")) {
+        return "preflight-unmerged-conflicts";
+    }
+    return "preflight-dirty-overlap";
+}
+/**
+ * Run a milestone merge behind the Worktree Lifecycle seam with the root-clean
+ * stash guard that protects user changes around merge.
+ *
+ * The helper owns the invariant ordering (preflight -> merge callback ->
+ * postflight on every attempted merge path) and returns the same typed result
+ * shape as `exitMilestone`. Auto closeout remains responsible for translating
+ * that result into loop policy (pause vs. stop, visible transcript
+ * preservation, projection rebuild).
+ */
+function runGuardedMilestoneMerge(request) {
+    const { merge, guard, milestoneId, notify } = request;
+    const preflight = guard.preflightCleanRoot(guard.projectRoot, milestoneId, notify);
+    if (preflight.blocked) {
+        return {
+            ok: false,
+            reason: preflightBlockedMergeReason(preflight.blockedReason),
+        };
+    }
+    let mergeError = null;
+    const exitResult = merge();
+    if (!exitResult.ok) {
+        mergeError = exitResult.cause ?? new Error(`exit ${exitResult.reason}`);
+    }
+    let postflight;
+    if (preflight.stashPushed) {
+        postflight = guard.postflightPopStash(guard.projectRoot, milestoneId, preflight.stashMarker, notify);
+    }
+    if (mergeError instanceof MergeConflictError) {
+        return { ok: false, reason: "merge-conflict", cause: mergeError, postflight };
+    }
+    if (mergeError) {
+        return { ok: false, reason: "merge-failed", cause: mergeError, postflight };
+    }
+    if (postflight?.needsManualRecovery) {
+        return { ok: false, reason: "postflight-stash-restore-failed", postflight };
+    }
+    return exitResult;
+}
 // ─── Validation ──────────────────────────────────────────────────────────
 function isValidMilestoneId(milestoneId) {
     return !/[\/\\]|\.\./.test(milestoneId);
@@ -645,7 +690,7 @@ function _mergeWorktreeModeImpl(deps, mctx) {
                 pushed: false,
             };
         }
-        const mergeResult = deps.mergeMilestoneToMain(originalBasePath, milestoneId, roadmapResolution.content);
+        const mergeResult = deps.mergeMilestone(originalBasePath, milestoneId, roadmapResolution.content);
         // #2945 Bug 3: mergeMilestoneToMain performs best-effort worktree
         // cleanup internally (step 12), but it can silently fail on Windows
         // or when the worktree directory is locked. Perform a secondary
@@ -780,7 +825,7 @@ function _mergeBranchModeImpl(deps, mctx) {
                 pushed: false,
             };
         }
-        const mergeResult = deps.mergeMilestoneToMain(worktreeBasePath, milestoneId, roadmapResolution.content);
+        const mergeResult = deps.mergeMilestone(worktreeBasePath, milestoneId, roadmapResolution.content);
         if (mergeResult.codeFilesChanged) {
             notify(`Milestone ${milestoneId} merged (branch mode).${mergeResult.pushed ? " Pushed to remote." : ""}`, "info");
         }
@@ -983,14 +1028,31 @@ export class WorktreeLifecycle {
      * With `opts.merge === false`, runs auto-commit and teardown without
      * merging to main.
      *
+     * When `opts.guardedMerge` is present with `opts.merge === true`, the
+     * lifecycle verb also owns the root-clean guard around the merge: preflight
+     * runs before the inner merge, postflight stash restore runs after every
+     * attempted merge path, and guard failures are returned as typed
+     * `ExitResult` reasons.
+     *
      * Returns a typed `ExitResult`. `MergeConflictError` is surfaced as
      * `{ ok: false, reason: "merge-conflict", cause }` instead of thrown,
-     * giving callers a typed branch for the expected failure path.
-     * Unexpected failures (filesystem, git permissions, etc.) are wrapped
-     * as `{ ok: false, reason: "teardown-failed", cause }` so callers always
+     * giving callers a typed branch for the expected failure path. Guarded merge
+     * failures surface as `preflight-dirty-overlap`,
+     * `preflight-unmerged-conflicts`, `merge-failed`, or
+     * `postflight-stash-restore-failed`. Unexpected failures (filesystem, git
+     * permissions, etc.) are wrapped as
+     * `{ ok: false, reason: "teardown-failed", cause }` so callers always
      * receive a discriminated union — no exceptions for any expected outcome.
      */
     exitMilestone(milestoneId, opts, ctx) {
+        if (opts.merge && opts.guardedMerge) {
+            return runGuardedMilestoneMerge({
+                merge: () => this.exitMilestone(milestoneId, { merge: true }, ctx),
+                guard: opts.guardedMerge,
+                milestoneId,
+                notify: ctx.notify,
+            });
+        }
         if (opts.merge) {
             try {
                 const merged = this._mergeAndExit(milestoneId, ctx);