gsd-pi 2.62.0 → 2.62.1-dev.1ae2b74

package/dist/resources/extensions/ask-user-questions.js

@@ -33,6 +33,31 @@ const AskUserQuestionsParams = Type.Object({
         description: "Questions to show the user. Prefer 1 and do not exceed 3.",
     }),
 });
+// ─── Per-turn deduplication ──────────────────────────────────────────────────
+// Prevents duplicate question dispatches (especially to remote channels like
+// Discord) when the LLM calls ask_user_questions multiple times with the same
+// questions in a single turn. Keyed by full canonicalized payload (id, header,
+// question, options, allowMultiple) — not just IDs — so that calls with the
+// same IDs but different text/options are treated as distinct.
+import { createHash } from "node:crypto";
+const turnCache = new Map();
+/** @internal Exported for testing only. */
+export function questionSignature(questions) {
+    const canonical = questions
+        .map((q) => ({
+        id: q.id,
+        header: q.header,
+        question: q.question,
+        options: (q.options || []).map((o) => ({ label: o.label, description: o.description })),
+        allowMultiple: !!q.allowMultiple,
+    }))
+        .sort((a, b) => a.id.localeCompare(b.id));
+    return createHash("sha256").update(JSON.stringify(canonical)).digest("hex").slice(0, 16);
+}
+/** Reset the dedup cache. Called on session boundaries. */
+export function resetAskUserQuestionsCache() {
+    turnCache.clear();
+}
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 const OTHER_OPTION_LABEL = "None of the above";
 function errorResult(message, questions = []) {
@@ -73,6 +98,15 @@ export default function AskUserQuestions(pi) {
         ],
         parameters: AskUserQuestionsParams,
         async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+            // ── Per-turn dedup: return cached result for identical question sets ──
+            const sig = questionSignature(params.questions);
+            const cached = turnCache.get(sig);
+            if (cached) {
+                return {
+                    content: [{ type: "text", text: cached.content[0].text + "\n(Returned cached answer — this question set was already asked this turn.)" }],
+                    details: cached.details,
+                };
+            }
             // Validation
             if (params.questions.length === 0 || params.questions.length > 3) {
                 return errorResult("Error: questions must contain 1-3 items", params.questions);
@@ -87,8 +121,14 @@ export default function AskUserQuestions(pi) {
             // this is a no-op when the user has not set up Slack/Discord/Telegram.
             const { tryRemoteQuestions } = await import("./remote-questions/manager.js");
             const remoteResult = await tryRemoteQuestions(params.questions, signal);
-            if (remoteResult)
+            if (remoteResult) {
+                // Cache successful remote results to prevent duplicate Discord dispatches
+                const remoteDetails = remoteResult.details;
+                if (remoteDetails && !remoteDetails.timed_out && !remoteDetails.error) {
+                    turnCache.set(sig, remoteResult);
+                }
                 return { ...remoteResult, details: remoteResult.details };
+            }
             if (!ctx.hasUI) {
                 return errorResult("Error: UI not available (non-interactive mode)", params.questions);
             }
@@ -131,7 +171,7 @@ export default function AskUserQuestions(pi) {
                         { selected: a.answers.length === 1 ? a.answers[0] : a.answers, notes: "" },
                     ])),
                 };
-                return {
+                const fallbackResult = {
                     content: [{ type: "text", text: JSON.stringify({ answers }) }],
                     details: {
                         questions: params.questions,
@@ -139,6 +179,8 @@ export default function AskUserQuestions(pi) {
                         cancelled: false,
                     },
                 };
+                turnCache.set(sig, fallbackResult);
+                return fallbackResult;
             }
             // Check if cancelled (empty answers = user exited)
             const hasAnswers = Object.keys(result.answers).length > 0;
@@ -148,10 +190,12 @@ export default function AskUserQuestions(pi) {
                     details: { questions: params.questions, response: null, cancelled: true },
                 };
             }
-            return {
+            const successResult = {
                 content: [{ type: "text", text: formatForLLM(result) }],
                 details: { questions: params.questions, response: result, cancelled: false },
             };
+            turnCache.set(sig, successResult);
+            return successResult;
         },
         // ─── Rendering ────────────────────────────────────────────────────────
         renderCall(args, theme) {

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

@@ -26,6 +26,7 @@ export async function autoLoop(ctx, pi, s, deps) {
     let iteration = 0;
     const loopState = { recentUnits: [], stuckRecoveryAttempts: 0 };
     let consecutiveErrors = 0;
+    const recentErrorMessages = [];
     while (s.active) {
         iteration++;
         debugLog("autoLoop", { phase: "loop-top", iteration });
@@ -157,6 +158,7 @@ export async function autoLoop(ctx, pi, s, deps) {
                 });
                 deps.clearUnitTimeout();
                 consecutiveErrors = 0;
+                recentErrorMessages.length = 0;
                 deps.emitJournalEvent({ ts: new Date().toISOString(), flowId, seq: nextSeq(), eventType: "iteration-end", data: { iteration } });
                 debugLog("autoLoop", { phase: "iteration-complete", iteration });
                 continue;
@@ -206,6 +208,7 @@ export async function autoLoop(ctx, pi, s, deps) {
             if (finalizeResult.action === "continue")
                 continue;
             consecutiveErrors = 0; // Iteration completed successfully
+            recentErrorMessages.length = 0;
             deps.emitJournalEvent({ ts: new Date().toISOString(), flowId, seq: nextSeq(), eventType: "iteration-end", data: { iteration } });
             debugLog("autoLoop", { phase: "iteration-complete", iteration });
         }
@@ -228,6 +231,7 @@ export async function autoLoop(ctx, pi, s, deps) {
                 break;
             }
             consecutiveErrors++;
+            recentErrorMessages.push(msg.length > 120 ? msg.slice(0, 120) + "..." : msg);
             debugLog("autoLoop", {
                 phase: "iteration-error",
                 iteration,
@@ -236,7 +240,10 @@ export async function autoLoop(ctx, pi, s, deps) {
             });
             if (consecutiveErrors >= 3) {
                 // 3+ consecutive: hard stop — something is fundamentally broken
-                ctx.ui.notify(`Auto-mode stopped: ${consecutiveErrors} consecutive iteration failures. Last: ${msg}`, "error");
+                const errorHistory = recentErrorMessages
+                    .map((m, i) => `  ${i + 1}. ${m}`)
+                    .join("\n");
+                ctx.ui.notify(`Auto-mode stopped: ${consecutiveErrors} consecutive iteration failures:\n${errorHistory}`, "error");
                 await deps.stopAuto(ctx, pi, `${consecutiveErrors} consecutive iteration failures`);
                 break;
             }

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

@@ -18,7 +18,7 @@ import { existsSync, cpSync } from "node:fs";
 import { logWarning, logError } from "../workflow-logger.js";
 import { gsdRoot } from "../paths.js";
 import { atomicWriteSync } from "../atomic-write.js";
-import { verifyExpectedArtifact } from "../auto-recovery.js";
+import { verifyExpectedArtifact, diagnoseExpectedArtifact, buildLoopRemediationSteps } from "../auto-recovery.js";
 import { writeUnitRuntimeRecord } from "../unit-runtime.js";
 // ─── generateMilestoneReport ──────────────────────────────────────────────────
 /**
@@ -116,7 +116,7 @@ export async function runPreDispatch(ic, loopState) {
             ctx.ui.notify(`Pre-dispatch: ${healthGate.fixesApplied.join(", ")}`, "info");
         }
         if (!healthGate.proceed) {
-            ctx.ui.notify(healthGate.reason ?? "Pre-dispatch health check failed.", "error");
+            ctx.ui.notify(healthGate.reason || "Pre-dispatch health check failed — run /gsd doctor for details.", "error");
             await deps.pauseAuto(ctx, pi);
             debugLog("autoLoop", { phase: "exit", reason: "health-gate-failed" });
             return { action: "break", reason: "health-gate-failed" };
@@ -431,8 +431,15 @@ export async function runDispatch(ic, preData, loopState) {
                     unitId,
                     reason: stuckSignal.reason,
                 });
+                const stuckDiag = diagnoseExpectedArtifact(unitType, unitId, s.basePath);
+                const stuckRemediation = buildLoopRemediationSteps(unitType, unitId, s.basePath);
+                const stuckParts = [`Stuck on ${unitType} ${unitId} — ${stuckSignal.reason}.`];
+                if (stuckDiag)
+                    stuckParts.push(`Expected: ${stuckDiag}`);
+                if (stuckRemediation)
+                    stuckParts.push(`To recover:\n${stuckRemediation}`);
+                ctx.ui.notify(stuckParts.join(" "), "error");
                 await deps.stopAuto(ctx, pi, `Stuck: ${stuckSignal.reason}`);
-                ctx.ui.notify(`Stuck on ${unitType} ${unitId} — ${stuckSignal.reason}. The expected artifact was not written.`, "error");
                 return { action: "break", reason: "stuck-detected" };
             }
         }

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

@@ -19,7 +19,7 @@ import { invalidateAllCaches } from "./cache.js";
 import { parseUnitId } from "./unit-id.js";
 import { closeoutUnit } from "./auto-unit-closeout.js";
 import { autoCommitCurrentBranch, } from "./worktree.js";
-import { verifyExpectedArtifact, resolveExpectedArtifactPath, } from "./auto-recovery.js";
+import { verifyExpectedArtifact, resolveExpectedArtifactPath, diagnoseExpectedArtifact, } from "./auto-recovery.js";
 import { regenerateIfMissing } from "./workflow-projections.js";
 import { syncStateToProjectRoot } from "./auto-worktree.js";
 import { isDbAvailable, getTask, getSlice, getMilestone, updateTaskStatus, _getAdapter } from "./gsd-db.js";
@@ -383,7 +383,8 @@ export async function postUnitPreVerification(pctx, opts) {
                 // db_unavailable so the artifact was never written. Retrying would
                 // produce an infinite re-dispatch loop (#2517).
                 debugLog("postUnit", { phase: "artifact-verify-skip-db-unavailable", unitType: s.currentUnit.type, unitId: s.currentUnit.id });
-                ctx.ui.notify(`Artifact missing for ${s.currentUnit.type} ${s.currentUnit.id} but DB is unavailable — skipping retry to avoid loop (#2517)`, "error");
+                const dbSkipDiag = diagnoseExpectedArtifact(s.currentUnit.type, s.currentUnit.id, s.basePath);
+                ctx.ui.notify(`Artifact missing for ${s.currentUnit.type} ${s.currentUnit.id} — DB unavailable, skipping retry.${dbSkipDiag ? ` Expected: ${dbSkipDiag}` : ""}`, "error");
             }
             else if (!triggerArtifactVerified) {
                 const hasExpectedArtifact = resolveExpectedArtifactPath(s.currentUnit.type, s.currentUnit.id, s.basePath) !== null;
@@ -391,13 +392,14 @@ export async function postUnitPreVerification(pctx, opts) {
                     const retryKey = `${s.currentUnit.type}:${s.currentUnit.id}`;
                     const attempt = (s.verificationRetryCount.get(retryKey) ?? 0) + 1;
                     s.verificationRetryCount.set(retryKey, attempt);
+                    const retryDiag = diagnoseExpectedArtifact(s.currentUnit.type, s.currentUnit.id, s.basePath);
                     s.pendingVerificationRetry = {
                         unitId: s.currentUnit.id,
-                        failureContext: `Artifact verification failed: expected artifact for ${s.currentUnit.type} "${s.currentUnit.id}" was not found on disk after unit execution (attempt ${attempt}).`,
+                        failureContext: `Artifact verification failed: expected artifact for ${s.currentUnit.type} "${s.currentUnit.id}" was not found on disk after unit execution (attempt ${attempt}).${retryDiag ? ` Expected: ${retryDiag}` : ""}`,
                         attempt,
                     };
                     debugLog("postUnit", { phase: "artifact-verify-retry", unitType: s.currentUnit.type, unitId: s.currentUnit.id, attempt });
-                    ctx.ui.notify(`Artifact missing for ${s.currentUnit.type} ${s.currentUnit.id} — retrying (attempt ${attempt})`, "warning");
+                    ctx.ui.notify(`Artifact missing for ${s.currentUnit.type} ${s.currentUnit.id} — retrying (attempt ${attempt}).${retryDiag ? ` Expected: ${retryDiag}` : ""}`, "warning");
                     return "retry";
                 }
             }

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

@@ -39,6 +39,7 @@ import { existsSync, mkdirSync, readdirSync, statSync, unlinkSync, } from "node:
 import { join } from "node:path";
 import { sep as pathSep } from "node:path";
 import { resolveProjectRootDbPath } from "./bootstrap/dynamic-tools.js";
+import { resolveDefaultSessionModel } from "./preferences-models.js";
 /**
  * Bootstrap a fresh auto-mode session. Handles everything from git init
  * through secrets collection, returning when ready for the first
@@ -89,12 +90,16 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
     }
     // Capture the user's session model before guided-flow dispatch can apply a
     // phase-specific planning model for a discuss turn (#2829).
-    const startModelSnapshot = ctx.model
-        ? {
-            provider: ctx.model.provider,
-            id: ctx.model.id,
-        }
-        : null;
+    //
+    // GSD PREFERENCES.md takes priority over the session model from settings.json
+    // (#3517).  The session model (ctx.model) comes from findInitialModel() which
+    // reads defaultProvider/defaultModel from ~/.gsd/agent/settings.json.  When
+    // the user has explicit model preferences in PREFERENCES.md, those should win.
+    const preferredModel = resolveDefaultSessionModel(ctx.model?.provider);
+    const startModelSnapshot = preferredModel
+        ?? (ctx.model
+            ? { provider: ctx.model.provider, id: ctx.model.id }
+            : null);
     try {
         // Validate GSD_PROJECT_ID early so the user gets immediate feedback
         const customProjectId = process.env.GSD_PROJECT_ID;

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

@@ -92,6 +92,10 @@ export function startUnitSupervision(sctx) {
             phase: "wrapup-warning-sent",
             wrapupWarningSent: true,
         });
+        // Only trigger a new turn if no tools are currently in flight.
+        // Triggering during active tool calls causes tool results to be skipped
+        // with "Skipped due to queued user message", leading to provider errors (#3512).
+        const softTrigger = getInFlightToolCount() === 0;
         pi.sendMessage({
             customType: "gsd-auto-wrapup",
             display: s.verbose,
@@ -104,7 +108,7 @@ export function startUnitSupervision(sctx) {
                 "3. mark task or slice state on disk correctly",
                 "4. leave precise resume notes if anything remains unfinished",
             ].join("\n"),
-        }, { triggerTurn: true });
+        }, { triggerTurn: softTrigger });
     }, softTimeoutMs);
     // ── 2. Idle watchdog ──
     s.idleWatchdogHandle = setInterval(async () => {
@@ -245,6 +249,8 @@ export function startUnitSupervision(sctx) {
         if (s.verbose) {
             ctx.ui.notify(`Context at ${contextUsage.percent}% (threshold: ${continueHereThreshold}%) — sending wrap-up signal.`, "info");
         }
+        // Only trigger a new turn if no tools are currently in flight (#3512).
+        const contextTrigger = getInFlightToolCount() === 0;
         pi.sendMessage({
             customType: "gsd-auto-wrapup",
             display: s.verbose,
@@ -258,7 +264,7 @@ export function startUnitSupervision(sctx) {
                 "4. Leave precise resume notes if anything remains unfinished",
                 "Do NOT start new sub-tasks or investigations.",
             ].join("\n"),
-        }, { triggerTurn: true });
+        }, { triggerTurn: contextTrigger });
         if (s.continueHereHandle) {
             clearInterval(s.continueHereHandle);
             s.continueHereHandle = null;

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

@@ -142,16 +142,27 @@ export async function runPostUnitVerification(vctx, pauseAuto) {
                 failureContext: formatFailureContext(result),
                 attempt: nextAttempt,
             };
-            ctx.ui.notify(`Verification failed — auto-fix attempt ${nextAttempt}/${maxRetries}`, "warning");
+            const failedCmds = result.checks
+                .filter((c) => c.exitCode !== 0)
+                .map((c) => c.command);
+            const cmdSummary = failedCmds.length <= 3
+                ? failedCmds.join(", ")
+                : `${failedCmds.slice(0, 3).join(", ")}... and ${failedCmds.length - 3} more`;
+            ctx.ui.notify(`Verification failed (${cmdSummary}) — auto-fix attempt ${nextAttempt}/${maxRetries}`, "warning");
             // Return "retry" — the autoLoop while loop will re-iterate with the retry context
             return "retry";
         }
         else {
             // Gate failed, retries exhausted
-            const exhaustedAttempt = attempt + 1;
             s.verificationRetryCount.delete(s.currentUnit.id);
             s.pendingVerificationRetry = null;
-            ctx.ui.notify(`Verification gate FAILED after ${exhaustedAttempt > maxRetries ? exhaustedAttempt - 1 : exhaustedAttempt} retries — pausing for human review`, "error");
+            const exhaustedFails = result.checks
+                .filter((c) => c.exitCode !== 0)
+                .map((c) => c.command);
+            const exhaustedSummary = exhaustedFails.length <= 3
+                ? exhaustedFails.join(", ")
+                : `${exhaustedFails.slice(0, 3).join(", ")}... and ${exhaustedFails.length - 3} more`;
+            ctx.ui.notify(`Verification gate FAILED after ${attempt} ${attempt === 1 ? "retry" : "retries"} (${exhaustedSummary}) — pausing for human review`, "error");
             await pauseAuto(ctx, pi);
             return "pause";
         }

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

@@ -234,10 +234,29 @@ export function syncProjectRootToWorktree(projectRoot, worktreePath_, milestoneI
     // openDatabase re-creates it, causing "no such table" failures (#2815).
     try {
         const wtDb = join(wtGsd, "gsd.db");
+        let deleteSidecars = false;
         if (existsSync(wtDb)) {
             const size = statSync(wtDb).size;
             if (size === 0) {
                 unlinkSync(wtDb);
+                deleteSidecars = true;
+            }
+        }
+        else {
+            // Main DB already missing — sidecars are orphaned from a previous
+            // partial cleanup and must still be removed.
+            deleteSidecars = true;
+        }
+        // Always clean up WAL/SHM sidecar files when the main DB was deleted
+        // or is already missing. Orphaned WAL/SHM files cause SQLite WAL
+        // recovery on next open, which triggers a CPU spin on Node 24's
+        // node:sqlite DatabaseSync implementation (#2478).
+        if (deleteSidecars) {
+            for (const suffix of ["-wal", "-shm"]) {
+                const f = wtDb + suffix;
+                if (existsSync(f)) {
+                    unlinkSync(f);
+                }
             }
         }
     }

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

@@ -377,6 +377,18 @@ export async function stopAuto(ctx, pi, reason) {
         catch (e) {
             debugLog("stop-cleanup-locks", { error: e instanceof Error ? e.message : String(e) });
         }
+        // ── Step 1b: Flush queued follow-up messages (#3512) ──
+        // Late async notifications (async_job_result, gsd-auto-wrapup) can trigger
+        // extra LLM turns after stop. Flush them the same way run-unit.ts does.
+        try {
+            const cmdCtxAny = s.cmdCtx;
+            if (typeof cmdCtxAny?.clearQueue === "function") {
+                cmdCtxAny.clearQueue();
+            }
+        }
+        catch (e) {
+            debugLog("stop-cleanup-queue", { error: e instanceof Error ? e.message : String(e) });
+        }
         // ── Step 2: Skill state ──
         try {
             clearSkillSnapshot();
@@ -589,6 +601,18 @@ export async function pauseAuto(ctx, _pi, _errorContext) {
     if (!s.active)
         return;
     clearUnitTimeout();
+    // Flush queued follow-up messages (#3512).
+    // Late async notifications (async_job_result, gsd-auto-wrapup) can trigger
+    // extra LLM turns after pause. Flush them the same way run-unit.ts does.
+    try {
+        const cmdCtxAny = s.cmdCtx;
+        if (typeof cmdCtxAny?.clearQueue === "function") {
+            cmdCtxAny.clearQueue();
+        }
+    }
+    catch (e) {
+        debugLog("pause-cleanup-queue", { error: e instanceof Error ? e.message : String(e) });
+    }
     // Unblock any pending unit promise so the auto-loop is not orphaned.
     // Pass errorContext so runUnitPhase can distinguish user-initiated pause
     // from provider-error pause and avoid hard-stopping (#2762).

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

@@ -14,6 +14,7 @@ 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 { resetAskUserQuestionsCache } from "../../ask-user-questions.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;
@@ -25,6 +26,7 @@ export function registerHooks(pi) {
     pi.on("session_start", async (_event, ctx) => {
         resetWriteGateState();
         resetToolCallLoopGuard();
+        resetAskUserQuestionsCache();
         await syncServiceTierStatus(ctx);
         // Apply show_token_cost preference (#1515)
         try {
@@ -60,6 +62,7 @@ export function registerHooks(pi) {
     pi.on("session_switch", async (_event, ctx) => {
         resetWriteGateState();
         resetToolCallLoopGuard();
+        resetAskUserQuestionsCache();
         clearDiscussionFlowState();
         await syncServiceTierStatus(ctx);
         loadToolApiKeys();
@@ -69,6 +72,7 @@ export function registerHooks(pi) {
     });
     pi.on("agent_end", async (event, ctx) => {
         resetToolCallLoopGuard();
+        resetAskUserQuestionsCache();
         await handleAgentEnd(pi, event, ctx);
     });
     // Squash-merge quick-task branch back to the original branch after the

package/dist/resources/extensions/gsd/bootstrap/tool-call-loop-guard.js

@@ -13,8 +13,12 @@
  */
 import { createHash } from "node:crypto";
 const MAX_CONSECUTIVE_IDENTICAL_CALLS = 4;
+/** Interactive/user-facing tools where even 1 duplicate is confusing. */
+const STRICT_LOOP_TOOLS = new Set(["ask_user_questions"]);
+const MAX_CONSECUTIVE_STRICT = 1;
 let consecutiveCount = 0;
 let lastSignature = "";
+let lastToolName = "";
 let enabled = true;
 /** Hash tool name + args into a compact signature for comparison. */
 function hashToolCall(toolName, args) {
@@ -45,8 +49,12 @@ export function checkToolCallLoop(toolName, args) {
     else {
         consecutiveCount = 1;
         lastSignature = sig;
+        lastToolName = toolName;
     }
-    if (consecutiveCount > MAX_CONSECUTIVE_IDENTICAL_CALLS) {
+    const threshold = STRICT_LOOP_TOOLS.has(toolName)
+        ? MAX_CONSECUTIVE_STRICT
+        : MAX_CONSECUTIVE_IDENTICAL_CALLS;
+    if (consecutiveCount > threshold) {
         return {
             block: true,
             reason: `Tool loop detected: ${toolName} called ${consecutiveCount} times ` +
@@ -61,6 +69,7 @@ export function checkToolCallLoop(toolName, args) {
 export function resetToolCallLoopGuard() {
     consecutiveCount = 0;
     lastSignature = "";
+    lastToolName = "";
     enabled = true;
 }
 /** Disable the guard (e.g. during shutdown). */
@@ -68,6 +77,7 @@ export function disableToolCallLoopGuard() {
     enabled = false;
     consecutiveCount = 0;
     lastSignature = "";
+    lastToolName = "";
 }
 /** Get current consecutive count for diagnostics. */
 export function getToolCallLoopCount() {

package/dist/resources/extensions/gsd/commands-handlers.js

@@ -11,7 +11,8 @@ import { gsdRoot } from "./paths.js";
 import { appendCapture, hasPendingCaptures, loadPendingCaptures } from "./captures.js";
 import { appendOverride, appendKnowledge } from "./files.js";
 import { formatDoctorIssuesForPrompt, formatDoctorReport, formatDoctorReportJson, runGSDDoctor, selectDoctorScope, filterDoctorIssues, } from "./doctor.js";
-import { isAutoActive } from "./auto.js";
+import { isAutoActive, checkRemoteAutoSession } from "./auto.js";
+import { getAutoWorktreePath } from "./auto-worktree.js";
 import { projectRoot } from "./commands/context.js";
 import { loadPrompt } from "./prompt-loader.js";
 export function dispatchDoctorHeal(pi, scope, reportText, structuredIssues) {
@@ -172,7 +173,17 @@ export async function handleSteer(change, ctx, pi) {
     const sid = state.activeSlice?.id ?? "none";
     const tid = state.activeTask?.id ?? "none";
     const appliedAt = `${mid}/${sid}/${tid}`;
-    await appendOverride(basePath, change, appliedAt);
+    // Resolve the correct target path: only route to a worktree when auto-mode
+    // is actively running there (in-process or remote). A worktree directory may
+    // exist from a previous session without being the active runtime path —
+    // writing there without a live session would silently drop the override.
+    const autoRunning = isAutoActive() || checkRemoteAutoSession(basePath).running;
+    const wtPath = autoRunning && mid !== "none"
+        ? getAutoWorktreePath(basePath, mid)
+        : null;
+    const targetPath = wtPath ?? basePath;
+    await appendOverride(targetPath, change, appliedAt);
+    const overrideLoc = wtPath ? "worktree `.gsd/OVERRIDES.md`" : "`.gsd/OVERRIDES.md`";
     if (isAutoActive()) {
         pi.sendMessage({
             customType: "gsd-hard-steer",
@@ -181,14 +192,14 @@ export async function handleSteer(change, ctx, pi) {
                 "",
                 `**Override:** ${change}`,
                 "",
-                "This override has been saved to `.gsd/OVERRIDES.md` and will be injected into all future task prompts.",
+                `This override has been saved to ${overrideLoc} and will be injected into all future task prompts.`,
                 "A document rewrite unit will run before the next task to propagate this change across all active plan documents.",
                 "",
                 "If you are mid-task, finish your current work respecting this override. The next dispatched unit will be a document rewrite.",
             ].join("\n"),
             display: false,
         }, { triggerTurn: true });
-        ctx.ui.notify(`Override registered: "${change}". Will be applied before next task dispatch.`, "info");
+        ctx.ui.notify(`Override registered (${overrideLoc}): "${change}". Will be applied before next task dispatch.`, "info");
     }
     else {
         pi.sendMessage({
@@ -198,13 +209,13 @@ export async function handleSteer(change, ctx, pi) {
                 "",
                 `**Override:** ${change}`,
                 "",
-                "This override has been saved to `.gsd/OVERRIDES.md`.",
-                "Before continuing, read `.gsd/OVERRIDES.md` and update the current plan documents to reflect this change.",
+                `This override has been saved to ${overrideLoc}.`,
+                `Before continuing, read ${overrideLoc} and update the current plan documents to reflect this change.`,
                 "Focus on: active slice plan, incomplete task plans, and DECISIONS.md.",
             ].join("\n"),
             display: false,
         }, { triggerTurn: true });
-        ctx.ui.notify(`Override registered: "${change}". Update plan documents to reflect this change.`, "info");
+        ctx.ui.notify(`Override registered (${overrideLoc}): "${change}". Update plan documents to reflect this change.`, "info");
     }
 }
 export async function handleKnowledge(args, ctx) {

package/dist/resources/extensions/gsd/db-writer.js

@@ -11,7 +11,7 @@ import { resolve } from 'node:path';
 import { readFileSync, existsSync, statSync } from 'node:fs';
 import { resolveGsdRootFile } from './paths.js';
 import { saveFile } from './files.js';
-import { GSDError, GSD_IO_ERROR } from './errors.js';
+import { GSDError, GSD_STALE_STATE, GSD_IO_ERROR } from './errors.js';
 import { logWarning, logError } from './workflow-logger.js';
 import { invalidateStateCache } from './state.js';
 import { clearPathCache } from './paths.js';
@@ -234,27 +234,44 @@ export async function nextRequirementId() {
 /**
  * Save a new requirement to DB and regenerate REQUIREMENTS.md.
  * Auto-assigns the next ID via nextRequirementId().
+ *
+ * The ID computation and insert are wrapped in a single transaction
+ * to prevent parallel race conditions (same pattern as saveDecisionToDb).
+ *
  * Returns the assigned ID.
  */
 export async function saveRequirementToDb(fields, basePath) {
     try {
         const db = await import('./gsd-db.js');
-        const id = await nextRequirementId();
-        const requirement = {
-            id,
-            class: fields.class,
-            status: fields.status ?? 'active',
-            description: fields.description,
-            why: fields.why,
-            source: fields.source,
-            primary_owner: fields.primary_owner ?? '',
-            supporting_slices: fields.supporting_slices ?? '',
-            validation: fields.validation ?? '',
-            notes: fields.notes ?? '',
-            full_content: '',
-            superseded_by: null,
-        };
-        db.upsertRequirement(requirement);
+        // Atomic ID assignment + insert inside a transaction.
+        const id = db.transaction(() => {
+            const adapter = db._getAdapter();
+            if (!adapter)
+                throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+            const row = adapter
+                .prepare('SELECT MAX(CAST(SUBSTR(id, 2) AS INTEGER)) as max_num FROM requirements')
+                .get();
+            const maxNum = row ? row['max_num'] : null;
+            const nextId = (maxNum == null || isNaN(maxNum))
+                ? 'R001'
+                : `R${String(maxNum + 1).padStart(3, '0')}`;
+            const requirement = {
+                id: nextId,
+                class: fields.class,
+                status: fields.status ?? 'active',
+                description: fields.description,
+                why: fields.why,
+                source: fields.source,
+                primary_owner: fields.primary_owner ?? '',
+                supporting_slices: fields.supporting_slices ?? '',
+                validation: fields.validation ?? '',
+                notes: fields.notes ?? '',
+                full_content: '',
+                superseded_by: null,
+            };
+            db.upsertRequirement(requirement);
+            return nextId;
+        });
         // Fetch all requirements for full file regeneration
         const adapter = db._getAdapter();
         let allRequirements = [];
@@ -300,22 +317,41 @@ export async function saveRequirementToDb(fields, basePath) {
 /**
  * Save a new decision to DB and regenerate DECISIONS.md.
  * Auto-assigns the next ID via nextDecisionId().
+ *
+ * The ID computation (SELECT MAX) and insert are wrapped in a single
+ * transaction to prevent parallel tool calls from computing the same ID
+ * and silently overwriting each other (#3326, #3339, #3459).
+ *
  * Returns the assigned ID.
  */
 export async function saveDecisionToDb(fields, basePath) {
     try {
         const db = await import('./gsd-db.js');
-        const id = await nextDecisionId();
-        db.upsertDecision({
-            id,
-            when_context: fields.when_context ?? '',
-            scope: fields.scope,
-            decision: fields.decision,
-            choice: fields.choice,
-            rationale: fields.rationale,
-            revisable: fields.revisable ?? 'Yes',
-            made_by: fields.made_by ?? 'agent',
-            superseded_by: null,
+        // Atomic ID assignment + insert inside a transaction to prevent
+        // parallel calls from racing on the same MAX(id) value.
+        const id = db.transaction(() => {
+            const adapter = db._getAdapter();
+            if (!adapter)
+                throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+            const row = adapter
+                .prepare('SELECT MAX(CAST(SUBSTR(id, 2) AS INTEGER)) as max_num FROM decisions')
+                .get();
+            const maxNum = row ? row['max_num'] : null;
+            const nextId = (maxNum == null || isNaN(maxNum))
+                ? 'D001'
+                : `D${String(maxNum + 1).padStart(3, '0')}`;
+            db.upsertDecision({
+                id: nextId,
+                when_context: fields.when_context ?? '',
+                scope: fields.scope,
+                decision: fields.decision,
+                choice: fields.choice,
+                rationale: fields.rationale,
+                revisable: fields.revisable ?? 'Yes',
+                made_by: fields.made_by ?? 'agent',
+                superseded_by: null,
+            });
+            return nextId;
         });
         // Fetch all decisions (including superseded for the full register)
         const adapter = db._getAdapter();