gsd-pi 2.77.0 → 2.78.0-dev.aeeb2ca00

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

@@ -24,9 +24,9 @@ import { acquireSessionLock, getSessionLockStatus, releaseSessionLock, updateSes
 import { resolveAutoSupervisorConfig, loadEffectiveGSDPreferences, getIsolationMode, } from "./preferences.js";
 import { sendDesktopNotification } from "./notifications.js";
 import { getBudgetAlertLevel, getNewBudgetAlertLevel, getBudgetEnforcementAction, } from "./auto-budget.js";
-import { markToolStart as _markToolStart, markToolEnd as _markToolEnd, getOldestInFlightToolAgeMs as _getOldestInFlightToolAgeMs, clearInFlightTools, isToolInvocationError, isQueuedUserMessageSkip, } from "./auto-tool-tracking.js";
+import { markToolStart as _markToolStart, markToolEnd as _markToolEnd, getOldestInFlightToolAgeMs as _getOldestInFlightToolAgeMs, clearInFlightTools, isToolInvocationError, isQueuedUserMessageSkip, isDeterministicPolicyError, } from "./auto-tool-tracking.js";
 import { closeoutUnit } from "./auto-unit-closeout.js";
-import { selectAndApplyModel, resolveModelId } from "./auto-model-selection.js";
+import { selectAndApplyModel, resolveModelId, clearToolBaseline } from "./auto-model-selection.js";
 import { resetRoutingHistory, recordOutcome } from "./routing-history.js";
 import { resetHookState, runPreDispatchHooks, restoreHookState, clearPersistedHookState, } from "./post-unit-hooks.js";
 import { runGSDDoctor, rebuildState } from "./doctor.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";
@@ -74,7 +82,7 @@ import { WorktreeResolver, } from "./worktree-resolver.js";
 import { reorderForCaching } from "./prompt-ordering.js";
 // ─── Session State ─────────────────────────────────────────────────────────
 import { AutoSession, } from "./auto/session.js";
-export { MAX_UNIT_DISPATCHES, STUB_RECOVERY_THRESHOLD, MAX_LIFETIME_DISPATCHES, NEW_SESSION_TIMEOUT_MS, } from "./auto/session.js";
+export { STUB_RECOVERY_THRESHOLD, NEW_SESSION_TIMEOUT_MS, } from "./auto/session.js";
 // ── ENCAPSULATION INVARIANT ─────────────────────────────────────────────────
 // ALL mutable auto-mode state lives in the AutoSession class (auto/session.ts).
 // This file must NOT declare module-level `let` or `var` variables for state.
@@ -155,6 +163,13 @@ function normalizeSessionFilePath(raw) {
         return null;
     return candidate;
 }
+function synthesizePausedSessionRecovery(basePath, unitType, unitId, sessionFile) {
+    const activityDir = join(gsdRoot(basePath), "activity");
+    return synthesizeCrashRecovery(basePath, unitType, unitId, sessionFile, activityDir);
+}
+export function _synthesizePausedSessionRecoveryForTest(basePath, unitType, unitId, sessionFile) {
+    return synthesizePausedSessionRecovery(basePath, unitType, unitId, sessionFile);
+}
 export function startAutoDetached(ctx, pi, base, verboseMode, options) {
     void startAuto(ctx, pi, base, verboseMode, options).catch((err) => {
         const message = getErrorMessage(err);
@@ -267,6 +282,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;
 }
@@ -308,13 +327,15 @@ export function markToolEnd(toolCallId) {
 /**
  * Record a tool invocation error on the current session (#2883).
  * Called from tool_execution_end when a GSD tool fails with isError.
- * Only stores the error if it matches the tool-invocation-error pattern
- * (malformed/truncated JSON), not normal business-logic errors.
+ * Stores the error if it matches:
+ *   - tool-invocation-error pattern (malformed/truncated JSON)
+ *   - queued-user-message skip pattern
+ *   - deterministic policy rejection (#4973, e.g. context_write_blocked)
  */
 export function recordToolInvocationError(toolName, errorMsg) {
     if (!s.active)
         return;
-    if (isToolInvocationError(errorMsg) || isQueuedUserMessageSkip(errorMsg)) {
+    if (isToolInvocationError(errorMsg) || isQueuedUserMessageSkip(errorMsg) || isDeterministicPolicyError(errorMsg)) {
         s.lastToolInvocationError = `${toolName}: ${errorMsg}`;
     }
 }
@@ -446,7 +467,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 +537,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 +728,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) });
@@ -764,6 +822,12 @@ export async function stopAuto(ctx, pi, reason) {
             initHealthWidget(ctx);
         restoreProjectRootEnv();
         restoreMilestoneLockEnv();
+        // Drop the active-tool baseline so a subsequent /gsd auto run on the
+        // same `pi` instance recaptures from the live tool set rather than
+        // restoring this session's snapshot and silently undoing any tool
+        // changes the user made between sessions (#4959 / CodeRabbit).
+        if (pi)
+            clearToolBaseline(pi);
         // Reset all session state in one call
         s.reset();
     }
@@ -892,11 +956,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 +969,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 +988,6 @@ function buildLoopDeps() {
         // Session lock
         validateSessionLock: getSessionLockStatus,
         updateSessionLock,
-        handleLostSessionLock,
         // Milestone transition
         sendDesktopNotification,
         setActiveMilestoneId,
@@ -1008,6 +1075,15 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         debugLog("startAuto", { phase: "already-active", skipping: true });
         return;
     }
+    // On a *fresh* start, drop any stale active-tool baseline left by a prior
+    // auto session that didn't run stopAuto cleanly.  Skip on resume: pauseAuto
+    // leaves the last provider-trimmed active tools in place, so clearing here
+    // would let the next selectAndApplyModel recapture that already-narrowed
+    // set as the new baseline — exactly the cross-unit poisoning this PR is
+    // fixing (#4959 / CodeRabbit Major).  The pre-pause baseline survives in
+    // the WeakMap keyed by `pi`.
+    if (!s.paused)
+        clearToolBaseline(pi);
     const requestedStepMode = options?.step ?? false;
     const interruptedAssessment = options?.interrupted ?? null;
     if (options?.milestoneLock !== undefined) {
@@ -1067,7 +1143,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);
                         }
@@ -1156,18 +1241,6 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
             ctx.ui.notify(`Cannot resume: ${resumeLock.reason}`, "error");
             return;
         }
-        // Lock acquired — now safe to delete the pause file
-        if (s.pausedSessionFile) {
-            try {
-                unlinkSync(s.pausedSessionFile);
-            }
-            catch (err) {
-                if (err.code !== "ENOENT") {
-                    logWarning("session", `pause file cleanup failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
-                }
-            }
-            s.pausedSessionFile = null;
-        }
         s.paused = false;
         s.active = true;
         s.verbose = verboseMode;
@@ -1236,7 +1309,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", {
@@ -1256,8 +1329,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         }
         invalidateAllCaches();
         if (s.pausedSessionFile) {
-            const activityDir = join(gsdRoot(s.basePath), "activity");
-            const recovery = synthesizeCrashRecovery(s.basePath, s.currentUnit?.type ?? s.pausedUnitType ?? "unknown", s.currentUnit?.id ?? s.pausedUnitId ?? "unknown", s.pausedSessionFile ?? undefined, activityDir);
+            const recovery = synthesizePausedSessionRecovery(s.basePath, s.currentUnit?.type ?? s.pausedUnitType ?? "unknown", s.currentUnit?.id ?? s.pausedUnitId ?? "unknown", s.pausedSessionFile);
             if (recovery && recovery.trace.toolCallCount > 0) {
                 s.pendingCrashRecovery = recovery.prompt;
                 ctx.ui.notify(`Recovered ${recovery.trace.toolCallCount} tool calls from paused session. Resuming with context.`, "info");
@@ -1266,14 +1338,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 +1364,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";
@@ -11,7 +12,15 @@ import { classifyError, createRetryState, resetRetryState, isTransient, } from "
 import { blockModel, isModelBlocked } from "../blocked-models.js";
 const retryState = createRetryState();
 const MAX_NETWORK_RETRIES = 2;
-const MAX_TRANSIENT_AUTO_RESUMES = 8;
+/**
+ * Cap on auto-resume attempts for sustained transient-provider errors.
+ *
+ * Exported so tests assert against the shared constant instead of
+ * regex-scraping the source literal (see #4837). Raising this value to
+ * handle longer provider overloads should update the single constant; the
+ * test in provider-errors.test.ts consumes it directly.
+ */
+export const MAX_TRANSIENT_AUTO_RESUMES = 8;
 /**
  * Reset the module-level retry state so a resumed auto-session starts fresh.
  * Called by provider-error-resume.ts before startAuto() — without this, the
@@ -49,6 +58,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/db-tools.js

@@ -462,6 +462,9 @@ export function registerDbTools(pi) {
             definitionOfDone: Type.Optional(Type.Array(Type.String(), { description: "Definition of done bullets" })),
             requirementCoverage: Type.Optional(Type.String({ description: "Requirement coverage text" })),
             boundaryMapMarkdown: Type.Optional(Type.String({ description: "Boundary map markdown block" })),
+            // Single-writer v3 audit trail (Stream 2): caller-provided actor identity + causation.
+            actorName: Type.Optional(Type.String({ description: "Caller-provided actor identity for the audit trail (e.g. 'executor-01', 'gsd-orchestrator')" })),
+            triggerReason: Type.Optional(Type.String({ description: "Caller-provided reason this action was triggered (e.g. 'plan-phase complete')" })),
         }),
         execute: planMilestoneExecute,
     };
@@ -503,6 +506,9 @@ export function registerDbTools(pi) {
             proofLevel: Type.Optional(Type.String({ description: "Slice proof level" })),
             integrationClosure: Type.Optional(Type.String({ description: "Slice integration closure" })),
             observabilityImpact: Type.Optional(Type.String({ description: "Slice observability impact" })),
+            // Single-writer v3 audit trail (Stream 2): caller-provided actor identity + causation.
+            actorName: Type.Optional(Type.String({ description: "Caller-provided actor identity for the audit trail (e.g. 'executor-01', 'gsd-orchestrator')" })),
+            triggerReason: Type.Optional(Type.String({ description: "Caller-provided reason this action was triggered (e.g. 'plan-phase complete')" })),
         }),
         execute: planSliceExecute,
     };
@@ -569,6 +575,9 @@ export function registerDbTools(pi) {
             inputs: Type.Array(Type.String(), { description: "Input files or references" }),
             expectedOutput: Type.Array(Type.String(), { description: "Expected output files or artifacts" }),
             observabilityImpact: Type.Optional(Type.String({ description: "Task observability impact" })),
+            // Single-writer v3 audit trail (Stream 2): caller-provided actor identity + causation.
+            actorName: Type.Optional(Type.String({ description: "Caller-provided actor identity for the audit trail (e.g. 'executor-01', 'gsd-orchestrator')" })),
+            triggerReason: Type.Optional(Type.String({ description: "Caller-provided reason this action was triggered (e.g. 'plan-phase complete')" })),
         }),
         execute: planTaskExecute,
     };
@@ -628,6 +637,9 @@ export function registerDbTools(pi) {
                 }),
                 Type.String({ description: "Fallback: verification summary string" }),
             ]), { description: "Array of verification evidence entries" })),
+            // Single-writer v3 audit trail (Stream 2): caller-provided actor identity + causation.
+            actorName: Type.Optional(Type.String({ description: "Caller-provided actor identity for the audit trail (e.g. 'executor-01', 'gsd-orchestrator')" })),
+            triggerReason: Type.Optional(Type.String({ description: "Caller-provided reason this action was triggered (e.g. 'task verified after retry')" })),
         }),
         execute: taskCompleteExecute,
     };
@@ -705,6 +717,9 @@ export function registerDbTools(pi) {
                 }),
                 Type.String({ description: "Fallback: slice ID string" }),
             ]), { description: "Upstream slice dependencies consumed" })),
+            // Single-writer v3 audit trail (Stream 2): caller-provided actor identity + causation.
+            actorName: Type.Optional(Type.String({ description: "Caller-provided actor identity for the audit trail (e.g. 'executor-01', 'gsd-orchestrator')" })),
+            triggerReason: Type.Optional(Type.String({ description: "Caller-provided reason this action was triggered (e.g. 'all tasks verified')" })),
         }),
         execute: sliceCompleteExecute,
     };
@@ -826,6 +841,9 @@ export function registerDbTools(pi) {
             lessonsLearned: Type.Optional(Type.Array(Type.String(), { description: "Lessons learned during the milestone" })),
             followUps: Type.Optional(Type.String({ description: "Follow-up items for future milestones" })),
             deviations: Type.Optional(Type.String({ description: "Deviations from the original plan" })),
+            // Single-writer v3 audit trail (Stream 2): caller-provided actor identity + causation.
+            actorName: Type.Optional(Type.String({ description: "Caller-provided actor identity for the audit trail (e.g. 'executor-01', 'gsd-orchestrator')" })),
+            triggerReason: Type.Optional(Type.String({ description: "Caller-provided reason this action was triggered (e.g. 'milestone validation passed')" })),
         }),
         execute: milestoneCompleteExecute,
     };
@@ -897,6 +915,9 @@ export function registerDbTools(pi) {
                 expectedOutput: Type.Array(Type.String(), { description: "Expected output files or artifacts" }),
             }), { description: "Tasks to upsert (update existing or insert new)" }),
             removedTaskIds: Type.Array(Type.String(), { description: "Task IDs to remove from the slice" }),
+            // Single-writer v3 audit trail (Stream 2): caller-provided actor identity + causation.
+            actorName: Type.Optional(Type.String({ description: "Caller-provided actor identity for the audit trail (e.g. 'executor-01', 'gsd-orchestrator')" })),
+            triggerReason: Type.Optional(Type.String({ description: "Caller-provided reason this action was triggered (e.g. 'blocker discovered during execution')" })),
         }),
         execute: replanSliceExecute,
     };
@@ -941,11 +962,199 @@ export function registerDbTools(pi) {
                 }), { description: "New slices to add" }),
                 removed: Type.Array(Type.String(), { description: "Slice IDs to remove" }),
             }, { description: "Slice changes to apply" }),
+            // Single-writer v3 audit trail (Stream 2): caller-provided actor identity + causation.
+            actorName: Type.Optional(Type.String({ description: "Caller-provided actor identity for the audit trail (e.g. 'executor-01', 'gsd-orchestrator')" })),
+            triggerReason: Type.Optional(Type.String({ description: "Caller-provided reason this action was triggered (e.g. 'slice S01 completed, reassessing remaining roadmap')" })),
         }),
         execute: reassessRoadmapExecute,
     };
     pi.registerTool(reassessRoadmapTool);
     registerAlias(pi, reassessRoadmapTool, "gsd_roadmap_reassess", "gsd_reassess_roadmap");
+    // ─── gsd_task_reopen (gsd_reopen_task alias) ───────────────────────────
+    // Single-writer v3, Stream 3: reversibility tools for closed units.
+    const reopenTaskExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
+        const dbAvailable = await ensureDbOpen();
+        if (!dbAvailable) {
+            return {
+                content: [{ type: "text", text: "Error: GSD database is not available. Cannot reopen task." }],
+                details: { operation: "reopen_task", error: "db_unavailable" },
+            };
+        }
+        try {
+            const { handleReopenTask } = await import("../tools/reopen-task.js");
+            const result = await handleReopenTask(params, process.cwd());
+            if ("error" in result) {
+                return {
+                    content: [{ type: "text", text: `Error reopening task: ${result.error}` }],
+                    details: { operation: "reopen_task", error: result.error },
+                };
+            }
+            return {
+                content: [{ type: "text", text: `Reopened task ${result.taskId} (${result.sliceId}/${result.milestoneId})` }],
+                details: {
+                    operation: "reopen_task",
+                    milestoneId: result.milestoneId,
+                    sliceId: result.sliceId,
+                    taskId: result.taskId,
+                },
+            };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            logError("tool", `reopen_task tool failed: ${msg}`, { tool: "gsd_task_reopen", error: String(err) });
+            return {
+                content: [{ type: "text", text: `Error reopening task: ${msg}` }],
+                details: { operation: "reopen_task", error: msg },
+            };
+        }
+    };
+    const reopenTaskTool = {
+        name: "gsd_task_reopen",
+        label: "Reopen Task",
+        description: "Reset a completed task back to 'pending' so it can be re-done. Cleans up SUMMARY.md so the DB-filesystem reconciler does not auto-correct the task back to complete. " +
+            "Both the parent slice and milestone must still be open — use gsd_slice_reopen first if the slice has been closed.",
+        promptSnippet: "Reopen a completed GSD task (resets status to pending, removes SUMMARY.md)",
+        promptGuidelines: [
+            "Use gsd_task_reopen when a completed task needs to be re-done (e.g. verification missed a regression, requirements changed).",
+            "Will fail if the parent slice or milestone is already closed — reopen those first.",
+            "Will fail if the task is not currently 'complete' — there is nothing to reopen.",
+            "Use the canonical name gsd_task_reopen; gsd_reopen_task is only an alias.",
+        ],
+        parameters: Type.Object({
+            milestoneId: Type.String({ description: "Milestone ID (e.g. M001)" }),
+            sliceId: Type.String({ description: "Slice ID (e.g. S01)" }),
+            taskId: Type.String({ description: "Task ID (e.g. T01)" }),
+            reason: Type.Optional(Type.String({ description: "Why the task is being reopened (recorded in the audit trail)" })),
+            // Single-writer v3 audit trail (Stream 2): caller-provided actor identity + causation.
+            actorName: Type.Optional(Type.String({ description: "Caller-provided actor identity for the audit trail (e.g. 'executor-01', 'gsd-orchestrator')" })),
+            triggerReason: Type.Optional(Type.String({ description: "Caller-provided reason this action was triggered (e.g. 'regression discovered post-completion')" })),
+        }),
+        execute: reopenTaskExecute,
+    };
+    pi.registerTool(reopenTaskTool);
+    registerAlias(pi, reopenTaskTool, "gsd_reopen_task", "gsd_task_reopen");
+    // ─── gsd_slice_reopen (gsd_reopen_slice alias) ─────────────────────────
+    const reopenSliceExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
+        const dbAvailable = await ensureDbOpen();
+        if (!dbAvailable) {
+            return {
+                content: [{ type: "text", text: "Error: GSD database is not available. Cannot reopen slice." }],
+                details: { operation: "reopen_slice", error: "db_unavailable" },
+            };
+        }
+        try {
+            const { handleReopenSlice } = await import("../tools/reopen-slice.js");
+            const result = await handleReopenSlice(params, process.cwd());
+            if ("error" in result) {
+                return {
+                    content: [{ type: "text", text: `Error reopening slice: ${result.error}` }],
+                    details: { operation: "reopen_slice", error: result.error },
+                };
+            }
+            return {
+                content: [{ type: "text", text: `Reopened slice ${result.sliceId} (${result.milestoneId}); reset ${result.tasksReset} task(s) to pending.` }],
+                details: {
+                    operation: "reopen_slice",
+                    milestoneId: result.milestoneId,
+                    sliceId: result.sliceId,
+                    tasksReset: result.tasksReset,
+                },
+            };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            logError("tool", `reopen_slice tool failed: ${msg}`, { tool: "gsd_slice_reopen", error: String(err) });
+            return {
+                content: [{ type: "text", text: `Error reopening slice: ${msg}` }],
+                details: { operation: "reopen_slice", error: msg },
+            };
+        }
+    };
+    const reopenSliceTool = {
+        name: "gsd_slice_reopen",
+        label: "Reopen Slice",
+        description: "Reset a completed slice back to 'in_progress' and reset ALL of its tasks back to 'pending'. Cleans up SUMMARY.md / UAT.md and per-task summaries. " +
+            "Reopening a slice means re-doing the work — partial resets create ambiguous state, so all tasks are reset.",
+        promptSnippet: "Reopen a completed GSD slice (resets all tasks to pending, removes summaries)",
+        promptGuidelines: [
+            "Use gsd_slice_reopen when a completed slice needs to be re-done (e.g. integration issue surfaced, requirements changed).",
+            "All tasks within the slice are reset to 'pending' — there is no partial-reopen.",
+            "Will fail if the parent milestone is already closed — reopen the milestone first.",
+            "Will fail if the slice is not currently 'complete' — there is nothing to reopen.",
+            "Use the canonical name gsd_slice_reopen; gsd_reopen_slice is only an alias.",
+        ],
+        parameters: Type.Object({
+            milestoneId: Type.String({ description: "Milestone ID (e.g. M001)" }),
+            sliceId: Type.String({ description: "Slice ID (e.g. S01)" }),
+            reason: Type.Optional(Type.String({ description: "Why the slice is being reopened (recorded in the audit trail)" })),
+            // Single-writer v3 audit trail (Stream 2): caller-provided actor identity + causation.
+            actorName: Type.Optional(Type.String({ description: "Caller-provided actor identity for the audit trail (e.g. 'executor-01', 'gsd-orchestrator')" })),
+            triggerReason: Type.Optional(Type.String({ description: "Caller-provided reason this action was triggered (e.g. 'cross-slice regression discovered')" })),
+        }),
+        execute: reopenSliceExecute,
+    };
+    pi.registerTool(reopenSliceTool);
+    registerAlias(pi, reopenSliceTool, "gsd_reopen_slice", "gsd_slice_reopen");
+    // ─── gsd_milestone_reopen (gsd_reopen_milestone alias) ─────────────────
+    const reopenMilestoneExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
+        const dbAvailable = await ensureDbOpen();
+        if (!dbAvailable) {
+            return {
+                content: [{ type: "text", text: "Error: GSD database is not available. Cannot reopen milestone." }],
+                details: { operation: "reopen_milestone", error: "db_unavailable" },
+            };
+        }
+        try {
+            const { handleReopenMilestone } = await import("../tools/reopen-milestone.js");
+            const result = await handleReopenMilestone(params, process.cwd());
+            if ("error" in result) {
+                return {
+                    content: [{ type: "text", text: `Error reopening milestone: ${result.error}` }],
+                    details: { operation: "reopen_milestone", error: result.error },
+                };
+            }
+            return {
+                content: [{ type: "text", text: `Reopened milestone ${result.milestoneId}; reset ${result.slicesReset} slice(s) and ${result.tasksReset} task(s).` }],
+                details: {
+                    operation: "reopen_milestone",
+                    milestoneId: result.milestoneId,
+                    slicesReset: result.slicesReset,
+                    tasksReset: result.tasksReset,
+                },
+            };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            logError("tool", `reopen_milestone tool failed: ${msg}`, { tool: "gsd_milestone_reopen", error: String(err) });
+            return {
+                content: [{ type: "text", text: `Error reopening milestone: ${msg}` }],
+                details: { operation: "reopen_milestone", error: msg },
+            };
+        }
+    };
+    const reopenMilestoneTool = {
+        name: "gsd_milestone_reopen",
+        label: "Reopen Milestone",
+        description: "Reset a closed milestone back to 'active', all of its slices to 'in_progress', and all tasks to 'pending'. " +
+            "Cleans up MILESTONE-SUMMARY.md, slice summaries, and task summaries so the DB-filesystem reconciler does not auto-correct status back to complete.",
+        promptSnippet: "Reopen a closed GSD milestone (resets slices and tasks, removes summaries)",
+        promptGuidelines: [
+            "Use gsd_milestone_reopen when a closed milestone needs to be re-done (e.g. validation failure surfaced after closure).",
+            "All slices reset to 'in_progress' and all tasks reset to 'pending' — no partial reopen.",
+            "Will fail if the milestone is not currently closed — there is nothing to reopen.",
+            "Use the canonical name gsd_milestone_reopen; gsd_reopen_milestone is only an alias.",
+        ],
+        parameters: Type.Object({
+            milestoneId: Type.String({ description: "Milestone ID (e.g. M001)" }),
+            reason: Type.Optional(Type.String({ description: "Why the milestone is being reopened (recorded in the audit trail)" })),
+            // Single-writer v3 audit trail (Stream 2): caller-provided actor identity + causation.
+            actorName: Type.Optional(Type.String({ description: "Caller-provided actor identity for the audit trail (e.g. 'executor-01', 'gsd-orchestrator')" })),
+            triggerReason: Type.Optional(Type.String({ description: "Caller-provided reason this action was triggered (e.g. 'post-closure validation failure')" })),
+        }),
+        execute: reopenMilestoneExecute,
+    };
+    pi.registerTool(reopenMilestoneTool);
+    registerAlias(pi, reopenMilestoneTool, "gsd_reopen_milestone", "gsd_milestone_reopen");
     // ─── gsd_save_gate_result ──────────────────────────────────────────────
     const saveGateResultExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
         return executeSaveGateResult(params, process.cwd());

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

@@ -1,8 +1,8 @@
 import { getAutoDashboardData, startAuto } from "../auto.js";
 import { resetTransientRetryState } from "./agent-end-recovery.js";
-import { resetSessionTimeoutState } from "../auto/phases.js";
 const defaultDeps = {
     getSnapshot: () => getAutoDashboardData(),
+    resetTransientRetryState,
     startAuto,
 };
 export async function resumeAutoAfterProviderDelay(pi, ctx, deps = defaultDeps) {
@@ -15,11 +15,10 @@ export async function resumeAutoAfterProviderDelay(pi, ctx, deps = defaultDeps)
         ctx.ui.notify("Provider error recovery delay elapsed, but no paused auto-mode base path was available. Leaving auto-mode paused.", "warning");
         return "missing-base";
     }
-    // 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();
+    // Reset provider-error retry state before restarting. Session-creation
+    // timeout state intentionally survives delayed resumes so the bounded
+    // auto-resume limit cannot be reset into an infinite pause/resume loop.
+    deps.resetTransientRetryState();
     await deps.startAuto(ctx, pi, snapshot.basePath, false, { step: snapshot.stepMode });
     return "resumed";
 }