gsd-pi 2.77.0-dev.538325aea → 2.77.0-dev.58d3d4d6c

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

@@ -15,7 +15,6 @@ import { isDbAvailable, getTask, getSlice, getSliceTasks, getPendingGates, updat
 import { isValidationTerminal } from "./state.js";
 import { getErrorMessage } from "./error-utils.js";
 import { logWarning, logError } from "./workflow-logger.js";
-import { splitFrontmatter, parseFrontmatterMap } from "./files.js";
 import { isClosedStatus } from "./status-guards.js";
 import { nativeConflictFiles, nativeCommit, nativeCheckoutTheirs, nativeAddPaths, nativeMergeAbort, nativeResetHard, } from "./native-git-bridge.js";
 import { resolveSlicePath, resolveSliceFile, resolveTasksDir, resolveTaskFiles, relMilestoneFile, relSliceFile, buildSliceFileName, resolveMilestoneFile, clearPathCache, resolveGsdRootFile, } from "./paths.js";
@@ -23,32 +22,10 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, } from
 import { execFileSync } from "node:child_process";
 import { dirname, join } from "node:path";
 import { resolveExpectedArtifactPath, diagnoseExpectedArtifact, } from "./auto-artifact-paths.js";
+import { classifyMilestoneSummaryContent } from "./milestone-summary-classifier.js";
 // Re-export so existing consumers of auto-recovery.ts keep working.
 export { resolveExpectedArtifactPath, diagnoseExpectedArtifact };
-/**
- * Classify milestone summary content for recovery/dispatch decisions.
- * - success: canonical completion summary (frontmatter status is closed)
- * - failure: explicit blocker/failure markers
- * - unknown: ambiguous content
- */
-export function classifyMilestoneSummaryContent(content) {
-    const [fmLines] = splitFrontmatter(content);
-    const fm = fmLines ? parseFrontmatterMap(fmLines) : null;
-    const rawStatus = typeof fm?.status === "string" ? fm.status.trim().toLowerCase() : "";
-    if (rawStatus) {
-        if (isClosedStatus(rawStatus))
-            return "success";
-        if (["active", "pending", "blocked", "failed", "incomplete"].includes(rawStatus))
-            return "failure";
-    }
-    const failureSignal = /(?:^|\n)\s*#\s*BLOCKER\b/i.test(content)
-        || /auto-mode recovery failed/i.test(content)
-        || /verification\s+failed/i.test(content)
-        || /\bnot complete\b/i.test(content);
-    if (failureSignal)
-        return "failure";
-    return "unknown";
-}
+export { classifyMilestoneSummaryContent, } from "./milestone-summary-classifier.js";
 // ─── Artifact Resolution & Verification ───────────────────────────────────────
 /**
  * Check whether a milestone produced implementation artifacts (non-`.gsd/` files)

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

@@ -19,12 +19,13 @@ import { invalidateAllCaches } from "./cache.js";
 import { writeLock, clearLock } from "./crash-recovery.js";
 import { acquireSessionLock, releaseSessionLock, updateSessionLock, } from "./session-lock.js";
 import { ensureGitignore, untrackRuntimeFiles } from "./gitignore.js";
-import { nativeIsRepo, nativeInit, nativeAddAll, nativeCommit, nativeGetCurrentBranch, nativeDetectMainBranch, nativeCheckoutBranch, nativeBranchList, nativeBranchListMerged, nativeBranchDelete, nativeWorktreeRemove, } from "./native-git-bridge.js";
+import { nativeIsRepo, nativeInit, nativeAddAll, nativeCommit, nativeGetCurrentBranch, nativeDetectMainBranch, nativeCheckoutBranch, nativeBranchList, nativeBranchListMerged, nativeBranchDelete, nativeWorktreeRemove, nativeCommitCountBetween, } from "./native-git-bridge.js";
 import { GitServiceImpl } from "./git-service.js";
 import { captureIntegrationBranch, detectWorktreeName, setActiveMilestoneId, } from "./worktree.js";
 import { getAutoWorktreePath } from "./auto-worktree.js";
 import { readResourceVersion, cleanStaleRuntimeUnits } from "./auto-worktree.js";
 import { worktreePath as getWorktreeDir, isInsideWorktreesDir } from "./worktree-manager.js";
+import { emitWorktreeOrphaned } from "./worktree-telemetry.js";
 import { initMetrics } from "./metrics.js";
 import { initRoutingHistory } from "./routing-history.js";
 import { restoreHookState, resetHookState } from "./post-unit-hooks.js";
@@ -32,9 +33,10 @@ import { resetProactiveHealing, setLevelChangeCallback } from "./doctor-proactiv
 import { snapshotSkills } from "./skill-discovery.js";
 import { isDbAvailable, getMilestone, openDatabase, getDbStatus } from "./gsd-db.js";
 import { isClosedStatus } from "./status-guards.js";
+import { classifyMilestoneSummaryContent } from "./milestone-summary-classifier.js";
 import { debugLog, enableDebug, isDebugEnabled, getDebugLogPath, } from "./debug-logger.js";
 import { logWarning, logError } from "./workflow-logger.js";
-import { existsSync, mkdirSync, readdirSync, rmSync, statSync, unlinkSync, } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, unlinkSync, } from "node:fs";
 import { join } from "node:path";
 import { sep as pathSep } from "node:path";
 import { resolveProjectRootDbPath } from "./bootstrap/dynamic-tools.js";
@@ -119,10 +121,58 @@ export function auditOrphanedMilestoneBranches(basePath, isolationMode) {
     for (const branch of milestoneBranches) {
         const milestoneId = branch.replace(/^milestone\//, "");
         const milestone = getMilestone(milestoneId);
-        // Only audit completed milestones
-        if (!milestone || milestone.status !== "complete")
+        if (!milestone)
             continue;
         const isMerged = mergedBranches.has(branch);
+        // #4762 — in-progress milestone branch with unmerged commits ahead of
+        // main. This is the pre-completion orphan case: auto-mode exited without
+        // completing the milestone (pause, stop, crash, merge error, blocker) and
+        // work is stranded on the branch or in the worktree. Data safety first:
+        // we never delete or touch; we just surface a warning so the user knows
+        // where to look.
+        //
+        // Gate on isClosedStatus so we only warn about genuinely open milestones.
+        // Parked/other closed statuses go through the legacy complete/unmerged
+        // path below where appropriate.
+        if (!isClosedStatus(milestone.status)) {
+            if (isMerged)
+                continue; // nothing to recover
+            let commitsAhead = 0;
+            try {
+                commitsAhead = nativeCommitCountBetween(basePath, mainBranch, branch);
+            }
+            catch {
+                // Rev-walk failure — skip rather than noise
+                continue;
+            }
+            if (commitsAhead === 0)
+                continue;
+            const wtDir = getWorktreeDir(basePath, milestoneId);
+            const wtDirExists = existsSync(wtDir);
+            const wtSuffix = wtDirExists
+                ? ` Worktree directory at .gsd/worktrees/${milestoneId}/ holds the live work.`
+                : "";
+            warnings.push(`Branch ${branch} has ${commitsAhead} commit(s) ahead of ${mainBranch} for in-progress milestone ${milestoneId}.` +
+                wtSuffix +
+                ` Run \`/gsd auto\` to resume, or merge manually if abandoning.`);
+            // #4764 telemetry
+            try {
+                emitWorktreeOrphaned(basePath, milestoneId, {
+                    reason: "in-progress-unmerged",
+                    commitsAhead,
+                    worktreeDirExists: wtDirExists,
+                });
+            }
+            catch (err) {
+                logWarning("engine", `worktree-orphaned telemetry failed for ${milestoneId}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            continue;
+        }
+        // Only the "complete" status participates in the merged/unmerged cleanup
+        // paths below — other closed statuses (parked, etc.) are intentionally
+        // left alone.
+        if (milestone.status !== "complete")
+            continue;
         if (isMerged) {
             // Branch is merged — safe to delete branch and clean up worktree dir
             try {
@@ -169,6 +219,16 @@ export function auditOrphanedMilestoneBranches(basePath, isolationMode) {
             // Branch is NOT merged — preserve for safety, warn the user
             warnings.push(`Branch ${branch} exists for completed milestone ${milestoneId} but is NOT merged into ${mainBranch}. ` +
                 `This may contain unmerged work. Merge manually or run \`/gsd health --fix\` to resolve.`);
+            // #4764 telemetry
+            try {
+                emitWorktreeOrphaned(basePath, milestoneId, {
+                    reason: "complete-unmerged",
+                    worktreeDirExists: existsSync(getWorktreeDir(basePath, milestoneId)),
+                });
+            }
+            catch (err) {
+                logWarning("engine", `worktree-orphaned telemetry failed for ${milestoneId}: ${err instanceof Error ? err.message : String(err)}`);
+            }
         }
     }
     return { recovered, warnings };
@@ -328,7 +388,15 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
                 const row = getMilestone(mid);
                 return !!row && isClosedStatus(row.status);
             }
-            return !!resolveMilestoneFile(base, mid, "SUMMARY");
+            const summaryFile = resolveMilestoneFile(base, mid, "SUMMARY");
+            if (!summaryFile)
+                return false;
+            try {
+                return classifyMilestoneSummaryContent(readFileSync(summaryFile, "utf-8")) !== "failure";
+            }
+            catch {
+                return false;
+            }
         });
         // ── Orphaned milestone branch audit ──
         // Catches completed milestones whose teardown (merge + branch delete)

package/dist/resources/extensions/gsd/auto-timeout-recovery.js

@@ -6,8 +6,14 @@
 import { readUnitRuntimeRecord, writeUnitRuntimeRecord, formatExecuteTaskRecoveryStatus, inspectExecuteTaskDurability, } from "./unit-runtime.js";
 import { resolveExpectedArtifactPath, diagnoseExpectedArtifact, writeBlockerPlaceholder, } from "./auto-recovery.js";
 import { existsSync } from "node:fs";
-import { resolveAgentEnd } from "./auto-loop.js";
+import { bumpAndResolveSynthetic } from "./auto/resolve.js";
 export async function recoverTimedOutUnit(ctx, pi, unitType, unitId, reason, rctx) {
+    // Note on turn epoch: the bump is intentionally NOT unconditional at
+    // function entry. Two branches below (the "steering retry" paths) keep
+    // the same LLM turn alive and let it try again — they must NOT bump,
+    // otherwise the retry's legitimate writes get marked stale and drop.
+    // Each advance branch calls `bumpAndResolveSynthetic` to bump+resolve
+    // atomically. Search for that helper to find all supersede sites.
     const { basePath, verbose, currentUnitStartedAt, unitRecoveryCount } = rctx;
     const runtime = readUnitRuntimeRecord(basePath, unitType, unitId);
     const recoveryAttempts = runtime?.recoveryAttempts ?? 0;
@@ -36,7 +42,7 @@ export async function recoverTimedOutUnit(ctx, pi, unitType, unitId, reason, rct
             });
             ctx.ui.notify(`${reason === "idle" ? "Idle" : "Timeout"} recovery: ${unitType} ${unitId} already completed on disk. Continuing auto-mode. (attempt ${attemptNumber})`, "info");
             unitRecoveryCount.delete(recoveryKey);
-            resolveAgentEnd({ messages: [], _synthetic: "timeout-recovery" });
+            bumpAndResolveSynthetic(`timeout-recovery:${reason}:${unitType}/${unitId}`);
             return "recovered";
         }
         if (recoveryAttempts < maxRecoveryAttempts) {
@@ -90,7 +96,7 @@ export async function recoverTimedOutUnit(ctx, pi, unitType, unitId, reason, rct
             });
             ctx.ui.notify(`${unitType} ${unitId} skipped after ${maxRecoveryAttempts} recovery attempts (${diagnostic}). Blocker artifacts written. Advancing pipeline. (attempt ${attemptNumber})`, "warning");
             unitRecoveryCount.delete(recoveryKey);
-            resolveAgentEnd({ messages: [], _synthetic: "timeout-recovery" });
+            bumpAndResolveSynthetic(`timeout-recovery:${reason}:${unitType}/${unitId}`);
             return "recovered";
         }
         // Fallback: couldn't write skip artifacts — pause as before.
@@ -115,7 +121,7 @@ export async function recoverTimedOutUnit(ctx, pi, unitType, unitId, reason, rct
         });
         ctx.ui.notify(`${reason === "idle" ? "Idle" : "Timeout"} recovery: ${unitType} ${unitId} artifact already exists on disk. Advancing. (attempt ${attemptNumber})`, "info");
         unitRecoveryCount.delete(recoveryKey);
-        resolveAgentEnd({ messages: [], _synthetic: "timeout-recovery" });
+        bumpAndResolveSynthetic(`timeout-recovery:${reason}:${unitType}/${unitId}`);
         return "recovered";
     }
     if (recoveryAttempts < maxRecoveryAttempts) {
@@ -180,7 +186,7 @@ export async function recoverTimedOutUnit(ctx, pi, unitType, unitId, reason, rct
         });
         ctx.ui.notify(`${unitType} ${unitId} skipped after ${maxRecoveryAttempts} recovery attempts. Blocker placeholder written to ${placeholder}. Advancing pipeline. (attempt ${attemptNumber})`, "warning");
         unitRecoveryCount.delete(recoveryKey);
-        resolveAgentEnd({ messages: [], _synthetic: "timeout-recovery" });
+        bumpAndResolveSynthetic(`timeout-recovery:${reason}:${unitType}/${unitId}`);
         return "recovered";
     }
     // Fallback: couldn't resolve artifact path — pause as before.

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

@@ -20,9 +20,18 @@ export async function closeoutUnit(ctx, basePath, unitType, unitId, startedAt, o
             const { buildMemoryLLMCall, extractMemoriesFromUnit } = await import('./memory-extractor.js');
             const llmCallFn = buildMemoryLLMCall(ctx);
             if (llmCallFn) {
-                extractMemoriesFromUnit(activityFile, unitType, unitId, llmCallFn).catch((err) => {
+                // Awaited: a fire-and-forget here lets memory-extractor writes land in
+                // .gsd/ after closeoutUnit returns but before the milestone merge
+                // runs, which made the working tree appear dirty to `git merge
+                // --squash` (root cause class of #4704). Completion latency is now
+                // bounded by the extractor's LLM call, which is the acceptable price
+                // for not racing the merge boundary.
+                try {
+                    await extractMemoriesFromUnit(activityFile, unitType, unitId, llmCallFn);
+                }
+                catch (err) {
                     logWarning("engine", `memory extraction failed for ${unitType}/${unitId}: ${err.message}`);
-                });
+                }
             }
         }
         catch (err) { /* non-fatal */

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

@@ -9,7 +9,7 @@ import { existsSync, cpSync, readFileSync, readdirSync, mkdirSync, realpathSync,
 import { isAbsolute, join, sep as pathSep } from "node:path";
 import { homedir } from "node:os";
 import { GSDError, GSD_IO_ERROR, GSD_GIT_ERROR } from "./errors.js";
-import { reconcileWorktreeDb, isDbAvailable, getMilestone, getMilestoneSlices, } from "./gsd-db.js";
+import { reconcileWorktreeDb, isDbAvailable, getMilestone, getMilestoneSlices, closeDatabase, openDatabase, getDbPath, } from "./gsd-db.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { execFileSync } from "node:child_process";
 import { safeCopy, safeCopyRecursive } from "./safe-fs.js";
@@ -1433,26 +1433,53 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
     const milestonesDir = join(gsdRoot(originalBasePath_), "milestones");
     const shelterDir = join(gsdRoot(originalBasePath_), ".milestone-shelter");
     const shelteredDirs = [];
+    let shelterRestored = false;
     // Helper: restore sheltered milestone directories (#2505).
     // Called on both success and error paths to ensure queued CONTEXT files
-    // are never permanently lost.
+    // are never permanently lost. Idempotent — the error path may fire after
+    // the success path has already restored and removed the shelter dir; a
+    // second call is a no-op instead of logging a misleading "shelter restore
+    // failed: ENOENT" error for shelter sources that were cleaned up legitimately.
     const restoreShelter = () => {
+        if (shelterRestored)
+            return;
+        shelterRestored = true;
         if (shelteredDirs.length === 0)
             return;
+        let restoreFailed = false;
         for (const dirName of shelteredDirs) {
+            const src = join(shelterDir, dirName);
+            // If the shelter source is missing the restore cannot proceed for this
+            // entry. Distinguish "legitimately missing" (shelter dir removed by a
+            // prior successful restore or never copied) from a surprising ENOENT
+            // inside an otherwise-populated shelter.
+            if (!existsSync(src)) {
+                logWarning("worktree", `shelter source missing for ${dirName}; skipping restore (shelter already cleaned or entry never staged)`);
+                continue;
+            }
             try {
                 mkdirSync(milestonesDir, { recursive: true });
-                cpSync(join(shelterDir, dirName), join(milestonesDir, dirName), { recursive: true, force: true });
+                cpSync(src, join(milestonesDir, dirName), { recursive: true, force: true });
             }
             catch (err) { /* best-effort */
-                logError("worktree", `shelter restore failed: ${err instanceof Error ? err.message : String(err)}`);
+                restoreFailed = true;
+                logError("worktree", `shelter restore failed (${dirName}): ${err instanceof Error ? err.message : String(err)}`);
             }
         }
-        try {
-            rmSync(shelterDir, { recursive: true, force: true });
+        // Preserve the shelter if any per-entry restore failed — it is the only
+        // surviving copy of the queued milestone dirs (sources were deleted during
+        // shelter). Deleting it here would permanently lose those files (#2505).
+        if (restoreFailed) {
+            logWarning("worktree", `shelter retained at ${shelterDir} — manual recovery required for unrestored entries`);
+            return;
         }
-        catch (err) { /* best-effort */
-            logWarning("worktree", `shelter cleanup failed: ${err instanceof Error ? err.message : String(err)}`);
+        if (existsSync(shelterDir)) {
+            try {
+                rmSync(shelterDir, { recursive: true, force: true });
+            }
+            catch (err) { /* best-effort */
+                logWarning("worktree", `shelter cleanup failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
         }
     };
     try {
@@ -1491,6 +1518,21 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
     //     entries (e.g. a gitignored `.gsd` symlink under ADR-002) (#4573).
     //     Queued CONTEXT files under `.gsd/milestones/*` are already sheltered
     //     in step 7 above, so they won't be swept into the stash.
+    // On Windows, SQLite holds mandatory file locks on the gsd.db WAL/SHM
+    // sidecars while the connection is open. `git stash --include-untracked`
+    // walks those files and fails with EBUSY (#4704). Close the DB before
+    // stashing so Windows releases the handles; reopen after. No-op on
+    // POSIX, where advisory locks don't block git.
+    const needsDbCycle = process.platform === "win32" && isDbAvailable();
+    const dbPathToReopen = needsDbCycle ? getDbPath() : null;
+    if (needsDbCycle) {
+        try {
+            closeDatabase();
+        }
+        catch (err) {
+            logWarning("worktree", `pre-stash db close failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
     let stashed = false;
     try {
         const status = execFileSync("git", ["status", "--porcelain"], {
@@ -1508,6 +1550,14 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
         // report the dirty tree if it fails.
         logWarning("worktree", `git stash failed: ${err instanceof Error ? err.message : String(err)}`);
     }
+    if (needsDbCycle && dbPathToReopen) {
+        try {
+            openDatabase(dbPathToReopen);
+        }
+        catch (err) {
+            logWarning("worktree", `post-stash db reopen failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
     // 7b. Clean up stale merge state before attempting squash merge (#2912).
     // A leftover MERGE_HEAD (from a previous failed merge, libgit2 native path,
     // or interrupted operation) causes `git merge --squash` to refuse with

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

@@ -51,6 +51,7 @@ import { pruneQueueOrder } from "./queue-order.js";
 import { startCommandPolling as _startCommandPolling, isRemoteConfigured } from "../remote-questions/manager.js";
 import { debugLog, isDebugEnabled, writeDebugSummary } from "./debug-logger.js";
 import { reconcileMergeState, } from "./auto-recovery.js";
+import { classifyMilestoneSummaryContent } from "./milestone-summary-classifier.js";
 import { resolveDispatch, DISPATCH_RULES } from "./auto-dispatch.js";
 import { getErrorMessage } from "./error-utils.js";
 import { recoverFailedMigration } from "./migrate-external.js";
@@ -60,7 +61,14 @@ import { updateProgressWidget as _updateProgressWidget, updateSliceProgressCache
 import { registerSigtermHandler as _registerSigtermHandler, deregisterSigtermHandler as _deregisterSigtermHandler, } from "./auto-supervisor.js";
 import { isDbAvailable, getMilestone } from "./gsd-db.js";
 import { countPendingCaptures } from "./captures.js";
-import { clearCmuxSidebar, logCmuxEvent, syncCmuxSidebar } from "../cmux/index.js";
+import { CMUX_CHANNELS } from "../shared/cmux-events.js";
+function makeCmuxEmitters(pi) {
+    return {
+        syncCmuxSidebar: (preferences, state) => pi.events.emit(CMUX_CHANNELS.SIDEBAR, { action: "sync", preferences, state }),
+        logCmuxEvent: (preferences, message, level) => pi.events.emit(CMUX_CHANNELS.LOG, { preferences, message, level: level ?? "info" }),
+        clearCmuxSidebar: (preferences) => pi.events.emit(CMUX_CHANNELS.SIDEBAR, { action: "clear", preferences }),
+    };
+}
 // ── Extracted modules ──────────────────────────────────────────────────────
 import { startUnitSupervision } from "./auto-timers.js";
 import { runPostUnitVerification } from "./auto-verification.js";
@@ -267,6 +275,10 @@ export function getAutoDashboardData() {
 export function isAutoActive() {
     return s.active;
 }
+/** Test-only seam for validating auto-mode guards (#4704). Do not use in production code. */
+export function _setAutoActiveForTest(active) {
+    s.active = active;
+}
 export function isAutoPaused() {
     return s.paused;
 }
@@ -446,7 +458,6 @@ function handleLostSessionLock(ctx, lockStatus) {
     restoreProjectRootEnv();
     restoreMilestoneLockEnv();
     deregisterSigtermHandler();
-    clearCmuxSidebar(loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences);
     const base = lockBase();
     const lockFilePath = base ? join(gsdRoot(base), "auto.lock") : "unknown";
     const recoverySuggestion = "\nTo recover, run: gsd doctor --fix";
@@ -517,6 +528,40 @@ export async function stopAuto(ctx, pi, reason) {
         return;
     const loadedPreferences = loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences;
     const reasonSuffix = reason ? ` — ${reason}` : "";
+    // #4764 — telemetry: record the exit reason and whether the current milestone
+    // was merged before we entered stopAuto. This is the producer-side signal for
+    // the #4761 orphan class: milestoneMerged=false + currentMilestoneId present
+    // is exactly the pattern that strands work.
+    try {
+        const { emitAutoExit } = await import("./worktree-telemetry.js");
+        // Normalize the free-form reason to a closed set so the telemetry
+        // aggregator buckets stably. Raw detail is preserved in the phases.ts
+        // notification and the notify'd error string.
+        const rawReason = reason ?? "stop";
+        const normalizedReason = rawReason.startsWith("Blocked:")
+            ? "blocked"
+            : rawReason.startsWith("Merge conflict")
+                ? "merge-conflict"
+                : rawReason.startsWith("Merge error") || rawReason.startsWith("Merge failed")
+                    ? "merge-failed"
+                    : rawReason.startsWith("slice-merge-conflict")
+                        ? "slice-merge-conflict"
+                        : rawReason === "All milestones complete"
+                            ? "all-complete"
+                            : rawReason === "No active milestone"
+                                ? "no-active-milestone"
+                                : rawReason === "stop" || rawReason === "pause"
+                                    ? rawReason
+                                    : "other";
+        emitAutoExit(s.originalBasePath || s.basePath, {
+            reason: normalizedReason,
+            milestoneId: s.currentMilestoneId ?? undefined,
+            milestoneMerged: s.milestoneMergedInPhases === true,
+        });
+    }
+    catch (err) {
+        logWarning("engine", `auto-exit telemetry failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
     try {
         // ── Step 1: Timers and locks ──
         try {
@@ -674,8 +719,12 @@ export async function stopAuto(ctx, pi, reason) {
         }
         // ── Step 9: Cmux sidebar / event log ──
         try {
-            clearCmuxSidebar(loadedPreferences);
-            logCmuxEvent(loadedPreferences, `Auto-mode stopped${reasonSuffix || ""}.`, reason?.startsWith("Blocked:") ? "warning" : "info");
+            pi?.events.emit(CMUX_CHANNELS.SIDEBAR, { action: "clear", preferences: loadedPreferences });
+            pi?.events.emit(CMUX_CHANNELS.LOG, {
+                preferences: loadedPreferences,
+                message: `Auto-mode stopped${reasonSuffix || ""}.`,
+                level: reason?.startsWith("Blocked:") ? "warning" : "info",
+            });
         }
         catch (e) {
             debugLog("stop-cleanup-cmux", { error: e instanceof Error ? e.message : String(e) });
@@ -892,11 +941,12 @@ function buildResolver() {
  * Build the LoopDeps object from auto.ts private scope.
  * This bundles all private functions that autoLoop needs without exporting them.
  */
-function buildLoopDeps() {
+function buildLoopDeps(pi) {
     // Initialize the unified rule registry with converted dispatch rules.
     // Must happen before LoopDeps is assembled so facade functions
     // (resolveDispatch, runPreDispatchHooks, etc.) delegate to the registry.
     initRegistry(convertDispatchRules(DISPATCH_RULES));
+    const cmux = makeCmuxEmitters(pi);
     return {
         lockBase,
         buildSnapshotOpts,
@@ -904,8 +954,11 @@ function buildLoopDeps() {
         pauseAuto,
         clearUnitTimeout,
         updateProgressWidget,
-        syncCmuxSidebar,
-        logCmuxEvent,
+        ...cmux,
+        handleLostSessionLock: (ctx, lockStatus) => {
+            cmux.clearCmuxSidebar(loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences);
+            handleLostSessionLock(ctx, lockStatus);
+        },
         // State and cache
         invalidateAllCaches,
         deriveState,
@@ -920,7 +973,6 @@ function buildLoopDeps() {
         // Session lock
         validateSessionLock: getSessionLockStatus,
         updateSessionLock,
-        handleLostSessionLock,
         // Milestone transition
         sendDesktopNotification,
         setActiveMilestoneId,
@@ -1067,7 +1119,16 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
                     // Validate the milestone still exists and isn't already complete (#1664).
                     const mDir = resolveMilestonePath(base, meta.milestoneId);
                     const summaryFile = resolveMilestoneFile(base, meta.milestoneId, "SUMMARY");
-                    if (!mDir || summaryFile) {
+                    let summaryIsTerminal = false;
+                    if (summaryFile) {
+                        try {
+                            summaryIsTerminal = classifyMilestoneSummaryContent(readFileSync(summaryFile, "utf-8")) !== "failure";
+                        }
+                        catch {
+                            summaryIsTerminal = false;
+                        }
+                    }
+                    if (!mDir || summaryIsTerminal) {
                         try {
                             unlinkSync(pausedPath);
                         }
@@ -1236,7 +1297,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         await openProjectDbIfPresent(s.basePath);
         try {
             await rebuildState(s.basePath);
-            syncCmuxSidebar(loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences, await deriveState(s.basePath));
+            pi.events.emit(CMUX_CHANNELS.SIDEBAR, { action: "sync", preferences: loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences, state: await deriveState(s.basePath) });
         }
         catch (e) {
             debugLog("resume-rebuild-state-failed", {
@@ -1266,14 +1327,14 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         }
         updateSessionLock(lockBase(), "resuming", s.currentMilestoneId ?? "unknown");
         writeLock(lockBase(), "resuming", s.currentMilestoneId ?? "unknown");
-        logCmuxEvent(loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences, s.stepMode ? "Step-mode resumed." : "Auto-mode resumed.", "progress");
+        pi.events.emit(CMUX_CHANNELS.LOG, { preferences: loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences, message: s.stepMode ? "Step-mode resumed." : "Auto-mode resumed.", level: "progress" });
         captureProjectRootEnv(s.originalBasePath || s.basePath);
         startAutoCommandPolling(s.basePath);
         await runAutoLoopWithUok({
             ctx,
             pi,
             s,
-            deps: buildLoopDeps(),
+            deps: buildLoopDeps(pi),
             runKernelLoop: runUokKernelLoop,
             runLegacyLoop: runLegacyAutoLoop,
         });
@@ -1292,20 +1353,20 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         return;
     captureProjectRootEnv(s.originalBasePath || s.basePath);
     try {
-        syncCmuxSidebar(loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences, await deriveState(s.basePath));
+        pi.events.emit(CMUX_CHANNELS.SIDEBAR, { action: "sync", preferences: loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences, state: await deriveState(s.basePath) });
     }
     catch (err) {
         // Best-effort only — sidebar sync must never block auto-mode startup
         logWarning("engine", `cmux sync failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
     }
-    logCmuxEvent(loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences, requestedStepMode ? "Step-mode started." : "Auto-mode started.", "progress");
+    pi.events.emit(CMUX_CHANNELS.LOG, { preferences: loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences, message: requestedStepMode ? "Step-mode started." : "Auto-mode started.", level: "progress" });
     startAutoCommandPolling(s.basePath);
     // Dispatch the first unit
     await runAutoLoopWithUok({
         ctx,
         pi,
         s,
-        deps: buildLoopDeps(),
+        deps: buildLoopDeps(pi),
         runKernelLoop: runUokKernelLoop,
         runLegacyLoop: runLegacyAutoLoop,
     });

package/dist/resources/extensions/gsd/bootstrap/agent-end-recovery.js

@@ -1,5 +1,6 @@
 import { logWarning } from "../workflow-logger.js";
 import { checkAutoStartAfterDiscuss, maybeHandleReadyPhraseWithoutFiles, maybeHandleEmptyIntentTurn, resetEmptyTurnCounter, } from "../guided-flow.js";
+import { clearPathCache } from "../paths.js";
 import { getAutoDashboardData, getAutoModeStartModel, isAutoActive, pauseAuto, setCurrentDispatchedModelId } from "../auto.js";
 import { getNextFallbackModel, resolveModelWithFallbacksForUnit } from "../preferences.js";
 import { pauseAutoForProviderError } from "../provider-error-pause.js";
@@ -49,6 +50,15 @@ async function pauseTransientWithBackoff(cls, pi, ctx, errorDetail, isRateLimit)
     });
 }
 export async function handleAgentEnd(pi, event, ctx) {
+    // #4648 — Invalidate the directory-listing cache before any artifact-existence
+    // checks. The LLM may have written milestone files (CONTEXT.md, ROADMAP.md,
+    // PROJECT.md, REQUIREMENTS.md) via tool calls during the turn that just
+    // ended. `paths.ts` caches readdir() results without a TTL, so without this
+    // flush, `resolveMilestoneFile` returns the pre-write listing and the guards
+    // below (`checkAutoStartAfterDiscuss` and `maybeHandleReadyPhraseWithoutFiles`)
+    // falsely report files as missing — producing a spurious "ready signal
+    // rejected" loop even though the files are on disk.
+    clearPathCache();
     if (checkAutoStartAfterDiscuss()) {
         clearDiscussionFlowState();
         return;

package/dist/resources/extensions/gsd/bootstrap/provider-error-resume.js

@@ -3,6 +3,8 @@ import { resetTransientRetryState } from "./agent-end-recovery.js";
 import { resetSessionTimeoutState } from "../auto/phases.js";
 const defaultDeps = {
     getSnapshot: () => getAutoDashboardData(),
+    resetTransientRetryState,
+    resetSessionTimeoutState,
     startAuto,
 };
 export async function resumeAutoAfterProviderDelay(pi, ctx, deps = defaultDeps) {
@@ -18,8 +20,8 @@ export async function resumeAutoAfterProviderDelay(pi, ctx, deps = defaultDeps)
     // Reset retry counters before restarting — without this, counters
     // accumulate across pause/resume cycles and permanently lock out
     // auto-resume after their respective MAX thresholds.
-    resetTransientRetryState();
-    resetSessionTimeoutState();
+    deps.resetTransientRetryState();
+    deps.resetSessionTimeoutState();
     await deps.startAuto(ctx, pi, snapshot.basePath, false, { step: snapshot.stepMode });
     return "resumed";
 }

package/dist/resources/extensions/gsd/bootstrap/register-extension.js

@@ -12,6 +12,13 @@ import { registerHooks } from "./register-hooks.js";
 import { registerShortcuts } from "./register-shortcuts.js";
 import { writeCrashLog } from "./crash-log.js";
 import { logWarning } from "../workflow-logger.js";
+// Static import so cmux event listeners are registered synchronously during
+// extension bootstrap. Prior implementation used `void import().then()` which
+// queued listener registration as a microtask — any CMUX_CHANNELS emit fired
+// in the same event loop turn as registration (e.g. from a provider-error
+// session hook calling startAuto) would be silently dropped because Node's
+// EventEmitter does not buffer events for late subscribers.
+import { initCmuxEventListeners } from "../../cmux/index.js";
 export { writeCrashLog } from "./crash-log.js";
 export function handleRecoverableExtensionProcessError(err) {
     if (err.code === "EPIPE") {
@@ -89,6 +96,10 @@ export function registerGsdExtension(pi) {
         ["memory-tools", () => registerMemoryTools(pi)],
         ["exec-tools", () => registerExecTools(pi)],
         ["shortcuts", () => registerShortcuts(pi)],
+        // cmux is a library (no pi), so gsd sets up the event listeners on its
+        // behalf using the shared event channel contract. Registration is
+        // synchronous — see the import comment above for the rationale.
+        ["cmux-events", () => initCmuxEventListeners(pi.events)],
         ["hooks", () => registerHooks(pi, ecosystemHandlers)],
         ["ecosystem", () => {
                 void loadEcosystemExtensions(pi, ecosystemHandlers).catch((err) => {