gsd-pi 2.82.0-dev.2841a1e44 → 2.82.0-dev.9d5798940

package/dist/resources/.managed-resources-content-hash

@@ -1 +1 @@
-0829fe9060dc3f75
+ed49f911008c62ca

package/dist/resources/extensions/claude-code-cli/partial-builder.js

@@ -105,9 +105,10 @@ export function mapUsage(sdkUsage, totalCostUsd) {
         output: sdkUsage.output_tokens,
         cacheRead: sdkUsage.cache_read_input_tokens,
         cacheWrite: sdkUsage.cache_creation_input_tokens,
+        // Claude Agent SDK result usage is cumulative across its internal loop;
+        // repeated cache reads do not represent additional live context.
         totalTokens: sdkUsage.input_tokens +
             sdkUsage.output_tokens +
-            sdkUsage.cache_read_input_tokens +
             sdkUsage.cache_creation_input_tokens,
         cost: {
             input: 0,

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

@@ -102,6 +102,9 @@ function missingSliceStop(mid, phase) {
         level: "error",
     };
 }
+function isRegistryMilestoneComplete(state, mid) {
+    return state.registry.some((milestone) => milestone.id === mid && milestone.status === "complete");
+}
 /**
  * Check for milestone slices missing SUMMARY files.
  * Returns array of missing slice IDs, or empty array if all present or DB unavailable.
@@ -247,6 +250,8 @@ export const DISPATCH_RULES = [
                 return null;
             if (!MILESTONE_ID_RE.test(mid))
                 return null;
+            if (isRegistryMilestoneComplete(state, mid))
+                return null;
             // Align with the plan-v2 gate's lookup semantics: whitespace-only counts
             // as missing, and an auto worktree may fall back to GSD_PROJECT_ROOT.
             if (hasFinalizedMilestoneContext(basePath, mid))
@@ -557,6 +562,8 @@ export const DISPATCH_RULES = [
         match: async ({ state, mid, midTitle, basePath, prefs, structuredQuestionsAvailable }) => {
             if (state.phase !== "pre-planning")
                 return null;
+            if (isRegistryMilestoneComplete(state, mid))
+                return null;
             const contextFile = resolveMilestoneFile(basePath, mid, "CONTEXT");
             const hasContext = !!(contextFile && (await loadFile(contextFile)));
             if (hasContext)
@@ -1091,19 +1098,19 @@ export const DISPATCH_RULES = [
                     return { action: "skip" };
                 }
             }
-            // Safety guard (#2675): block completion when VALIDATION verdict is
-            // needs-remediation. The state machine treats needs-remediation as
-            // terminal (to prevent validate-milestone loops per #832), but
-            // completing-milestone should NOT proceed — remediation work is needed.
+            // Safety guard (#2675, #5747): block completion when VALIDATION
+            // verdict is non-passing. The state machine treats these verdicts as
+            // terminal, but completing-milestone should NOT proceed — remediation
+            // or human attention is needed.
             const validationFile = resolveMilestoneFile(basePath, mid, "VALIDATION");
             if (validationFile) {
                 const validationContent = await loadFile(validationFile);
                 if (validationContent) {
                     const verdict = extractVerdict(validationContent);
-                    if (verdict === "needs-remediation") {
+                    if (verdict === "needs-remediation" || verdict === "needs-attention") {
                         return {
                             action: "stop",
-                            reason: `Cannot complete milestone ${mid}: VALIDATION verdict is "needs-remediation". Address the remediation findings and re-run validation, or update the verdict manually.`,
+                            reason: `Cannot complete milestone ${mid}: VALIDATION verdict is "${verdict}". Address the validation findings and re-run validation, or update the verdict manually.`,
                             level: "warning",
                         };
                     }

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

@@ -23,7 +23,7 @@ import { rebuildState } from "./doctor.js";
 import { parseUnitId } from "./unit-id.js";
 import { closeoutUnit } from "./auto-unit-closeout.js";
 import { runTurnGitAction, } from "./git-service.js";
-import { verifyExpectedArtifact, resolveExpectedArtifactPath, writeBlockerPlaceholder, diagnoseExpectedArtifact, } from "./auto-recovery.js";
+import { verifyExpectedArtifact, resolveExpectedArtifactPath, writeBlockerPlaceholder, diagnoseExpectedArtifact, diagnoseWorktreeIntegrityFailure, } from "./auto-recovery.js";
 import { regenerateIfMissing } from "./workflow-projections.js";
 import { WorktreeStateProjection } from "./worktree-state-projection.js";
 import { createWorkspace, scopeMilestone } from "./workspace.js";
@@ -303,6 +303,19 @@ export function buildStepCompleteMessage(nextState) {
     return `Step complete. Next: ${next.label}\n`
         + `Run /clear, then /gsd to continue (or /gsd auto to run continuously).`;
 }
+/**
+ * Decide whether step mode should stop at the step wizard after a unit finishes.
+ *
+ * @param currentUnitType The just-finished unit type, such as "execute-task" or
+ *   "complete-milestone"; may be null/undefined when no current unit is known.
+ * @param phaseAfterUnit The freshly derived next phase, such as "executing" or
+ *   "complete"; may be null/undefined if state derivation failed.
+ * @returns true to show the step wizard; false to keep the loop running so
+ *   terminal milestone completion can reach the merge/finalization path.
+ */
+export function shouldReturnStepWizardAfterUnit(currentUnitType, phaseAfterUnit) {
+    return currentUnitType !== "complete-milestone" && phaseAfterUnit !== "complete";
+}
 export const USER_DRIVEN_DEEP_UNITS = new Set([
     "discuss-project",
     "discuss-requirements",
@@ -318,6 +331,10 @@ function artifactValidationKind(unitType) {
     return null;
 }
 function describeArtifactVerificationFailure(unitType, unitId, basePath) {
+    const worktreeFailure = diagnoseWorktreeIntegrityFailure(basePath);
+    if (worktreeFailure) {
+        return `${worktreeFailure} Unit: ${unitType} ${unitId}.`;
+    }
     const artifactPath = resolveExpectedArtifactPath(unitType, unitId, basePath);
     if (!artifactPath) {
         return `Artifact verification failed: ${unitType} "${unitId}" has no resolvable artifact path.`;
@@ -362,7 +379,14 @@ export async function autoCommitUnit(basePath, unitType, unitId, ctx) {
         return null;
     }
 }
-async function runCloseoutGitAction(pctx, unit) {
+/**
+ * Execute the turn-level git action (commit, snapshot, or status-only).
+ *
+ * @param opts.softFailure - Defaults to false. When true, retry git failures,
+ * warn, and continue without pausing auto-mode; use for best-effort deferred
+ * closeout work where a git failure should not block the run.
+ */
+async function runCloseoutGitAction(pctx, unit, opts) {
     const { s, ctx, pi, pauseAuto } = pctx;
     const prefs = loadEffectiveGSDPreferences()?.preferences;
     const uokFlags = resolveUokFlags(prefs);
@@ -390,13 +414,24 @@ async function runCloseoutGitAction(pctx, unit) {
             });
         }
         else {
-            const gitResult = runTurnGitAction({
+            const maxAttempts = opts?.softFailure ? 3 : 1;
+            let gitResult = runTurnGitAction({
                 basePath: s.basePath,
                 action: turnAction,
                 unitType: unit.type,
                 unitId: unit.id,
                 taskContext,
             });
+            for (let attempt = 1; gitResult.status === "failed" && attempt < maxAttempts; attempt++) {
+                await new Promise((resolve) => setTimeout(resolve, 250 * attempt));
+                gitResult = runTurnGitAction({
+                    basePath: s.basePath,
+                    action: turnAction,
+                    unitType: unit.type,
+                    unitId: unit.id,
+                    taskContext,
+                });
+            }
             if (uokFlags.gitops) {
                 writeTurnGitTransaction({
                     basePath: s.basePath,
@@ -444,12 +479,15 @@ async function runCloseoutGitAction(pctx, unit) {
                     });
                 }
                 const failureMsg = `Git ${turnAction} failed: ${(gitResult.error ?? "unknown error").split("\n")[0]}`;
-                ctx.ui.notify(failureMsg, "error");
+                ctx.ui.notify(failureMsg, opts?.softFailure ? "warning" : "error");
                 debugLog("postUnit", {
-                    phase: "git-action-failed-blocking",
+                    phase: opts?.softFailure ? "git-action-failed-soft" : "git-action-failed-blocking",
                     action: turnAction,
                     error: gitResult.error ?? "unknown error",
                 });
+                if (opts?.softFailure) {
+                    return "continue";
+                }
                 await pauseAuto(ctx, pi);
                 return "dispatched";
             }
@@ -467,7 +505,10 @@ async function runCloseoutGitAction(pctx, unit) {
         s.lastGitActionFailure = message;
         s.lastGitActionStatus = "failed";
         debugLog("postUnit", { phase: "git-action", error: message, action: turnAction });
-        ctx.ui.notify(`Git ${turnAction} failed: ${message.split("\n")[0]}`, uokFlags.gitops ? "error" : "warning");
+        ctx.ui.notify(`Git ${turnAction} failed: ${message.split("\n")[0]}`, opts?.softFailure ? "warning" : "error");
+        if (opts?.softFailure) {
+            return "continue";
+        }
         if (uokFlags.gitops) {
             await pauseAuto(ctx, pi);
             return "dispatched";
@@ -961,6 +1002,22 @@ export async function postUnitPreVerification(pctx, opts) {
                 ctx.ui.notify(`${s.currentUnit.type} ${s.currentUnit.id} — deterministic policy rejection, wrote blocker placeholder (no retries) (#4973)`, "warning");
                 // Fall through to "continue" — do NOT enter the retry or db-unavailable paths.
             }
+            else if (!triggerArtifactVerified && diagnoseWorktreeIntegrityFailure(s.basePath)) {
+                const retryKey = `${s.currentUnit.type}:${s.currentUnit.id}`;
+                const worktreeFailure = diagnoseWorktreeIntegrityFailure(s.basePath);
+                s.pendingVerificationRetry = null;
+                s.verificationRetryCount.delete(retryKey);
+                s.verificationRetryFailureHashes.delete(retryKey);
+                debugLog("postUnit", {
+                    phase: "worktree-integrity-failure",
+                    unitType: s.currentUnit.type,
+                    unitId: s.currentUnit.id,
+                    basePath: s.basePath,
+                });
+                ctx.ui.notify(`${worktreeFailure} Retry ${s.currentUnit.id} after repair.`, "error");
+                await pauseAuto(ctx, pi);
+                return "dispatched";
+            }
             else if (!triggerArtifactVerified && !isDbAvailable()) {
                 debugLog("postUnit", { phase: "artifact-verify-skip-db-unavailable", unitType: s.currentUnit.type, unitId: s.currentUnit.id });
                 const dbSkipDiag = diagnoseExpectedArtifact(s.currentUnit.type, s.currentUnit.id, s.basePath);
@@ -1032,7 +1089,7 @@ export async function postUnitPostVerification(pctx) {
     const { s, ctx, pi, buildSnapshotOpts, lockBase, stopAuto, pauseAuto, updateProgressWidget } = pctx;
     if (s.currentUnit) {
         if (shouldDeferCloseoutGitAction(s.currentUnit.type)) {
-            const gitActionResult = await runCloseoutGitAction(pctx, s.currentUnit);
+            const gitActionResult = await runCloseoutGitAction(pctx, s.currentUnit, { softFailure: true });
             if (gitActionResult === "dispatched") {
                 return "stopped";
             }
@@ -1404,15 +1461,19 @@ export async function postUnitPostVerification(pctx) {
     // Without this notify(), /gsd in step mode finishes a unit and silently
     // exits the loop, leaving the user with no hint to /clear and /gsd again.
     if (s.stepMode) {
+        let phaseAfterUnit = null;
         try {
             const nextState = await deriveState(s.canonicalProjectRoot);
+            phaseAfterUnit = nextState.phase;
             ctx.ui.notify(buildStepCompleteMessage(nextState), "info");
         }
         catch (e) {
             debugLog("postUnit", { phase: "step-wizard-notify", error: String(e) });
             ctx.ui.notify(STEP_COMPLETE_FALLBACK_MESSAGE, "info");
         }
-        return "step-wizard";
+        return shouldReturnStepWizardAfterUnit(s.currentUnit?.type, phaseAfterUnit)
+            ? "step-wizard"
+            : "continue";
     }
     return "continue";
 }

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

@@ -14,7 +14,8 @@ import { clearParseCache } from "./files.js";
 import { parseRoadmap as parseLegacyRoadmap, parsePlan as parseLegacyPlan } from "./parsers-legacy.js";
 import { isDbAvailable, getTask, getSlice, getSliceTasks, getPendingGates, updateTaskStatus, updateSliceStatus, insertSlice, getMilestone, refreshOpenDatabaseFromDisk, getCompletedMilestoneTaskFileHints, getMilestoneCommitAttributionShas, recordMilestoneCommitAttribution } from "./gsd-db.js";
 import { isValidationTerminal } from "./state.js";
-import { logWarning } from "./workflow-logger.js";
+import { getErrorMessage } from "./error-utils.js";
+import { logWarning, logError } from "./workflow-logger.js";
 import { readIntegrationBranch } from "./git-service.js";
 import { isClosedStatus } from "./status-guards.js";
 import { resolveSlicePath, resolveSliceFile, resolveTasksDir, resolveTaskFiles, relMilestoneFile, relSliceFile, buildSliceFileName, resolveMilestoneFile, clearPathCache, resolveGsdRootFile, } from "./paths.js";
@@ -25,9 +26,33 @@ import { resolveExpectedArtifactPath, diagnoseExpectedArtifact, } from "./auto-a
 import { classifyMilestoneSummaryContent } from "./milestone-summary-classifier.js";
 import { validateArtifact } from "./schemas/validate.js";
 import { getProjectResearchStatus } from "./project-research-policy.js";
+import { isGsdWorktreePath } from "./worktree-root.js";
 // Re-export so existing consumers of auto-recovery.ts keep working.
 export { resolveExpectedArtifactPath, diagnoseExpectedArtifact };
 export { classifyMilestoneSummaryContent, } from "./milestone-summary-classifier.js";
+// ─── Artifact Resolution & Verification ───────────────────────────────────────
+export function diagnoseWorktreeIntegrityFailure(basePath) {
+    if (!isGsdWorktreePath(basePath))
+        return null;
+    if (!existsSync(basePath)) {
+        return `Worktree integrity failure: ${basePath} does not exist. Repair or recreate the worktree before retrying.`;
+    }
+    const gitPath = join(basePath, ".git");
+    if (!existsSync(gitPath)) {
+        return `Worktree integrity failure: ${basePath} is not a valid git worktree (.git missing). Repair or recreate the worktree before retrying.`;
+    }
+    try {
+        execFileSync("git", ["rev-parse", "--git-dir"], {
+            cwd: basePath,
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+        });
+        return null;
+    }
+    catch (err) {
+        return `Worktree integrity failure: ${basePath} is not a valid git worktree (git rev-parse failed: ${getErrorMessage(err).split("\n")[0]}). Repair or recreate the worktree before retrying.`;
+    }
+}
 export function refreshRecoveryDbForArtifact(unitType, unitId) {
     if (unitType !== "plan-slice" && unitType !== "execute-task")
         return { ok: true };
@@ -673,6 +698,11 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
         return false;
     }
     if (!existsSync(absPath)) {
+        const worktreeFailure = diagnoseWorktreeIntegrityFailure(base);
+        if (worktreeFailure) {
+            logError("recovery", `${worktreeFailure} Unit: ${unitType} ${unitId}.`);
+            return false;
+        }
         logWarning("recovery", `verify-fail ${unitType} ${unitId}: existsSync false for ${absPath}`);
         return false;
     }

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

@@ -606,12 +606,16 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         // worktree cleanup) was never run — the survivor branch must be merged.
         // Applies to both worktree and branch isolation modes.
         let hasSurvivorBranch = false;
-        if (state.activeMilestone &&
+        let survivorMilestoneId = state.activeMilestone?.id ?? null;
+        if (!survivorMilestoneId && state.phase === "complete") {
+            survivorMilestoneId = findUnmergedCompletedMilestone(base, getIsolationMode(base));
+        }
+        if (survivorMilestoneId &&
             (state.phase === "pre-planning" || state.phase === "complete") &&
             getIsolationMode(base) !== "none" &&
             !detectWorktreeName(base) &&
             !base.includes(`${pathSep}.gsd${pathSep}worktrees${pathSep}`)) {
-            const milestoneBranch = `milestone/${state.activeMilestone.id}`;
+            const milestoneBranch = `milestone/${survivorMilestoneId}`;
             const { nativeBranchExists } = await import("./native-git-bridge.js");
             hasSurvivorBranch = nativeBranchExists(base, milestoneBranch);
             if (hasSurvivorBranch) {
@@ -645,7 +649,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         // Re-evaluate via the helper — the discuss branch above may have cleared
         // hasSurvivorBranch after a successful promotion.
         if (decideSurvivorAction(hasSurvivorBranch, state.phase) === "finalize") {
-            const mid = state.activeMilestone.id;
+            const mid = survivorMilestoneId;
             // Commit 68ef58a3c made `_mergeBranchMode` throw on wrong-branch
             // instead of returning false silently. Wrap the call so the throw is
             // converted into an error notify + clean bootstrap abort, not an

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

@@ -204,6 +204,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
@@ -1482,6 +1528,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

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

@@ -18,6 +18,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.
  *
@@ -246,7 +249,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

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(),
@@ -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");

package/dist/resources/extensions/gsd/db/unit-dispatches.js

@@ -391,7 +391,7 @@ export function getRecentUnitKeysForProjectRoot(projectRootRealpath, limit = 20)
     if (!isDbAvailable())
         return [];
     const db = _getAdapter();
-    const rows = db.prepare(`SELECT ud.unit_id
+    const rows = db.prepare(`SELECT ud.unit_type, ud.unit_id
      FROM unit_dispatches ud
      INNER JOIN workers w ON w.worker_id = ud.worker_id
      WHERE w.project_root_realpath = :project_root_realpath
@@ -400,7 +400,7 @@ export function getRecentUnitKeysForProjectRoot(projectRootRealpath, limit = 20)
         ":project_root_realpath": projectRootRealpath,
         ":limit": limit,
     });
-    return rows.reverse().map((r) => ({ key: r.unit_id }));
+    return rows.reverse().map((r) => ({ key: `${r.unit_type}/${r.unit_id}` }));
 }
 /**
  * Fetch dispatches for a milestone filtered by status. Useful for janitors