gsd-pi 2.22.0 → 2.23.0

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

@@ -125,6 +125,18 @@ import {
   reconcileMergeState,
 } from "./auto-recovery.js";
 import { resolveDispatch, resetRewriteCircuitBreaker } from "./auto-dispatch.js";
+import {
+  buildResearchSlicePrompt,
+  buildResearchMilestonePrompt,
+  buildPlanSlicePrompt,
+  buildPlanMilestonePrompt,
+  buildExecuteTaskPrompt,
+  buildCompleteSlicePrompt,
+  buildCompleteMilestonePrompt,
+  buildReassessRoadmapPrompt,
+  buildRunUatPrompt,
+  buildReplanSlicePrompt,
+} from "./auto-prompts.js";
 import {
   type AutoDashboardData,
   updateProgressWidget as _updateProgressWidget,
@@ -211,6 +223,11 @@ const MAX_LIFETIME_DISPATCHES = 6;
 /** Tracks recovery attempt count per unit for backoff and diagnostics. */
 const unitRecoveryCount = new Map<string, number>();
 
+/** Track consecutive skips per unit — catches infinite skip loops where deriveState
+ *  keeps returning the same already-completed unit. Reset on any real dispatch. */
+const unitConsecutiveSkips = new Map<string, number>();
+const MAX_CONSECUTIVE_SKIPS = 3;
+
 /** Persisted completed-unit keys — survives restarts. Loaded from .gsd/completed-units.json. */
 const completedKeySet = new Set<string>();
 
@@ -297,6 +314,9 @@ let currentUnit: { type: string; id: string; startedAt: number } | null = null;
 /** Track dynamic routing decision for the current unit (for metrics) */
 let currentUnitRouting: { tier: string; modelDowngraded: boolean } | null = null;
 
+/** Queue of quick-task captures awaiting dispatch after triage resolution */
+let pendingQuickTasks: import("./captures.js").CaptureEntry[] = [];
+
 /**
  * Model captured at auto-mode start. Used to prevent model bleed between
  * concurrent GSD instances sharing the same global settings.json (#650).
@@ -334,8 +354,12 @@ let lastBaselineCharCount: number | undefined;
 /** SIGTERM handler registered while auto-mode is active — cleared on stop/pause. */
 let _sigtermHandler: (() => void) | null = null;
 
-/** Tool calls currently being executed — prevents false idle detection during long-running tools. */
-const inFlightTools = new Set<string>();
+/**
+ * Tool calls currently being executed — prevents false idle detection during long-running tools.
+ * Maps toolCallId → start timestamp (ms) so the idle watchdog can detect tools that have been
+ * running suspiciously long (e.g., a Bash command hung because `&` kept stdout open).
+ */
+const inFlightTools = new Map<string, number>();
 
 type BudgetAlertLevel = 0 | 75 | 90 | 100;
 
@@ -414,11 +438,11 @@ export function isAutoPaused(): boolean {
 
 /**
  * Mark a tool execution as in-flight. Called from index.ts on tool_execution_start.
- * Prevents the idle watchdog from declaring the agent idle while tools are executing.
+ * Records start time so the idle watchdog can detect tools hung longer than the idle timeout.
  */
 export function markToolStart(toolCallId: string): void {
   if (!active) return;
-  inFlightTools.add(toolCallId);
+  inFlightTools.set(toolCallId, Date.now());
 }
 
 /**
@@ -428,6 +452,16 @@ export function markToolEnd(toolCallId: string): void {
   inFlightTools.delete(toolCallId);
 }
 
+/**
+ * Returns the age (ms) of the oldest currently in-flight tool, or 0 if none.
+ * Exported for testing.
+ */
+export function getOldestInFlightToolAgeMs(): number {
+  if (inFlightTools.size === 0) return 0;
+  const oldestStart = Math.min(...inFlightTools.values());
+  return Date.now() - oldestStart;
+}
+
 /**
  * Return the base path to use for the auto.lock file.
  * Always uses the original project root (not the worktree) so that
@@ -621,6 +655,7 @@ export async function stopAuto(ctx?: ExtensionContext, pi?: ExtensionAPI): Promi
   stepMode = false;
   unitDispatchCount.clear();
   unitRecoveryCount.clear();
+  unitConsecutiveSkips.clear();
   inFlightTools.clear();
   lastBudgetAlertLevel = 0;
   unitLifetimeDispatches.clear();
@@ -629,6 +664,7 @@ export async function stopAuto(ctx?: ExtensionContext, pi?: ExtensionAPI): Promi
   currentMilestoneId = null;
   originalBasePath = "";
   completedUnits = [];
+  pendingQuickTasks = [];
   clearSliceProgressCache();
   clearActivityLogState();
   resetProactiveHealing();
@@ -710,6 +746,7 @@ export async function startAuto(
     basePath = base;
     unitDispatchCount.clear();
     unitLifetimeDispatches.clear();
+    unitConsecutiveSkips.clear();
     // Re-initialize metrics in case ledger was lost during pause
     if (!getLedger()) initMetrics(base);
     // Ensure milestone ID is set on git service for integration branch resolution
@@ -782,6 +819,9 @@ export async function startAuto(
       pausedSessionFile = null;
     }
 
+    // Write lock on resume so cross-process status detection works (#723).
+    writeLock(lockBase(), "resuming", currentMilestoneId ?? "unknown", completedUnits.length);
+
     await dispatchNextUnit(ctx, pi);
     return;
   }
@@ -988,6 +1028,7 @@ export async function startAuto(
   basePath = base;
   unitDispatchCount.clear();
   unitRecoveryCount.clear();
+  unitConsecutiveSkips.clear();
   lastBudgetAlertLevel = 0;
   unitLifetimeDispatches.clear();
   completedKeySet.clear();
@@ -998,6 +1039,7 @@ export async function startAuto(
   autoStartTime = Date.now();
   resourceSyncedAtOnStart = readResourceSyncedAt();
   completedUnits = [];
+  pendingQuickTasks = [];
   currentUnit = null;
   currentMilestoneId = state.activeMilestone?.id ?? null;
   originalModelId = ctx.model?.id ?? null;
@@ -1116,6 +1158,11 @@ export async function startAuto(
     : "Will loop until milestone complete.";
   ctx.ui.notify(`${modeLabel} started. ${scopeMsg}`, "info");
 
+  // Write initial lock file immediately so cross-process status detection
+  // works even before the first unit is dispatched (#723).
+  // The lock is updated with unit-specific info on each dispatch and cleared on stop.
+  writeLock(lockBase(), "starting", currentMilestoneId ?? "unknown", 0);
+
   // Secrets collection gate — collect pending secrets before first dispatch
   const mid = state.activeMilestone!.id;
   try {
@@ -1297,6 +1344,53 @@ export async function handleAgentEnd(
       }
     }
 
+    // ── Post-triage: execute actionable resolutions (inject, replan, queue quick-tasks) ──
+    // After a triage-captures unit completes, the LLM has classified captures and
+    // updated CAPTURES.md. Now we execute those classifications: inject tasks into
+    // the plan, write replan triggers, and queue quick-tasks for dispatch.
+    if (currentUnit.type === "triage-captures") {
+      try {
+        const { executeTriageResolutions } = await import("./triage-resolution.js");
+        const state = await deriveState(basePath);
+        const mid = state.activeMilestone?.id;
+        const sid = state.activeSlice?.id;
+
+        if (mid && sid) {
+          const triageResult = executeTriageResolutions(basePath, mid, sid);
+
+          if (triageResult.injected > 0) {
+            ctx.ui.notify(
+              `Triage: injected ${triageResult.injected} task${triageResult.injected === 1 ? "" : "s"} into ${sid} plan.`,
+              "info",
+            );
+          }
+          if (triageResult.replanned > 0) {
+            ctx.ui.notify(
+              `Triage: replan trigger written for ${sid} — next dispatch will enter replanning.`,
+              "info",
+            );
+          }
+          if (triageResult.quickTasks.length > 0) {
+            // Queue quick-tasks for dispatch. They'll be picked up by the
+            // quick-task dispatch block below the triage check.
+            for (const qt of triageResult.quickTasks) {
+              pendingQuickTasks.push(qt);
+            }
+            ctx.ui.notify(
+              `Triage: ${triageResult.quickTasks.length} quick-task${triageResult.quickTasks.length === 1 ? "" : "s"} queued for execution.`,
+              "info",
+            );
+          }
+          for (const action of triageResult.actions) {
+            process.stderr.write(`gsd-triage: ${action}\n`);
+          }
+        }
+      } catch (err) {
+        // Non-fatal — triage resolution failure shouldn't block dispatch
+        process.stderr.write(`gsd-triage: resolution execution failed: ${(err as Error).message}\n`);
+      }
+    }
+
     // ── Path A fix: verify artifact and persist completion before re-entering dispatch ──
     // After doctor + rebuildState, check whether the just-completed unit actually
     // produced its expected artifact. If so, persist the completion key now so the
@@ -1521,7 +1615,7 @@ export async function handleAgentEnd(
               return;
             }
             const sessionFile = ctx.sessionManager.getSessionFile();
-            writeLock(basePath, triageUnitType, triageUnitId, completedUnits.length, sessionFile);
+            writeLock(lockBase(), triageUnitType, triageUnitId, completedUnits.length, sessionFile);
 
             // Start unit timeout for triage (use same supervisor config as hooks)
             clearUnitTimeout();
@@ -1551,6 +1645,85 @@ export async function handleAgentEnd(
     }
   }
 
+  // ── Quick-task dispatch: execute queued quick-tasks from triage resolution ──
+  // Quick-tasks are self-contained one-off tasks that don't modify the plan.
+  // They're queued during post-triage resolution and dispatched here one at a time.
+  if (
+    !stepMode &&
+    pendingQuickTasks.length > 0 &&
+    currentUnit &&
+    currentUnit.type !== "quick-task"
+  ) {
+    try {
+      const capture = pendingQuickTasks.shift()!;
+      const { buildQuickTaskPrompt } = await import("./triage-resolution.js");
+      const { markCaptureExecuted } = await import("./captures.js");
+      const prompt = buildQuickTaskPrompt(capture);
+
+      ctx.ui.notify(
+        `Executing quick-task: ${capture.id} — "${capture.text}"`,
+        "info",
+      );
+
+      // Close out previous unit metrics
+      if (currentUnit) {
+        const modelId = ctx.model?.id ?? "unknown";
+        snapshotUnitMetrics(ctx, currentUnit.type, currentUnit.id, currentUnit.startedAt, modelId);
+        saveActivityLog(ctx, basePath, currentUnit.type, currentUnit.id);
+      }
+
+      // Dispatch quick-task as a new unit
+      const qtUnitType = "quick-task";
+      const qtUnitId = `${currentMilestoneId}/${capture.id}`;
+      const qtStartedAt = Date.now();
+      currentUnit = { type: qtUnitType, id: qtUnitId, startedAt: qtStartedAt };
+      writeUnitRuntimeRecord(basePath, qtUnitType, qtUnitId, qtStartedAt, {
+        phase: "dispatched",
+        wrapupWarningSent: false,
+        timeoutAt: null,
+        lastProgressAt: qtStartedAt,
+        progressCount: 0,
+        lastProgressKind: "dispatch",
+      });
+      const state = await deriveState(basePath);
+      updateProgressWidget(ctx, qtUnitType, qtUnitId, state);
+
+      const result = await cmdCtx!.newSession();
+      if (result.cancelled) {
+        await stopAuto(ctx, pi);
+        return;
+      }
+      const sessionFile = ctx.sessionManager.getSessionFile();
+      writeLock(lockBase(), qtUnitType, qtUnitId, completedUnits.length, sessionFile);
+
+      // Mark capture as executed now that the unit is dispatched
+      markCaptureExecuted(basePath, capture.id);
+
+      // Start unit timeout for quick-task
+      clearUnitTimeout();
+      const supervisor = resolveAutoSupervisorConfig();
+      const qtTimeoutMs = (supervisor.hard_timeout_minutes ?? 30) * 60 * 1000;
+      unitTimeoutHandle = setTimeout(async () => {
+        unitTimeoutHandle = null;
+        if (!active) return;
+        ctx.ui.notify(
+          `Quick-task ${capture.id} exceeded timeout. Pausing auto-mode.`,
+          "warning",
+        );
+        await pauseAuto(ctx, pi);
+      }, qtTimeoutMs);
+
+      if (!active) return;
+      pi.sendMessage(
+        { customType: "gsd-auto", content: prompt, display: verbose },
+        { triggerTurn: true },
+      );
+      return; // handleAgentEnd will fire again when quick-task session completes
+    } catch {
+      // Non-fatal — proceed to normal dispatch
+    }
+  }
+
   // In step mode, pause and show a wizard instead of immediately dispatching
   if (stepMode) {
     await showStepWizard(ctx, pi);
@@ -1788,6 +1961,7 @@ async function dispatchNextUnit(
     // Reset stuck detection for new milestone
     unitDispatchCount.clear();
     unitRecoveryCount.clear();
+  unitConsecutiveSkips.clear();
     unitLifetimeDispatches.clear();
     // Clear completed-units.json for the finished milestone
     try {
@@ -2155,6 +2329,26 @@ async function dispatchNextUnit(
     // Cross-validate: does the expected artifact actually exist?
     const artifactExists = verifyExpectedArtifact(unitType, unitId, basePath);
     if (artifactExists) {
+      // Guard against infinite skip loops: if deriveState keeps returning the
+      // same completed unit, consecutive skips will trip this breaker. Evict the
+      // key so the next dispatch forces full reconciliation instead of looping.
+      const skipCount = (unitConsecutiveSkips.get(idempotencyKey) ?? 0) + 1;
+      unitConsecutiveSkips.set(idempotencyKey, skipCount);
+      if (skipCount > MAX_CONSECUTIVE_SKIPS) {
+        unitConsecutiveSkips.delete(idempotencyKey);
+        completedKeySet.delete(idempotencyKey);
+        removePersistedKey(basePath, idempotencyKey);
+        invalidateStateCache();
+        ctx.ui.notify(
+          `Skip loop detected: ${unitType} ${unitId} skipped ${skipCount} times without advancing. Evicting completion record and forcing reconciliation.`,
+          "warning",
+        );
+        _skipDepth++;
+        await new Promise(r => setTimeout(r, 50));
+        await dispatchNextUnit(ctx, pi);
+        _skipDepth = Math.max(0, _skipDepth - 1);
+        return;
+      }
       ctx.ui.notify(
         `Skipping ${unitType} ${unitId} — already completed in a prior session. Advancing.`,
         "info",
@@ -2184,6 +2378,24 @@ async function dispatchNextUnit(
     persistCompletedKey(basePath, idempotencyKey);
     completedKeySet.add(idempotencyKey);
     invalidateStateCache();
+    // Same consecutive-skip guard as the idempotency path above.
+    const skipCount2 = (unitConsecutiveSkips.get(idempotencyKey) ?? 0) + 1;
+    unitConsecutiveSkips.set(idempotencyKey, skipCount2);
+    if (skipCount2 > MAX_CONSECUTIVE_SKIPS) {
+      unitConsecutiveSkips.delete(idempotencyKey);
+      completedKeySet.delete(idempotencyKey);
+      removePersistedKey(basePath, idempotencyKey);
+      invalidateStateCache();
+      ctx.ui.notify(
+        `Skip loop detected: ${unitType} ${unitId} skipped ${skipCount2} times without advancing. Evicting completion record and forcing reconciliation.`,
+        "warning",
+      );
+      _skipDepth++;
+      await new Promise(r => setTimeout(r, 50));
+      await dispatchNextUnit(ctx, pi);
+      _skipDepth = Math.max(0, _skipDepth - 1);
+      return;
+    }
     ctx.ui.notify(
       `Skipping ${unitType} ${unitId} — artifact exists but completion key was missing. Repaired and advancing.`,
       "info",
@@ -2199,6 +2411,8 @@ async function dispatchNextUnit(
   // Pattern A→B→A→B would reset retryCount every time; this map catches it.
   const dispatchKey = `${unitType}/${unitId}`;
   const prevCount = unitDispatchCount.get(dispatchKey) ?? 0;
+  // Real dispatch reached — clear the consecutive-skip counter for this unit.
+  unitConsecutiveSkips.delete(dispatchKey);
 
   debugLog("dispatch-unit", {
     type: unitType,
@@ -2713,13 +2927,27 @@ async function dispatchNextUnit(
     if (Date.now() - runtime.lastProgressAt < idleTimeoutMs) return;
 
     // Agent has tool calls currently executing (await_job, long bash, etc.) —
-    // not idle, just waiting for tool completion.
+    // not idle, just waiting for tool completion. But only suppress recovery
+    // if the tool started recently. A tool in-flight for longer than the idle
+    // timeout is likely stuck — e.g., `python -m http.server 8080 &` keeps the
+    // shell's stdout/stderr open, causing the Bash tool to hang indefinitely.
     if (inFlightTools.size > 0) {
-      writeUnitRuntimeRecord(basePath, unitType, unitId, currentUnit.startedAt, {
-        lastProgressAt: Date.now(),
-        lastProgressKind: "tool-in-flight",
-      });
-      return;
+      const oldestStart = Math.min(...inFlightTools.values());
+      const toolAgeMs = Date.now() - oldestStart;
+      if (toolAgeMs < idleTimeoutMs) {
+        writeUnitRuntimeRecord(basePath, unitType, unitId, currentUnit.startedAt, {
+          lastProgressAt: Date.now(),
+          lastProgressKind: "tool-in-flight",
+        });
+        return;
+      }
+      // Oldest tool has been running >= idleTimeoutMs — treat as a stuck/hung
+      // tool (e.g., background process holding stdout open). Fall through to
+      // idle recovery without resetting the progress clock.
+      ctx.ui.notify(
+        `Stalled tool detected: a tool has been in-flight for ${Math.round(toolAgeMs / 60000)}min. Treating as hung — attempting idle recovery.`,
+        "warning",
+      );
     }
 
     // Before triggering recovery, check if the agent is actually producing
@@ -3144,6 +3372,14 @@ export {
   buildLoopRemediationSteps,
 } from "./auto-recovery.js";
 
+/**
+ * Test-only: expose skip-loop state for unit tests.
+ * Not part of the public API.
+ */
+export function _getUnitConsecutiveSkips(): Map<string, number> { return unitConsecutiveSkips; }
+export function _resetUnitConsecutiveSkips(): void { unitConsecutiveSkips.clear(); }
+export { MAX_CONSECUTIVE_SKIPS };
+
 /**
  * Dispatch a hook unit directly, bypassing normal pre-dispatch hooks.
  * Used for manual hook triggers via /gsd run-hook.
@@ -3168,6 +3404,7 @@ export async function dispatchHookUnit(
     autoStartTime = Date.now();
     currentUnit = null;
     completedUnits = [];
+    pendingQuickTasks = [];
   }
 
   const hookUnitType = `hook/${hookName}`;
@@ -3248,3 +3485,192 @@ export async function dispatchHookUnit(
   
   return true;
 }
+
+
+// ─── Direct Phase Dispatch ────────────────────────────────────────────────────
+
+export async function dispatchDirectPhase(
+  ctx: ExtensionCommandContext,
+  pi: ExtensionAPI,
+  phase: string,
+  base: string,
+): Promise<void> {
+  const state = await deriveState(base);
+  const mid = state.activeMilestone?.id;
+  const midTitle = state.activeMilestone?.title ?? "";
+
+  if (!mid) {
+    ctx.ui.notify("Cannot dispatch: no active milestone.", "warning");
+    return;
+  }
+
+  const normalized = phase.toLowerCase();
+  let unitType: string;
+  let unitId: string;
+  let prompt: string;
+
+  switch (normalized) {
+    case "research":
+    case "research-milestone":
+    case "research-slice": {
+      const isSlice = normalized === "research-slice" || (normalized === "research" && state.phase !== "pre-planning");
+      if (isSlice) {
+        const sid = state.activeSlice?.id;
+        const sTitle = state.activeSlice?.title ?? "";
+        if (!sid) {
+          ctx.ui.notify("Cannot dispatch research-slice: no active slice.", "warning");
+          return;
+        }
+        unitType = "research-slice";
+        unitId = `${mid}/${sid}`;
+        prompt = await buildResearchSlicePrompt(mid, midTitle, sid, sTitle, base);
+      } else {
+        unitType = "research-milestone";
+        unitId = mid;
+        prompt = await buildResearchMilestonePrompt(mid, midTitle, base);
+      }
+      break;
+    }
+
+    case "plan":
+    case "plan-milestone":
+    case "plan-slice": {
+      const isSlice = normalized === "plan-slice" || (normalized === "plan" && state.phase !== "pre-planning");
+      if (isSlice) {
+        const sid = state.activeSlice?.id;
+        const sTitle = state.activeSlice?.title ?? "";
+        if (!sid) {
+          ctx.ui.notify("Cannot dispatch plan-slice: no active slice.", "warning");
+          return;
+        }
+        unitType = "plan-slice";
+        unitId = `${mid}/${sid}`;
+        prompt = await buildPlanSlicePrompt(mid, midTitle, sid, sTitle, base);
+      } else {
+        unitType = "plan-milestone";
+        unitId = mid;
+        prompt = await buildPlanMilestonePrompt(mid, midTitle, base);
+      }
+      break;
+    }
+
+    case "execute":
+    case "execute-task": {
+      const sid = state.activeSlice?.id;
+      const sTitle = state.activeSlice?.title ?? "";
+      const tid = state.activeTask?.id;
+      const tTitle = state.activeTask?.title ?? "";
+      if (!sid) {
+        ctx.ui.notify("Cannot dispatch execute-task: no active slice.", "warning");
+        return;
+      }
+      if (!tid) {
+        ctx.ui.notify("Cannot dispatch execute-task: no active task.", "warning");
+        return;
+      }
+      unitType = "execute-task";
+      unitId = `${mid}/${sid}/${tid}`;
+      prompt = await buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base);
+      break;
+    }
+
+    case "complete":
+    case "complete-slice":
+    case "complete-milestone": {
+      const isSlice = normalized === "complete-slice" || (normalized === "complete" && state.phase === "summarizing");
+      if (isSlice) {
+        const sid = state.activeSlice?.id;
+        const sTitle = state.activeSlice?.title ?? "";
+        if (!sid) {
+          ctx.ui.notify("Cannot dispatch complete-slice: no active slice.", "warning");
+          return;
+        }
+        unitType = "complete-slice";
+        unitId = `${mid}/${sid}`;
+        prompt = await buildCompleteSlicePrompt(mid, midTitle, sid, sTitle, base);
+      } else {
+        unitType = "complete-milestone";
+        unitId = mid;
+        prompt = await buildCompleteMilestonePrompt(mid, midTitle, base);
+      }
+      break;
+    }
+
+    case "reassess":
+    case "reassess-roadmap": {
+      const roadmapFile = resolveMilestoneFile(base, mid, "ROADMAP");
+      const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
+      if (!roadmapContent) {
+        ctx.ui.notify("Cannot dispatch reassess-roadmap: no roadmap found.", "warning");
+        return;
+      }
+      const roadmap = parseRoadmap(roadmapContent);
+      const completedSlices = roadmap.slices.filter(s => s.done);
+      if (completedSlices.length === 0) {
+        ctx.ui.notify("Cannot dispatch reassess-roadmap: no completed slices.", "warning");
+        return;
+      }
+      const completedSliceId = completedSlices[completedSlices.length - 1].id;
+      unitType = "reassess-roadmap";
+      unitId = `${mid}/${completedSliceId}`;
+      prompt = await buildReassessRoadmapPrompt(mid, midTitle, completedSliceId, base);
+      break;
+    }
+
+    case "uat":
+    case "run-uat": {
+      const sid = state.activeSlice?.id;
+      if (!sid) {
+        ctx.ui.notify("Cannot dispatch run-uat: no active slice.", "warning");
+        return;
+      }
+      const uatFile = resolveSliceFile(base, mid, sid, "UAT");
+      if (!uatFile) {
+        ctx.ui.notify("Cannot dispatch run-uat: no UAT file found.", "warning");
+        return;
+      }
+      const uatContent = await loadFile(uatFile);
+      if (!uatContent) {
+        ctx.ui.notify("Cannot dispatch run-uat: UAT file is empty.", "warning");
+        return;
+      }
+      const uatPath = relSliceFile(base, mid, sid, "UAT");
+      unitType = "run-uat";
+      unitId = `${mid}/${sid}`;
+      prompt = await buildRunUatPrompt(mid, sid, uatPath, uatContent, base);
+      break;
+    }
+
+    case "replan":
+    case "replan-slice": {
+      const sid = state.activeSlice?.id;
+      const sTitle = state.activeSlice?.title ?? "";
+      if (!sid) {
+        ctx.ui.notify("Cannot dispatch replan-slice: no active slice.", "warning");
+        return;
+      }
+      unitType = "replan-slice";
+      unitId = `${mid}/${sid}`;
+      prompt = await buildReplanSlicePrompt(mid, midTitle, sid, sTitle, base);
+      break;
+    }
+
+    default:
+      ctx.ui.notify(
+        `Unknown phase "${phase}". Valid phases: research, plan, execute, complete, reassess, uat, replan.`,
+        "warning",
+      );
+      return;
+  }
+
+  ctx.ui.notify(`Dispatching ${unitType} for ${unitId}...`, "info");
+  const result = await ctx.newSession();
+  if (result.cancelled) {
+    ctx.ui.notify("Session creation cancelled.", "warning");
+    return;
+  }
+  pi.sendMessage(
+    { customType: "gsd-dispatch", content: prompt, display: false },
+    { triggerTurn: true },
+  );
+}

package/dist/resources/extensions/gsd/captures.ts

@@ -26,6 +26,7 @@ export interface CaptureEntry {
   resolution?: string;
   rationale?: string;
   resolvedAt?: string;
+  executed?: boolean;
 }
 
 export interface TriageResult {
@@ -211,6 +212,52 @@ export function markCaptureResolved(
   writeFileSync(filePath, updated, "utf-8");
 }
 
+/**
+ * Mark a resolved capture as executed — its resolution action was carried out.
+ * Appends `**Executed:** <timestamp>` to the capture's section in CAPTURES.md.
+ */
+export function markCaptureExecuted(basePath: string, captureId: string): void {
+  const filePath = resolveCapturesPath(basePath);
+  if (!existsSync(filePath)) return;
+
+  const content = readFileSync(filePath, "utf-8");
+  const executedAt = new Date().toISOString();
+
+  const sectionRegex = new RegExp(
+    `(### ${escapeRegex(captureId)}\\n(?:(?!### ).)*?)(?=### |$)`,
+    "s",
+  );
+  const match = sectionRegex.exec(content);
+  if (!match) return;
+
+  let section = match[1];
+
+  // Remove any existing Executed field (in case of re-execution)
+  section = section.replace(/\*\*Executed:\*\*\s*.+\n?/g, "");
+
+  // Append Executed timestamp
+  section = section.trimEnd() + "\n" + `**Executed:** ${executedAt}` + "\n";
+
+  const updated = content.replace(sectionRegex, section);
+  writeFileSync(filePath, updated, "utf-8");
+}
+
+/**
+ * Load resolved captures that have actionable classifications (inject, replan,
+ * quick-task) but have NOT yet been executed.
+ * These are captures whose resolutions need to be carried out.
+ */
+export function loadActionableCaptures(basePath: string): CaptureEntry[] {
+  return loadAllCaptures(basePath).filter(
+    c =>
+      c.status === "resolved" &&
+      !c.executed &&
+      (c.classification === "inject" ||
+        c.classification === "replan" ||
+        c.classification === "quick-task"),
+  );
+}
+
 // ─── Parser ───────────────────────────────────────────────────────────────────
 
 /**
@@ -235,6 +282,7 @@ function parseCapturesContent(content: string): CaptureEntry[] {
     const resolution = extractBoldField(body, "Resolution");
     const rationale = extractBoldField(body, "Rationale");
     const resolvedAt = extractBoldField(body, "Resolved");
+    const executedAt = extractBoldField(body, "Executed");
 
     if (!text || !timestamp) continue;
 
@@ -251,6 +299,7 @@ function parseCapturesContent(content: string): CaptureEntry[] {
       ...(resolution ? { resolution } : {}),
       ...(rationale ? { rationale } : {}),
       ...(resolvedAt ? { resolvedAt } : {}),
+      ...(executedAt ? { executed: true } : {}),
     });
   }