@opengsd/gsd-pi 1.1.1-dev.616a1a1 → 1.1.1-dev.74e8dd1

package/src/resources/extensions/gsd/auto-post-unit.ts

@@ -394,6 +394,50 @@ function stripKnownIdPrefix(value: string | undefined | null, id: string): strin
   return raw;
 }
 
+function parseReactiveBatchTaskIds(unitId: string): string[] {
+  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<string>();
+  for (const taskId of rawIds) {
+    unique.add(taskId);
+  }
+  return [...unique];
+}
+
+function dedupePaths(values: string[]): string[] {
+  const seen = new Set<string>();
+  const result: string[] = [];
+  for (const value of values) {
+    if (!seen.has(value)) {
+      seen.add(value);
+      result.push(value);
+    }
+  }
+  return result;
+}
+
+function getPlannedKeyFiles(tasks: Array<
+  { expected_output?: string[]; files?: string[]; key_files?: string[] }
+>): string[] {
+  return dedupePaths(
+    tasks.flatMap((taskRow) => [
+      ...(taskRow.expected_output ?? []),
+      ...(taskRow.files ?? []),
+      ...(taskRow.key_files ?? []),
+    ]),
+  );
+}
+
+export const _parseReactiveBatchTaskIdsForTest = parseReactiveBatchTaskIds;
+export const _getPlannedKeyFilesForTest = getPlannedKeyFiles;
+
 function resolveVerificationFailureMarkerPath(
   unitType: string,
   unitId: string,
@@ -481,6 +525,40 @@ async function buildTaskCommitContextForUnit(
   };
 }
 
+async function buildReactiveTaskCommitContext(
+  _basePath: string,
+  unitId: string,
+): Promise<TaskCommitContext | undefined> {
+  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 is NonNullable<ReturnType<typeof getTask>> => 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: string,
   unit: NonNullable<AutoSession["currentUnit"]>,
@@ -943,6 +1021,8 @@ export async function autoCommitUnit(
 
     if (unitType === "execute-task") {
       taskContext = await buildTaskCommitContextForUnit(basePath, unitId);
+    } else if (unitType === "reactive-execute") {
+      taskContext = await buildReactiveTaskCommitContext(basePath, unitId);
     }
 
     _resetHasChangesCache();
@@ -1005,6 +1085,21 @@ async function runCloseoutGitAction(
       if (mid && sid && tid && isDbAvailable()) {
         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<string>();
+        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).
@@ -1436,12 +1531,24 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
         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");
@@ -1455,6 +1562,30 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
                   );
                 }
               }
+            } 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) });
@@ -2134,8 +2265,8 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
               await renderPlanCheckboxes(s.canonicalProjectRoot, mid, sid);
             } catch (dbErr) {
               // DB unavailable — fail explicitly rather than silently reverting to markdown mutation.
-              // Use 'gsd recover' to rebuild DB state from disk if needed.
-              logError("engine", `retry state-reset failed (DB unavailable): ${(dbErr as Error).message}. Run 'gsd recover' to reconcile.`);
+              // Use 'gsd recover --confirm' to import markdown into the DB if needed.
+              logError("engine", `retry state-reset failed (DB unavailable): ${(dbErr as Error).message}. Run 'gsd recover --confirm' to import markdown into the DB.`);
             }
           }
 

package/src/resources/extensions/gsd/auto-prompts.ts

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

package/src/resources/extensions/gsd/auto-recovery.ts

@@ -867,7 +867,7 @@ export function buildLoopRemediationSteps(
       return [
         `   1. Run \`gsd undo-task ${mid}/${sid}/${tid}\` to reset the task state`,
         `   2. Resume auto-mode — it will re-execute the task`,
-        `   3. If the task keeps failing, run \`gsd recover\` to rebuild DB state from disk`,
+        `   3. If the task keeps failing and markdown should repopulate the DB, run \`gsd recover --confirm\``,
       ].join("\n");
     }
     case "plan-slice":
@@ -879,7 +879,7 @@ export function buildLoopRemediationSteps(
           : relSliceFile(base, mid, sid, "RESEARCH");
       return [
         `   1. Write ${artifactRel} manually (or with the LLM in interactive mode)`,
-        `   2. Run \`gsd recover\` to rebuild DB state from disk`,
+        `   2. Run \`gsd recover --confirm\` to import the markdown into the DB`,
         `   3. Resume auto-mode`,
       ].join("\n");
     }
@@ -888,7 +888,7 @@ export function buildLoopRemediationSteps(
       return [
         `   1. Run \`gsd reset-slice ${mid}/${sid}\` to reset the slice and all its tasks`,
         `   2. Resume auto-mode — it will re-execute incomplete tasks and re-complete the slice`,
-        `   3. If the slice keeps failing, run \`gsd recover\` to rebuild DB state from disk`,
+        `   3. If the slice keeps failing and markdown should repopulate the DB, run \`gsd recover --confirm\``,
       ].join("\n");
     }
     case "validate-milestone": {
@@ -896,7 +896,7 @@ export function buildLoopRemediationSteps(
       const artifactRel = relMilestoneFile(base, mid, "VALIDATION");
       return [
         `   1. Write ${artifactRel} with verdict: pass`,
-        `   2. Run \`gsd recover\` to rebuild DB state from disk`,
+        `   2. Run \`gsd recover --confirm\` to import the markdown into the DB`,
         `   3. Resume auto-mode`,
       ].join("\n");
     }

package/src/resources/extensions/gsd/auto-start.ts

@@ -60,12 +60,13 @@ import { getAutoWorktreePath, isInAutoWorktree, checkoutBranchWithStashGuard } f
 import { readResourceVersion, cleanStaleRuntimeUnits } from "./auto-worktree.js";
 import { worktreePath as getWorktreeDir, isInsideWorktreesDir } from "./worktree-manager.js";
 import { emitWorktreeOrphaned } from "./worktree-telemetry.js";
+import { queryJournal } from "./journal.js";
 import { initMetrics } from "./metrics.js";
 import { initRoutingHistory } from "./routing-history.js";
 import { restoreHookState, resetHookState } from "./post-unit-hooks.js";
 import { resetProactiveHealing, setLevelChangeCallback } from "./doctor-proactive.js";
 import { snapshotSkills } from "./skill-discovery.js";
-import { isDbAvailable, getMilestone, getAllMilestones, insertMilestone, openDatabase, getDbStatus } from "./gsd-db.js";
+import { isDbAvailable, getMilestone, getAllMilestones, insertMilestone, openDatabase, getDbStatus, updateMilestoneStatus } from "./gsd-db.js";
 import { isClosedStatus } from "./status-guards.js";
 import { classifyMilestoneSummaryContent } from "./milestone-summary-classifier.js";
 import { extractVerdict } from "./verdict-parser.js";
@@ -100,6 +101,7 @@ import {
 } from "./preferences-models.js";
 import type { WorktreeLifecycle } from "./worktree-lifecycle.js";
 import { getSessionModelOverride } from "./session-model-override.js";
+import { setAutoActiveStatus } from "./auto-dashboard.js";
 
 export interface BootstrapDeps {
   shouldUseWorktreeIsolation: (basePath?: string) => boolean;
@@ -187,6 +189,40 @@ export function reconcileProjectMilestonesFromDisk(basePath: string): number {
   }
 }
 
+export function reconcileMergedMilestonesFromJournal(basePath: string): number {
+  if (!isDbAvailable()) return 0;
+
+  const mergedAtByMilestone = new Map<string, string>();
+  for (const entry of queryJournal(basePath, { eventType: "worktree-merged" })) {
+    const data = entry.data ?? {};
+    const milestoneId = typeof data.milestoneId === "string" ? data.milestoneId : null;
+    if (!milestoneId) continue;
+    if (data.conflict === true) continue;
+
+    const endedAt = typeof data.endedAt === "string" ? data.endedAt : entry.ts;
+    const previous = mergedAtByMilestone.get(milestoneId);
+    if (!previous || endedAt > previous) mergedAtByMilestone.set(milestoneId, endedAt);
+  }
+
+  let closed = 0;
+  for (const [milestoneId, completedAt] of mergedAtByMilestone) {
+    const existing = getMilestone(milestoneId);
+    if (!existing) {
+      insertMilestone({ id: milestoneId, title: milestoneId, status: "complete" });
+      updateMilestoneStatus(milestoneId, "complete", completedAt);
+      closed++;
+      continue;
+    }
+    if (!isClosedStatus(existing.status)) {
+      updateMilestoneStatus(milestoneId, "complete", completedAt);
+      closed++;
+    }
+  }
+
+  if (closed > 0) invalidateAllCaches();
+  return closed;
+}
+
 /**
  * Audit for orphaned milestone branches at bootstrap.
  *
@@ -258,6 +294,7 @@ export interface OrphanAuditAction {
   message: string;
   severity: "info" | "warning";
   branch?: string;
+  mainBranch?: string;
   commitsAhead?: number;
   dirtyWorktree?: boolean;
   worktreeDirExists?: boolean;
@@ -276,6 +313,27 @@ function isBlockingStrandedWorkAction(action: OrphanAuditAction): boolean {
   return action.kind === "in-progress-stranded-work" && action.blocksAuto;
 }
 
+function strandedWorkEvidence(args: {
+  branch?: string;
+  commitsAhead: number;
+  mainBranch: string;
+  dirtyWorktree: boolean;
+}): string[] {
+  const evidence: string[] = [];
+  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: string,
   milestoneId: string,
@@ -307,18 +365,7 @@ function strandedWorkMessage(args: {
   worktreeDirExists: boolean;
   recoveryMode: StrandedWorkRecoveryMode;
 }): string {
-  const evidence: string[] = [];
-  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.`
@@ -334,6 +381,45 @@ function strandedWorkMessage(args: {
   );
 }
 
+function formatStrandedWorkRecoveryMessage(action: OrphanAuditAction): string {
+  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: OrphanAuditAction,
+  activeMilestoneId: string | null,
+): string {
+  const target = action.milestoneId;
+  const mode = action.recoveryMode === "worktree" ? "existing worktree" : "milestone branch";
+  const intro = activeMilestoneId
+    ? `Stranded work for ${target} blocks auto-mode before ${activeMilestoneId}.`
+    : `Stranded work for ${target} blocks auto-mode, but that milestone is not active in project state.`;
+
+  return [
+    intro,
+    "Choose one explicit next step:",
+    `1. Recover it: run \`/gsd auto ${target}\` to adopt the ${mode}.`,
+    `2. Defer it: run \`/gsd park ${target} "reason"\`, then rerun \`/gsd auto\`.`,
+    `3. Abandon it: run \`/gsd rethink\` and explicitly discard ${target}.`,
+  ].join("\n");
+}
+
 export function auditOrphanedMilestoneBranches(
   basePath: string,
   _isolationMode: "worktree" | "branch" | "none",
@@ -435,6 +521,7 @@ export function auditOrphanedMilestoneBranches(
         kind: "in-progress-stranded-work",
         milestoneId,
         branch,
+        mainBranch,
         commitsAhead,
         dirtyWorktree: worktreeEvidence.dirty,
         worktreeDirExists: worktreeEvidence.dirExists,
@@ -589,6 +676,7 @@ export function auditOrphanedMilestoneBranches(
       pushAction({
         kind: "in-progress-stranded-work",
         milestoneId: m.id,
+        mainBranch,
         commitsAhead: 0,
         dirtyWorktree: true,
         worktreeDirExists: worktreeEvidence.dirExists,
@@ -1066,6 +1154,7 @@ export async function bootstrapAutoSession(
     await openProjectDbIfPresent(base);
     registerAutoWorkerForSession(base);
     reconcileProjectMilestonesFromDisk(base);
+    reconcileMergedMilestonesFromJournal(base);
 
     // Clean stale runtime unit files for completed milestones (#887).
     // DB-authoritative: when DB is available, require DB status to be closed
@@ -1103,7 +1192,13 @@ export async function bootstrapAutoSession(
       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");
       }
@@ -1177,21 +1272,21 @@ export async function bootstrapAutoSession(
     if (blockingStrandedRecoveryAction) {
       if (!state.activeMilestone) {
         ctx.ui.notify(
-          `Stranded work for ${blockingStrandedRecoveryAction.milestoneId} blocks auto-mode, but that milestone is not active in project state. Park or discard it explicitly before continuing.`,
+          formatStrandedWorkBlockerMessage(blockingStrandedRecoveryAction, null),
           "error",
         );
         return releaseLockAndReturn();
       }
       if (state.activeMilestone.id !== blockingStrandedRecoveryAction.milestoneId) {
         ctx.ui.notify(
-          `Stranded work for ${blockingStrandedRecoveryAction.milestoneId} blocks auto-mode before ${state.activeMilestone.id}. Recover, park, or discard ${blockingStrandedRecoveryAction.milestoneId} explicitly before continuing.`,
+          formatStrandedWorkBlockerMessage(blockingStrandedRecoveryAction, state.activeMilestone.id),
           "error",
         );
         return releaseLockAndReturn();
       }
       strandedRecoveryAction = blockingStrandedRecoveryAction;
       ctx.ui.notify(
-        `Recovering stranded work for ${strandedRecoveryAction.milestoneId} before dispatching new units.`,
+        formatStrandedWorkRecoveryMessage(strandedRecoveryAction),
         "info",
       );
     }
@@ -1663,7 +1758,7 @@ export async function bootstrapAutoSession(
       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(

package/src/resources/extensions/gsd/auto-unit-tool-scope.ts

@@ -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",
@@ -44,7 +45,7 @@ export const AUTO_UNIT_SCOPED_TOOLS: Record<string, readonly string[]> = {
   "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/src/resources/extensions/gsd/auto.ts

@@ -205,6 +205,7 @@ import {
   updateProgressWidget as _updateProgressWidget,
   setCompletionProgressWidget,
   setAutoOutcomeWidget,
+  setAutoActiveStatus,
   updateSliceProgressCache,
   clearSliceProgressCache,
   describeNextUnit as _describeNextUnit,
@@ -254,7 +255,12 @@ import {
   postUnitPreVerification,
   postUnitPostVerification,
 } from "./auto-post-unit.js";
-import { bootstrapAutoSession, openProjectDbIfPresent, type BootstrapDeps } from "./auto-start.js";
+import {
+  bootstrapAutoSession,
+  openProjectDbIfPresent,
+  reconcileMergedMilestonesFromJournal,
+  type BootstrapDeps,
+} from "./auto-start.js";
 import { initHealthWidget } from "./health-widget.js";
 import { runLegacyAutoLoop, runUokKernelLoop } from "./auto/loop.js";
 import { resolveAgentEnd, resolveAgentEndCancelled, _resetPendingResolve, isSessionSwitchInFlight } from "./auto/resolve.js";
@@ -2102,6 +2108,28 @@ export function createWiredDispatchAdapter(
     return null;
   }
 
+  function shouldAdoptActiveMilestone(
+    state: GSDState,
+    activeSession: AutoSession | undefined,
+    activeDispatchBasePath: string,
+  ): boolean {
+    const activeMilestoneId = state.activeMilestone?.id;
+    const currentMilestoneId = activeSession?.currentMilestoneId;
+    if (!activeSession || !activeMilestoneId || !currentMilestoneId || activeMilestoneId === currentMilestoneId) {
+      return false;
+    }
+
+    const scopedWorktreeMilestone =
+      (activeSession.basePath ? detectWorktreeName(activeSession.basePath) : null) ??
+      detectWorktreeName(activeDispatchBasePath);
+    if (scopedWorktreeMilestone && scopedWorktreeMilestone !== activeMilestoneId) {
+      return false;
+    }
+
+    const currentMilestone = state.registry.find((milestone) => milestone.id === currentMilestoneId);
+    return !!currentMilestone && isClosedStatus(currentMilestone.status);
+  }
+
   return {
     async decideNextUnit(input) {
       const state = input.stateSnapshot;
@@ -2110,6 +2138,9 @@ export function createWiredDispatchAdapter(
 
       const activeSession = input.session ?? session;
       const activeDispatchBasePath = activeSession?.basePath || dispatchBasePath;
+      if (activeSession && shouldAdoptActiveMilestone(state, activeSession, activeDispatchBasePath)) {
+        activeSession.currentMilestoneId = active.id;
+      }
       const prefs = loadEffectiveGSDPreferences(activeDispatchBasePath)?.preferences;
 
       // Derive session-derived dispatch inputs the same way phases.ts:runDispatch does
@@ -2955,6 +2986,7 @@ export async function startAuto(
     if (!getLedger()) initMetrics(base);
     if (s.currentMilestoneId) setActiveMilestoneId(base, s.currentMilestoneId);
     await openProjectDbIfPresent(base);
+    reconcileMergedMilestonesFromJournal(base);
     registerAutoWorkerForSession(s, base);
 
     // Re-register health level notification callback lost across process restart
@@ -2991,7 +3023,7 @@ export async function startAuto(
     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.",
@@ -3320,7 +3352,7 @@ export async function dispatchHookUnit(
     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", {

package/src/resources/extensions/gsd/bootstrap/db-tools.ts

@@ -413,6 +413,92 @@ export function registerDbTools(pi: ExtensionAPI): void {
   pi.registerTool(summarySaveTool);
   registerAlias(pi, summarySaveTool, "gsd_save_summary", "gsd_summary_save");
 
+  // ─── gsd_uat_result_save ─────────────────────────────────────────────────
+
+  const uatResultSaveExecute = async (_toolCallId: string, params: any, _signal: AbortSignal | undefined, _onUpdate: unknown, _ctx: unknown) => {
+    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: any, theme: any) {
+      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: any, _options: any, theme: any) {
+      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: string, _params: any, _signal: AbortSignal | undefined, _onUpdate: unknown, _ctx: unknown) => {