gsd-pi 2.82.0-dev.2841a1e44 → 2.82.0-dev.3a3c6509d

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

@@ -173,7 +173,18 @@ function gitPathspecForWorktreePath(basePath, targetPath) {
     let base = basePath;
     let target = targetPath;
     try {
-        base = realpathSync.native(basePath);
+        base = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+            cwd: basePath,
+            stdio: ["ignore", "pipe", "ignore"],
+            encoding: "utf-8",
+        }).trim() || basePath;
+    }
+    catch {
+        /* keep original */
+        void base;
+    }
+    try {
+        base = realpathSync.native(base);
     }
     catch {
         /* keep original */
@@ -191,6 +202,9 @@ function gitPathspecForWorktreePath(basePath, targetPath) {
         return null;
     return rel.replaceAll("\\", "/");
 }
+export function _gitPathspecForWorktreePath(basePath, targetPath) {
+    return gitPathspecForWorktreePath(basePath, targetPath);
+}
 function gitRemoteExists(basePath, remote) {
     try {
         execFileSync("git", ["remote", "get-url", remote], {
@@ -204,6 +218,52 @@ function gitRemoteExists(basePath, remote) {
         return false;
     }
 }
+function findRegularMergeChangedPaths(basePath, milestoneBranch, mainBranch) {
+    const changedPaths = new Set();
+    let mergeLog = "";
+    try {
+        mergeLog = execFileSync("git", ["rev-list", "--merges", "--parents", mainBranch], {
+            cwd: basePath,
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+        }).trim();
+    }
+    catch (err) {
+        logWarning("worktree", `regular merge lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+        return changedPaths;
+    }
+    for (const line of mergeLog.split("\n").filter(Boolean)) {
+        const [mergeCommit, firstParent, ...otherParents] = line.split(" ");
+        if (!mergeCommit || !firstParent || otherParents.length === 0)
+            continue;
+        const mergedMilestone = otherParents.some((parent) => {
+            try {
+                return nativeIsAncestor(basePath, milestoneBranch, parent);
+            }
+            catch {
+                return false;
+            }
+        });
+        if (!mergedMilestone)
+            continue;
+        try {
+            const output = execFileSync("git", ["diff", "--name-only", firstParent, mergeCommit], {
+                cwd: basePath,
+                stdio: ["ignore", "pipe", "pipe"],
+                encoding: "utf-8",
+            }).trim();
+            for (const path of output.split("\n").filter(Boolean)) {
+                if (!path.startsWith(".gsd/"))
+                    changedPaths.add(path);
+            }
+        }
+        catch (err) {
+            logWarning("worktree", `regular merge diff lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        return changedPaths;
+    }
+    return changedPaths;
+}
 function clearProjectRootStateFiles(basePath, milestoneId) {
     const gsdDir = gsdRoot(basePath);
     // Phase C pt 2: auto.lock removed from this list — the file is gone
@@ -810,7 +870,63 @@ export function enterBranchModeForMilestone(basePath, milestoneId) {
             reused: true,
         });
     }
-    nativeCheckoutBranch(basePath, branch);
+    checkoutBranchWithStashGuard(basePath, branch, `enter-branch-mode:${milestoneId}`);
+}
+export function checkoutBranchWithStashGuard(basePath, branch, reason) {
+    let stashMarker = null;
+    let stashed = false;
+    const status = nativeWorkingTreeStatus(basePath).trim();
+    if (status.length > 0) {
+        stashMarker = `gsd-checkout-stash:${reason}:${process.pid}:${Date.now()}:${process.hrtime.bigint().toString(36)}`;
+        const stashListBefore = execFileSync("git", ["stash", "list"], {
+            cwd: basePath,
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+        });
+        execFileSync("git", ["stash", "push", "--include-untracked", "-m", `gsd: checkout stash [${stashMarker}]`], {
+            cwd: basePath,
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+        });
+        const stashListAfter = execFileSync("git", ["stash", "list"], {
+            cwd: basePath,
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+        });
+        stashed = stashListAfter !== stashListBefore;
+    }
+    // Checkout and stash-restore are split so we can distinguish two failure
+    // modes: (a) checkout failed → HEAD did not move, restore stash and rethrow;
+    // (b) checkout succeeded but stash pop failed → HEAD moved to `branch` but
+    // the working-tree changes remain in the stash list. We surface a distinct
+    // error in case (b) so callers don't assume the branch switch was rolled back.
+    try {
+        nativeCheckoutBranch(basePath, branch);
+    }
+    catch (checkoutErr) {
+        if (stashed) {
+            try {
+                popStashByRef(basePath, stashMarker);
+            }
+            catch (restoreErr) {
+                logWarning("worktree", `git stash pop failed during checkout restore: ${restoreErr instanceof Error ? restoreErr.message : String(restoreErr)}`);
+            }
+        }
+        throw checkoutErr;
+    }
+    if (stashed) {
+        try {
+            popStashByRef(basePath, stashMarker);
+        }
+        catch (popErr) {
+            const msg = popErr instanceof Error ? popErr.message : String(popErr);
+            const wrapped = new Error(`checkout to '${branch}' succeeded but stash restore failed; working tree changes remain in the stash list. Original error: ${msg}`);
+            const ref = popErr?.stashRef;
+            if (ref)
+                wrapped.stashRef = ref;
+            throw wrapped;
+        }
+    }
 }
 // ─── Public API ────────────────────────────────────────────────────────────
 /**
@@ -1482,6 +1598,56 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
             });
         }
     }
+    // Already regular-merged milestones can skip the squash path and proceed to cleanup (#5831).
+    if (nativeIsAncestor(originalBasePath_, milestoneBranch, mainBranch)) {
+        const codeChanges = nativeDiffNumstat(originalBasePath_, mainBranch, milestoneBranch).filter((entry) => !entry.path.startsWith(".gsd/"));
+        if (codeChanges.length > 0) {
+            const regularMergeChangedPaths = findRegularMergeChangedPaths(originalBasePath_, milestoneBranch, mainBranch);
+            const unanchoredCodeChanges = codeChanges.filter((entry) => regularMergeChangedPaths.has(entry.path));
+            if (unanchoredCodeChanges.length > 0) {
+                process.chdir(previousCwd);
+                throw new GSDError(GSD_GIT_ERROR, `Milestone branch "${milestoneBranch}" is reachable from "${mainBranch}" ` +
+                    `but has ${unanchoredCodeChanges.length} milestone-touched code file(s) not on current "${mainBranch}". ` +
+                    `Aborting worktree teardown to prevent data loss.`);
+            }
+        }
+        debugLog("mergeMilestoneToMain", {
+            action: "skip-squash-already-merged",
+            milestoneId,
+            milestoneBranch,
+            mainBranch,
+        });
+        try {
+            clearProjectRootStateFiles(originalBasePath_, milestoneId);
+        }
+        catch (err) {
+            logWarning("worktree", `clearProjectRootStateFiles failed during already-merged cleanup: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        try {
+            removeWorktree(originalBasePath_, milestoneId, {
+                branch: milestoneBranch,
+                deleteBranch: false,
+            });
+        }
+        catch (err) {
+            logWarning("worktree", `worktree removal failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        try {
+            nativeBranchDelete(originalBasePath_, milestoneBranch);
+        }
+        catch (err) {
+            logWarning("worktree", `git branch-delete failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        setActiveWorkspace(null);
+        nudgeGitBranchCache(previousCwd);
+        try {
+            process.chdir(originalBasePath_);
+        }
+        catch (err) {
+            logWarning("worktree", `chdir to project root after already-merged cleanup failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        return { commitMessage, pushed: false, prCreated: false, codeFilesChanged: true };
+    }
     // 7. Shelter queued milestone directories before the squash merge (#2505).
     // The milestone branch may contain copies of queued milestone dirs (via
     // copyPlanningArtifacts), so `git merge --squash` rejects when those same
@@ -1617,14 +1783,6 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
         // report the dirty tree if it fails.
         logWarning("worktree", `git stash failed: ${err instanceof Error ? err.message : String(err)}`);
     }
-    if (needsDbCycle && dbPathToReopen) {
-        try {
-            openDatabase(dbPathToReopen);
-        }
-        catch (err) {
-            logWarning("worktree", `post-stash db reopen failed: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
     // 7b. Clean up stale merge state before attempting squash merge (#2912).
     // A leftover MERGE_HEAD (from a previous failed merge, libgit2 native path,
     // or interrupted operation) causes `git merge --squash` to refuse with
@@ -1633,6 +1791,14 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
     removeMergeStateFiles(originalBasePath_, "pre-merge");
     // 8. Squash merge — auto-resolve .gsd/ state file conflicts (#530)
     const mergeResult = nativeMergeSquash(originalBasePath_, milestoneBranch);
+    if (needsDbCycle && dbPathToReopen) {
+        try {
+            openDatabase(dbPathToReopen);
+        }
+        catch (err) {
+            logWarning("worktree", `post-merge db reopen failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
     if (!mergeResult.success) {
         // Dirty working tree — the merge was rejected before it started (e.g.
         // untracked .gsd/ files left by syncStateToProjectRoot).  Preserve the

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

@@ -22,7 +22,7 @@ import { gsdRoot, resolveMilestoneFile, resolveMilestonePath, resolveDir, milest
 import { invalidateAllCaches } from "./cache.js";
 import { clearActivityLogState } from "./activity-log.js";
 import { synthesizeCrashRecovery, getDeepDiagnostic, readActiveMilestoneId, } from "./session-forensics.js";
-import { writeLock, clearLock, readCrashLock, isLockProcessAlive, formatCrashInfo, emitCrashRecoveredUnitEnd, emitOpenUnitEndForUnit, } from "./crash-recovery.js";
+import { writeLock, clearLock, clearStaleWorkerLock, readCrashLock, isLockProcessAlive, formatCrashInfo, emitCrashRecoveredUnitEnd, emitOpenUnitEndForUnit, } from "./crash-recovery.js";
 import { acquireSessionLock, getSessionLockStatus, releaseSessionLock, updateSessionLock, } from "./session-lock.js";
 import { resolveAutoSupervisorConfig, loadEffectiveGSDPreferences, getIsolationMode, } from "./preferences.js";
 import { sendDesktopNotification } from "./notifications.js";
@@ -127,6 +127,12 @@ import { normalizeRealPath } from "./paths.js";
 // ─────────────────────────────────────────────────────────────────────────────
 /** Throttle STATE.md rebuilds — at most once per 30 seconds */
 const STATE_REBUILD_MIN_INTERVAL_MS = 30_000;
+export function formatAutoStopNotification(prefix, totals, unitCount) {
+    return [
+        `${prefix}.`,
+        `Session: ${formatCost(totals.cost)} · ${formatTokenCount(totals.tokens.total)} tokens · ${unitCount} units`,
+    ].join("\n");
+}
 /**
  * Phase B — register this auto-mode process in the workers table so other
  * workers and janitors can detect liveness via heartbeat. Best-effort: if
@@ -707,6 +713,7 @@ export async function cleanupAfterLoopExit(ctx) {
     // visible so the user still has a resumable auto-mode signal on screen.
     if (!s.paused) {
         ctx.ui.setStatus("gsd-auto", undefined);
+        ctx.ui.setWidget("gsd-progress", undefined);
         if (s.completionStopInProgress) {
             s.completionStopInProgress = false;
         }
@@ -1029,7 +1036,7 @@ export async function stopAuto(ctx, pi, reason, options = {}) {
                     : `Auto-mode stopped${reasonSuffix}`;
             if (ledger && ledger.units.length > 0) {
                 const totals = getProjectTotals(ledger.units);
-                ctx?.ui.notify(`${notificationPrefix}. Session: ${formatCost(totals.cost)} · ${formatTokenCount(totals.tokens.total)} tokens · ${ledger.units.length} units`, "info");
+                ctx?.ui.notify(formatAutoStopNotification(notificationPrefix, totals, ledger.units.length), "info");
             }
             else {
                 ctx?.ui.notify(`${notificationPrefix}.`, "info");
@@ -1318,7 +1325,6 @@ export async function pauseAuto(ctx, _pi, _errorContext) {
     restoreProjectRootEnv();
     restoreMilestoneLockEnv();
     s.pendingVerificationRetry = null;
-    s.verificationRetryCount.clear();
     ctx?.ui.setStatus("gsd-auto", "paused");
     ctx?.ui.setWidget("gsd-progress", undefined);
     const resumeCmd = s.stepMode ? "/gsd next" : "/gsd auto";
@@ -1420,6 +1426,13 @@ export function createWiredDispatchAdapter(ctx, pi, dispatchBasePath) {
                 sessionProvider,
                 modelRegistry,
             });
+            if (action.action === "stop") {
+                return {
+                    kind: "blocked",
+                    reason: action.reason,
+                    action: action.level === "warning" ? "pause" : "stop",
+                };
+            }
             if (action.action !== "dispatch")
                 return null;
             return {
@@ -1640,6 +1653,17 @@ export function createWiredAutoOrchestrationModule(ctx, pi, dispatchBasePath, ru
     };
     return createAutoOrchestrator(deps);
 }
+function notifyResumeBlocked(ctx, result) {
+    const resumeCmd = s.stepMode ? "/gsd next" : "/gsd auto";
+    ctx.ui.notify(`Auto-mode blocked: ${result.reason}. Fix and run ${resumeCmd} to resume.`, "warning");
+    setLifecycleOutcome(ctx, {
+        status: "blocked",
+        title: "Auto-mode blocked",
+        detail: result.reason,
+        nextAction: `Fix the blocker, then run ${resumeCmd} to resume.`,
+        commands: ["/gsd status for overview", `${resumeCmd} to resume`, "/gsd doctor to diagnose"],
+    });
+}
 function ensureOrchestrationModule(ctx, pi, basePath) {
     s.orchestration = createWiredAutoOrchestrationModule(ctx, pi, basePath, lockBase());
 }
@@ -1924,7 +1948,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         // This closes the journal gap reported in #3348 where the worker wrote side
         // effects (SUMMARY.md, DB updates) but died before emitting unit-end.
         emitCrashRecoveredUnitEnd(base, freshStartAssessment.lock);
-        clearLock(base);
+        clearStaleWorkerLock(base);
     }
     if (!s.paused) {
         s.pendingCrashRecovery =
@@ -1987,6 +2011,8 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
             initMetrics(base);
         if (s.currentMilestoneId)
             setActiveMilestoneId(base, s.currentMilestoneId);
+        await openProjectDbIfPresent(base);
+        registerAutoWorkerForSession(s, base);
         // Re-register health level notification callback lost across process restart
         setLevelChangeCallback((_from, to, summary) => {
             const level = to === "red" ? "error" : to === "yellow" ? "warning" : "info";
@@ -2062,7 +2088,12 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         }
         pi.events.emit(CMUX_CHANNELS.LOG, { preferences: loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences, message: s.stepMode ? "Step-mode resumed." : "Auto-mode resumed.", level: "progress" });
         try {
-            await s.orchestration?.resume();
+            const resumeResult = await s.orchestration?.resume();
+            if (resumeResult?.kind === "blocked") {
+                notifyResumeBlocked(ctx, resumeResult);
+                await cleanupAfterLoopExit(ctx);
+                return;
+            }
         }
         catch (err) {
             debugLog("resume-orchestration-resume", { error: err instanceof Error ? err.message : String(err) });
@@ -2083,6 +2114,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
     const bootstrapDeps = {
         shouldUseWorktreeIsolation,
         registerSigtermHandler,
+        registerAutoWorkerForSession: (projectRoot) => registerAutoWorkerForSession(s, projectRoot),
         lockBase,
         buildLifecycle,
     };

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

@@ -10,6 +10,7 @@ import { shouldIgnoreAgentEndForActiveUnit } from "../auto/unit-runner-events.js
 import { resolveModelId } from "../auto-model-selection.js";
 import { resolveProjectRoot } from "../worktree.js";
 import { clearDiscussionFlowState } from "./write-gate.js";
+import { clearGuidedUnitContext } from "../guided-unit-context.js";
 import { resumeAutoAfterProviderDelay } from "./provider-error-resume.js";
 import { classifyError, createRetryState, resetRetryState, isTransient, } from "../error-classifier.js";
 import { blockModel, isModelBlocked } from "../blocked-models.js";
@@ -18,6 +19,9 @@ const MAX_NETWORK_RETRIES = 2;
 function isObjectRecord(value) {
     return !!value && typeof value === "object";
 }
+export function _hasEmptyAgentEndContent(content) {
+    return content == null || (Array.isArray(content) && content.length === 0);
+}
 /**
  * Cap on auto-resume attempts for sustained transient-provider errors.
  *
@@ -57,6 +61,11 @@ export function isUserInitiatedAbortMessage(message) {
         return false;
     return /\b(?:claude code process aborted by user|request aborted by user|process aborted by user)\b/i.test(message);
 }
+export function shouldDeferTransientErrorToCoreRetry(cls, rawErrorMsg) {
+    if (!isTransient(cls) || cls.kind === "rate-limit")
+        return false;
+    return !/retry failed after \d+ attempts:/i.test(rawErrorMsg);
+}
 function isBareClaudeCodeSessionSwitchAbortMarker(message) {
     if (!message)
         return false;
@@ -150,6 +159,13 @@ export function resolveAgentEndErrorDisplay(rawErrorMsg, content) {
     }
     return rawErrorMsg;
 }
+export function isTerminalDeletedWorktreeProviderError(message) {
+    if (!message)
+        return false;
+    if (!/\bdoes not exist\b/i.test(message))
+        return false;
+    return /[/\\]\.gsd[/\\](?:projects[/\\][^/\\]+[/\\])?worktrees[/\\][^/\\\s"']+/i.test(message);
+}
 async function pauseTransientWithBackoff(cls, pi, ctx, errorDetail, isRateLimit) {
     retryState.consecutiveTransientCount += 1;
     const baseRetryAfterMs = "retryAfterMs" in cls ? cls.retryAfterMs : 15_000;
@@ -187,8 +203,10 @@ export async function handleAgentEnd(pi, event, ctx) {
     // falsely report files as missing — producing a spurious "ready signal
     // rejected" loop even though the files are on disk.
     clearPathCache();
+    const basePath = resolveAgentEndBasePath();
+    clearGuidedUnitContext(basePath);
     try {
-        if (await checkDeepProjectSetupAfterTurn(event, ctx, resolveAgentEndBasePath())) {
+        if (await checkDeepProjectSetupAfterTurn(event, ctx, basePath)) {
             return;
         }
     }
@@ -196,22 +214,22 @@ export async function handleAgentEnd(pi, event, ctx) {
         const message = err instanceof Error ? err.message : String(err);
         logWarning("bootstrap", `checkDeepProjectSetupAfterTurn failed: ${message}`);
     }
-    if (checkAutoStartAfterDiscuss()) {
-        clearDiscussionFlowState(resolveAgentEndBasePath() ?? process.cwd());
+    if (checkAutoStartAfterDiscuss(basePath)) {
+        clearDiscussionFlowState(basePath ?? process.cwd());
         return;
     }
     // #4573 — When the LLM emits "Milestone X ready." but the required files
     // are missing, `checkAutoStartAfterDiscuss` returns false silently. Surface
     // that and nudge the LLM to complete the writes before the user hits the
     // downstream "All milestones complete" warning loop.
-    if (maybeHandleReadyPhraseWithoutFiles(event))
+    if (maybeHandleReadyPhraseWithoutFiles(event, basePath))
         return;
     // #4573 — Empty-turn recovery: if the LLM announced intent in prose but
     // emitted no tool calls, nudge it to execute. Fires only when auto-mode is
     // active or a discussion autostart is pending (non-auto interactive discuss
     // is user-driven). Runs before `isAutoActive` early return so pending
     // discussions (where isAutoActive may be false) still get recovered.
-    if (maybeHandleEmptyIntentTurn(event, isAutoActive()))
+    if (maybeHandleEmptyIntentTurn(event, isAutoActive(), basePath))
         return;
     if (!isAutoActive())
         return;
@@ -246,7 +264,7 @@ export async function handleAgentEnd(pi, event, ctx) {
         // that carry error context — e.g. errorMessage field or non-empty content
         // indicating a mid-stream failure. (#2695)
         const content = "content" in lastMsg ? lastMsg.content : undefined;
-        const hasEmptyContent = Array.isArray(content) && content.length === 0;
+        const hasEmptyContent = _hasEmptyAgentEndContent(content);
         const hasErrorMessage = "errorMessage" in lastMsg && !!lastMsg.errorMessage;
         if (hasEmptyContent && !hasErrorMessage) {
             // Non-fatal: treat as a normal agent end so the loop can continue
@@ -292,6 +310,12 @@ export async function handleAgentEnd(pi, event, ctx) {
         // the assistant message text content for display purposes only.
         // Classification still uses rawErrorMsg to avoid false positives from prose.
         const displayMsg = resolveAgentEndErrorDisplay(rawErrorMsg, "content" in lastMsg ? lastMsg.content : undefined);
+        if (isAutoCompletionStopInProgress() &&
+            isTerminalDeletedWorktreeProviderError(`${rawErrorMsg}\n${displayMsg}`)) {
+            resetRetryState(retryState);
+            logWarning("bootstrap", `Ignoring stale deleted-worktree provider error during terminal completion reroot: ${displayMsg || rawErrorMsg}`);
+            return;
+        }
         const errorDetail = displayMsg ? `: ${displayMsg}` : "";
         const explicitRetryAfterMs = ("retryAfterMs" in lastMsg && typeof lastMsg.retryAfterMs === "number") ? lastMsg.retryAfterMs : undefined;
         // ── 1. Classify using rawErrorMsg to avoid prose false-positives ────
@@ -375,7 +399,7 @@ export async function handleAgentEnd(pi, event, ctx) {
         // Core retries transient failures in-session after this handler.
         // Keep that behavior for non-rate-limit classes to avoid pause/retry races,
         // but let rate-limit continue into model fallback logic below (#4373).
-        if (isTransient(cls) && cls.kind !== "rate-limit") {
+        if (shouldDeferTransientErrorToCoreRetry(cls, rawErrorMsg)) {
             return;
         }
         // Cap rate-limit backoff for CLI-style providers (openai-codex, google-gemini-cli)

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

@@ -468,17 +468,18 @@ export function registerDbTools(pi) {
         promptGuidelines: [
             "Use gsd_plan_milestone for milestone planning instead of writing ROADMAP.md directly.",
             "Keep parameters flat and provide the full milestone planning payload, including slices.",
+            "Milestone and slice titles must not contain forward slash (/), en dash, or em dash characters.",
             "The tool validates input, writes milestone and slice planning data transactionally, renders ROADMAP.md from DB, and clears both state and parse caches after success.",
             "Use the canonical name gsd_plan_milestone; gsd_milestone_plan is only an alias.",
         ],
         parameters: Type.Object({
             // ── Core identification + content (required) ──────────────────────
             milestoneId: Type.String({ description: "Milestone ID (e.g. M001)" }),
-            title: Type.String({ description: "Milestone title" }),
+            title: Type.String({ description: "Milestone title; must not contain forward slash (/), en dash, or em dash characters" }),
             vision: Type.String({ description: "Milestone vision" }),
             slices: Type.Array(Type.Object({
                 sliceId: Type.String({ description: "Slice ID (e.g. S01)" }),
-                title: Type.String({ description: "Slice title" }),
+                title: Type.String({ description: "Slice title; must not contain forward slash (/), en dash, or em dash characters" }),
                 risk: Type.String({ description: "Slice risk" }),
                 depends: Type.Array(Type.String(), { description: "Slice dependency IDs" }),
                 demo: Type.String({ description: "Roadmap demo text / After this" }),
@@ -546,10 +547,10 @@ export function registerDbTools(pi) {
                 title: Type.String({ description: "Task title" }),
                 description: Type.String({ description: "Task description / steps block" }),
                 estimate: Type.String({ description: "Task estimate string" }),
-                files: Type.Array(Type.String(), { description: "Files likely touched" }),
+                files: Type.Array(Type.String(), { description: "Array<string> of files likely touched; pass [\"path\"] or [], never a single string" }),
                 verify: Type.String({ description: "Verification command or block" }),
-                inputs: Type.Array(Type.String(), { description: "Input files or references" }),
-                expectedOutput: Type.Array(Type.String(), { description: "Expected output files or artifacts" }),
+                inputs: Type.Array(Type.String(), { description: "Array<string> of input files or references; pass [\"path\"] or [], never a single string" }),
+                expectedOutput: Type.Array(Type.String(), { description: "Array<string> of expected output files or artifacts; pass [\"path\"] or [], never a single string" }),
                 observabilityImpact: Type.Optional(Type.String({ description: "Task observability impact" })),
             }), { description: "Planned tasks for the slice" }),
             // ── Enrichment metadata (optional — defaults to empty) ────────────
@@ -622,10 +623,10 @@ export function registerDbTools(pi) {
             title: Type.String({ description: "Task title" }),
             description: Type.String({ description: "Task description / steps block" }),
             estimate: Type.String({ description: "Task estimate string" }),
-            files: Type.Array(Type.String(), { description: "Files likely touched" }),
+            files: Type.Array(Type.String(), { description: "Array<string> of files likely touched; pass [\"path\"] or [], never a single string" }),
             verify: Type.String({ description: "Verification command or block" }),
-            inputs: Type.Array(Type.String(), { description: "Input files or references" }),
-            expectedOutput: Type.Array(Type.String(), { description: "Expected output files or artifacts" }),
+            inputs: Type.Array(Type.String(), { description: "Array<string> of input files or references; pass [\"path\"] or [], never a single string" }),
+            expectedOutput: Type.Array(Type.String(), { description: "Array<string> of expected output files or artifacts; pass [\"path\"] or [], never a single string" }),
             observabilityImpact: Type.Optional(Type.String({ description: "Task observability impact" })),
             // Single-writer v3 audit trail (Stream 2): caller-provided actor identity + causation.
             actorName: Type.Optional(Type.String({ description: "Caller-provided actor identity for the audit trail (e.g. 'executor-01', 'gsd-orchestrator')" })),
@@ -847,7 +848,7 @@ export function registerDbTools(pi) {
         name: "gsd_skip_slice",
         label: "Skip Slice",
         description: "Mark a slice as skipped so auto-mode advances past it without executing. " +
-            "Non-closed tasks within the slice are cascaded to skipped so milestone completion is not blocked by leftover pending tasks (#4375). " +
+            "Non-closed tasks within the slice are cascaded to skipped so milestone completion is not blocked by leftover pending tasks. " +
             "The slice data is preserved for reference. The state machine treats skipped slices like completed ones for dependency satisfaction.",
         promptSnippet: "Skip a GSD slice (mark as skipped, auto-mode will advance past it)",
         promptGuidelines: [

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

@@ -24,6 +24,7 @@ import { resolveWorktreeProjectRoot } from "../worktree-root.js";
 import { extractSubagentAgentClasses } from "./subagent-input.js";
 import { approvalGateIdForUnit, isExplicitApprovalResponse, shouldPauseForUserApprovalQuestion } from "../user-input-boundary.js";
 import { resolveSkillManifest } from "../skill-manifest.js";
+import { getGuidedUnitContext } from "../guided-unit-context.js";
 let approvalQuestionAbortInFlight = false;
 async function loadWelcomeScreenModule() {
     const candidates = [];
@@ -675,7 +676,8 @@ export function registerHooks(pi, ecosystemHandlers) {
         // subagent dispatch. Closes the b23 bug class where a discuss-milestone
         // turn used the host Edit tool to modify user source files.
         const dash = getAutoRuntimeSnapshot();
-        const activeUnitType = dash.currentUnit?.type;
+        const guidedUnit = getGuidedUnitContext(discussionBasePath);
+        const activeUnitType = dash.currentUnit?.type ?? guidedUnit?.unitType;
         if (activeUnitType) {
             const manifest = resolveManifest(activeUnitType);
             if (manifest) {
@@ -694,7 +696,7 @@ export function registerHooks(pi, ecosystemHandlers) {
                     // Subagent inputs use { agent }, { tasks: [{ agent }] }, or { chain: [{ agent }] }.
                     agentClasses = extractSubagentAgentClasses(event.input);
                 }
-                const planningGuard = shouldBlockPlanningUnit(event.toolName, planningInput, dash.basePath || discussionBasePath, activeUnitType, manifest.tools, agentClasses);
+                const planningGuard = shouldBlockPlanningUnit(event.toolName, planningInput, dash.basePath || guidedUnit?.basePath || discussionBasePath, activeUnitType, manifest.tools, agentClasses);
                 if (planningGuard.block)
                     return planningGuard;
             }

package/dist/resources/extensions/gsd/bootstrap/subagent-input.js

@@ -4,8 +4,11 @@ export function extractSubagentAgentClasses(input) {
     const agentClasses = [];
     const visited = new WeakSet();
     const addAgentClass = (value) => {
-        if (typeof value === "string" && value.trim().length > 0)
-            agentClasses.push(value.trim());
+        if (typeof value !== "string")
+            return;
+        const normalized = value.trim().replace(/\.md$/i, "");
+        if (normalized.length > 0)
+            agentClasses.push(normalized);
     };
     const visitItems = (value) => {
         if (!Array.isArray(value))

package/dist/resources/extensions/gsd/bootstrap/write-gate.js

@@ -59,6 +59,7 @@ const QUEUE_SAFE_TOOLS = new Set([
  *   true / false        — shell no-ops / test exit codes
  */
 const BASH_READ_ONLY_RE = /^\s*(cat|head|tail|less|more|wc|file|stat|du|df|which|type|echo|printf|ls|find|grep|rg|awk|sed\b(?!.*-i)|sort|uniq|diff|comm|tr|cut|tee\s+-a\s+\/dev\/null|git\s+(log|show|diff|status|branch|tag|remote|rev-parse|ls-files|blame|shortlog|describe|stash\s+list|config\s+--get|cat-file)|gh\s+(issue|pr|api|repo|release)\s+(view|list|diff|status|checks)|mkdir\s+-p\s+\.gsd|rtk\s|npm\s+run\s+(test|test:\w+|lint|lint:\w+|typecheck|type-check|type-check:\w+|check|verify|audit|outdated|format:check|ci|validate)\b|npm\s+(ls|list|info|view|show|outdated|audit|explain|doctor|ping|--version|-v)\b|npx\s|tsx\s|node\s+(--print|--version|-v\b)|python[23]?\s+(-c\s+'[^']*'|--version|-V\b|-m\s+(pip\s+show|pip\s+list|site))|pip[23]?\s+(show|list|freeze|check|index\s+versions)\b|jq\s|yq\s|curl\s+(-s\b|--silent\b)(?!\s+[^|>]*\s-[oO]\b)(?!\s+[^|>]*\s--output\b)[^|>]*$|openssl\s+(version|x509|s_client)|env\b|printenv\b|true\b|false\b)/;
+const BASH_VERIFICATION_RE = /^\s*(npm\s+(run\s+(build|test|test:\w+|lint|lint:\w+|typecheck|type-check|verify|ci|validate)\b|test\b)|pnpm\s+(build|test|lint|typecheck|verify)\b|yarn\s+(build|test|lint|typecheck|verify)\b|vitest\b|jest\b|go\s+test\b)/;
 function createEmptyWriteGateState() {
     return {
         verifiedDepthMilestones: new Set(),
@@ -624,7 +625,7 @@ function matchesAllowedGlob(absPath, basePath, globs) {
 function blockReason(unitType, mode, what) {
     return [
         `HARD BLOCK: unit "${unitType}" runs under tools-policy "${mode}" — ${what}.`,
-        `This is a mechanical gate enforced by manifest.tools (#4934). You MUST NOT proceed,`,
+        `This is a mechanical gate enforced by manifest.tools. You MUST NOT proceed,`,
         `retry the same call, or rationalize past this block. If you need to write user source,`,
         `the work belongs in execute-task, not in a planning unit.`,
     ].join(" ");
@@ -643,6 +644,9 @@ function blockReason(unitType, mode, what) {
  *                    and listed in the policy's allowedSubagents.
  *   - "docs"       → like "planning" but also allows writes to paths
  *                    matching `allowedPathGlobs` relative to basePath.
+ *   - "verification"
+ *                  → allows Bash for project verification commands, but keeps
+ *                    writes restricted to .gsd/ and blocks subagent dispatch.
  *
  * `pathOrCommand` is the file path for write/edit-shaped tools and the
  * shell command for bash. Other tools ignore this argument.
@@ -674,7 +678,7 @@ export function shouldBlockPlanningUnit(toolName, pathOrCommand, basePath, unitT
         // Unknown tool in read-only mode — block by default.
         return { block: true, reason: blockReason(unitType, policy.mode, `tool "${tool}" is not on the read-only allowlist`) };
     }
-    // planning / planning-dispatch / docs modes share the same surface for safe tools, bash, and subagent.
+    // planning / planning-dispatch / docs / verification modes share the same surface for safe tools, bash, and subagent.
     if (PLANNING_SAFE_TOOLS.has(tool))
         return { block: false };
     if (tool.startsWith("gsd_"))
@@ -720,6 +724,14 @@ export function shouldBlockPlanningUnit(toolName, pathOrCommand, basePath, unitT
         return { block: true, reason: blockReason(unitType, policy.mode, `subagent dispatch is not permitted in planning units`) };
     }
     if (tool === "bash") {
+        if (policy.mode === "verification") {
+            if (BASH_VERIFICATION_RE.test(pathOrCommand) || BASH_READ_ONLY_RE.test(pathOrCommand))
+                return { block: false };
+            return {
+                block: true,
+                reason: blockReason(unitType, policy.mode, `bash is restricted to build/test verification commands (npm run build, npm test, etc.); cannot run "${pathOrCommand.slice(0, 80)}${pathOrCommand.length > 80 ? "…" : ""}"`),
+            };
+        }
         if (BASH_READ_ONLY_RE.test(pathOrCommand))
             return { block: false };
         return {

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

@@ -1,3 +1,4 @@
+import { createRequire } from "node:module";
 import { computeProgressScore, formatProgressLine } from "../../progress-score.js";
 import { getGlobalGSDPreferencesPath, getProjectGSDPreferencesPath } from "../../preferences.js";
 import { ensurePreferencesFile, handlePrefs, handlePrefsMode, handlePrefsWizard, handleLanguage } from "../../commands-prefs-wizard.js";
@@ -197,7 +198,22 @@ export async function handleBrief(args, ctx, pi) {
         return;
     }
     const outputDir = getVisualBriefOutputDir();
-    pi.sendUserMessage(buildVisualBriefPrompt(request, { outputDir }));
+    const version = resolveGsdVersion();
+    pi.sendUserMessage(buildVisualBriefPrompt(request, { outputDir, version }));
+}
+const briefRequire = createRequire(import.meta.url);
+function resolveGsdVersion() {
+    const envVersion = process.env.GSD_VERSION?.trim();
+    if (envVersion)
+        return envVersion;
+    try {
+        const pkg = briefRequire("../../../../../../package.json");
+        const fromPkg = typeof pkg.version === "string" ? pkg.version.trim() : "";
+        return fromPkg || undefined;
+    }
+    catch {
+        return undefined;
+    }
 }
 export async function handleSetup(args, ctx, pi) {
     const { detectProjectState, hasGlobalSetup } = await import("../../detection.js");