gsd-pi 2.64.0-dev.f8aad9b → 2.65.0-dev.16e10d7

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

@@ -754,6 +754,7 @@ export async function buildDiscussMilestonePrompt(mid, midTitle, base) {
         inlinedTemplates: discussTemplates,
         structuredQuestionsAvailable: "true",
         commitInstruction: "Do not commit planning artifacts — .gsd/ is managed externally.",
+        fastPathInstruction: "",
     });
     // If a CONTEXT-DRAFT.md exists, append it as seed material
     const draftPath = resolveMilestoneFile(base, mid, "CONTEXT-DRAFT");
@@ -1607,6 +1608,29 @@ const GATE_QUESTIONS = {
         ].join("\n"),
     },
 };
+export async function buildParallelResearchSlicesPrompt(mid, midTitle, slices, basePath) {
+    // Build individual research-slice prompts for each slice
+    const subagentSections = [];
+    for (const slice of slices) {
+        const slicePrompt = await buildResearchSlicePrompt(mid, midTitle, slice.id, slice.title, basePath);
+        subagentSections.push([
+            `### ${slice.id}: ${slice.title}`,
+            "",
+            "Use this as the prompt for a `subagent` call (agent: `gsd-executor` or the default agent):",
+            "",
+            "```",
+            slicePrompt,
+            "```",
+        ].join("\n"));
+    }
+    return loadPrompt("parallel-research-slices", {
+        mid,
+        midTitle,
+        sliceCount: String(slices.length),
+        sliceList: slices.map((s) => `- **${s.id}**: ${s.title}`).join("\n"),
+        subagentPrompts: subagentSections.join("\n\n---\n\n"),
+    });
+}
 export async function buildGateEvaluatePrompt(mid, midTitle, sid, sTitle, base) {
     const pending = getPendingGates(mid, sid, "slice");
     // Load the slice plan for context

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

@@ -238,7 +238,7 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
         if (!hasCheckboxTask && !hasHeadingTask)
             return false;
     }
-    // execute-task: DB status is authoritative. Fall back to heading-style plan
+    // execute-task: DB status is authoritative. Fall back to checked-checkbox
     // detection when the DB is unavailable (unmigrated projects).
     if (unitType === "execute-task") {
         const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
@@ -251,21 +251,25 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
             }
             else if (!isDbAvailable()) {
                 // LEGACY: Pre-migration fallback for projects without DB.
-                // Fall back to plan heading check (format detection, not reconciliation).
-                // Heading-style entries (### T01 --) count as verified because the
-                // summary file existence (checked above) is the real signal.
+                // Require a CHECKED checkbox — a bare heading or unchecked checkbox
+                // does not prove gsd_complete_task ran. Summary file on disk alone
+                // is not sufficient evidence (could be a rogue write) (#3607).
                 const planAbs = resolveSliceFile(base, mid, sid, "PLAN");
                 if (planAbs && existsSync(planAbs)) {
                     const planContent = readFileSync(planAbs, "utf-8");
                     const escapedTid = tid.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-                    const hdRe = new RegExp(`^#{2,4}\\s+${escapedTid}\\s*(?:--|—|:)`, "m");
                     const cbRe = new RegExp(`^- \\[[xX]\\] \\*\\*${escapedTid}:`, "m");
-                    if (!hdRe.test(planContent) && !cbRe.test(planContent))
+                    if (!cbRe.test(planContent))
                         return false;
                 }
+                else {
+                    return false; // no plan file → cannot verify
+                }
+            }
+            else {
+                // DB available but task row not found — completion tool never ran (#3607)
+                return false;
             }
-            // else: DB available but task not found — summary file exists (checked above),
-            // so treat as verified (task may not be imported yet)
         }
     }
     // plan-slice must also produce individual task plan files for every task listed

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

@@ -20,7 +20,7 @@ import { synthesizeCrashRecovery } from "./session-forensics.js";
 import { writeLock, clearLock, readCrashLock, formatCrashInfo, isLockProcessAlive, } from "./crash-recovery.js";
 import { acquireSessionLock, releaseSessionLock, updateSessionLock, } from "./session-lock.js";
 import { ensureGitignore, untrackRuntimeFiles } from "./gitignore.js";
-import { nativeInit, nativeAddAll, nativeCommit, } from "./native-git-bridge.js";
+import { nativeIsRepo, nativeInit, nativeAddAll, nativeCommit, nativeGetCurrentBranch, nativeDetectMainBranch, nativeCheckoutBranch, } from "./native-git-bridge.js";
 import { GitServiceImpl } from "./git-service.js";
 import { captureIntegrationBranch, detectWorktreeName, setActiveMilestoneId, } from "./worktree.js";
 import { getAutoWorktreePath } from "./auto-worktree.js";
@@ -373,6 +373,22 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
             }
             setActiveMilestoneId(base, s.currentMilestoneId);
         }
+        // Guard against stale milestone branch when isolation:none (#3613).
+        // A prior session with isolation:branch/worktree may have left HEAD on
+        // milestone/<MID>. Auto-checkout back to the integration branch.
+        if (getIsolationMode() === "none" && nativeIsRepo(base)) {
+            try {
+                const currentBranch = nativeGetCurrentBranch(base);
+                if (currentBranch.startsWith("milestone/")) {
+                    const integrationBranch = nativeDetectMainBranch(base);
+                    nativeCheckoutBranch(base, integrationBranch);
+                    logWarning("bootstrap", `Returned to "${integrationBranch}" — HEAD was on stale milestone branch "${currentBranch}" (isolation: none does not use milestone branches).`);
+                }
+            }
+            catch (err) {
+                logWarning("bootstrap", `Could not auto-checkout from stale milestone branch: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
         // ── Auto-worktree setup ──
         s.originalBasePath = base;
         const isUnderGsdWorktrees = (p) => {
@@ -448,6 +464,24 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
                 id: startModelSnapshot.id,
             };
         }
+        // Apply worker model override from parallel orchestrator (#worker-model).
+        // GSD_WORKER_MODEL is injected by the coordinator when parallel.worker_model
+        // is configured, so parallel milestone workers use a cheaper model than the
+        // coordinator session (e.g. Haiku for execution, Sonnet for planning).
+        const workerModelOverride = process.env.GSD_WORKER_MODEL;
+        if (workerModelOverride && process.env.GSD_PARALLEL_WORKER === "1") {
+            const availableModels = ctx.modelRegistry.getAvailable();
+            const { resolveModelId } = await import("./auto-model-selection.js");
+            const overrideModel = resolveModelId(workerModelOverride, availableModels, ctx.model?.provider);
+            if (overrideModel) {
+                const ok = await pi.setModel(overrideModel, { persist: false });
+                if (ok) {
+                    // Update start model so all subsequent units use this as the baseline
+                    s.autoModeStartModel = { provider: overrideModel.provider, id: overrideModel.id };
+                    ctx.ui.notify(`Worker model override: ${overrideModel.provider}/${overrideModel.id}`, "info");
+                }
+            }
+        }
         // Snapshot installed skills
         if (resolveSkillDiscoveryMode() !== "off") {
             snapshotSkills();

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

@@ -92,3 +92,13 @@ export function isToolInvocationError(errorMsg) {
         return false;
     return TOOL_INVOCATION_ERROR_RE.test(errorMsg);
 }
+/**
+ * Returns true if the error message indicates the tool was skipped because
+ * a queued user message interrupted the turn (#3595).  Retrying will produce
+ * the same skip, so the unit should be paused rather than retried.
+ */
+export function isQueuedUserMessageSkip(errorMsg) {
+    if (!errorMsg)
+        return false;
+    return /^Skipped due to queued user message\.?$/i.test(errorMsg.trim());
+}

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

@@ -9,13 +9,15 @@
  * value instead of calling return/pauseAuto directly — the caller
  * checks the result and handles control flow.
  */
+import { mkdirSync, writeFileSync } from "node:fs";
 import { resolveSlicePath } from "./paths.js";
 import { parseUnitId } from "./unit-id.js";
-import { isDbAvailable, getTask } from "./gsd-db.js";
+import { isDbAvailable, getTask, getSliceTasks } from "./gsd-db.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { runVerificationGate, formatFailureContext, captureRuntimeErrors, runDependencyAudit, } from "./verification-gate.js";
 import { writeVerificationJSON } from "./verification-evidence.js";
 import { logWarning } from "./workflow-logger.js";
+import { runPostExecutionChecks } from "./post-execution-checks.js";
 import { join } from "node:path";
 function isInfraVerificationFailure(stderr) {
     return /\b(ENOENT|ENOTFOUND|ETIMEDOUT|ECONNRESET|EAI_AGAIN|spawn\s+\S+\s+ENOENT|command not found)\b/i.test(stderr);
@@ -128,12 +130,104 @@ export async function runPostUnitVerification(vctx, pauseAuto) {
                 : "Verification failed due to infrastructure/runtime environment issues — treating as advisory.", "warning");
             return "continue";
         }
+        // ── Post-execution checks (run after main verification passes for execute-task units) ──
+        let postExecChecks;
+        let postExecBlockingFailure = false;
+        if (result.passed && mid && sid && tid) {
+            // Check preferences — respect enhanced_verification and enhanced_verification_post
+            const enhancedEnabled = prefs?.enhanced_verification !== false; // default true
+            const postEnabled = prefs?.enhanced_verification_post !== false; // default true
+            if (enhancedEnabled && postEnabled && isDbAvailable()) {
+                try {
+                    // Get the completed task from DB
+                    const taskRow = getTask(mid, sid, tid);
+                    if (taskRow && taskRow.key_files && taskRow.key_files.length > 0) {
+                        // Get all tasks in the slice
+                        const allTasks = getSliceTasks(mid, sid);
+                        // Filter to prior completed tasks (status = 'complete' or 'done', before current task)
+                        const priorTasks = allTasks.filter((t) => (t.status === "complete" || t.status === "done") &&
+                            t.id !== tid &&
+                            t.sequence < taskRow.sequence);
+                        // Run post-execution checks
+                        const postExecResult = runPostExecutionChecks(taskRow, priorTasks, s.basePath);
+                        // Store checks for evidence JSON
+                        postExecChecks = postExecResult.checks;
+                        // Log summary to stderr with gsd-post-exec: prefix
+                        const emoji = postExecResult.status === "pass"
+                            ? "✅"
+                            : postExecResult.status === "warn"
+                                ? "⚠️"
+                                : "❌";
+                        process.stderr.write(`gsd-post-exec: ${emoji} Post-execution checks ${postExecResult.status} for ${mid}/${sid}/${tid} (${postExecResult.durationMs}ms)\n`);
+                        // Log individual check results
+                        for (const check of postExecResult.checks) {
+                            const checkEmoji = check.passed
+                                ? "✓"
+                                : check.blocking
+                                    ? "✗"
+                                    : "⚠";
+                            process.stderr.write(`gsd-post-exec:   ${checkEmoji} [${check.category}] ${check.target}: ${check.message}\n`);
+                        }
+                        // Check for blocking failures
+                        if (postExecResult.status === "fail") {
+                            postExecBlockingFailure = true;
+                            const blockingCount = postExecResult.checks.filter((c) => !c.passed && c.blocking).length;
+                            ctx.ui.notify(`Post-execution checks failed: ${blockingCount} blocking issue${blockingCount === 1 ? "" : "s"} found`, "error");
+                        }
+                        else if (postExecResult.status === "warn") {
+                            ctx.ui.notify(`Post-execution checks passed with warnings`, "warning");
+                            // Strict mode: treat warnings as blocking
+                            if (prefs?.enhanced_verification_strict === true) {
+                                postExecBlockingFailure = true;
+                            }
+                        }
+                    }
+                }
+                catch (postExecErr) {
+                    // Post-execution check errors are non-fatal — log and continue
+                    logWarning("engine", `gsd-post-exec: error — ${postExecErr.message}`);
+                }
+            }
+        }
+        // Re-write verification evidence JSON with post-execution checks
+        if (postExecChecks && postExecChecks.length > 0 && mid && sid && tid) {
+            try {
+                const sDir = resolveSlicePath(s.basePath, mid, sid);
+                if (sDir) {
+                    const tasksDir = join(sDir, "tasks");
+                    // Add postExecutionChecks to the result for the JSON write
+                    const resultWithPostExec = {
+                        ...result,
+                        // Mark as failed if there was a blocking post-exec failure
+                        passed: result.passed && !postExecBlockingFailure,
+                    };
+                    // Manually write with postExecutionChecks field
+                    writeVerificationJSONWithPostExec(resultWithPostExec, tasksDir, tid, s.currentUnit.id, postExecChecks, postExecBlockingFailure ? attempt + 1 : undefined, postExecBlockingFailure ? maxRetries : undefined);
+                }
+            }
+            catch (evidenceErr) {
+                logWarning("engine", `verification-evidence: post-exec write error — ${evidenceErr.message}`);
+            }
+        }
+        // Update result.passed based on post-execution checks
+        if (postExecBlockingFailure) {
+            result.passed = false;
+        }
         // ── Auto-fix retry logic ──
         if (result.passed) {
             s.verificationRetryCount.delete(s.currentUnit.id);
             s.pendingVerificationRetry = null;
             return "continue";
         }
+        else if (postExecBlockingFailure) {
+            // Post-execution failures are cross-task consistency issues — retrying the same task won't fix them.
+            // Skip retry and pause immediately for human review.
+            s.verificationRetryCount.delete(s.currentUnit.id);
+            s.pendingVerificationRetry = null;
+            ctx.ui.notify(`Post-execution checks failed — cross-task consistency issue detected, pausing for human review`, "error");
+            await pauseAuto(ctx, pi);
+            return "pause";
+        }
         else if (autoFixEnabled && attempt + 1 <= maxRetries) {
             const nextAttempt = attempt + 1;
             s.verificationRetryCount.set(s.currentUnit.id, nextAttempt);
@@ -173,3 +267,46 @@ export async function runPostUnitVerification(vctx, pauseAuto) {
         return "continue";
     }
 }
+/**
+ * Write verification evidence JSON with post-execution checks included.
+ * This is a variant of writeVerificationJSON that adds the postExecutionChecks field.
+ */
+function writeVerificationJSONWithPostExec(result, tasksDir, taskId, unitId, postExecutionChecks, retryAttempt, maxRetries) {
+    mkdirSync(tasksDir, { recursive: true });
+    const evidence = {
+        schemaVersion: 1,
+        taskId,
+        unitId: unitId ?? taskId,
+        timestamp: result.timestamp,
+        passed: result.passed,
+        discoverySource: result.discoverySource,
+        checks: result.checks.map((check) => ({
+            command: check.command,
+            exitCode: check.exitCode,
+            durationMs: check.durationMs,
+            verdict: check.exitCode === 0 ? "pass" : "fail",
+        })),
+        ...(retryAttempt !== undefined ? { retryAttempt } : {}),
+        ...(maxRetries !== undefined ? { maxRetries } : {}),
+        postExecutionChecks,
+    };
+    if (result.runtimeErrors && result.runtimeErrors.length > 0) {
+        evidence.runtimeErrors = result.runtimeErrors.map(e => ({
+            source: e.source,
+            severity: e.severity,
+            message: e.message,
+            blocking: e.blocking,
+        }));
+    }
+    if (result.auditWarnings && result.auditWarnings.length > 0) {
+        evidence.auditWarnings = result.auditWarnings.map(w => ({
+            name: w.name,
+            severity: w.severity,
+            title: w.title,
+            url: w.url,
+            fixAvailable: w.fixAvailable,
+        }));
+    }
+    const filePath = join(tasksDir, `${taskId}-VERIFY.json`);
+    writeFileSync(filePath, JSON.stringify(evidence, null, 2) + "\n", "utf-8");
+}

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

@@ -135,8 +135,10 @@ function clearProjectRootStateFiles(basePath, milestoneId) {
             unlinkSync(file);
         }
         catch (err) {
-            /* non-fatal — file may not exist */
-            logWarning("worktree", `file unlink failed: ${err instanceof Error ? err.message : String(err)}`);
+            // ENOENT is expected — file may not exist (#3597)
+            if (err.code !== "ENOENT") {
+                logWarning("worktree", `file unlink failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
         }
     }
     // Clean up entire synced milestone directory and runtime/units.
@@ -160,8 +162,11 @@ function clearProjectRootStateFiles(basePath, milestoneId) {
                             unlinkSync(join(basePath, f));
                         }
                         catch (err) {
-                            /* non-fatal */
-                            logWarning("worktree", `untracked file unlink failed: ${err instanceof Error ? err.message : String(err)}`);
+                            // ENOENT/EISDIR are expected for already-removed or directory entries (#3597)
+                            const code = err.code;
+                            if (code !== "ENOENT" && code !== "EISDIR") {
+                                logWarning("worktree", `untracked file unlink failed: ${err instanceof Error ? err.message : String(err)}`);
+                            }
                         }
                     }
                 }
@@ -656,6 +661,10 @@ export function syncWorktreeStateBack(mainBasePath, worktreePath, milestoneId) {
             .filter((d) => d.isDirectory())
             .map((d) => d.name);
         for (const mid of wtMilestones) {
+            // Skip the current milestone being merged — its files are already in the
+            // milestone branch and would conflict with the squash merge (#3641).
+            if (mid === milestoneId)
+                continue;
             syncMilestoneDir(wtGsd, mainGsd, mid, synced);
         }
     }
@@ -901,11 +910,19 @@ export function createAutoWorktree(basePath, milestoneId) {
         });
     }
     else {
-        // Fresh start — create branch from integration branch
+        // Fresh start — create branch from integration branch.
+        // Use the same 3-tier fallback as mergeMilestoneToMain (#3461):
+        //   1. META.json integration branch (explicit per-milestone override)
+        //   2. git.main_branch preference (user's configured working branch)
+        //   3. nativeDetectMainBranch (origin/HEAD auto-detection)
+        // Without tier 2, projects with main_branch=dev but origin/HEAD→master
+        // would fork worktrees from the wrong (stale) branch.
         const integrationBranch = readIntegrationBranch(basePath, milestoneId) ?? undefined;
+        const gitPrefs = loadEffectiveGSDPreferences()?.preferences?.git;
+        const startPoint = integrationBranch ?? gitPrefs?.main_branch ?? undefined;
         info = createWorktree(basePath, milestoneId, {
             branch,
-            startPoint: integrationBranch,
+            startPoint,
         });
     }
     // Copy .gsd/ planning artifacts from the source repo into the new worktree.
@@ -1235,7 +1252,12 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
     //    checkout and leave the user with a broken merge state (#1668).
     const prefs = loadEffectiveGSDPreferences()?.preferences?.git ?? {};
     const integrationBranch = readIntegrationBranch(originalBasePath_, milestoneId);
-    const mainBranch = integrationBranch ?? prefs.main_branch ?? nativeDetectMainBranch(originalBasePath_);
+    // Validate prefs.main_branch exists before using it — a stale preference
+    // (e.g. "master" when repo uses "main") causes merge failure (#3589).
+    const validatedPrefBranch = prefs.main_branch && nativeBranchExists(originalBasePath_, prefs.main_branch)
+        ? prefs.main_branch
+        : undefined;
+    const mainBranch = integrationBranch ?? validatedPrefBranch ?? nativeDetectMainBranch(originalBasePath_);
     // Remove transient project-root state files before any branch or merge
     // operation. Untracked milestone metadata can otherwise block squash merges.
     clearProjectRootStateFiles(originalBasePath_, milestoneId);

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

@@ -23,7 +23,7 @@ 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, } from "./auto-tool-tracking.js";
+import { markToolStart as _markToolStart, markToolEnd as _markToolEnd, getOldestInFlightToolAgeMs as _getOldestInFlightToolAgeMs, clearInFlightTools, isToolInvocationError, isQueuedUserMessageSkip, } from "./auto-tool-tracking.js";
 import { closeoutUnit } from "./auto-unit-closeout.js";
 import { selectAndApplyModel, resolveModelId } from "./auto-model-selection.js";
 import { resetRoutingHistory, recordOutcome } from "./routing-history.js";
@@ -201,7 +201,7 @@ export function markToolEnd(toolCallId) {
 export function recordToolInvocationError(toolName, errorMsg) {
     if (!s.active)
         return;
-    if (isToolInvocationError(errorMsg)) {
+    if (isToolInvocationError(errorMsg) || isQueuedUserMessageSkip(errorMsg)) {
         s.lastToolInvocationError = `${toolName}: ${errorMsg}`;
     }
 }

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

@@ -79,11 +79,24 @@ export async function handleAgentEnd(pi, event, ctx) {
         return;
     }
     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) : "";
+        // #3588: errorMessage can be useless (e.g. "success") while the real error
+        // is in the assistant message text content. Fall back to content when
+        // errorMessage looks uninformative.
+        const rawErrorMsg = ("errorMessage" in lastMsg && lastMsg.errorMessage) ? String(lastMsg.errorMessage) : "";
+        const isUseless = !rawErrorMsg || /^(success|ok|true|error|unknown)$/i.test(rawErrorMsg.trim());
+        // #3588: When errorMessage is uninformative, extract the real error from
+        // the assistant message text content for display purposes only.
+        // Classification still uses rawErrorMsg to avoid false positives from prose.
+        let displayMsg = rawErrorMsg;
+        if (isUseless && "content" in lastMsg && Array.isArray(lastMsg.content)) {
+            const textBlock = lastMsg.content.find((b) => b.type === "text" && b.text);
+            if (textBlock)
+                displayMsg = textBlock.text.slice(0, 300);
+        }
+        const errorDetail = displayMsg ? `: ${displayMsg}` : "";
         const explicitRetryAfterMs = ("retryAfterMs" in lastMsg && typeof lastMsg.retryAfterMs === "number") ? lastMsg.retryAfterMs : undefined;
-        // ── 1. Classify ──────────────────────────────────────────────────────
-        const cls = classifyError(errorMsg, explicitRetryAfterMs);
+        // ── 1. Classify using rawErrorMsg to avoid prose false-positives ────
+        const cls = classifyError(rawErrorMsg, explicitRetryAfterMs);
         // Cap rate-limit backoff for CLI-style providers (openai-codex, google-gemini-cli)
         // which use per-user quotas with shorter windows (#2922).
         if (cls.kind === "rate-limit") {

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

@@ -768,31 +768,42 @@ export function registerDbTools(pi) {
                 return m ? [m[1].trim(), m[2].trim()] : [s.trim(), ""];
             };
             const coerced = { ...params };
-            coerced.filesModified = (params.filesModified ?? []).map((f) => {
+            // Coerce simple string-array fields: LLMs sometimes pass a plain string
+            // instead of a single-element array (#3585).
+            const wrapArray = (v) => v == null ? [] : Array.isArray(v) ? v : [v];
+            coerced.provides = wrapArray(params.provides);
+            coerced.keyFiles = wrapArray(params.keyFiles);
+            coerced.keyDecisions = wrapArray(params.keyDecisions);
+            coerced.patternsEstablished = wrapArray(params.patternsEstablished);
+            coerced.observabilitySurfaces = wrapArray(params.observabilitySurfaces);
+            coerced.requirementsSurfaced = wrapArray(params.requirementsSurfaced);
+            coerced.drillDownPaths = wrapArray(params.drillDownPaths);
+            coerced.affects = wrapArray(params.affects);
+            coerced.filesModified = wrapArray(params.filesModified).map((f) => {
                 if (typeof f !== "string")
                     return f;
                 const [path, description] = splitPair(f);
                 return { path, description };
             });
-            coerced.requires = (params.requires ?? []).map((r) => {
+            coerced.requires = wrapArray(params.requires).map((r) => {
                 if (typeof r !== "string")
                     return r;
                 const [slice, provides] = splitPair(r);
                 return { slice, provides };
             });
-            coerced.requirementsAdvanced = (params.requirementsAdvanced ?? []).map((r) => {
+            coerced.requirementsAdvanced = wrapArray(params.requirementsAdvanced).map((r) => {
                 if (typeof r !== "string")
                     return r;
                 const [id, how] = splitPair(r);
                 return { id, how };
             });
-            coerced.requirementsValidated = (params.requirementsValidated ?? []).map((r) => {
+            coerced.requirementsValidated = wrapArray(params.requirementsValidated).map((r) => {
                 if (typeof r !== "string")
                     return r;
                 const [id, proof] = splitPair(r);
                 return { id, proof };
             });
-            coerced.requirementsInvalidated = (params.requirementsInvalidated ?? []).map((r) => {
+            coerced.requirementsInvalidated = wrapArray(params.requirementsInvalidated).map((r) => {
                 if (typeof r !== "string")
                     return r;
                 const [id, what] = splitPair(r);
@@ -851,14 +862,14 @@ export function registerDbTools(pi) {
             deviations: Type.Optional(Type.String({ description: "Deviations from the slice plan, or 'None.'" })),
             knownLimitations: Type.Optional(Type.String({ description: "Known limitations or gaps, or 'None.'" })),
             followUps: Type.Optional(Type.String({ description: "Follow-up work discovered during execution, or 'None.'" })),
-            keyFiles: Type.Optional(Type.Array(Type.String(), { description: "Key files created or modified" })),
-            keyDecisions: Type.Optional(Type.Array(Type.String(), { description: "Key decisions made during this slice" })),
-            patternsEstablished: Type.Optional(Type.Array(Type.String(), { description: "Patterns established by this slice" })),
-            observabilitySurfaces: Type.Optional(Type.Array(Type.String(), { description: "Observability surfaces added" })),
-            provides: Type.Optional(Type.Array(Type.String(), { description: "What this slice provides to downstream slices" })),
-            requirementsSurfaced: Type.Optional(Type.Array(Type.String(), { description: "New requirements surfaced" })),
-            drillDownPaths: Type.Optional(Type.Array(Type.String(), { description: "Paths to task summaries for drill-down" })),
-            affects: Type.Optional(Type.Array(Type.String(), { description: "Downstream slices affected" })),
+            keyFiles: Type.Optional(Type.Union([Type.Array(Type.String()), Type.String()], { description: "Key files created or modified" })),
+            keyDecisions: Type.Optional(Type.Union([Type.Array(Type.String()), Type.String()], { description: "Key decisions made during this slice" })),
+            patternsEstablished: Type.Optional(Type.Union([Type.Array(Type.String()), Type.String()], { description: "Patterns established by this slice" })),
+            observabilitySurfaces: Type.Optional(Type.Union([Type.Array(Type.String()), Type.String()], { description: "Observability surfaces added" })),
+            provides: Type.Optional(Type.Union([Type.Array(Type.String()), Type.String()], { description: "What this slice provides to downstream slices" })),
+            requirementsSurfaced: Type.Optional(Type.Union([Type.Array(Type.String()), Type.String()], { description: "New requirements surfaced" })),
+            drillDownPaths: Type.Optional(Type.Union([Type.Array(Type.String()), Type.String()], { description: "Paths to task summaries for drill-down" })),
+            affects: Type.Optional(Type.Union([Type.Array(Type.String()), Type.String()], { description: "Downstream slices affected" })),
             requirementsAdvanced: Type.Optional(Type.Array(Type.Union([
                 Type.Object({
                     id: Type.String({ description: "Requirement ID" }),
@@ -932,6 +943,16 @@ export function registerDbTools(pi) {
             }
             updateSliceStatus(params.milestoneId, params.sliceId, "skipped");
             invalidateStateCache();
+            // Rebuild STATE.md so it reflects the skip immediately (#3477).
+            // Without this, /gsd auto reads stale STATE.md and resumes the skipped slice.
+            try {
+                const basePath = process.cwd();
+                const { rebuildState } = await import("../doctor.js");
+                await rebuildState(basePath);
+            }
+            catch (err) {
+                logError("tool", `skip_slice rebuildState failed: ${err.message}`, { tool: "gsd_skip_slice" });
+            }
             return {
                 content: [{ type: "text", text: `Skipped slice ${params.sliceId} (${params.milestoneId}). Reason: ${params.reason ?? "User-directed skip"}. Auto-mode will advance past this slice.` }],
                 details: {

package/dist/resources/extensions/gsd/bootstrap/notify-interceptor.js

@@ -0,0 +1,28 @@
+// GSD Extension — Notify Interceptor
+// Wraps ctx.ui.notify() in-place to persist every notification through the
+// notification store. Uses a WeakSet to prevent double-wrapping and handle
+// UI context replacement on /reload gracefully.
+import { appendNotification } from "../notification-store.js";
+// Track which ui context objects have been wrapped to prevent double-install.
+// WeakSet allows GC to collect replaced uiContext instances after /reload.
+const _wrappedContexts = new WeakSet();
+/**
+ * Install the notify interceptor on a context's UI object.
+ * Mutates ctx.ui.notify in place — the original is called after persistence.
+ * Safe to call multiple times; no-ops if already installed on the same ui object.
+ */
+export function installNotifyInterceptor(ctx) {
+    if (_wrappedContexts.has(ctx.ui))
+        return;
+    const originalNotify = ctx.ui.notify.bind(ctx.ui);
+    ctx.ui.notify = (message, type) => {
+        try {
+            appendNotification(message, (type ?? "info"), "notify");
+        }
+        catch {
+            // Non-fatal — never let persistence break the UI
+        }
+        originalNotify(message, type);
+    };
+    _wrappedContexts.add(ctx.ui);
+}

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

@@ -17,10 +17,12 @@ export function registerQueryTools(pi) {
         }),
         async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
             try {
-                // Strictly read-only: only use an already-open DB connection.
-                // Do NOT call ensureDbOpen() — it can create/migrate the DB as a side effect.
-                const { isDbAvailable, getMilestone, getSliceStatusSummary, getSliceTaskCounts, _getAdapter, } = await import("../gsd-db.js");
-                if (!isDbAvailable()) {
+                // Open the DB if not already open — safe for read-only use since
+                // ensureDbOpen() only creates/migrates when .gsd/ has content (#3644).
+                const { ensureDbOpen } = await import("./dynamic-tools.js");
+                const dbAvailable = await ensureDbOpen();
+                const { getMilestone, getSliceStatusSummary, getSliceTaskCounts, _getAdapter, } = await import("../gsd-db.js");
+                if (!dbAvailable) {
                     return {
                         content: [{ type: "text", text: "Error: GSD database is not available." }],
                         details: { operation: "milestone_status", error: "db_unavailable" },

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

@@ -31,7 +31,11 @@ function installEpipeGuard() {
             if (handleRecoverableExtensionProcessError(err)) {
                 return;
             }
-            throw err;
+            // Log unhandled errors instead of re-throwing — throwing inside an
+            // uncaughtException handler is a fatal double-fault in Node.js (#3163).
+            process.stderr.write(`[gsd] uncaught extension error (non-fatal): ${err.message}\n`);
+            if (err.stack)
+                process.stderr.write(`${err.stack}\n`);
         };
         process.on("uncaughtException", _gsdEpipeGuard);
     }

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

@@ -18,6 +18,9 @@ import { resetAskUserQuestionsCache } from "../../ask-user-questions.js";
 import { recordToolCall as safetyRecordToolCall, recordToolResult as safetyRecordToolResult } from "../safety/evidence-collector.js";
 import { classifyCommand } from "../safety/destructive-guard.js";
 import { logWarning as safetyLogWarning } from "../workflow-logger.js";
+import { installNotifyInterceptor } from "./notify-interceptor.js";
+import { initNotificationStore } from "../notification-store.js";
+import { initNotificationWidget } from "../notification-widget.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;
@@ -27,6 +30,9 @@ async function syncServiceTierStatus(ctx) {
 }
 export function registerHooks(pi) {
     pi.on("session_start", async (_event, ctx) => {
+        initNotificationStore(process.cwd());
+        installNotifyInterceptor(ctx);
+        initNotificationWidget(ctx);
         resetWriteGateState();
         resetToolCallLoopGuard();
         resetAskUserQuestionsCache();
@@ -63,6 +69,8 @@ export function registerHooks(pi) {
         loadToolApiKeys();
     });
     pi.on("session_switch", async (_event, ctx) => {
+        initNotificationStore(process.cwd());
+        installNotifyInterceptor(ctx);
         resetWriteGateState();
         resetToolCallLoopGuard();
         resetAskUserQuestionsCache();
@@ -90,7 +98,10 @@ export function registerHooks(pi) {
         }
     });
     pi.on("session_before_compact", async () => {
-        if (isAutoActive() || isAutoPaused()) {
+        // Only cancel compaction while auto-mode is actively running.
+        // Paused auto-mode should allow compaction — the user may be doing
+        // interactive work (#3165).
+        if (isAutoActive()) {
             return { cancel: true };
         }
         const basePath = process.cwd();