@opengsd/gsd-pi 1.1.1-dev.3ea310e → 1.1.1-dev.595401e

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

@@ -49,6 +49,7 @@ import { resolveProjectRootDbPath } from "./bootstrap/dynamic-tools.js";
 import { validateDirectory } from "./validate-directory.js";
 import { isCustomProvider, resolveDefaultSessionModel, resolveDynamicRoutingConfig, } from "./preferences-models.js";
 import { getSessionModelOverride } from "./session-model-override.js";
+import { setAutoActiveStatus } from "./auto-dashboard.js";
 export function resolveIsolationNoneBranchCheckout(currentBranch, integrationBranch, isolationMode, isRepo) {
     if (!isRepo || isolationMode !== "none")
         return null;
@@ -164,6 +165,19 @@ export function resolveSurvivorRecoveryIsolationMode(isolationMode, phase) {
 function isBlockingStrandedWorkAction(action) {
     return action.kind === "in-progress-stranded-work" && action.blocksAuto;
 }
+function strandedWorkEvidence(args) {
+    const evidence = [];
+    if (args.branch && args.commitsAhead > 0) {
+        evidence.push(`branch ${args.branch} has ${args.commitsAhead} commit(s) ahead of ${args.mainBranch}`);
+    }
+    if (args.dirtyWorktree) {
+        evidence.push("the worktree has uncommitted changes");
+    }
+    if (evidence.length === 0) {
+        evidence.push("physical git evidence exists");
+    }
+    return evidence;
+}
 function detectWorktreeEvidence(basePath, milestoneId, hasChanges) {
     const wtDir = getWorktreeDir(basePath, milestoneId);
     const wtPath = getAutoWorktreePath(basePath, milestoneId);
@@ -183,16 +197,7 @@ function detectWorktreeEvidence(basePath, milestoneId, hasChanges) {
     };
 }
 function strandedWorkMessage(args) {
-    const evidence = [];
-    if (args.branch && args.commitsAhead > 0) {
-        evidence.push(`branch ${args.branch} has ${args.commitsAhead} commit(s) ahead of ${args.mainBranch}`);
-    }
-    if (args.dirtyWorktree) {
-        evidence.push("the worktree has uncommitted changes");
-    }
-    if (evidence.length === 0) {
-        evidence.push("physical git evidence exists");
-    }
+    const evidence = strandedWorkEvidence(args);
     const wtSuffix = args.worktreeDirExists
         ? ` Worktree directory at .gsd/worktrees/${args.milestoneId}/ holds live work.`
         : "";
@@ -203,6 +208,23 @@ function strandedWorkMessage(args) {
         wtSuffix +
         ` ${recovery} Park or discard explicitly if abandoning.`);
 }
+function formatStrandedWorkRecoveryMessage(action) {
+    const recoveryMode = action.recoveryMode === "worktree"
+        ? "existing worktree"
+        : "milestone branch";
+    const evidence = strandedWorkEvidence({
+        branch: action.branch,
+        commitsAhead: action.commitsAhead ?? 0,
+        mainBranch: action.mainBranch ?? "main",
+        dirtyWorktree: action.dirtyWorktree ?? false,
+    });
+    const wtSuffix = action.worktreeDirExists
+        ? ` Worktree directory at .gsd/worktrees/${action.milestoneId}/ holds live work.`
+        : "";
+    return (`Resuming saved milestone work for ${action.milestoneId}: ${evidence.join("; ")}.` +
+        wtSuffix +
+        ` Adopting the ${recoveryMode} before dispatching new units. Park or discard explicitly if abandoning.`);
+}
 function formatStrandedWorkBlockerMessage(action, activeMilestoneId) {
     const target = action.milestoneId;
     const mode = action.recoveryMode === "worktree" ? "existing worktree" : "milestone branch";
@@ -307,6 +329,7 @@ export function auditOrphanedMilestoneBranches(basePath, _isolationMode, gitDeps
                 kind: "in-progress-stranded-work",
                 milestoneId,
                 branch,
+                mainBranch,
                 commitsAhead,
                 dirtyWorktree: worktreeEvidence.dirty,
                 worktreeDirExists: worktreeEvidence.dirExists,
@@ -462,6 +485,7 @@ export function auditOrphanedMilestoneBranches(basePath, _isolationMode, gitDeps
             pushAction({
                 kind: "in-progress-stranded-work",
                 milestoneId: m.id,
+                mainBranch,
                 commitsAhead: 0,
                 dirtyWorktree: true,
                 worktreeDirExists: worktreeEvidence.dirExists,
@@ -890,7 +914,12 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
             for (const msg of auditResult.recovered) {
                 ctx.ui.notify(`Orphan audit: ${msg}`, "info");
             }
+            const deferredStrandedMessages = new Set(auditResult.actions
+                .filter(isBlockingStrandedWorkAction)
+                .map((action) => action.message));
             for (const msg of auditResult.warnings) {
+                if (deferredStrandedMessages.has(msg))
+                    continue;
                 const prefix = msg.startsWith("Stranded work") ? "" : "Orphan audit: ";
                 ctx.ui.notify(`${prefix}${msg}`, "warning");
             }
@@ -958,7 +987,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
                 return releaseLockAndReturn();
             }
             strandedRecoveryAction = blockingStrandedRecoveryAction;
-            ctx.ui.notify(`Recovering stranded work for ${strandedRecoveryAction.milestoneId} before dispatching new units.`, "info");
+            ctx.ui.notify(formatStrandedWorkRecoveryMessage(strandedRecoveryAction), "info");
         }
         if (process.env.GSD_HEADLESS === "1" &&
             orphanAuditRecovered &&
@@ -1343,7 +1372,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         if (resolveSkillDiscoveryMode(base) !== "off") {
             snapshotSkills();
         }
-        ctx.ui.setStatus("gsd-auto", s.stepMode ? "next" : "auto");
+        setAutoActiveStatus(ctx, s.stepMode ? "next" : "auto");
         ctx.ui.setWidget("gsd-health", undefined);
         const modeLabel = s.stepMode ? "Step-mode" : "Auto-mode";
         const pendingCount = (state.registry ?? []).filter((m) => m.status !== "complete" && m.status !== "parked").length;

package/dist/resources/extensions/gsd/auto-unit-tool-scope.js

@@ -1,4 +1,5 @@
 import { parseUnitId } from "./unit-id.js";
+import { RUN_UAT_WORKFLOW_TOOL_NAMES } from "./tool-presentation-plan.js";
 export const RUN_UAT_BROWSER_TOOL_NAMES = [
     "browser_navigate",
     "browser_click",
@@ -42,7 +43,7 @@ export const AUTO_UNIT_SCOPED_TOOLS = {
     "execute-task": ["gsd_task_complete", "gsd_decision_save"],
     "execute-task-simple": ["gsd_task_complete", "gsd_decision_save"],
     "reactive-execute": ["gsd_task_complete", "gsd_decision_save"],
-    "run-uat": ["gsd_summary_save", ...RUN_UAT_BROWSER_TOOL_NAMES],
+    "run-uat": [...RUN_UAT_WORKFLOW_TOOL_NAMES, "subagent", ...RUN_UAT_BROWSER_TOOL_NAMES],
     "gate-evaluate": ["gsd_save_gate_result"],
     "rewrite-docs": ["gsd_summary_save", "gsd_decision_save"],
     "workflow-preferences": ["gsd_summary_save"],

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

@@ -64,7 +64,7 @@ import { initRegistry, convertDispatchRules } from "./rule-registry.js";
 import { emitJournalEvent as _emitJournalEvent } from "./journal.js";
 import { isClosedStatus } from "./status-guards.js";
 import { MILESTONE_ID_RE } from "./milestone-ids.js";
-import { updateProgressWidget as _updateProgressWidget, setCompletionProgressWidget, setAutoOutcomeWidget, updateSliceProgressCache, clearSliceProgressCache, unitVerb, } from "./auto-dashboard.js";
+import { updateProgressWidget as _updateProgressWidget, setCompletionProgressWidget, setAutoOutcomeWidget, setAutoActiveStatus, updateSliceProgressCache, clearSliceProgressCache, unitVerb, } from "./auto-dashboard.js";
 import { registerSigtermHandler as _registerSigtermHandler, deregisterSigtermHandler as _deregisterSigtermHandler, } from "./auto-supervisor.js";
 import { isDbAvailable, getMilestone, getMilestoneSlices, getSlice, getTask, refreshOpenDatabaseFromDisk, } from "./gsd-db.js";
 import { markLatestActiveForWorkerCanceled } from "./db/unit-dispatches.js";
@@ -1774,10 +1774,17 @@ export function createWiredAutoOrchestrationModule(ctx, pi, dispatchBasePath, ru
             async reconcileBeforeDispatch() {
                 const activeBasePath = getLiveDispatchBasePath();
                 const result = await reconcileBeforeDispatch(activeBasePath);
-                if (result.blockers.length > 0) {
+                // Failure-path summaries written by gsd_summary_save create
+                // artifact-db-status-divergence blockers for tasks that are still
+                // pending (gsd_task_complete never ran). These tasks can still be
+                // dispatched and the drift self-heals once they complete successfully.
+                const hardBlockers = result.blockers.filter((b) => !b.includes("has SUMMARY artifact while DB status is") &&
+                    !b.includes("has SUMMARY on disk while DB status is") &&
+                    !b.includes("has task SUMMARY artifacts but no DB tasks"));
+                if (hardBlockers.length > 0) {
                     return {
                         ok: false,
-                        reason: result.blockers[0],
+                        reason: hardBlockers[0],
                         stateSnapshot: result.stateSnapshot,
                     };
                 }
@@ -2414,7 +2421,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         const loopDeps = buildLoopDeps(pi);
         ensureOrchestrationModule(ctx, pi, s.basePath || base);
         registerSigtermHandler(lockBase());
-        ctx.ui.setStatus("gsd-auto", s.stepMode ? "next" : "auto");
+        setAutoActiveStatus(ctx, s.stepMode ? "next" : "auto");
         ctx.ui.setWidget("gsd-health", undefined);
         ctx.ui.notify(s.stepMode ? "Step-mode resumed." : "Auto-mode resumed.", "info");
         restoreHookState(s.basePath);
@@ -2659,7 +2666,7 @@ export async function dispatchHookUnit(ctx, pi, hookName, triggerUnitType, trigg
         resetHookState();
         await pauseAuto(ctx, pi);
     }, hookHardTimeoutMs);
-    ctx.ui.setStatus("gsd-auto", s.stepMode ? "next" : "auto");
+    setAutoActiveStatus(ctx, s.stepMode ? "next" : "auto");
     ctx.ui.notify(`Running post-unit hook: ${hookName}`, "info");
     debugLog("dispatchHookUnit", {
         phase: "send-message",

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

@@ -396,6 +396,85 @@ export function registerDbTools(pi) {
     };
     pi.registerTool(summarySaveTool);
     registerAlias(pi, summarySaveTool, "gsd_save_summary", "gsd_summary_save");
+    // ─── gsd_uat_result_save ─────────────────────────────────────────────────
+    const uatResultSaveExecute = async (_toolCallId, params, _signal, _onUpdate, _ctx) => {
+        const { executeUatResultSave } = await loadWorkflowExecutors();
+        return executeUatResultSave(params, resolveWorkflowToolBasePath(_ctx, params));
+    };
+    const uatEvidenceRef = Type.Object({
+        kind: StringEnum(["gsd_uat_exec", "gsd_exec", "screenshot", "log", "url", "browser"], { description: "Evidence kind" }),
+        ref: Type.String({ description: "Evidence ID, approved .gsd path, or URL" }),
+        note: Type.Optional(Type.String({ description: "Short evidence note" })),
+    });
+    const uatCheck = Type.Object({
+        id: Type.String({ description: "Stable check ID from the UAT spec" }),
+        description: Type.String({ description: "Check description" }),
+        mode: StringEnum(["artifact", "runtime", "browser", "human-follow-up"], { description: "Evidence mode" }),
+        result: StringEnum(["PASS", "FAIL", "NEEDS-HUMAN"], { description: "Check result" }),
+        evidence: Type.Optional(Type.Array(uatEvidenceRef, { description: "Objective evidence references" })),
+        notes: Type.Optional(Type.String({ description: "Observed result, failure notes, or human instruction" })),
+        nonAutomatable: Type.Optional(Type.Boolean({ description: "True when the check is explicitly non-automatable" })),
+    });
+    const toolPresentationBlock = Type.Object({
+        surface: StringEnum(["provider-tools", "claude-code-sdk", "mcp", "hybrid"], { description: "Tool presentation surface" }),
+        model: Type.Optional(Type.Object({
+            provider: Type.Optional(Type.String()),
+            api: Type.Optional(Type.String()),
+            id: Type.Optional(Type.String()),
+        })),
+        presentedTools: Type.Array(Type.String(), { description: "Tool names actually presented to the model" }),
+        blockedTools: Type.Array(Type.Object({
+            name: Type.String(),
+            reason: Type.String(),
+        }), { description: "Tool names blocked from the model with reasons" }),
+        aliases: Type.Optional(Type.Array(Type.Object({
+            requested: Type.String(),
+            canonical: Type.String(),
+        }))),
+        fallbackToolsUsed: Type.Optional(Type.Array(Type.String())),
+        toolPresentationPlanId: Type.Optional(Type.String()),
+        notes: Type.Optional(Type.String()),
+    });
+    const uatResultSaveTool = {
+        name: "gsd_uat_result_save",
+        label: "Save UAT Result",
+        description: "Save a structured UAT result for a slice. Validates evidence, writes the ASSESSMENT artifact, " +
+            "records attempt history, and saves the aggregate UAT gate result.",
+        promptSnippet: "Save structured UAT checks, evidence, verdict, and tool-presentation proof",
+        promptGuidelines: [
+            "Call gsd_uat_result_save once after all UAT checks have been executed.",
+            "Every PASS or FAIL check must cite objective evidence, preferably a gsd_uat_exec evidence ID.",
+            "Include the presented and blocked tool set in presentation so tool timing is auditable.",
+            "Do not use raw gsd_summary_save as a substitute for UAT results.",
+        ],
+        parameters: Type.Object({
+            milestoneId: Type.String({ description: "Milestone ID (e.g. M001)" }),
+            sliceId: Type.String({ description: "Slice ID (e.g. S01)" }),
+            uatType: StringEnum(["artifact-driven", "browser-executable", "runtime-executable", "live-runtime", "mixed", "human-experience"], { description: "Declared UAT mode" }),
+            verdict: StringEnum(["PASS", "FAIL", "PARTIAL"], { description: "Overall UAT verdict" }),
+            checks: Type.Array(uatCheck, { description: "Structured check results" }),
+            presentation: toolPresentationBlock,
+            notes: Type.Optional(Type.String({ description: "Overall verdict rationale" })),
+            attempt: Type.Optional(Type.String({ description: "Attempt number or auto" })),
+            previousAttemptId: Type.Optional(Type.String({ description: "Prior attempt ID, when retrying" })),
+        }),
+        execute: uatResultSaveExecute,
+        renderCall(args, theme) {
+            let text = theme.fg("toolTitle", theme.bold("uat_result_save "));
+            text += theme.fg("accent", `${args.milestoneId ?? "?"}/${args.sliceId ?? "?"}`);
+            if (args.verdict)
+                text += theme.fg("dim", ` → ${args.verdict}`);
+            return new Text(text, 0, 0);
+        },
+        renderResult(result, _options, theme) {
+            const d = readDetails(result);
+            if (result.isError || d?.error) {
+                return new Text(theme.fg("error", formatToolErrorText(result, d)), 0, 0);
+            }
+            return new Text(theme.fg("success", `UAT ${d?.sliceId ?? ""}: ${d?.verdict ?? "saved"}`), 0, 0);
+        },
+    };
+    pi.registerTool(uatResultSaveTool);
     // ─── gsd_milestone_generate_id (formerly gsd_generate_milestone_id) ────
     const milestoneGenerateIdExecute = async (_toolCallId, _params, _signal, _onUpdate, _ctx) => {
         try {
@@ -709,7 +788,7 @@ export function registerDbTools(pi) {
                 recommendation: Type.String({ description: "Option id the executor recommends." }),
                 recommendationRationale: Type.String({ description: "Why the recommendation — 1–2 sentences." }),
                 continueWithDefault: Type.Boolean({
-                    description: "When true, loop continues (artifact logged for later review). When false, auto-mode pauses until the user resolves via /gsd escalate resolve.",
+                    description: "When true, the recommendation is recorded as the default, but auto-mode still pauses until the user resolves via /gsd escalate resolve.",
                 }),
             }, { description: "ADR-011 Phase 2: optional escalation payload. Only honored when phases.mid_execution_escalation is true." })),
             verificationEvidence: Type.Optional(Type.Array(Type.Object({
@@ -931,7 +1010,7 @@ export function registerDbTools(pi) {
         promptGuidelines: [
             "Use gsd_validate_milestone when all slices are done and the milestone needs validation before completion.",
             "Parameters: milestoneId, verdict, remediationRound, successCriteriaChecklist, sliceDeliveryAudit, crossSliceIntegration, requirementCoverage, verificationClasses (optional), verdictRationale, remediationPlan (optional).",
-            "If verification classes were planned, verificationClasses must include canonical class rows using the exact class names Contract, Integration, Operational, and UAT when present in planning.",
+            "If verification classes were planned, verificationClasses must be a complete canonical table with one row for every applicable planned class using the exact class names Contract, Integration, Operational, and UAT. Do not submit a partial table.",
             "Planned verification text marked as none/not required/not applicable/N/A (including suffixed variants such as 'not required - backend-only') is treated as not applicable and does not require a class row.",
             "If verdict is 'needs-remediation', also provide remediationPlan and use gsd_reassess_roadmap to add remediation slices to the roadmap.",
             "On success, returns validationPath where VALIDATION.md was written.",
@@ -944,7 +1023,7 @@ export function registerDbTools(pi) {
             sliceDeliveryAudit: Type.String({ description: "Markdown table auditing each slice's claimed vs delivered output" }),
             crossSliceIntegration: Type.String({ description: "Markdown describing any cross-slice boundary mismatches" }),
             requirementCoverage: Type.String({ description: "Markdown describing any unaddressed requirements" }),
-            verificationClasses: Type.Optional(Type.String({ description: "Markdown describing verification class compliance and gaps using canonical class names (Contract, Integration, Operational, UAT) for each applicable planned class" })),
+            verificationClasses: Type.Optional(Type.String({ description: "Complete markdown table describing verification class compliance and gaps; include one canonical row for every applicable planned class (Contract, Integration, Operational, UAT)" })),
             verdictRationale: Type.String({ description: "Why this verdict was chosen" }),
             remediationPlan: Type.Optional(Type.String({ description: "Remediation plan (required if verdict is needs-remediation)" })),
         }),

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

@@ -20,6 +20,49 @@ async function loadContextModePreferences(baseDir) {
     }
 }
 export function registerExecTools(pi) {
+    pi.registerTool({
+        name: "gsd_uat_exec",
+        label: "UAT Exec",
+        description: "Run a UAT-scoped bash/node/python check with milestone/slice/check metadata. " +
+            "Uses the same capped .gsd/exec evidence store as gsd_exec, but rejects commands that mutate dependencies, git state, credentials, or destructive files.",
+        promptSnippet: "Run one UAT check and save typed evidence under .gsd/exec",
+        promptGuidelines: [
+            "Use gsd_uat_exec for each automated UAT check.",
+            "Every PASS/FAIL check saved by gsd_uat_result_save must reference objective evidence from this tool or another approved GSD evidence path.",
+            "Do not install packages, mutate git state, edit source files, or dump credentials during UAT.",
+        ],
+        parameters: Type.Object({
+            milestoneId: Type.String({ description: "Milestone ID (e.g. M001)" }),
+            sliceId: Type.String({ description: "Slice ID (e.g. S01)" }),
+            checkId: Type.String({ description: "Stable check ID from the UAT spec (e.g. UAT-01)" }),
+            intent: Type.String({
+                description: "UAT command intent. Use one canonical value: uat-artifact-check, uat-runtime-check, " +
+                    "uat-browser-check, uat-service-start, or uat-log-inspection. Short aliases such as artifact, " +
+                    "runtime, browser, service-start, and log-inspection are accepted.",
+            }),
+            runtime: Type.Optional(Type.String({
+                description: "Optional interpreter. Defaults to bash. Supported: bash, node, python; sh/shell, js/nodejs, and py/python3 aliases are accepted.",
+            })),
+            script: Type.Optional(Type.String({ description: "Script body. Keep output small (log the finding, not the data)." })),
+            command: Type.Optional(Type.String({ description: "Alias for script; defaults to bash when runtime is omitted." })),
+            cmd: Type.Optional(Type.String({ description: "Short alias for script." })),
+            code: Type.Optional(Type.String({ description: "Alias for script, useful for node/python snippets." })),
+            expected: Type.Optional(Type.String({ description: "Expected outcome for this UAT check." })),
+            timeout_ms: Type.Optional(Type.Number({
+                description: "Per-invocation timeout (ms). Capped at 600000. Default from preferences.",
+                minimum: 1_000,
+                maximum: 600_000,
+            })),
+        }),
+        async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+            const { executeUatExec } = await import("../tools/exec-tool.js");
+            const baseDir = resolveCtxCwd(_ctx);
+            return executeUatExec(params, {
+                baseDir,
+                preferences: await loadContextModePreferences(baseDir),
+            });
+        },
+    });
     pi.registerTool({
         name: "gsd_exec",
         label: "Exec (Sandboxed)",

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

@@ -28,7 +28,9 @@ import { approvalGateIdForUnit, isExplicitApprovalResponse, shouldPauseForUserAp
 import { applyUnitSkillVisibility, unitHasSkillManifest } from "../skill-scope.js";
 import { getGuidedUnitContext } from "../guided-unit-context.js";
 import { registerPlanMilestoneSchemaRecovery } from "./plan-milestone-schema-recovery.js";
-import { AUTO_UNIT_SCOPED_TOOLS, isWorkflowAliasTool } from "../auto-unit-tool-scope.js";
+import { AUTO_UNIT_SCOPED_TOOLS, RUN_UAT_BROWSER_TOOL_NAMES, isWorkflowAliasTool } from "../auto-unit-tool-scope.js";
+import { filterToolsForProvider } from "../model-router.js";
+import { RUN_UAT_WORKFLOW_TOOL_NAMES } from "../tool-presentation-plan.js";
 let approvalQuestionAbortInFlight = false;
 async function loadWelcomeScreenModule() {
     const candidates = [];
@@ -104,6 +106,7 @@ export const MINIMAL_GSD_TOOL_NAMES = [
     "gsd_resume",
     "gsd_milestone_status",
     "gsd_checkpoint_db",
+    "gsd_plan_milestone",
     "memory_query",
     "capture_thought",
 ];
@@ -187,6 +190,9 @@ export function buildMinimalGsdToolSet(activeToolNames) {
     return withPreservedShimTools([...new Set([...preserved, ...minimal])]);
 }
 export function buildMinimalAutoGsdToolSet(activeToolNames, unitType, registeredToolNames = activeToolNames) {
+    if (unitType === "run-uat") {
+        return buildRunUatGsdToolSet(activeToolNames, registeredToolNames);
+    }
     const unitTools = unitType ? AUTO_UNIT_SCOPED_TOOLS[unitType] ?? [] : [];
     const autoBaseTools = new Set(MINIMAL_AUTO_BASE_TOOL_NAMES);
     const availableBaseTools = registeredToolNames.filter((name) => autoBaseTools.has(name));
@@ -197,6 +203,10 @@ export function buildMinimalAutoGsdToolSet(activeToolNames, unitType, registered
     const scoped = resolveScopedToolNames([...activeToolNames, ...registeredToolNames], [...MINIMAL_GSD_TOOL_NAMES, ...unitTools]);
     return withPreservedShimTools([...new Set([...preserved, ...scoped])]);
 }
+export function buildRunUatGsdToolSet(activeToolNames, registeredToolNames = activeToolNames) {
+    const scoped = resolveScopedToolNames([...activeToolNames, ...registeredToolNames], [...RUN_UAT_WORKFLOW_TOOL_NAMES, "subagent", ...RUN_UAT_BROWSER_TOOL_NAMES]);
+    return [...new Set(scoped)];
+}
 export function buildMinimalGsdWorkflowToolSet(activeToolNames, registeredToolNames = activeToolNames) {
     const autoBaseTools = new Set(MINIMAL_AUTO_BASE_TOOL_NAMES);
     const availableBaseTools = registeredToolNames.filter((name) => autoBaseTools.has(name));
@@ -836,10 +846,8 @@ export function registerHooks(pi, ecosystemHandlers) {
         if (result.block)
             return result;
     });
-    // ── Safety harness: evidence collection + destructive command warnings ──
+    // ── Safety harness: evidence collection + destructive command blocking ──
     pi.on("tool_call", async (event, ctx) => {
-        if (!isAutoActive())
-            return;
         markToolStart(event.toolCallId, event.toolName);
         safetyRecordToolCall(event.toolCallId, event.toolName, event.input);
         // Persist immediately at dispatch so a mid-unit re-dispatch — which calls
@@ -854,14 +862,23 @@ export function registerHooks(pi, ecosystemHandlers) {
                 saveEvidenceToDisk(callDash.basePath, cMid, cSid, cTid);
             }
         }
-        // Destructive command classification (warn only, never block)
+        // Destructive command classification + hard gate in all modes.
         if (isToolCallEventType("bash", event)) {
             const classification = classifyCommand(event.input.command);
             if (classification.destructive) {
+                const reason = [
+                    "HARD BLOCK: destructive Bash command requires explicit human confirmation.",
+                    `Detected: ${classification.labels.join(", ")}`,
+                    "Run this via ask_user_questions, wait for the user's response,",
+                    "then issue the command only when confirmed in the current turn.",
+                ].join(" ");
                 safetyLogWarning("safety", `destructive command: ${classification.labels.join(", ")}`, {
                     command: String(event.input.command).slice(0, 200),
                 });
-                ctx.ui.notify(`Destructive command detected: ${classification.labels.join(", ")}`, "warning");
+                if (ctx) {
+                    await maybePauseAutoForApprovalGate(ctx, pi, isAutoActive(), "Depth confirmation is waiting for your answer — pausing auto-mode.");
+                }
+                return { block: true, reason };
             }
         }
     });
@@ -1123,21 +1140,25 @@ export function registerHooks(pi, ecosystemHandlers) {
         const fullToolsRequested = isFullGsdToolSurfaceRequested();
         const dropAliases = !fullToolsRequested;
         const dropBrowser = !fullToolsRequested && !isBrowserToolSurfaceRequested();
-        const providerCompatible = compatible.filter((name) => !(dropAliases && isWorkflowAliasTool(name)) && !(dropBrowser && isBrowserTool(name)));
+        const aliasFilteredCompatible = compatible.filter((name) => !(dropAliases && isWorkflowAliasTool(name)));
+        const providerCompatible = aliasFilteredCompatible.filter((name) => !(dropBrowser && isBrowserTool(name)));
         const surfaceReduced = providerCompatible.length !== compatible.length;
         if (fullToolsRequested) {
             return surfaceReduced ? { toolNames: providerCompatible } : undefined;
         }
         const registeredToolNames = resolveRegisteredToolNames(pi, event.activeToolNames);
+        const compatibleRegisteredToolNames = filterToolsForProvider(registeredToolNames, event.selectedModelApi, event.selectedModelProvider).compatible.filter((name) => !(dropAliases && isWorkflowAliasTool(name)));
         const guidedUnit = getGuidedUnitContext();
-        const requestScoped = buildRequestScopedGsdToolSet(providerCompatible, event.requestCustomMessages, registeredToolNames, guidedUnit?.unitType);
+        const requestScoped = buildRequestScopedGsdToolSet(guidedUnit?.unitType === "run-uat" ? aliasFilteredCompatible : providerCompatible, event.requestCustomMessages, guidedUnit?.unitType === "run-uat" ? compatibleRegisteredToolNames : registeredToolNames, guidedUnit?.unitType);
         if (requestScoped) {
             return { toolNames: requestScoped };
         }
         const dash = getAutoRuntimeSnapshot();
         if (dash.active && dash.currentUnit) {
             return {
-                toolNames: buildMinimalAutoGsdToolSet(providerCompatible, dash.currentUnit.type, resolveRegisteredToolNames(pi, event.activeToolNames)),
+                toolNames: buildMinimalAutoGsdToolSet(dash.currentUnit.type === "run-uat" ? aliasFilteredCompatible : providerCompatible, dash.currentUnit.type, dash.currentUnit.type === "run-uat"
+                    ? compatibleRegisteredToolNames
+                    : resolveRegisteredToolNames(pi, event.activeToolNames)),
             };
         }
         if (isGeneralGsdToolScopingRequested()) {

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

@@ -565,6 +565,7 @@ const PLANNING_SUBAGENT_TOOLS = new Set(["subagent", "task"]);
  * manifests still declare per-unit subsets via ToolsPolicy.allowedSubagents.
  */
 const PLANNING_DISPATCH_AGENT_REGISTRY = {
+    mnemo: { readOnlySpecialist: true },
     scout: { readOnlySpecialist: true },
     planner: { readOnlySpecialist: true },
     reviewer: { readOnlySpecialist: true },
@@ -574,7 +575,7 @@ const PLANNING_DISPATCH_AGENT_REGISTRY = {
 export const ALLOWED_PLANNING_DISPATCH_AGENTS = new Set(Object.entries(PLANNING_DISPATCH_AGENT_REGISTRY)
     .filter(([, metadata]) => metadata.readOnlySpecialist)
     .map(([agentId]) => agentId));
-let warnedMissingPlanningDispatchAgentClasses = false;
+let warnedMissingControlledDispatchAgentClasses = false;
 function isReadOnlySpecialist(agentId) {
     const metadata = PLANNING_DISPATCH_AGENT_REGISTRY[agentId];
     return metadata?.readOnlySpecialist === true;
@@ -582,12 +583,16 @@ function isReadOnlySpecialist(agentId) {
 function allowedPlanningDispatchAgentsList() {
     return [...ALLOWED_PLANNING_DISPATCH_AGENTS].join(", ");
 }
-function warnMissingPlanningDispatchAgentClasses(unitType, mode, toolName) {
-    if (warnedMissingPlanningDispatchAgentClasses)
+function allowsControlledSubagentDispatch(policy) {
+    return ((policy.mode === "planning-dispatch" || policy.mode === "verification") &&
+        Array.isArray(policy.allowedSubagents));
+}
+function warnMissingControlledDispatchAgentClasses(unitType, mode, toolName) {
+    if (warnedMissingControlledDispatchAgentClasses)
         return;
-    warnedMissingPlanningDispatchAgentClasses = true;
+    warnedMissingControlledDispatchAgentClasses = true;
     // TODO(#5060): Remove this migration shim once all subagent/task callers are verified to forward agent identities.
-    const message = `[write-gate] planning-dispatch: shouldBlockPlanningUnit called for tool "${toolName}" ` +
+    const message = `[write-gate] controlled-dispatch: shouldBlockPlanningUnit called for tool "${toolName}" ` +
         `on unit "${unitType}" without agentClasses - stale caller; blocking dispatch.`;
     console.warn(message);
     logWarning("intercept", message, {
@@ -653,8 +658,9 @@ function blockReason(unitType, mode, what) {
  *   - "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.
+ *                  → allows Bash for project verification commands, keeps
+ *                    writes restricted to .gsd/, and permits subagent dispatch
+ *                    only when the manifest declares allowedSubagents.
  *
  * `pathOrCommand` is the file path for write/edit-shaped tools and the
  * shell command for bash. Other tools ignore this argument.
@@ -695,7 +701,7 @@ export function shouldBlockPlanningUnit(toolName, pathOrCommand, basePath, unitT
     if (tool.startsWith("gsd_"))
         return { block: false };
     if (PLANNING_SUBAGENT_TOOLS.has(tool)) {
-        if (policy.mode === "planning-dispatch") {
+        if (allowsControlledSubagentDispatch(policy)) {
             const requested = (agentClasses ?? []).map(a => a.trim()).filter(Boolean);
             const dispatchContract = compileSubagentPermissionContract(policy);
             const allowedSubagents = dispatchContract.allowedSubagents;
@@ -704,7 +710,7 @@ export function shouldBlockPlanningUnit(toolName, pathOrCommand, basePath, unitT
             // agent identities yet. Block and warn so stale callers surface in telemetry
             // instead of silently bypassing the gate.
             if (agentClasses === undefined) {
-                warnMissingPlanningDispatchAgentClasses(unitType, policy.mode, tool);
+                warnMissingControlledDispatchAgentClasses(unitType, policy.mode, tool);
                 return {
                     block: true,
                     reason: blockReason(unitType, policy.mode, `subagent dispatch blocked: stale caller did not supply agent identities for "${tool}"; update extractSubagentAgentClasses to handle this input shape`),
@@ -720,7 +726,7 @@ export function shouldBlockPlanningUnit(toolName, pathOrCommand, basePath, unitT
             if (globallyDisallowed) {
                 return {
                     block: true,
-                    reason: blockReason(unitType, policy.mode, `subagent dispatch of "${globallyDisallowed}" not permitted; only read-only specialists (${allowedPlanningDispatchAgentsList()}) may be dispatched from planning-dispatch units`),
+                    reason: blockReason(unitType, policy.mode, `subagent dispatch of "${globallyDisallowed}" not permitted; only read-only specialists (${allowedPlanningDispatchAgentsList()}) may be dispatched from ${policy.mode} units`),
                 };
             }
             const disallowedByPolicy = requested.find(a => !allowed.has(a));

package/dist/resources/extensions/gsd/browser-evidence.js

@@ -1,17 +1,44 @@
 // Project/App: gsd-pi
 // File Purpose: Shared browser-observable UAT requirement and evidence detection.
-export const BROWSER_REQUIREMENT_RE = /\b(?:browser|file:\/\/|localhost|dom|localstorage|click(?:ing|ed)?|button|screenshot|snapshot|reload(?:ed)?|page refresh|user-visible|strikethrough|search box)\b/i;
+export const BROWSER_REQUIREMENT_RE = /\b(?:file:\/\/|localhost|playwright|chrome|screenshot|snapshot|browser_(?:assert|batch|find|verify|snapshot_refs))\b|\b(?:open|launch|navigate|load|visit|serve|start)\b.{0,80}\b(?:browser|page|localhost|file:\/\/)\b|\bbrowser\s+(?:check|session|test|uat|tool|automation|interaction|flow)\b/i;
 export const NO_BROWSER_EVIDENCE_RE = /\b(?:no|without|not|wasn'?t|isn'?t)\s+(?:automated\s+)?(?:live\s+)?browser(?:\s+(?:session|test|uat))?|\bno\s+automated\s+browser\b|\bnot\s+conducted\b/i;
 export const BROWSER_RUNTIME_RE = /\b(?:browser|playwright|chrome|camoufox|browser_(?:assert|batch|find|verify|snapshot_refs)|screenshot|snapshot|file:\/\/|localhost)\b/i;
 export const BROWSER_ACTION_RE = /\b(?:open(?:ed)?|navigate(?:d)?|click(?:ed)?|type(?:d)?|reload(?:ed)?|capture(?:d)?|screenshot|snapshot)\b/i;
 export const BROWSER_ASSERTION_RE = /\b(?:assert(?:ed|ion)?|observed|confirmed|verified|expected|visible|text|count|label|strikethrough|localstorage|screenshot|snapshot|passed)\b/i;
+const NON_REQUIREMENT_BROWSER_HEADING_RE = /^(?:not\s+proven|not\s+covered|out\s+of\s+scope|deferred|follow-?ups?|known\s+limitations|notes\s+for\s+tester)\b/i;
+const NON_REQUIREMENT_BROWSER_LINE_RE = /\b(?:deferred|not\s+proven|not\s+covered|out\s+of\s+scope|future\s+slice|follow-?up|no\s+(?:live\s+)?browser|without\s+(?:a\s+)?browser|not\s+(?:a\s+)?browser)\b/i;
 export function compactTextParts(parts) {
     return parts.flatMap((part) => Array.isArray(part) ? part : [part])
         .filter((part) => typeof part === "string" && part.trim().length > 0)
         .join("\n");
 }
 export function hasBrowserRequiredText(text) {
-    return BROWSER_REQUIREMENT_RE.test(text);
+    let inNonRequirementSection = false;
+    let nonRequirementDepth = 0;
+    for (const line of text.split(/\r?\n/)) {
+        const headingMatch = line.match(/^(#{1,6})\s+(.+?)\s*$/);
+        if (headingMatch) {
+            const depth = headingMatch[1].length;
+            const title = headingMatch[2] ?? "";
+            // Only update section context when at the same or higher level than the
+            // heading that opened the non-requirement zone. A sub-heading deeper than
+            // the opening heading must not escape or re-enter the zone on its own.
+            if (!inNonRequirementSection || depth <= nonRequirementDepth) {
+                inNonRequirementSection = NON_REQUIREMENT_BROWSER_HEADING_RE.test(title);
+                nonRequirementDepth = inNonRequirementSection ? depth : 0;
+            }
+            // Check the heading title itself — section state is already updated, so
+            // we correctly skip headings that opened a non-requirement zone.
+            if (!inNonRequirementSection && BROWSER_REQUIREMENT_RE.test(title))
+                return true;
+            continue;
+        }
+        if (inNonRequirementSection || NON_REQUIREMENT_BROWSER_LINE_RE.test(line))
+            continue;
+        if (BROWSER_REQUIREMENT_RE.test(line))
+            return true;
+    }
+    return false;
 }
 export function hasBrowserEvidenceText(text) {
     if (!text.trim())

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

@@ -69,7 +69,7 @@ export function showHelp(ctx, args = "") {
         "  /gsd new-milestone  Create milestone from headless context (used by gsd headless)",
         "  /gsd new-project    Bootstrap a new project (use --deep for staged project-level discovery)",
         "  /gsd quick          Execute a quick task without full planning overhead",
-        "  /gsd dispatch       Dispatch a specific phase directly  [research|plan|execute|complete|uat|replan]",
+        "  /gsd dispatch       Dispatch a specific phase directly  [research|plan|execute|complete|validate|reassess|uat|replan]",
         "  /gsd verdict <v>    Override milestone validation verdict  [pass|needs-attention|needs-remediation] [--milestone Mxxx] [--rationale \"...\"]",
         "  /gsd parallel       Parallel milestone orchestration  [start|status|stop|pause|resume|merge|watch]",
         "  /gsd workflow       Custom workflow lifecycle  [new|run|list|validate|pause|resume]",

package/dist/resources/extensions/gsd/commands-prefs-wizard.js

@@ -11,6 +11,8 @@ import { fileURLToPath } from "node:url";
 import { getGlobalGSDPreferencesPath, getLegacyGlobalGSDPreferencesPath, getProjectGSDPreferencesPath, loadGlobalGSDPreferences, loadProjectGSDPreferences, loadEffectiveGSDPreferences, normalizePreferencesShape, resolveAllSkillReferences, } from "./preferences.js";
 import { loadFile, saveFile, splitFrontmatter, parseFrontmatterMap } from "./files.js";
 import { runClaudeImportFlow } from "./claude-import.js";
+const DEFAULT_WIDGET_MODE = "small";
+const WIDGET_MODE_OPTIONS = [DEFAULT_WIDGET_MODE, "full", "min", "off"];
 /** Extract body content after frontmatter closing delimiter, or null if none. */
 function extractBodyAfterFrontmatter(content) {
     const closingIdx = content.indexOf("\n---", content.indexOf("---"));
@@ -1509,7 +1511,7 @@ async function configureAdvanced(ctx, prefs) {
     else if (minRequestInterval !== undefined) {
         prefs.min_request_interval_ms = minRequestInterval;
     }
-    const widget = await promptEnum(ctx, "Auto-mode widget display", prefs.widget_mode, ["full", "small", "min", "off"], "full");
+    const widget = await promptEnum(ctx, "Auto-mode widget display", prefs.widget_mode, WIDGET_MODE_OPTIONS, DEFAULT_WIDGET_MODE);
     if (widget !== undefined)
         prefs.widget_mode = widget;
     const experimental = prefs.experimental ?? {};

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

@@ -166,6 +166,6 @@ export async function handleVerdict(rawArgs, ctx, basePath) {
         ctx.ui.notify(`Milestone ${milestoneId} verdict: ${prevVerdict} -> ${effectiveVerdict} (${existingValidation.source})`, "success");
     }
     if (effectiveVerdict === "needs-remediation") {
-        ctx.ui.notify("Follow up with gsd_reassess_roadmap to add remediation slices, then re-run /gsd auto.", "info");
+        ctx.ui.notify("Follow up with /gsd dispatch reassess to add remediation slices, then re-run /gsd auto.", "info");
     }
 }

package/dist/resources/extensions/gsd/config-overlay.js

@@ -9,6 +9,7 @@
 import { matchesKey, Key, truncateToWidth } from "@gsd/pi-tui";
 import { renderDialogFrame, renderKeyHints } from "./tui/render-kit.js";
 import { loadEffectiveGSDPreferences, loadGlobalGSDPreferences, loadProjectGSDPreferences, getGlobalGSDPreferencesPath, getProjectGSDPreferencesPath, resolveDynamicRoutingConfig, resolveEffectiveProfile, resolveModelWithFallbacksForUnit, resolveAutoSupervisorConfig, } from "./preferences.js";
+const DEFAULT_WIDGET_MODE = "small";
 function collectConfigSections() {
     const sections = [];
     const globalPrefs = loadGlobalGSDPreferences();
@@ -157,7 +158,7 @@ function collectConfigSections() {
         toggleRows.push({ label: "search_provider", value: prefs.search_provider });
     if (prefs?.context_selection)
         toggleRows.push({ label: "context_selection", value: prefs.context_selection });
-    if (prefs?.widget_mode && prefs.widget_mode !== "full")
+    if (prefs?.widget_mode && prefs.widget_mode !== DEFAULT_WIDGET_MODE)
         toggleRows.push({ label: "widget_mode", value: prefs.widget_mode });
     if (prefs?.experimental?.rtk)
         toggleRows.push({ label: "experimental.rtk", value: "on" });