gsd-pi 2.50.0 → 2.51.0-dev.7d435fe

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

@@ -9,7 +9,7 @@ import { readUnitRuntimeRecord, writeUnitRuntimeRecord } from "./unit-runtime.js
 import { isDbAvailable, getMilestoneSlices, getSliceTasks } from "./gsd-db.js";
 import { resolveAutoSupervisorConfig } from "./preferences.js";
 import { computeBudgets, resolveExecutorContextWindow } from "./context-budget.js";
-import { getInFlightToolCount, getOldestInFlightToolStart, } from "./auto-tool-tracking.js";
+import { getInFlightToolCount, getOldestInFlightToolStart, clearInFlightTools, hasInteractiveToolInFlight, } from "./auto-tool-tracking.js";
 import { detectWorkingTreeActivity } from "./auto-supervisor.js";
 import { closeoutUnit } from "./auto-unit-closeout.js";
 import { saveActivityLog } from "./activity-log.js";
@@ -116,7 +116,17 @@ export function startUnitSupervision(sctx) {
                 return;
             // Agent has tool calls currently executing — not idle, just waiting.
             // But only suppress recovery if the tool started recently.
+            let stalledToolDetected = false;
             if (getInFlightToolCount() > 0) {
+                // User-interactive tools (ask_user_questions, secure_env_collect) block
+                // waiting for human input by design — never treat them as stalled (#2676).
+                if (hasInteractiveToolInFlight()) {
+                    writeUnitRuntimeRecord(s.basePath, unitType, unitId, s.currentUnit.startedAt, {
+                        lastProgressAt: Date.now(),
+                        lastProgressKind: "interactive-tool-waiting",
+                    });
+                    return;
+                }
                 const oldestStart = getOldestInFlightToolStart();
                 const toolAgeMs = Date.now() - oldestStart;
                 if (toolAgeMs < idleTimeoutMs) {
@@ -126,10 +136,18 @@ export function startUnitSupervision(sctx) {
                     });
                     return;
                 }
+                // Tool has been in-flight longer than idle timeout — treat as hung.
+                // Clear the stale entries so subsequent ticks don't re-detect them,
+                // and set the flag so the filesystem-activity check below does not
+                // override the stall verdict (#2527).
+                stalledToolDetected = true;
+                clearInFlightTools();
                 ctx.ui.notify(`Stalled tool detected: a tool has been in-flight for ${Math.round(toolAgeMs / 60000)}min. Treating as hung — attempting idle recovery.`, "warning");
             }
             // Check if the agent is producing work on disk.
-            if (detectWorkingTreeActivity(s.basePath)) {
+            // Skip this when a stalled tool was just detected — filesystem changes
+            // from earlier in the task should not override the stall verdict (#2527).
+            if (!stalledToolDetected && detectWorkingTreeActivity(s.basePath)) {
                 writeUnitRuntimeRecord(s.basePath, unitType, unitId, s.currentUnit.startedAt, {
                     lastProgressAt: Date.now(),
                     lastProgressKind: "filesystem-activity",
@@ -145,6 +163,10 @@ export function startUnitSupervision(sctx) {
             const recovery = await recoverTimedOutUnit(ctx, pi, unitType, unitId, "idle", buildRecoveryContext());
             if (recovery === "recovered")
                 return;
+            // Guard: recoverTimedOutUnit is async — pauseAuto/stopAuto may have
+            // set s.currentUnit = null during the await (#2527).
+            if (!s.currentUnit)
+                return;
             writeUnitRuntimeRecord(s.basePath, unitType, unitId, s.currentUnit.startedAt, {
                 phase: "paused",
             });

package/dist/resources/extensions/gsd/auto-tool-tracking.js

@@ -4,14 +4,20 @@
  * can distinguish "waiting for tool completion" from "truly idle".
  */
 const inFlightTools = new Map();
+/**
+ * Tools that block waiting for human input by design.
+ * The idle watchdog must not treat these as stalled.
+ */
+const INTERACTIVE_TOOLS = new Set(["ask_user_questions", "secure_env_collect"]);
 /**
  * Mark a tool execution as in-flight.
- * Records start time so the idle watchdog can detect tools hung longer than the idle timeout.
+ * Records start time and tool name so the idle watchdog can detect tools
+ * hung longer than the idle timeout while exempting interactive tools.
  */
-export function markToolStart(toolCallId, isActive) {
+export function markToolStart(toolCallId, isActive, toolName) {
     if (!isActive)
         return;
-    inFlightTools.set(toolCallId, Date.now());
+    inFlightTools.set(toolCallId, { startedAt: Date.now(), toolName: toolName ?? "unknown" });
 }
 /**
  * Mark a tool execution as completed.
@@ -27,8 +33,8 @@ export function getOldestInFlightToolAgeMs() {
         return 0;
     let oldestStart = Infinity;
     for (const t of inFlightTools.values()) {
-        if (t < oldestStart)
-            oldestStart = t;
+        if (t.startedAt < oldestStart)
+            oldestStart = t.startedAt;
     }
     return Date.now() - oldestStart;
 }
@@ -46,11 +52,23 @@ export function getOldestInFlightToolStart() {
         return undefined;
     let oldest = Infinity;
     for (const t of inFlightTools.values()) {
-        if (t < oldest)
-            oldest = t;
+        if (t.startedAt < oldest)
+            oldest = t.startedAt;
     }
     return oldest;
 }
+/**
+ * Returns true if any currently in-flight tool is a user-interactive tool
+ * (e.g. ask_user_questions, secure_env_collect) that blocks waiting for
+ * human input. These must be exempt from idle stall detection.
+ */
+export function hasInteractiveToolInFlight() {
+    for (const { toolName } of inFlightTools.values()) {
+        if (INTERACTIVE_TOOLS.has(toolName))
+            return true;
+    }
+    return false;
+}
 /**
  * Clear all in-flight tool tracking state.
  */

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

@@ -0,0 +1,20 @@
+// Shared utilities for the auto-loop modules (auto-post-unit, auto, etc.).
+import { debugLog } from "./debug-logger.js";
+/**
+ * Run a non-fatal operation, logging any error via `debugLog` and continuing.
+ *
+ * Replaces the repeated try-catch-debugLog-continue boilerplate that wraps
+ * operations whose failure should not abort the post-unit pipeline.
+ *
+ * @param context - The debugLog event name (e.g. "postUnit")
+ * @param phase   - The phase label attached to the debug entry
+ * @param fn      - The operation to execute (may be sync or async)
+ */
+export async function runSafely(context, phase, fn) {
+    try {
+        await fn();
+    }
+    catch (e) {
+        debugLog(context, { phase, error: String(e) });
+    }
+}

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

@@ -37,6 +37,10 @@ const ROOT_STATE_FILES = [
     "QUEUE.md",
     "completed-units.json",
     "metrics.json",
+    // NOTE: preferences.md is intentionally NOT in ROOT_STATE_FILES.
+    // Forward-sync (main → worktree) is handled explicitly in syncGsdStateToWorktree().
+    // Back-sync (worktree → main) must NEVER overwrite the project root's copy
+    // because the project root is authoritative for preferences (#2684).
 ];
 /**
  * Check if two filesystem paths resolve to the same real location.
@@ -319,6 +323,22 @@ export function syncGsdStateToWorktree(mainBasePath, worktreePath_) {
             }
         }
     }
+    // Forward-sync preferences.md from project root to worktree (additive only).
+    // NOT in ROOT_STATE_FILES because syncWorktreeStateBack() must never overwrite
+    // the project root's preferences — the project root is authoritative (#2684).
+    {
+        const src = join(mainGsd, "preferences.md");
+        const dst = join(wtGsd, "preferences.md");
+        if (existsSync(src) && !existsSync(dst)) {
+            try {
+                cpSync(src, dst);
+                synced.push("preferences.md");
+            }
+            catch {
+                /* non-fatal */
+            }
+        }
+    }
     // Sync milestones: copy entire milestone directories that are missing
     const mainMilestonesDir = join(mainGsd, "milestones");
     const wtMilestonesDir = join(wtGsd, "milestones");
@@ -801,6 +821,7 @@ function copyPlanningArtifacts(srcBase, wtPath) {
         "STATE.md",
         "KNOWLEDGE.md",
         "OVERRIDES.md",
+        "preferences.md",
     ]) {
         safeCopy(join(srcGsd, file), join(dstGsd, file), { force: true });
     }

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

@@ -10,6 +10,7 @@
  * telling the LLM which files to read and what to do.
  */
 import { deriveState } from "./state.js";
+import { parseUnitId } from "./unit-id.js";
 import { getManifestStatus } from "./files.js";
 export { inlinePriorMilestoneSummary } from "./files.js";
 import { collectSecretsFromManifest } from "../get-secrets-from-user.js";
@@ -31,7 +32,9 @@ import { runGSDDoctor, rebuildState } from "./doctor.js";
 import { preDispatchHealthGate, resetProactiveHealing, setLevelChangeCallback, } from "./doctor-proactive.js";
 import { clearSkillSnapshot } from "./skill-discovery.js";
 import { captureAvailableSkills, resetSkillTelemetry, } from "./skill-telemetry.js";
+import { getRtkSessionSavings } from "../shared/rtk-session-stats.js";
 import { initMetrics, resetMetrics, getLedger, getProjectTotals, formatCost, formatTokenCount, } from "./metrics.js";
+import { setLogBasePath } from "./workflow-logger.js";
 import { join } from "node:path";
 import { readFileSync, existsSync, mkdirSync, writeFileSync, unlinkSync } from "node:fs";
 import { atomicWriteSync } from "./atomic-write.js";
@@ -122,6 +125,11 @@ function deregisterSigtermHandler() {
 export function getAutoDashboardData() {
     const ledger = getLedger();
     const totals = ledger ? getProjectTotals(ledger.units) : null;
+    const sessionId = s.cmdCtx?.sessionManager?.getSessionId?.() ?? null;
+    const rtkSavings = sessionId && s.basePath
+        ? getRtkSessionSavings(s.basePath, sessionId)
+        : null;
+    const rtkEnabled = loadEffectiveGSDPreferences()?.preferences.experimental?.rtk === true;
     // Pending capture count — lazy check, non-fatal
     let pendingCaptureCount = 0;
     try {
@@ -145,6 +153,8 @@ export function getAutoDashboardData() {
         totalCost: totals?.cost ?? 0,
         totalTokens: totals?.tokens.total ?? 0,
         pendingCaptureCount,
+        rtkSavings,
+        rtkEnabled,
     };
 }
 // ─── Public API ───────────────────────────────────────────────────────────────
@@ -175,8 +185,8 @@ export function getAutoModeStartModel() {
     return s.autoModeStartModel;
 }
 // Tool tracking — delegates to auto-tool-tracking.ts
-export function markToolStart(toolCallId) {
-    _markToolStart(toolCallId, s.active);
+export function markToolStart(toolCallId, toolName) {
+    _markToolStart(toolCallId, s.active, toolName);
 }
 export function markToolEnd(toolCallId) {
     _markToolEnd(toolCallId);
@@ -361,8 +371,11 @@ export async function stopAuto(ctx, pi, reason) {
         // When the milestone is complete (has a SUMMARY), merge the worktree branch
         // back to main so code isn't stranded on the worktree branch (#2317).
         // For incomplete milestones, preserve the branch for later resumption.
+        //
+        // Skip if phases.ts already merged this milestone — avoids the double
+        // mergeAndExit that fails because the branch was already deleted (#2645).
         try {
-            if (s.currentMilestoneId) {
+            if (s.currentMilestoneId && !s.milestoneMergedInPhases) {
                 const notifyCtx = ctx
                     ? { notify: ctx.ui.notify.bind(ctx.ui) }
                     : { notify: () => { } };
@@ -803,6 +816,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         s.stepMode = requestedStepMode;
         s.cmdCtx = ctx;
         s.basePath = base;
+        setLogBasePath(base);
         s.unitDispatchCount.clear();
         s.unitLifetimeDispatches.clear();
         if (!getLedger())
@@ -927,15 +941,13 @@ const widgetStateAccessors = {
  * dispatching a unit. The LLM should never need to mkdir or git checkout.
  */
 function ensurePreconditions(unitType, unitId, base, state) {
-    const parts = unitId.split("/");
-    const mid = parts[0];
+    const { milestone: mid, slice: sid } = parseUnitId(unitId);
     const mDir = resolveMilestonePath(base, mid);
     if (!mDir) {
         const newDir = join(milestonesDir(base), mid);
         mkdirSync(join(newDir, "slices"), { recursive: true });
     }
-    if (parts.length >= 2) {
-        const sid = parts[1];
+    if (sid !== undefined) {
         const mDirResolved = resolveMilestonePath(base, mid);
         if (mDirResolved) {
             const slicesDir = join(mDirResolved, "slices");

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

@@ -1,12 +1,33 @@
 import { checkAutoStartAfterDiscuss } from "../guided-flow.js";
 import { getAutoDashboardData, getAutoModeStartModel, isAutoActive, pauseAuto } from "../auto.js";
-import { getNextFallbackModel, isTransientNetworkError, resolveModelWithFallbacksForUnit } from "../preferences.js";
-import { classifyProviderError, pauseAutoForProviderError } from "../provider-error-pause.js";
+import { getNextFallbackModel, resolveModelWithFallbacksForUnit } from "../preferences.js";
+import { pauseAutoForProviderError } from "../provider-error-pause.js";
 import { isSessionSwitchInFlight, resolveAgentEnd } from "../auto-loop.js";
+import { resolveModelId } from "../auto-model-selection.js";
 import { clearDiscussionFlowState } from "./write-gate.js";
-const networkRetryCounters = new Map();
+import { classifyError, createRetryState, resetRetryState, isTransient, } from "../error-classifier.js";
+const retryState = createRetryState();
+const MAX_NETWORK_RETRIES = 2;
 const MAX_TRANSIENT_AUTO_RESUMES = 3;
-let consecutiveTransientErrors = 0;
+async function pauseTransientWithBackoff(cls, pi, ctx, errorDetail, isRateLimit) {
+    retryState.consecutiveTransientCount += 1;
+    const baseRetryAfterMs = "retryAfterMs" in cls ? cls.retryAfterMs : 15_000;
+    const retryAfterMs = baseRetryAfterMs * 2 ** Math.max(0, retryState.consecutiveTransientCount - 1);
+    const allowAutoResume = retryState.consecutiveTransientCount <= MAX_TRANSIENT_AUTO_RESUMES;
+    if (!allowAutoResume) {
+        ctx.ui.notify(`Transient provider errors persisted after ${MAX_TRANSIENT_AUTO_RESUMES} auto-resume attempts. Pausing for manual review.`, "warning");
+    }
+    await pauseAutoForProviderError(ctx.ui, errorDetail, () => pauseAuto(ctx, pi), {
+        isRateLimit,
+        isTransient: allowAutoResume,
+        retryAfterMs,
+        resume: allowAutoResume
+            ? () => {
+                pi.sendMessage({ customType: "gsd-auto-timeout-recovery", content: "Continue execution — provider error recovery delay elapsed.", display: false }, { triggerTurn: true });
+            }
+            : undefined,
+    });
+}
 export async function handleAgentEnd(pi, event, ctx) {
     if (checkAutoStartAfterDiscuss()) {
         clearDiscussionFlowState();
@@ -24,93 +45,98 @@ export async function handleAgentEnd(pi, event, ctx) {
     if (lastMsg && "stopReason" in lastMsg && lastMsg.stopReason === "error") {
         const errorDetail = "errorMessage" in lastMsg && lastMsg.errorMessage ? `: ${lastMsg.errorMessage}` : "";
         const errorMsg = ("errorMessage" in lastMsg && lastMsg.errorMessage) ? String(lastMsg.errorMessage) : "";
-        if (isTransientNetworkError(errorMsg)) {
+        const explicitRetryAfterMs = ("retryAfterMs" in lastMsg && typeof lastMsg.retryAfterMs === "number") ? lastMsg.retryAfterMs : undefined;
+        // ── 1. Classify ──────────────────────────────────────────────────────
+        const cls = classifyError(errorMsg, explicitRetryAfterMs);
+        // ── 2. Decide & Act ──────────────────────────────────────────────────
+        // --- Network errors: same-model retry with backoff ---
+        if (cls.kind === "network") {
             const currentModelId = ctx.model?.id ?? "unknown";
-            const retryKey = `network-retry:${currentModelId}`;
-            const currentRetries = networkRetryCounters.get(retryKey) ?? 0;
-            const maxRetries = 2;
-            if (currentRetries < maxRetries) {
-                networkRetryCounters.set(retryKey, currentRetries + 1);
-                const attempt = currentRetries + 1;
-                const delayMs = attempt * 3000;
-                ctx.ui.notify(`Network error on ${currentModelId}${errorDetail}. Retry ${attempt}/${maxRetries} in ${delayMs / 1000}s...`, "warning");
+            if (retryState.currentRetryModelId !== currentModelId) {
+                retryState.networkRetryCount = 0;
+                retryState.currentRetryModelId = currentModelId;
+            }
+            if (retryState.networkRetryCount < MAX_NETWORK_RETRIES) {
+                retryState.networkRetryCount += 1;
+                retryState.consecutiveTransientCount += 1;
+                const attempt = retryState.networkRetryCount;
+                const delayMs = attempt * cls.retryAfterMs;
+                ctx.ui.notify(`Network error on ${currentModelId}${errorDetail}. Retry ${attempt}/${MAX_NETWORK_RETRIES} in ${delayMs / 1000}s...`, "warning");
                 setTimeout(() => {
                     pi.sendMessage({ customType: "gsd-auto-timeout-recovery", content: "Continue execution — retrying after transient network error.", display: false }, { triggerTurn: true });
                 }, delayMs);
                 return;
             }
-            networkRetryCounters.delete(retryKey);
+            // Network retries exhausted — fall through to model fallback
+            retryState.networkRetryCount = 0;
+            retryState.currentRetryModelId = undefined;
             ctx.ui.notify(`Network retries exhausted for ${currentModelId}. Attempting model fallback.`, "warning");
         }
-        const dash = getAutoDashboardData();
-        if (dash.currentUnit) {
-            const modelConfig = resolveModelWithFallbacksForUnit(dash.currentUnit.type);
-            if (modelConfig && modelConfig.fallbacks.length > 0) {
-                const availableModels = ctx.modelRegistry.getAvailable();
-                const nextModelId = getNextFallbackModel(ctx.model?.id, modelConfig);
-                if (nextModelId) {
-                    networkRetryCounters.clear();
-                    const slashIdx = nextModelId.indexOf("/");
-                    const modelToSet = slashIdx !== -1
-                        ? availableModels.find((m) => m.provider.toLowerCase() === nextModelId.substring(0, slashIdx).toLowerCase() && m.id.toLowerCase() === nextModelId.substring(slashIdx + 1).toLowerCase())
-                        : (availableModels.find((m) => m.id === nextModelId && m.provider === ctx.model?.provider) ?? availableModels.find((m) => m.id === nextModelId));
-                    if (modelToSet) {
-                        const ok = await pi.setModel(modelToSet, { persist: false });
-                        if (ok) {
-                            ctx.ui.notify(`Model error${errorDetail}. Switched to fallback: ${nextModelId} and resuming.`, "warning");
-                            pi.sendMessage({ customType: "gsd-auto-timeout-recovery", content: "Continue execution.", display: false }, { triggerTurn: true });
-                            return;
+        // --- Rate limit: skip model fallback, go straight to pause ---
+        // Rate-limiting is a provider issue, not a model issue.
+        // Switching models won't help if the provider is throttling you.
+        if (cls.kind === "rate-limit") {
+            await pauseTransientWithBackoff(cls, pi, ctx, errorDetail, true);
+            return;
+        }
+        // --- Server/connection/stream errors: try model fallback first ---
+        if (cls.kind === "network" || cls.kind === "server" || cls.kind === "connection" || cls.kind === "stream") {
+            // Try model fallback
+            const dash = getAutoDashboardData();
+            if (dash.currentUnit) {
+                const modelConfig = resolveModelWithFallbacksForUnit(dash.currentUnit.type);
+                if (modelConfig && modelConfig.fallbacks.length > 0) {
+                    const availableModels = ctx.modelRegistry.getAvailable();
+                    const nextModelId = getNextFallbackModel(ctx.model?.id, modelConfig);
+                    if (nextModelId) {
+                        retryState.networkRetryCount = 0;
+                        retryState.currentRetryModelId = undefined;
+                        const modelToSet = resolveModelId(nextModelId, availableModels, ctx.model?.provider);
+                        if (modelToSet) {
+                            const ok = await pi.setModel(modelToSet, { persist: false });
+                            if (ok) {
+                                ctx.ui.notify(`Model error${errorDetail}. Switched to fallback: ${nextModelId} and resuming.`, "warning");
+                                pi.sendMessage({ customType: "gsd-auto-timeout-recovery", content: "Continue execution.", display: false }, { triggerTurn: true });
+                                return;
+                            }
                         }
                     }
                 }
             }
-        }
-        const sessionModel = getAutoModeStartModel();
-        if (sessionModel) {
-            if (ctx.model?.id !== sessionModel.id || ctx.model?.provider !== sessionModel.provider) {
-                const startModel = ctx.modelRegistry.getAvailable().find((m) => m.provider === sessionModel.provider && m.id === sessionModel.id);
-                if (startModel) {
-                    const ok = await pi.setModel(startModel, { persist: false });
-                    if (ok) {
-                        networkRetryCounters.clear();
-                        ctx.ui.notify(`Model error${errorDetail}. Restored session model: ${sessionModel.provider}/${sessionModel.id} and resuming.`, "warning");
-                        pi.sendMessage({ customType: "gsd-auto-timeout-recovery", content: "Continue execution.", display: false }, { triggerTurn: true });
-                        return;
+            // Try restoring session model
+            const sessionModel = getAutoModeStartModel();
+            if (sessionModel) {
+                if (ctx.model?.id !== sessionModel.id || ctx.model?.provider !== sessionModel.provider) {
+                    const startModel = ctx.modelRegistry.getAvailable().find((m) => m.provider === sessionModel.provider && m.id === sessionModel.id);
+                    if (startModel) {
+                        const ok = await pi.setModel(startModel, { persist: false });
+                        if (ok) {
+                            retryState.networkRetryCount = 0;
+                            retryState.currentRetryModelId = undefined;
+                            ctx.ui.notify(`Model error${errorDetail}. Restored session model: ${sessionModel.provider}/${sessionModel.id} and resuming.`, "warning");
+                            pi.sendMessage({ customType: "gsd-auto-timeout-recovery", content: "Continue execution.", display: false }, { triggerTurn: true });
+                            return;
+                        }
                     }
                 }
             }
         }
-        const classification = classifyProviderError(errorMsg);
-        const explicitRetryAfterMs = ("retryAfterMs" in lastMsg && typeof lastMsg.retryAfterMs === "number") ? lastMsg.retryAfterMs : undefined;
-        if (classification.isTransient) {
-            consecutiveTransientErrors += 1;
-        }
-        else {
-            consecutiveTransientErrors = 0;
-        }
-        const baseRetryAfterMs = explicitRetryAfterMs ?? classification.suggestedDelayMs;
-        const retryAfterMs = classification.isTransient
-            ? baseRetryAfterMs * 2 ** Math.max(0, consecutiveTransientErrors - 1)
-            : baseRetryAfterMs;
-        const allowAutoResume = classification.isTransient && consecutiveTransientErrors <= MAX_TRANSIENT_AUTO_RESUMES;
-        if (classification.isTransient && !allowAutoResume) {
-            ctx.ui.notify(`Transient provider errors persisted after ${MAX_TRANSIENT_AUTO_RESUMES} auto-resume attempts. Pausing for manual review.`, "warning");
+        // --- Transient fallback: pause with auto-resume ---
+        if (isTransient(cls)) {
+            await pauseTransientWithBackoff(cls, pi, ctx, errorDetail, false);
+            return;
         }
+        // --- Permanent / unknown: pause indefinitely ---
         await pauseAutoForProviderError(ctx.ui, errorDetail, () => pauseAuto(ctx, pi), {
-            isRateLimit: classification.isRateLimit,
-            isTransient: allowAutoResume,
-            retryAfterMs,
-            resume: allowAutoResume
-                ? () => {
-                    pi.sendMessage({ customType: "gsd-auto-timeout-recovery", content: "Continue execution — provider error recovery delay elapsed.", display: false }, { triggerTurn: true });
-                }
-                : undefined,
+            isRateLimit: false,
+            isTransient: false,
+            retryAfterMs: 0,
         });
         return;
     }
+    // ── Success path ─────────────────────────────────────────────────────────
     try {
-        consecutiveTransientErrors = 0;
-        networkRetryCounters.clear();
+        resetRetryState(retryState);
         resolveAgentEnd(event);
     }
     catch (err) {

package/dist/resources/extensions/gsd/bootstrap/dynamic-tools.js

@@ -2,6 +2,7 @@ import { existsSync } from "node:fs";
 import { join, sep } from "node:path";
 import { createBashTool, createEditTool, createReadTool, createWriteTool } from "@gsd/pi-coding-agent";
 import { DEFAULT_BASH_TIMEOUT_SECS } from "../constants.js";
+import { setLogBasePath } from "../workflow-logger.js";
 /**
  * Resolve the correct DB path for the current working directory.
  * If `basePath` is inside a `.gsd/worktrees/<MID>/` directory, returns
@@ -35,9 +36,14 @@ export async function ensureDbOpen() {
         const basePath = process.cwd();
         const dbPath = resolveProjectRootDbPath(basePath);
         const gsdDir = join(basePath, ".gsd");
+        // Derive the project root from the DB path (strip .gsd/gsd.db)
+        const projectRoot = join(dbPath, "..", "..");
         // Open existing DB file (may be at project root for worktrees)
         if (existsSync(dbPath)) {
-            return db.openDatabase(dbPath);
+            const opened = db.openDatabase(dbPath);
+            if (opened)
+                setLogBasePath(projectRoot);
+            return opened;
         }
         // No DB file — create + migrate from Markdown if .gsd/ has content
         if (existsSync(gsdDir)) {
@@ -47,6 +53,7 @@ export async function ensureDbOpen() {
             if (hasDecisions || hasRequirements || hasMilestones) {
                 const opened = db.openDatabase(dbPath);
                 if (opened) {
+                    setLogBasePath(projectRoot);
                     try {
                         const { migrateFromMarkdown } = await import("../md-importer.js");
                         migrateFromMarkdown(basePath);
@@ -58,7 +65,10 @@ export async function ensureDbOpen() {
                 return opened;
             }
             // .gsd/ exists but has no Markdown content (fresh project) — create empty DB
-            return db.openDatabase(dbPath);
+            const opened = db.openDatabase(dbPath);
+            if (opened)
+                setLogBasePath(projectRoot);
+            return opened;
         }
         return false;
     }

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

@@ -13,6 +13,8 @@ import { getAutoDashboardData, isAutoActive, isAutoPaused, markToolEnd, markTool
 import { isParallelActive, shutdownParallel } from "../parallel-orchestrator.js";
 import { checkToolCallLoop, resetToolCallLoopGuard } from "./tool-call-loop-guard.js";
 import { saveActivityLog } from "../activity-log.js";
+import { startRtkStatusUpdates, stopRtkStatusUpdates } from "../rtk-status.js";
+import { rewriteCommandWithRtk } from "../../shared/rtk.js";
 // Skip the welcome screen on the very first session_start — cli.ts already
 // printed it before the TUI launched. Only re-print on /clear (subsequent sessions).
 let isFirstSession = true;
@@ -21,10 +23,19 @@ async function syncServiceTierStatus(ctx) {
     ctx.ui.setStatus("gsd-fast", formatServiceTierFooterStatus(getEffectiveServiceTier(), ctx.model?.id));
 }
 export function registerHooks(pi) {
+    // Route all agent bash tool commands through RTK rewrite when opted in.
+    // This is a no-op when RTK is disabled or not installed.
+    pi.on("bash_transform", async (event) => {
+        const rewritten = rewriteCommandWithRtk(event.command);
+        if (rewritten === event.command)
+            return undefined;
+        return { command: rewritten };
+    });
     pi.on("session_start", async (_event, ctx) => {
         resetWriteGateState();
         resetToolCallLoopGuard();
         await syncServiceTierStatus(ctx);
+        startRtkStatusUpdates(ctx);
         // Apply show_token_cost preference (#1515)
         try {
             const { loadEffectiveGSDPreferences } = await import("../preferences.js");
@@ -69,6 +80,10 @@ export function registerHooks(pi) {
         clearDiscussionFlowState();
         await syncServiceTierStatus(ctx);
         loadToolApiKeys();
+        startRtkStatusUpdates(ctx);
+    });
+    pi.on("session_fork", async (_event, ctx) => {
+        startRtkStatusUpdates(ctx);
     });
     pi.on("before_agent_start", async (event, ctx) => {
         return buildBeforeAgentStartResult(event, ctx);
@@ -115,6 +130,7 @@ export function registerHooks(pi) {
         }));
     });
     pi.on("session_shutdown", async (_event, ctx) => {
+        stopRtkStatusUpdates(ctx);
         if (isParallelActive()) {
             try {
                 await shutdownParallel(process.cwd());
@@ -211,7 +227,7 @@ export function registerHooks(pi) {
     pi.on("tool_execution_start", async (event) => {
         if (!isAutoActive())
             return;
-        markToolStart(event.toolCallId);
+        markToolStart(event.toolCallId, event.toolName);
     });
     pi.on("tool_execution_end", async (event) => {
         markToolEnd(event.toolCallId);