gsd-pi 2.80.0-dev.3065f7bfa → 2.80.0-dev.488219eb6

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

@@ -18,6 +18,8 @@ import { bumpTurnGeneration } from "./turn-epoch.js";
 let _currentResolve = null;
 let _sessionSwitchInFlight = false;
 let _pendingSwitchCancellation = null;
+let _sessionSwitchAbortGraceUntil = 0;
+const DEFAULT_SESSION_SWITCH_ABORT_GRACE_MS = 2_000;
 // ─── Setters (needed for cross-module mutation) ─────────────────────────────
 export function _setCurrentResolve(fn) {
     _currentResolve = fn;
@@ -25,6 +27,15 @@ export function _setCurrentResolve(fn) {
 export function _setSessionSwitchInFlight(v) {
     _sessionSwitchInFlight = v;
 }
+export function _markSessionSwitchAbortGraceWindow(durationMs = DEFAULT_SESSION_SWITCH_ABORT_GRACE_MS) {
+    _sessionSwitchAbortGraceUntil = Math.max(_sessionSwitchAbortGraceUntil, Date.now() + durationMs);
+}
+export function _clearSessionSwitchAbortGraceWindow() {
+    _sessionSwitchAbortGraceUntil = 0;
+}
+export function isSessionSwitchAbortGraceActive(now = Date.now()) {
+    return now < _sessionSwitchAbortGraceUntil;
+}
 export function _clearCurrentResolve() {
     _currentResolve = null;
 }
@@ -118,6 +129,7 @@ export function _resetPendingResolve() {
     _currentResolve = null;
     _sessionSwitchInFlight = false;
     _pendingSwitchCancellation = null;
+    _sessionSwitchAbortGraceUntil = 0;
 }
 export function _hasPendingResolveForTest() {
     return _currentResolve !== null;

package/dist/resources/extensions/gsd/auto/run-unit.js

@@ -1,6 +1,6 @@
 // GSD-2 + src/resources/extensions/gsd/auto/run-unit.ts - Runs one GSD auto-mode unit from session creation through agent completion.
 import { NEW_SESSION_TIMEOUT_MS } from "./session.js";
-import { _clearCurrentResolve, _consumePendingSwitchCancellation, _setCurrentResolve, _setSessionSwitchInFlight, } from "./resolve.js";
+import { _clearCurrentResolve, _consumePendingSwitchCancellation, _markSessionSwitchAbortGraceWindow, _setCurrentResolve, _setSessionSwitchInFlight, } from "./resolve.js";
 import { getCurrentTurnGeneration, runWithTurnGeneration, } from "./turn-epoch.js";
 import { debugLog } from "../debug-logger.js";
 import { logWarning } from "../workflow-logger.js";
@@ -35,6 +35,7 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
             workspaceRoot: s.basePath,
         }).finally(() => {
             if (sessionSwitchGeneration === mySessionSwitchGeneration) {
+                _markSessionSwitchAbortGraceWindow();
                 _setSessionSwitchInFlight(false);
             }
         });
@@ -89,6 +90,7 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     // ── Create the agent_end promise (per-unit one-shot) ──
     // This happens after newSession completes so session-switch agent_end events
     // from the previous session cannot resolve the new unit.
+    _markSessionSwitchAbortGraceWindow();
     _setSessionSwitchInFlight(false);
     const unitPromise = new Promise((resolve) => {
         _setCurrentResolve(resolve);

package/dist/resources/extensions/gsd/auto/workflow-dispatch-claim.js

@@ -1,7 +1,39 @@
 // Project/App: GSD-2
 // File Purpose: Best-effort unit dispatch claim adapter for auto-mode loop.
+export function ensureDispatchLease(s, milestoneId, deps, opts = {}) {
+    if (!s.workerId)
+        return { kind: "degraded", reason: "missing-worker" };
+    if (!milestoneId)
+        return { kind: "degraded", reason: "missing-milestone" };
+    if (!opts.forceReclaim && typeof s.milestoneLeaseToken === "number") {
+        return { kind: "ready", token: s.milestoneLeaseToken, recovered: false };
+    }
+    s.milestoneLeaseToken = null;
+    try {
+        const claim = deps.claimMilestoneLease(s.workerId, milestoneId);
+        if (!claim.ok) {
+            const reason = `Milestone ${milestoneId} is held by worker ${claim.byWorker} until ${claim.expiresAt}.`;
+            deps.logLeaseRecoveryFailed({ milestoneId, workerId: s.workerId, reason });
+            return { kind: "blocked", reason };
+        }
+        s.currentMilestoneId = milestoneId;
+        s.milestoneLeaseToken = claim.token;
+        deps.logLeaseRecovered({
+            milestoneId,
+            workerId: s.workerId,
+            token: claim.token,
+            recovered: opts.forceReclaim === true,
+        });
+        return { kind: "ready", token: claim.token, recovered: opts.forceReclaim === true };
+    }
+    catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        deps.logLeaseRecoveryFailed({ milestoneId, workerId: s.workerId, reason });
+        return { kind: "failed", reason };
+    }
+}
 export function openDispatchClaim(s, flowId, turnId, iterData, deps) {
-    if (!s.workerId || s.milestoneLeaseToken === null)
+    if (!s.workerId || typeof s.milestoneLeaseToken !== "number")
         return { kind: "degraded" };
     const mid = iterData.mid;
     if (!mid)

package/dist/resources/extensions/gsd/auto/workflow-worker-heartbeat.js

@@ -6,7 +6,15 @@ export function maintainWorkerHeartbeat(session, deps) {
     try {
         deps.heartbeatAutoWorker(session.workerId);
         if (session.currentMilestoneId && session.milestoneLeaseToken) {
-            deps.refreshMilestoneLease(session.workerId, session.currentMilestoneId, session.milestoneLeaseToken);
+            const refreshed = deps.refreshMilestoneLease(session.workerId, session.currentMilestoneId, session.milestoneLeaseToken);
+            if (!refreshed) {
+                deps.logLeaseRefreshMiss?.({
+                    workerId: session.workerId,
+                    milestoneId: session.currentMilestoneId,
+                    fencingToken: session.milestoneLeaseToken,
+                });
+                session.milestoneLeaseToken = null;
+            }
         }
     }
     catch (err) {

package/dist/resources/extensions/gsd/auto-post-unit.js

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Auto-mode post-unit git, verification, projection, and hook processing.
 /**
  * Post-unit processing for auto-loop — auto-commit, doctor run,
  * state rebuild, projection checks, DB tool closeout, hooks, triage, and
@@ -70,6 +72,62 @@ function formatPreExecutionCheckDetail(check) {
 }
 const COMPLETE_MILESTONE_DB_SETTLE_MS = 1500;
 const COMPLETE_MILESTONE_DB_SETTLE_POLL_MS = 100;
+function stripKnownIdPrefix(value, id) {
+    const raw = String(value ?? "").trim();
+    if (!raw)
+        return undefined;
+    const lower = raw.toLowerCase();
+    const idLower = id.toLowerCase();
+    if (lower.startsWith(`${idLower}:`))
+        return raw.slice(id.length + 1).trim() || undefined;
+    return raw;
+}
+async function buildTaskCommitContextForUnit(basePath, unitId) {
+    const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
+    if (!mid || !sid || !tid)
+        return undefined;
+    const milestone = isDbAvailable() ? getMilestone(mid) : null;
+    const slice = isDbAvailable() ? getSlice(mid, sid) : null;
+    const task = isDbAvailable() ? getTask(mid, sid, tid) : null;
+    let summary = null;
+    const summaryPath = resolveTaskFile(basePath, mid, sid, tid, "SUMMARY");
+    if (summaryPath) {
+        try {
+            const summaryContent = await loadFile(summaryPath);
+            if (summaryContent)
+                summary = parseSummary(summaryContent);
+        }
+        catch (e) {
+            debugLog("postUnit", { phase: "task-summary-parse", error: String(e) });
+        }
+    }
+    if (!summary && !task)
+        return undefined;
+    let ghIssueNumber;
+    try {
+        const { getTaskIssueNumberForCommit } = await import("../github-sync/sync.js");
+        ghIssueNumber = getTaskIssueNumberForCommit(basePath, mid, sid, tid) ?? undefined;
+    }
+    catch (err) {
+        logWarning("engine", `GitHub issue lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return {
+        taskId: `${sid}/${tid}`,
+        taskDisplayId: tid,
+        taskTitle: stripKnownIdPrefix(summary?.title, tid) ??
+            stripKnownIdPrefix(task?.title, tid) ??
+            tid,
+        milestoneId: mid,
+        milestoneTitle: stripKnownIdPrefix(milestone?.title, mid),
+        sliceId: sid,
+        sliceTitle: stripKnownIdPrefix(slice?.title, sid),
+        oneLiner: summary?.oneLiner || task?.one_liner || undefined,
+        keyFiles: summary?.frontmatter.key_files?.filter(f => !f.includes("{{")) ??
+            task?.key_files ??
+            undefined,
+        issueNumber: ghIssueNumber,
+    };
+}
 async function waitForMilestoneDbClose(mid) {
     const deadline = Date.now() + COMPLETE_MILESTONE_DB_SETTLE_MS;
     while (Date.now() < deadline) {
@@ -96,6 +154,19 @@ function enqueueSidecar(s, ctx, entry, debugExtra, notification) {
         ctx.ui.notify(notification, "info");
     return "continue";
 }
+export function _shouldDispatchTriageForTest(state) {
+    return !state.stepMode &&
+        !!state.currentUnit &&
+        !state.currentUnit.type.startsWith("hook/") &&
+        state.currentUnit.type !== "triage-captures" &&
+        state.currentUnit.type !== "quick-task";
+}
+export function _shouldDispatchQuickTaskForTest(state) {
+    return !state.stepMode &&
+        state.pendingQuickTasks.length > 0 &&
+        !!state.currentUnit &&
+        state.currentUnit.type !== "quick-task";
+}
 /** Unit types that only touch `.gsd/` internal state files (no code changes).
  *  Auto-commit is skipped for these — their state files are picked up by the
  *  next actual task commit via `smartStage()`. */
@@ -216,7 +287,7 @@ export function detectRogueFileWrites(unitType, unitId, basePath) {
  * in auto-verification.ts. Exceeding this limit pauses auto-mode instead of
  * looping indefinitely (#2007).
  */
-const MAX_ARTIFACT_VERIFICATION_RETRIES = 3;
+export const MAX_ARTIFACT_VERIFICATION_RETRIES = 3;
 export const STEP_COMPLETE_FALLBACK_MESSAGE = "Step complete. Run /clear, then /gsd to continue (or /gsd auto to run continuously).";
 export function buildStepCompleteMessage(nextState) {
     if (nextState.phase === "complete") {
@@ -267,36 +338,7 @@ export async function autoCommitUnit(basePath, unitType, unitId, ctx) {
     try {
         let taskContext;
         if (unitType === "execute-task") {
-            const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
-            if (mid && sid && tid) {
-                const summaryPath = resolveTaskFile(basePath, mid, sid, tid, "SUMMARY");
-                if (summaryPath) {
-                    try {
-                        const summaryContent = await loadFile(summaryPath);
-                        if (summaryContent) {
-                            const summary = parseSummary(summaryContent);
-                            let ghIssueNumber;
-                            try {
-                                const { getTaskIssueNumberForCommit } = await import("../github-sync/sync.js");
-                                ghIssueNumber = getTaskIssueNumberForCommit(basePath, mid, sid, tid) ?? undefined;
-                            }
-                            catch (err) {
-                                logWarning("engine", `GitHub issue lookup failed: ${err instanceof Error ? err.message : String(err)}`);
-                            }
-                            taskContext = {
-                                taskId: `${sid}/${tid}`,
-                                taskTitle: summary.title?.replace(/^T\d+:\s*/, "") || tid,
-                                oneLiner: summary.oneLiner || undefined,
-                                keyFiles: summary.frontmatter.key_files?.filter(f => !f.includes("{{")) || undefined,
-                                issueNumber: ghIssueNumber,
-                            };
-                        }
-                    }
-                    catch (e) {
-                        debugLog("postUnit", { phase: "task-summary-parse", error: String(e) });
-                    }
-                }
-            }
+            taskContext = await buildTaskCommitContextForUnit(basePath, unitId);
         }
         _resetHasChangesCache();
         if (LIFECYCLE_ONLY_UNITS.has(unitType)) {
@@ -359,38 +401,7 @@ export async function postUnitPreVerification(pctx, opts) {
         try {
             let taskContext;
             if (turnAction === "commit" && s.currentUnit.type === "execute-task") {
-                const { milestone: mid, slice: sid, task: tid } = parseUnitId(s.currentUnit.id);
-                if (mid && sid && tid) {
-                    const summaryPath = resolveTaskFile(s.basePath, mid, sid, tid, "SUMMARY");
-                    if (summaryPath) {
-                        try {
-                            const summaryContent = await loadFile(summaryPath);
-                            if (summaryContent) {
-                                const summary = parseSummary(summaryContent);
-                                // Look up GitHub issue number for commit linking
-                                let ghIssueNumber;
-                                try {
-                                    const { getTaskIssueNumberForCommit } = await import("../github-sync/sync.js");
-                                    ghIssueNumber = getTaskIssueNumberForCommit(s.basePath, mid, sid, tid) ?? undefined;
-                                }
-                                catch (err) {
-                                    // GitHub sync not available — skip
-                                    logWarning("engine", `GitHub issue lookup failed: ${err instanceof Error ? err.message : String(err)}`);
-                                }
-                                taskContext = {
-                                    taskId: `${sid}/${tid}`,
-                                    taskTitle: summary.title?.replace(/^T\d+:\s*/, "") || tid,
-                                    oneLiner: summary.oneLiner || undefined,
-                                    keyFiles: summary.frontmatter.key_files?.filter(f => !f.includes("{{")) || undefined,
-                                    issueNumber: ghIssueNumber,
-                                };
-                            }
-                        }
-                        catch (e) {
-                            debugLog("postUnit", { phase: "task-summary-parse", error: String(e) });
-                        }
-                    }
-                }
+                taskContext = await buildTaskCommitContextForUnit(s.basePath, s.currentUnit.id);
             }
             // Invalidate the nativeHasChanges cache before auto-commit (#1853).
             // The cache has a 10-second TTL and is keyed by basePath.  A stale
@@ -1123,10 +1134,11 @@ export async function postUnitPostVerification(pctx) {
                     return;
                 }
                 const strictMode = prefs?.enhanced_verification_strict === true;
-                // Run pre-execution checks against the canonical project root. In
-                // worktree isolation, s.basePath can point at a metadata-only worktree,
-                // while source files remain under the project root.
-                const preExecutionBasePath = s.canonicalProjectRoot;
+                // Run pre-execution checks against s.basePath — the actual checkout
+                // where prior-slice files were created.  In worktree isolation,
+                // s.canonicalProjectRoot is the project root and lacks files that a
+                // prior slice wrote to the worktree but hasn't merged to main yet.
+                const preExecutionBasePath = s.basePath;
                 const result = await runPreExecutionChecks(tasks, preExecutionBasePath);
                 // Log summary to stderr in existing verification output format
                 const emoji = result.status === "pass" ? "✅" : result.status === "warn" ? "⚠️" : "❌";
@@ -1266,11 +1278,7 @@ export async function postUnitPostVerification(pctx) {
         }
     }
     // ── Triage check ──
-    if (!s.stepMode &&
-        s.currentUnit &&
-        !s.currentUnit.type.startsWith("hook/") &&
-        s.currentUnit.type !== "triage-captures" &&
-        s.currentUnit.type !== "quick-task") {
+    if (_shouldDispatchTriageForTest(s)) {
         try {
             if (hasPendingCaptures(s.basePath)) {
                 const pending = loadPendingCaptures(s.basePath);
@@ -1308,10 +1316,7 @@ export async function postUnitPostVerification(pctx) {
         }
     }
     // ── Quick-task dispatch ──
-    if (!s.stepMode &&
-        s.pendingQuickTasks.length > 0 &&
-        s.currentUnit &&
-        s.currentUnit.type !== "quick-task") {
+    if (_shouldDispatchQuickTaskForTest(s)) {
         try {
             const capture = s.pendingQuickTasks.shift();
             const { buildQuickTaskPrompt } = await import("./triage-resolution.js");

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

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Auto-mode bootstrap, worktree recovery, and fresh-start initialization.
 /**
  * Auto-mode bootstrap — fresh-start initialization path.
  *
@@ -44,6 +46,11 @@ import { resolveProjectRootDbPath } from "./bootstrap/dynamic-tools.js";
 import { validateDirectory } from "./validate-directory.js";
 import { isCustomProvider, resolveDefaultSessionModel, resolveDynamicRoutingConfig, } from "./preferences-models.js";
 import { getSessionModelOverride } from "./session-model-override.js";
+export function resolveIsolationNoneBranchCheckout(currentBranch, integrationBranch, isolationMode, isRepo) {
+    if (!isRepo || isolationMode !== "none")
+        return null;
+    return currentBranch.startsWith("milestone/") ? integrationBranch : null;
+}
 /**
  * Bootstrap a fresh auto-mode session. Handles everything from git init
  * through secrets collection, returning when ready for the first
@@ -55,6 +62,12 @@ import { getSessionModelOverride } from "./session-model-override.js";
 // Guard constant for consecutive bootstrap attempts that found phase === "complete".
 // Counter moved to AutoSession.consecutiveCompleteBootstraps so s.reset() clears it.
 const MAX_CONSECUTIVE_COMPLETE_BOOTSTRAPS = 2;
+export function hasGitIndexLockForTest(basePath) {
+    return existsSync(join(basePath, ".git", "index.lock"));
+}
+export function _shouldAbortBootstrapForUnavailableDbForTest(gsdDbPath, dbAvailable, pathExists = existsSync) {
+    return pathExists(gsdDbPath) && !dbAvailable;
+}
 export async function openProjectDbIfPresent(basePath) {
     const gsdDbPath = resolveProjectRootDbPath(basePath);
     if (!existsSync(gsdDbPath) || isDbAvailable())
@@ -670,7 +683,26 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         {
             const orphan = findUnmergedCompletedMilestone(base, getIsolationMode(base));
             if (orphan && orphan !== state.activeMilestone?.id) {
+                const priorBasePath = s.basePath;
+                const priorOriginalBasePath = s.originalBasePath;
+                s.originalBasePath = base;
+                s.basePath = getAutoWorktreePath(base, orphan) ?? base;
                 const result = _mergeOrphanCompletedMilestone(buildResolver(), orphan, ctx.ui);
+                if (!result.merged) {
+                    s.basePath = base;
+                    s.originalBasePath = base;
+                    try {
+                        process.chdir(base);
+                    }
+                    catch (err) {
+                        logWarning("bootstrap", `could not restore cwd after orphan merge failure: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                    return releaseLockAndReturn();
+                }
+                if (!s.active) {
+                    s.basePath = priorBasePath || base;
+                    s.originalBasePath = priorOriginalBasePath || base;
+                }
                 if (result.merged) {
                     invalidateAllCaches();
                     state = await deriveState(base);
@@ -797,13 +829,16 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         // Guard against stale milestone branch when isolation:none (#3613).
         // A prior session with isolation:branch/worktree may have left HEAD on
         // milestone/<MID>. Auto-checkout back to the integration branch.
-        if (getIsolationMode(base) === "none" && nativeIsRepo(base)) {
+        const isolationMode = getIsolationMode(base);
+        const isRepo = nativeIsRepo(base);
+        if (isolationMode === "none" && isRepo) {
             try {
                 const currentBranch = nativeGetCurrentBranch(base);
-                if (currentBranch.startsWith("milestone/")) {
-                    const integrationBranch = nativeDetectMainBranch(base);
-                    nativeCheckoutBranch(base, integrationBranch);
-                    logWarning("bootstrap", `Returned to "${integrationBranch}" — HEAD was on stale milestone branch "${currentBranch}" (isolation: none does not use milestone branches).`);
+                const integrationBranch = nativeDetectMainBranch(base);
+                const branchToCheckout = resolveIsolationNoneBranchCheckout(currentBranch, integrationBranch, isolationMode, isRepo);
+                if (branchToCheckout) {
+                    nativeCheckoutBranch(base, branchToCheckout);
+                    logWarning("bootstrap", `Returned to "${branchToCheckout}" — HEAD was on stale milestone branch "${currentBranch}" (isolation: none does not use milestone branches).`);
                 }
             }
             catch (err) {
@@ -848,7 +883,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
                 logError("engine", `failed to initialize project database: ${err.message}`);
             }
         }
-        if (existsSync(gsdDbPath) && !isDbAvailable()) {
+        if (_shouldAbortBootstrapForUnavailableDbForTest(gsdDbPath, isDbAvailable())) {
             try {
                 const { openDatabase: openDb } = await import("./gsd-db.js");
                 openDb(gsdDbPath);