@opengsd/gsd-pi 1.1.1-dev.3ea310e → 1.1.1-dev.74e8dd1

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

@@ -1 +1 @@
-3a34fcd8ba090855
+5f6f7839b5420a75

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

@@ -51,13 +51,13 @@ import { resolveManifest } from "../unit-context-manifest.js";
 import { createWorktreeSafetyModule } from "../worktree-safety.js";
 import { isSuspiciousGhostCompletion } from "../auto-unit-closeout.js";
 import { decideVerificationRetry, verificationRetryKey } from "./verification-retry-policy.js";
-import { buildPhaseHandoffOutcome, setAutoOutcomeWidget } from "../auto-dashboard.js";
+import { buildPhaseHandoffOutcome, setAutoActiveStatus, setAutoOutcomeWidget } from "../auto-dashboard.js";
 import { getConsecutiveDispatchBlocker } from "../dispatch-guard.js";
 import { captureRootDirtySnapshot, detectRootWriteLeak, formatRootWriteLeakMessage, } from "../root-write-leak-guard.js";
 import { classifyError, isTransient } from "../error-classifier.js";
 export const STUCK_WINDOW_SIZE = 6;
 const STUCK_RECOVERY_ATTEMPTS_KEY = "stuck_recovery_attempts";
-const ZERO_TOOL_PROVIDER_ERROR_PREFIX_RE = /^(?:api error(?::|$|\s*\()|provider error(?::|$|\s*\()|request failed\b|(?:http\s*)?(?:429|500|502|503)\b|\b(?:econnreset|etimedout|econnrefused|epipe)\b|socket hang up\b|fetch failed\b|(?:network|connection|server) error(?::|$)|connection (?:reset|refused)(?::|$|\s+by\b)|dns\b.*(?:fail|error|timeout)|unexpected eof\b|stream idle timeout\b|partial response received\b|stream_exhausted\b|terminated(?::|$)|(?:connection|stream|request)\b.{0,40}\bterminated\b|other side closed\b|rate.?limit(?:ed| exceeded| reached| error)|too many requests\b|you(?:'ve| have) hit your limit\b|usage limit\b|out of extra usage\b|service.?unavailable\b|internal(?: server)? error(?::|$)|internal(?:[_-]server)?[_-]error\b|server[_-]error\b|(?:provider|server|api|model|codex|claude|openai|anthropic|gemini)\b.{0,80}\boverloaded\b|overloaded\b.{0,80}\b(?:provider|server|api|model)\b|context (?:window|length) exceed|context window exceed)/i;
+const ZERO_TOOL_PROVIDER_ERROR_PREFIX_RE = /^(?:api error(?::|$|\s*\()|provider error(?::|$|\s*\()|request failed\b|(?:http\s*)?(?:429|500|502|503)\b|\b(?:econnreset|etimedout|econnrefused|epipe)\b|socket hang up\b|fetch failed\b|(?:network|connection|server) error(?::|$)|connection (?:reset|refused)(?::|$|\s+by\b)|dns\b.*(?:fail|error|timeout)|unexpected eof\b|stream idle timeout\b|partial response received\b|stream_exhausted\b|terminated(?::|$)|(?:connection|stream|request)\b.{0,40}\bterminated\b|other side closed\b|rate.?limit(?:ed| exceeded| reached| error)|too many requests\b|you(?:'ve| have) (?:hit|reached) your (?:\w+ )?limit\b|.*\b(?:usage|session|weekly|daily|monthly|quota) limit\b|limit\b.{0,40}\bresets?\b|out of extra usage\b|service.?unavailable\b|internal(?: server)? error(?::|$)|internal(?:[_-]server)?[_-]error\b|server[_-]error\b|(?:provider|server|api|model|codex|claude|openai|anthropic|gemini)\b.{0,80}\boverloaded\b|overloaded\b.{0,80}\b(?:provider|server|api|model)\b|context (?:window|length) exceed|context window exceed)/i;
 const ZERO_TOOL_PROVIDER_ERROR_SIGNAL_RE = /(?:\b(?:http|status(?: code)?|code|error:)\s*(?:429|500|502|503)\b|\b(?:api|provider) error\s*[:(]?\s*(?:429|500|502|503)\b|\b(?:typeerror|error):\s*(?:fetch failed\b|socket hang up\b|terminated(?::|$)|connection (?:reset|refused)(?::|$|\s+by\b)|(?:network|connection|server) error(?::|$)|stream idle timeout\b|partial response received\b|unexpected eof\b)|\b(?:server_error|api_error|stream_exhausted(?:_without_result)?)\b|\b(?:econnreset|etimedout|econnrefused|epipe)\b|context (?:window|length) exceed|context window exceed)/i;
 function classifyZeroToolProviderMessage(message) {
     const firstLine = message.trim().split(/\r?\n/, 1)[0]?.trim() ?? "";
@@ -67,6 +67,7 @@ function classifyZeroToolProviderMessage(message) {
         return null;
     return classifyError(firstLine);
 }
+export const _classifyZeroToolProviderMessageForTest = classifyZeroToolProviderMessage;
 export function resolveDispatchRecoveryAttempts(unitRecoveryCount, unitType, unitId) {
     return (unitRecoveryCount.get(`${unitType}/${unitId}`) ?? 0) > 0
         ? 0
@@ -1582,7 +1583,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
     const dispatchKey = `${unitType}/${unitId}`;
     const nextDispatchCount = (s.unitDispatchCount.get(dispatchKey) ?? 0) + 1;
     // Status bar (widget + preconditions deferred until after model selection — see #2899)
-    ctx.ui.setStatus("gsd-auto", s.stepMode ? "next" : "auto");
+    setAutoActiveStatus(ctx, s.stepMode ? "next" : "auto");
     if (mid)
         deps.updateSliceProgressCache(s.basePath, mid, state.activeSlice?.id);
     // ── Safety harness: reset evidence + create checkpoint ──

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

@@ -369,8 +369,9 @@ export const hideFooter = (_tui, theme, footerData) => ({
     invalidate() { },
     dispose() { },
 });
+export const DEFAULT_WIDGET_MODE = "small";
 const WIDGET_MODES = ["full", "small", "min", "off"];
-let widgetMode = "full";
+let widgetMode = DEFAULT_WIDGET_MODE;
 let widgetModeInitialized = false;
 let widgetModePreferencePath = null;
 function safeReadTextFile(path) {
@@ -473,10 +474,19 @@ export function getWidgetMode(projectPath, globalPath) {
 }
 /** Test-only reset for widget mode caching. */
 export function _resetWidgetModeForTests() {
-    widgetMode = "full";
+    widgetMode = DEFAULT_WIDGET_MODE;
     widgetModeInitialized = false;
     widgetModePreferencePath = null;
 }
+function clearAutoOutcomeWidget(ctx) {
+    if (!ctx.hasUI)
+        return;
+    ctx.ui.setWidget("gsd-outcome", undefined);
+}
+export function setAutoActiveStatus(ctx, status) {
+    ctx.ui.setStatus("gsd-auto", status);
+    clearAutoOutcomeWidget(ctx);
+}
 export function updateProgressWidget(ctx, unitType, unitId, state, accessors, tierBadge) {
     if (!ctx.hasUI)
         return;
@@ -495,7 +505,7 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
         ctx.ui.setStatus("gsd-step", undefined);
     }
     if (!accessors.isSessionSwitching()) {
-        ctx.ui.setWidget("gsd-outcome", undefined);
+        clearAutoOutcomeWidget(ctx);
     }
     const verb = unitVerb(unitType);
     const phaseLabel = unitPhaseLabel(unitType);
@@ -548,6 +558,7 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
                 logWarning("dashboard", `DB status update failed: ${err instanceof Error ? err.message : String(err)}`);
             }
         }, 15_000);
+        progressRefreshTimer.unref?.();
         return {
             render(width) {
                 if (cachedLines && cachedWidth === width)
@@ -789,7 +800,7 @@ export function setCompletionProgressWidget(ctx, snapshot) {
     if (!ctx.hasUI)
         return;
     const widgetKey = "gsd-progress";
-    ctx.ui.setWidget("gsd-outcome", undefined);
+    clearAutoOutcomeWidget(ctx);
     if (typeof ctx.ui?.setHeader === "function") {
         ctx.ui.setHeader(() => ({
             render() { return []; },

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

@@ -323,6 +323,41 @@ function stripKnownIdPrefix(value, id) {
         return raw.slice(id.length + 1).trim() || undefined;
     return raw;
 }
+function parseReactiveBatchTaskIds(unitId) {
+    const { task: batchPart } = parseUnitId(unitId);
+    if (!batchPart?.startsWith("reactive+"))
+        return [];
+    const rawIds = batchPart
+        .slice("reactive+".length)
+        .split(",")
+        .map((taskId) => taskId.trim().toUpperCase())
+        .filter(Boolean);
+    const unique = new Set();
+    for (const taskId of rawIds) {
+        unique.add(taskId);
+    }
+    return [...unique];
+}
+function dedupePaths(values) {
+    const seen = new Set();
+    const result = [];
+    for (const value of values) {
+        if (!seen.has(value)) {
+            seen.add(value);
+            result.push(value);
+        }
+    }
+    return result;
+}
+function getPlannedKeyFiles(tasks) {
+    return dedupePaths(tasks.flatMap((taskRow) => [
+        ...(taskRow.expected_output ?? []),
+        ...(taskRow.files ?? []),
+        ...(taskRow.key_files ?? []),
+    ]));
+}
+export const _parseReactiveBatchTaskIdsForTest = parseReactiveBatchTaskIds;
+export const _getPlannedKeyFilesForTest = getPlannedKeyFiles;
 function resolveVerificationFailureMarkerPath(unitType, unitId, basePath) {
     const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
     switch (unitType) {
@@ -402,6 +437,34 @@ async function buildTaskCommitContextForUnit(basePath, unitId) {
         issueNumber: ghIssueNumber,
     };
 }
+async function buildReactiveTaskCommitContext(_basePath, unitId) {
+    const { milestone: mid, slice: sid } = parseUnitId(unitId);
+    if (!mid || !sid || !isDbAvailable())
+        return undefined;
+    const batchTaskIds = parseReactiveBatchTaskIds(unitId);
+    if (batchTaskIds.length === 0)
+        return undefined;
+    const milestone = getMilestone(mid);
+    const slice = getSlice(mid, sid);
+    const taskRows = batchTaskIds
+        .map((tid) => getTask(mid, sid, tid))
+        .filter((taskRow) => taskRow !== null);
+    const keyFiles = getPlannedKeyFiles(taskRows);
+    if (taskRows.length === 0 || keyFiles.length === 0)
+        return undefined;
+    const taskLabel = taskRows.map((row) => row.id).join(",");
+    return {
+        taskId: `${sid}/${taskLabel}`,
+        taskDisplayId: "reactive-batch",
+        taskTitle: `Reactive batch: ${taskLabel}`,
+        milestoneId: mid,
+        milestoneTitle: stripKnownIdPrefix(milestone?.title, mid),
+        sliceId: sid,
+        sliceTitle: stripKnownIdPrefix(slice?.title, sid),
+        oneLiner: `Reactive execute for ${taskLabel}`,
+        keyFiles,
+    };
+}
 async function runPostUnitGitHubSyncIfNeeded(basePath, unit) {
     if (unit.type === "complete-milestone")
         return;
@@ -761,6 +824,9 @@ export async function autoCommitUnit(basePath, unitType, unitId, ctx) {
         if (unitType === "execute-task") {
             taskContext = await buildTaskCommitContextForUnit(basePath, unitId);
         }
+        else if (unitType === "reactive-execute") {
+            taskContext = await buildReactiveTaskCommitContext(basePath, unitId);
+        }
         _resetHasChangesCache();
         if (LIFECYCLE_ONLY_UNITS.has(unitType)) {
             return null;
@@ -812,6 +878,22 @@ async function runCloseoutGitAction(pctx, unit, opts) {
                 targetRepositories = getTask(mid, sid, tid)?.target_repositories;
             }
         }
+        else if (turnAction === "commit" && unit.type === "reactive-execute") {
+            taskContext = await buildReactiveTaskCommitContext(s.basePath, unit.id);
+            const { milestone: mid, slice: sid } = parseUnitId(unit.id);
+            if (mid && sid && isDbAvailable()) {
+                const repositories = new Set();
+                for (const tid of parseReactiveBatchTaskIds(unit.id)) {
+                    const taskRow = getTask(mid, sid, tid);
+                    for (const repoId of taskRow?.target_repositories ?? []) {
+                        repositories.add(repoId);
+                    }
+                }
+                if (repositories.size > 0) {
+                    targetRepositories = [...repositories];
+                }
+            }
+        }
         // Invalidate the nativeHasChanges cache before auto-commit (#1853).
         // The cache has a 10-second TTL and is keyed by basePath. A stale
         // `false` result causes autoCommit to skip staging entirely.
@@ -1206,12 +1288,19 @@ export async function postUnitPreVerification(pctx, opts) {
             if (safetyConfig.enabled) {
                 const { milestone: sMid, slice: sSid, task: sTid } = parseUnitId(s.currentUnit.id);
                 // File change validation (execute-task only, after unit execution)
-                if (safetyConfig.file_change_validation && s.currentUnit.type === "execute-task" && sMid && sSid && sTid && isDbAvailable()) {
+                if (safetyConfig.file_change_validation && s.currentUnit.type === "execute-task" && sMid && sSid && sTid) {
                     try {
-                        const taskRow = getTask(sMid, sSid, sTid);
-                        if (taskRow) {
-                            const expectedOutput = taskRow.expected_output ?? [];
-                            const plannedFiles = taskRow.files ?? [];
+                        const sliceTaskRows = isDbAvailable()
+                            ? getSliceTasks(sMid, sSid).filter((t) => isClosedStatus(t.status) || t.id === sTid)
+                            : [];
+                        if (sliceTaskRows.length > 0) {
+                            const expectedOutput = getPlannedKeyFiles(sliceTaskRows.map((taskRow) => ({
+                                expected_output: taskRow.expected_output,
+                                files: taskRow.files,
+                            })));
+                            const plannedFiles = getPlannedKeyFiles(sliceTaskRows.map((taskRow) => ({
+                                files: taskRow.files,
+                            })));
                             const audit = validateFileChanges(s.basePath, expectedOutput, plannedFiles, safetyConfig.file_change_allowlist);
                             if (audit && audit.violations.length > 0) {
                                 const warnings = audit.violations.filter(v => v.severity === "warning");
@@ -1223,6 +1312,23 @@ export async function postUnitPreVerification(pctx, opts) {
                                 }
                             }
                         }
+                        else {
+                            const taskRow = getTask(sMid, sSid, sTid);
+                            if (taskRow) {
+                                const expectedOutput = taskRow.expected_output ?? [];
+                                const plannedFiles = taskRow.files ?? [];
+                                const audit = validateFileChanges(s.basePath, expectedOutput, plannedFiles, safetyConfig.file_change_allowlist);
+                                if (audit && audit.violations.length > 0) {
+                                    const warnings = audit.violations.filter(v => v.severity === "warning");
+                                    for (const v of warnings) {
+                                        logWarning("safety", `file-change: ${v.file} — ${v.reason}`);
+                                    }
+                                    if (warnings.length > 0) {
+                                        ctx.ui.notify(`Safety: ${warnings.length} unexpected file change(s) outside task plan`, "warning");
+                                    }
+                                }
+                            }
+                        }
                     }
                     catch (e) {
                         debugLog("postUnit", { phase: "safety-file-change", error: String(e) });

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

@@ -2351,6 +2351,15 @@ export async function buildCompleteSlicePrompt(mid, midTitle, sid, sTitle, base,
         sliceSummaryPath,
         sliceUatPath,
         gatesToClose,
+        skillActivation: buildSkillActivationBlock({
+            base,
+            milestoneId: mid,
+            milestoneTitle: midTitle,
+            sliceId: sid,
+            sliceTitle: sTitle,
+            extraContext: [inlinedContext],
+            unitType: "complete-slice",
+        }),
     });
 }
 export async function buildCompleteMilestonePrompt(mid, midTitle, base, level) {

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";
@@ -2414,7 +2414,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 +2659,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 {

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)",