gsd-pi 2.24.0 → 2.26.0

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

@@ -16,9 +16,9 @@ import type {
   ExtensionCommandContext,
 } from "@gsd/pi-coding-agent";
 
-import { deriveState, invalidateStateCache } from "./state.js";
+import { deriveState } from "./state.js";
 import type { BudgetEnforcementMode, GSDState } from "./types.js";
-import { loadFile, parseRoadmap, getManifestStatus, resolveAllOverrides } from "./files.js";
+import { loadFile, parseRoadmap, getManifestStatus, resolveAllOverrides, parseSummary } from "./files.js";
 import { loadPrompt } from "./prompt-loader.js";
 export { inlinePriorMilestoneSummary } from "./files.js";
 import { collectSecretsFromManifest } from "../get-secrets-from-user.js";
@@ -94,7 +94,7 @@ import {
   parseSliceBranch,
   setActiveMilestoneId,
 } from "./worktree.js";
-import { GitServiceImpl } from "./git-service.js";
+import { GitServiceImpl, type TaskCommitContext } from "./git-service.js";
 import { getPriorSliceCompletionBlocker } from "./dispatch-guard.js";
 import { formatGitError } from "./git-self-heal.js";
 import {
@@ -166,6 +166,41 @@ import { hasPendingCaptures, loadPendingCaptures, countPendingCaptures } from ".
 // auto-mode reads stale state from the project root and re-dispatches
 // already-completed units.
 
+/**
+ * Sync milestone artifacts from project root INTO worktree before deriveState.
+ * Covers the case where the LLM wrote artifacts to the main repo filesystem
+ * (e.g. via absolute paths) but the worktree has stale data. Also deletes
+ * gsd.db in the worktree so it rebuilds from fresh disk state (#853).
+ * Non-fatal — sync failure should never block dispatch.
+ */
+function syncProjectRootToWorktree(projectRoot: string, worktreePath: string, milestoneId: string | null): void {
+  if (!worktreePath || !projectRoot || worktreePath === projectRoot) return;
+  if (!milestoneId) return;
+
+  const prGsd = join(projectRoot, ".gsd");
+  const wtGsd = join(worktreePath, ".gsd");
+
+  // Copy milestone directory from project root to worktree if the project root
+  // has newer artifacts (e.g. slices that don't exist in the worktree yet)
+  try {
+    const srcMilestone = join(prGsd, "milestones", milestoneId);
+    const dstMilestone = join(wtGsd, "milestones", milestoneId);
+    if (existsSync(srcMilestone)) {
+      mkdirSync(dstMilestone, { recursive: true });
+      cpSync(srcMilestone, dstMilestone, { recursive: true, force: false });
+    }
+  } catch { /* non-fatal */ }
+
+  // Delete worktree gsd.db so it rebuilds from the freshly synced files.
+  // Stale DB rows are the root cause of the infinite skip loop (#853).
+  try {
+    const wtDb = join(wtGsd, "gsd.db");
+    if (existsSync(wtDb)) {
+      unlinkSync(wtDb);
+    }
+  } catch { /* non-fatal */ }
+}
+
 /**
  * Sync dispatch-critical .gsd/ state files from worktree to project root.
  * Only runs when inside an auto-worktree (worktreePath differs from projectRoot).
@@ -261,28 +296,30 @@ const MAX_CONSECUTIVE_SKIPS = 3;
 /** Persisted completed-unit keys — survives restarts. Loaded from .gsd/completed-units.json. */
 const completedKeySet = new Set<string>();
 
-/** Resource sync timestamp captured at auto-mode start. If the managed-resources
- *  manifest changes mid-session (e.g. /gsd:update or dev edit + copy-resources),
+/** Resource version captured at auto-mode start. If the managed-resources
+ *  manifest version changes mid-session (e.g. npm update -g gsd-pi),
  *  templates on disk may expect variables the in-memory code doesn't provide.
- *  Detect this and stop gracefully instead of crashing. */
-let resourceSyncedAtOnStart: number | null = null;
+ *  Detect this and stop gracefully instead of crashing.
+ *  Uses gsdVersion (semver) instead of syncedAt (timestamp) so that
+ *  launching a second session doesn't falsely trigger staleness (#804). */
+let resourceVersionOnStart: string | null = null;
 
-function readResourceSyncedAt(): number | null {
+function readResourceVersion(): string | null {
   const agentDir = process.env.GSD_CODING_AGENT_DIR || join(homedir(), ".gsd", "agent");
   const manifestPath = join(agentDir, "managed-resources.json");
   try {
     const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
-    return typeof manifest?.syncedAt === "number" ? manifest.syncedAt : null;
+    return typeof manifest?.gsdVersion === "string" ? manifest.gsdVersion : null;
   } catch {
     return null;
   }
 }
 
 function checkResourcesStale(): string | null {
-  if (resourceSyncedAtOnStart === null) return null;
-  const current = readResourceSyncedAt();
+  if (resourceVersionOnStart === null) return null;
+  const current = readResourceVersion();
   if (current === null) return null;
-  if (current !== resourceSyncedAtOnStart) {
+  if (current !== resourceVersionOnStart) {
     return "GSD resources were updated since this session started. Restart gsd to load the new code.";
   }
   return null;
@@ -889,23 +926,37 @@ export async function startAuto(
       );
       return;
     }
-    // Stale lock from a dead process — synthesize crash recovery context.
-    const activityDir = join(gsdRoot(base), "activity");
-    const recovery = synthesizeCrashRecovery(
-      base, crashLock.unitType, crashLock.unitId,
-      crashLock.sessionFile, activityDir,
-    );
-    if (recovery && recovery.trace.toolCallCount > 0) {
-      pendingCrashRecovery = recovery.prompt;
+    // Stale lock from a dead process — validate before synthesizing recovery context.
+    // If the recovered unit belongs to a fully-completed milestone (SUMMARY exists),
+    // discard recovery context to prevent phantom skip loops (#790).
+    const recoveredMid = crashLock.unitId.split("/")[0];
+    const milestoneAlreadyComplete = recoveredMid
+      ? !!resolveMilestoneFile(base, recoveredMid, "SUMMARY")
+      : false;
+
+    if (milestoneAlreadyComplete) {
       ctx.ui.notify(
-        `${formatCrashInfo(crashLock)}\nRecovered ${recovery.trace.toolCallCount} tool calls from crashed session. Resuming with full context.`,
-        "warning",
+        `Crash recovery: discarding stale context for ${crashLock.unitId} — milestone ${recoveredMid} is already complete.`,
+        "info",
       );
     } else {
-      ctx.ui.notify(
-        `${formatCrashInfo(crashLock)}\nNo session data recovered. Resuming from disk state.`,
-        "warning",
+      const activityDir = join(gsdRoot(base), "activity");
+      const recovery = synthesizeCrashRecovery(
+        base, crashLock.unitType, crashLock.unitId,
+        crashLock.sessionFile, activityDir,
       );
+      if (recovery && recovery.trace.toolCallCount > 0) {
+        pendingCrashRecovery = recovery.prompt;
+        ctx.ui.notify(
+          `${formatCrashInfo(crashLock)}\nRecovered ${recovery.trace.toolCallCount} tool calls from crashed session. Resuming with full context.`,
+          "warning",
+        );
+      } else {
+        ctx.ui.notify(
+          `${formatCrashInfo(crashLock)}\nNo session data recovered. Resuming from disk state.`,
+          "warning",
+        );
+      }
     }
     clearLock(base);
   }
@@ -928,6 +979,11 @@ export async function startAuto(
     ctx.ui.notify(`Debug logging enabled → ${getDebugLogPath()}`, "info");
   }
 
+  // Invalidate all caches before initial state derivation to ensure we read
+  // fresh disk state. Without this, a stale cache from a prior session (e.g.
+  // after a discussion that wrote new artifacts) may cause deriveState to
+  // return pre-planning when the roadmap already exists (#800).
+  invalidateAllCaches();
   let state = await deriveState(base);
 
   // ── Stale worktree state recovery (#654) ─────────────────────────────────
@@ -1061,7 +1117,7 @@ export async function startAuto(
   restoreHookState(base);
   resetProactiveHealing();
   autoStartTime = Date.now();
-  resourceSyncedAtOnStart = readResourceSyncedAt();
+  resourceVersionOnStart = readResourceVersion();
   completedUnits = [];
   pendingQuickTasks = [];
   currentUnit = null;
@@ -1314,12 +1370,41 @@ export async function handleAgentEnd(
   // Small delay to let files settle (git commits, file writes)
   await new Promise(r => setTimeout(r, 500));
 
-  // Auto-commit any dirty files the LLM left behind on the current branch.
+  // Commit any dirty files the LLM left behind on the current branch.
+  // For execute-task units, build a meaningful commit message from the
+  // task summary (one-liner, key_files, inferred type). For other unit
+  // types, fall back to the generic chore() message.
   if (currentUnit) {
     try {
-      const commitMsg = autoCommitCurrentBranch(basePath, currentUnit.type, currentUnit.id);
+      let taskContext: TaskCommitContext | undefined;
+
+      if (currentUnit.type === "execute-task") {
+        const parts = currentUnit.id.split("/");
+        const [mid, sid, tid] = parts;
+        if (mid && sid && tid) {
+          const summaryPath = resolveTaskFile(basePath, mid, sid, tid, "SUMMARY");
+          if (summaryPath) {
+            try {
+              const summaryContent = await loadFile(summaryPath);
+              if (summaryContent) {
+                const summary = parseSummary(summaryContent);
+                taskContext = {
+                  taskId: `${sid}/${tid}`,
+                  taskTitle: summary.title?.replace(/^T\d+:\s*/, "") || tid,
+                  oneLiner: summary.oneLiner || undefined,
+                  keyFiles: summary.frontmatter.key_files?.filter(f => !f.includes("{{")) || undefined,
+                };
+              }
+            } catch {
+              // Non-fatal — fall back to generic message
+            }
+          }
+        }
+      }
+
+      const commitMsg = autoCommitCurrentBranch(basePath, currentUnit.type, currentUnit.id, taskContext);
       if (commitMsg) {
-        ctx.ui.notify(`Auto-committed uncommitted changes.`, "info");
+        ctx.ui.notify(`Committed: ${commitMsg.split("\n")[0]}`, "info");
       }
     } catch {
       // Non-fatal
@@ -1331,10 +1416,13 @@ export async function handleAgentEnd(
     // fixLevel:"task" ensures doctor only fixes task-level issues (e.g. marking
     // checkboxes). Slice/milestone completion transitions (summary stubs,
     // roadmap [x] marking) are left for the complete-slice dispatch unit.
+    // Exception: after complete-slice itself, use fixLevel:"all" so roadmap
+    // checkboxes get fixed even if complete-slice crashed (#839).
     try {
       const scopeParts = currentUnit.id.split("/").slice(0, 2);
       const doctorScope = scopeParts.join("/");
-      const report = await runGSDDoctor(basePath, { fix: true, scope: doctorScope, fixLevel: "task" });
+      const effectiveFixLevel = currentUnit.type === "complete-slice" ? "all" as const : "task" as const;
+      const report = await runGSDDoctor(basePath, { fix: true, scope: doctorScope, fixLevel: effectiveFixLevel });
       if (report.fixesApplied.length > 0) {
         ctx.ui.notify(`Post-hook: applied ${report.fixesApplied.length} fix(es).`, "info");
       }
@@ -1372,7 +1460,8 @@ export async function handleAgentEnd(
     }
     try {
       await rebuildState(basePath);
-      autoCommitCurrentBranch(basePath, currentUnit.type, currentUnit.id);
+      // State rebuild commit is bookkeeping — generic message is appropriate
+      autoCommitCurrentBranch(basePath, "state-rebuild", currentUnit.id);
     } catch {
       // Non-fatal
     }
@@ -1465,7 +1554,7 @@ export async function handleAgentEnd(
             persistCompletedKey(basePath, completionKey);
             completedKeySet.add(completionKey);
           }
-          invalidateStateCache();
+          invalidateAllCaches();
         }
       } catch {
         // Non-fatal — worst case we fall through to normal dispatch which has its own checks
@@ -1504,7 +1593,16 @@ export async function handleAgentEnd(
       if (currentUnit) {
         const modelId = ctx.model?.id ?? "unknown";
         snapshotUnitMetrics(ctx, currentUnit.type, currentUnit.id, currentUnit.startedAt, modelId, { promptCharCount: lastPromptCharCount, baselineCharCount: lastBaselineCharCount, ...(currentUnitRouting ?? {}) });
-        saveActivityLog(ctx, basePath, currentUnit.type, currentUnit.id);
+        const hookActivityFile = saveActivityLog(ctx, basePath, currentUnit.type, currentUnit.id);
+        if (hookActivityFile) {
+          try {
+            const { buildMemoryLLMCall, extractMemoriesFromUnit } = await import('./memory-extractor.js');
+            const llmCallFn = buildMemoryLLMCall(ctx);
+            if (llmCallFn) {
+              extractMemoriesFromUnit(hookActivityFile, currentUnit.type, currentUnit.id, llmCallFn).catch(() => {});
+            }
+          } catch { /* non-fatal */ }
+        }
       }
       currentUnit = { type: hookUnit.unitType, id: hookUnit.unitId, startedAt: hookStartedAt };
       writeUnitRuntimeRecord(basePath, hookUnit.unitType, hookUnit.unitId, hookStartedAt, {
@@ -1646,7 +1744,16 @@ export async function handleAgentEnd(
             if (currentUnit) {
               const modelId = ctx.model?.id ?? "unknown";
               snapshotUnitMetrics(ctx, currentUnit.type, currentUnit.id, currentUnit.startedAt, modelId);
-              saveActivityLog(ctx, basePath, currentUnit.type, currentUnit.id);
+              const triageActivityFile = saveActivityLog(ctx, basePath, currentUnit.type, currentUnit.id);
+              if (triageActivityFile) {
+                try {
+                  const { buildMemoryLLMCall, extractMemoriesFromUnit } = await import('./memory-extractor.js');
+                  const llmCallFn = buildMemoryLLMCall(ctx);
+                  if (llmCallFn) {
+                    extractMemoriesFromUnit(triageActivityFile, currentUnit.type, currentUnit.id, llmCallFn).catch(() => {});
+                  }
+                } catch { /* non-fatal */ }
+              }
             }
 
             // Dispatch triage as a new unit (early-dispatch-and-return)
@@ -1724,7 +1831,16 @@ export async function handleAgentEnd(
       if (currentUnit) {
         const modelId = ctx.model?.id ?? "unknown";
         snapshotUnitMetrics(ctx, currentUnit.type, currentUnit.id, currentUnit.startedAt, modelId);
-        saveActivityLog(ctx, basePath, currentUnit.type, currentUnit.id);
+        const qtActivityFile = saveActivityLog(ctx, basePath, currentUnit.type, currentUnit.id);
+        if (qtActivityFile) {
+          try {
+            const { buildMemoryLLMCall, extractMemoriesFromUnit } = await import('./memory-extractor.js');
+            const llmCallFn = buildMemoryLLMCall(ctx);
+            if (llmCallFn) {
+              extractMemoriesFromUnit(qtActivityFile, currentUnit.type, currentUnit.id, llmCallFn).catch(() => {});
+            }
+          } catch { /* non-fatal */ }
+        }
       }
 
       // Dispatch quick-task as a new unit
@@ -1940,6 +2056,7 @@ async function dispatchNextUnit(
   pi: ExtensionAPI,
 ): Promise<void> {
   if (!active || !cmdCtx) {
+    debugLog(`dispatchNextUnit early return — active=${active}, cmdCtx=${!!cmdCtx}`);
     if (active && !cmdCtx) {
       ctx.ui.notify("Auto-mode session expired. Run /gsd auto to restart.", "info");
     }
@@ -1949,6 +2066,7 @@ async function dispatchNextUnit(
   // Reentrancy guard: allow recursive calls from skip paths (_skipDepth > 0)
   // but block concurrent external calls (watchdog, step wizard, etc.)
   if (_dispatching && _skipDepth === 0) {
+    debugLog("dispatchNextUnit reentrancy guard — another dispatch in progress, bailing");
     return; // Another dispatch is in progress — bail silently
   }
   _dispatching = true;
@@ -1984,7 +2102,7 @@ async function dispatchNextUnit(
   // Lightweight check for critical issues that would cause the next unit
   // to fail or corrupt state. Auto-heals what it can, blocks on the rest.
   try {
-    const healthGate = preDispatchHealthGate(basePath);
+    const healthGate = await preDispatchHealthGate(basePath);
     if (healthGate.fixesApplied.length > 0) {
       ctx.ui.notify(`Pre-dispatch: ${healthGate.fixesApplied.join(", ")}`, "info");
     }
@@ -1997,6 +2115,14 @@ async function dispatchNextUnit(
     // Non-fatal — health gate failure should never block dispatch
   }
 
+  // ── Sync project root artifacts into worktree (#853) ─────────────────
+  // When the LLM writes artifacts to the main repo filesystem instead of
+  // the worktree, the worktree's gsd.db becomes stale. Sync before
+  // deriveState to ensure the worktree has the latest artifacts.
+  if (originalBasePath && basePath !== originalBasePath && currentMilestoneId) {
+    syncProjectRootToWorktree(originalBasePath, basePath, currentMilestoneId);
+  }
+
   const stopDeriveTimer = debugTime("derive-state");
   let state = await deriveState(basePath);
   stopDeriveTimer({
@@ -2418,26 +2544,61 @@ async function dispatchNextUnit(
       const skipCount = (unitConsecutiveSkips.get(idempotencyKey) ?? 0) + 1;
       unitConsecutiveSkips.set(idempotencyKey, skipCount);
       if (skipCount > MAX_CONSECUTIVE_SKIPS) {
+        // Cross-check: verify deriveState actually returns this unit (#790).
+        // If the unit's milestone is already complete, this is a phantom skip
+        // loop from stale crash recovery context — don't evict.
+        const skippedMid = unitId.split("/")[0];
+        const skippedMilestoneComplete = skippedMid
+          ? !!resolveMilestoneFile(basePath, skippedMid, "SUMMARY")
+          : false;
+        if (skippedMilestoneComplete) {
+          // Milestone is complete — evicting this key would fight self-heal.
+          // Clear skip counter and re-dispatch from fresh state.
+          unitConsecutiveSkips.delete(idempotencyKey);
+          invalidateAllCaches();
+          ctx.ui.notify(
+            `Phantom skip loop cleared: ${unitType} ${unitId} belongs to completed milestone ${skippedMid}. Re-dispatching from fresh state.`,
+            "info",
+          );
+          _skipDepth++;
+          await new Promise(r => setTimeout(r, 50));
+          await dispatchNextUnit(ctx, pi);
+          _skipDepth = Math.max(0, _skipDepth - 1);
+          return;
+        }
         unitConsecutiveSkips.delete(idempotencyKey);
         completedKeySet.delete(idempotencyKey);
         removePersistedKey(basePath, idempotencyKey);
-        invalidateStateCache();
+        invalidateAllCaches();
         ctx.ui.notify(
           `Skip loop detected: ${unitType} ${unitId} skipped ${skipCount} times without advancing. Evicting completion record and forcing reconciliation.`,
           "warning",
         );
+        if (!active) return;
         _skipDepth++;
-        await new Promise(r => setTimeout(r, 50));
+        await new Promise(r => setTimeout(r, 150));
         await dispatchNextUnit(ctx, pi);
         _skipDepth = Math.max(0, _skipDepth - 1);
         return;
       }
+      // Count toward lifetime cap so hard-stop fires during skip loops (#792)
+      const lifeSkip = (unitLifetimeDispatches.get(idempotencyKey) ?? 0) + 1;
+      unitLifetimeDispatches.set(idempotencyKey, lifeSkip);
+      if (lifeSkip > MAX_LIFETIME_DISPATCHES) {
+        await stopAuto(ctx, pi, `Hard loop: ${unitType} ${unitId} (skip cycle)`);
+        ctx.ui.notify(
+          `Hard loop detected: ${unitType} ${unitId} hit lifetime cap during skip cycle (${lifeSkip} iterations).`,
+          "error",
+        );
+        return;
+      }
       ctx.ui.notify(
         `Skipping ${unitType} ${unitId} — already completed in a prior session. Advancing.`,
         "info",
       );
+      if (!active) return;
       _skipDepth++;
-      await new Promise(r => setTimeout(r, 50));
+      await new Promise(r => setTimeout(r, 150));
       await dispatchNextUnit(ctx, pi);
       _skipDepth = Math.max(0, _skipDepth - 1);
       return;
@@ -2460,31 +2621,62 @@ async function dispatchNextUnit(
   if (verifyExpectedArtifact(unitType, unitId, basePath)) {
     persistCompletedKey(basePath, idempotencyKey);
     completedKeySet.add(idempotencyKey);
-    invalidateStateCache();
+    invalidateAllCaches();
     // 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) {
+      // Cross-check: verify the unit's milestone is still active (#790).
+      const skippedMid2 = unitId.split("/")[0];
+      const skippedMilestoneComplete2 = skippedMid2
+        ? !!resolveMilestoneFile(basePath, skippedMid2, "SUMMARY")
+        : false;
+      if (skippedMilestoneComplete2) {
+        unitConsecutiveSkips.delete(idempotencyKey);
+        invalidateAllCaches();
+        ctx.ui.notify(
+          `Phantom skip loop cleared: ${unitType} ${unitId} belongs to completed milestone ${skippedMid2}. Re-dispatching from fresh state.`,
+          "info",
+        );
+        _skipDepth++;
+        await new Promise(r => setTimeout(r, 50));
+        await dispatchNextUnit(ctx, pi);
+        _skipDepth = Math.max(0, _skipDepth - 1);
+        return;
+      }
       unitConsecutiveSkips.delete(idempotencyKey);
       completedKeySet.delete(idempotencyKey);
       removePersistedKey(basePath, idempotencyKey);
-      invalidateStateCache();
+      invalidateAllCaches();
       ctx.ui.notify(
         `Skip loop detected: ${unitType} ${unitId} skipped ${skipCount2} times without advancing. Evicting completion record and forcing reconciliation.`,
         "warning",
       );
+      if (!active) return;
       _skipDepth++;
-      await new Promise(r => setTimeout(r, 50));
+      await new Promise(r => setTimeout(r, 150));
       await dispatchNextUnit(ctx, pi);
       _skipDepth = Math.max(0, _skipDepth - 1);
       return;
     }
+    // Count toward lifetime cap so hard-stop fires during skip loops (#792)
+    const lifeSkip2 = (unitLifetimeDispatches.get(idempotencyKey) ?? 0) + 1;
+    unitLifetimeDispatches.set(idempotencyKey, lifeSkip2);
+    if (lifeSkip2 > MAX_LIFETIME_DISPATCHES) {
+      await stopAuto(ctx, pi, `Hard loop: ${unitType} ${unitId} (skip cycle)`);
+      ctx.ui.notify(
+        `Hard loop detected: ${unitType} ${unitId} hit lifetime cap during skip cycle (${lifeSkip2} iterations).`,
+        "error",
+      );
+      return;
+    }
     ctx.ui.notify(
       `Skipping ${unitType} ${unitId} — artifact exists but completion key was missing. Repaired and advancing.`,
       "info",
     );
+    if (!active) return;
     _skipDepth++;
-    await new Promise(r => setTimeout(r, 50));
+    await new Promise(r => setTimeout(r, 150));
     await dispatchNextUnit(ctx, pi);
     _skipDepth = Math.max(0, _skipDepth - 1);
     return;
@@ -2554,7 +2746,7 @@ async function dispatchNextUnit(
             persistCompletedKey(basePath, reconciledKey);
             completedKeySet.add(reconciledKey);
             unitDispatchCount.delete(dispatchKey);
-            invalidateStateCache();
+            invalidateAllCaches();
             await new Promise(r => setImmediate(r));
             await dispatchNextUnit(ctx, pi);
             return;
@@ -2581,7 +2773,7 @@ async function dispatchNextUnit(
       persistCompletedKey(basePath, dispatchKey);
       completedKeySet.add(dispatchKey);
       unitDispatchCount.delete(dispatchKey);
-      invalidateStateCache();
+      invalidateAllCaches();
       await new Promise(r => setImmediate(r));
       await dispatchNextUnit(ctx, pi);
       return;
@@ -2601,7 +2793,7 @@ async function dispatchNextUnit(
             persistCompletedKey(basePath, dispatchKey);
             completedKeySet.add(dispatchKey);
             unitDispatchCount.delete(dispatchKey);
-            invalidateStateCache();
+            invalidateAllCaches();
             await new Promise(r => setImmediate(r));
             await dispatchNextUnit(ctx, pi);
             return;
@@ -2642,7 +2834,7 @@ async function dispatchNextUnit(
             persistCompletedKey(basePath, repairedKey);
             completedKeySet.add(repairedKey);
             unitDispatchCount.delete(dispatchKey);
-            invalidateStateCache();
+            invalidateAllCaches();
             await new Promise(r => setImmediate(r));
             await dispatchNextUnit(ctx, pi);
             return;
@@ -2686,7 +2878,18 @@ async function dispatchNextUnit(
   if (currentUnit) {
     const modelId = ctx.model?.id ?? "unknown";
     snapshotUnitMetrics(ctx, currentUnit.type, currentUnit.id, currentUnit.startedAt, modelId, { promptCharCount: lastPromptCharCount, baselineCharCount: lastBaselineCharCount, ...(currentUnitRouting ?? {}) });
-    saveActivityLog(ctx, basePath, currentUnit.type, currentUnit.id);
+    const activityFile = saveActivityLog(ctx, basePath, currentUnit.type, currentUnit.id);
+
+    // Fire-and-forget memory extraction from completed unit
+    if (activityFile) {
+      try {
+        const { buildMemoryLLMCall, extractMemoriesFromUnit } = await import('./memory-extractor.js');
+        const llmCallFn = buildMemoryLLMCall(ctx);
+        if (llmCallFn) {
+          extractMemoriesFromUnit(activityFile, currentUnit.type, currentUnit.id, llmCallFn).catch(() => {});
+        }
+      } catch { /* non-fatal */ }
+    }
 
     // Record routing outcome for adaptive learning
     if (currentUnitRouting) {
@@ -3603,6 +3806,20 @@ export async function dispatchDirectPhase(
           ctx.ui.notify("Cannot dispatch research-slice: no active slice.", "warning");
           return;
         }
+
+        // When require_slice_discussion is enabled, pause auto-mode before
+        // each new slice so the user can discuss requirements first (#789).
+        const sliceContextFile = resolveSliceFile(base, mid, sid, "CONTEXT");
+        const requireDiscussion = loadEffectiveGSDPreferences()?.preferences?.phases?.require_slice_discussion;
+        if (requireDiscussion && !sliceContextFile) {
+          ctx.ui.notify(
+            `Slice ${sid} requires discussion before planning. Run /gsd discuss to discuss this slice, then /gsd auto to resume.`,
+            "info",
+          );
+          await pauseAuto(ctx, pi);
+          return;
+        }
+
         unitType = "research-slice";
         unitId = `${mid}/${sid}`;
         prompt = await buildResearchSlicePrompt(mid, midTitle, sid, sTitle, base);

package/src/resources/extensions/gsd/cache.ts

@@ -12,16 +12,18 @@
 import { invalidateStateCache } from './state.js';
 import { clearPathCache } from './paths.js';
 import { clearParseCache } from './files.js';
+import { clearArtifacts } from './gsd-db.js';
 
 /**
  * Invalidate all GSD runtime caches in one call.
  *
  * Call this after file writes, milestone transitions, merge reconciliation,
  * or any operation that changes .gsd/ contents on disk. Forgetting to clear
- * any single cache causes stale reads (see #431).
+ * any single cache causes stale reads (see #431, #793).
  */
 export function invalidateAllCaches(): void {
   invalidateStateCache();
   clearPathCache();
   clearParseCache();
+  clearArtifacts();
 }

package/src/resources/extensions/gsd/doctor-proactive.ts

@@ -19,6 +19,7 @@ import { join } from "node:path";
 import { gsdRoot, resolveGsdRootFile } from "./paths.js";
 import { readCrashLock, isLockProcessAlive, clearLock } from "./crash-recovery.js";
 import { abortAndReset } from "./git-self-heal.js";
+import { rebuildState } from "./doctor.js";
 
 // ── Health Score Tracking ──────────────────────────────────────────────────
 
@@ -131,7 +132,7 @@ export interface PreDispatchHealthResult {
  *
  * Returns { proceed: true } if dispatch should continue.
  */
-export function preDispatchHealthGate(basePath: string): PreDispatchHealthResult {
+export async function preDispatchHealthGate(basePath: string): Promise<PreDispatchHealthResult> {
   const issues: string[] = [];
   const fixesApplied: string[] = [];
 
@@ -172,17 +173,17 @@ export function preDispatchHealthGate(basePath: string): PreDispatchHealthResult
   }
 
   // ── STATE.md existence check ──
-  // If STATE.md is missing, deriveState will still work but the LLM
-  // may get confused. Rebuild it silently.
+  // If STATE.md is missing, rebuild it now so the next unit has accurate
+  // context. Non-blocking — if the rebuild throws, dispatch continues anyway.
   try {
     const stateFile = resolveGsdRootFile(basePath, "STATE");
     const milestonesDir = join(gsdRoot(basePath), "milestones");
     if (existsSync(milestonesDir) && !existsSync(stateFile)) {
-      issues.push("STATE.md missing — will rebuild after this unit");
-      // Don't block dispatch — rebuilding happens in post-hook
+      await rebuildState(basePath);
+      fixesApplied.push("rebuilt missing STATE.md before dispatch");
     }
   } catch {
-    // Non-fatal
+    // Non-fatal — dispatch continues without STATE.md if rebuild fails
   }
 
   // If we had critical issues that couldn't be auto-healed, block dispatch

package/src/resources/extensions/gsd/doctor.ts

@@ -4,6 +4,7 @@ import { join, sep } from "node:path";
 import { loadFile, parsePlan, parseRoadmap, parseSummary, saveFile, parseTaskPlanMustHaves, countMustHavesMentionedInSummary } from "./files.js";
 import { resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveTaskFiles, resolveTasksDir, milestonesDir, gsdRoot, relMilestoneFile, relSliceFile, relTaskFile, relSlicePath, relGsdRootFile, resolveGsdRootFile } from "./paths.js";
 import { deriveState, isMilestoneComplete } from "./state.js";
+import { invalidateAllCaches } from "./cache.js";
 import { loadEffectiveGSDPreferences, type GSDPreferences } from "./preferences.js";
 import { listWorktrees, resolveGitDir } from "./worktree-manager.js";
 import { abortAndReset } from "./git-self-heal.js";
@@ -200,6 +201,7 @@ async function updateStateFile(basePath: string, fixesApplied: string[]): Promis
 
 /** Rebuild STATE.md from current disk state. Exported for auto-mode post-hooks. */
 export async function rebuildState(basePath: string): Promise<void> {
+  invalidateAllCaches();
   const state = await deriveState(basePath);
   const path = resolveGsdRootFile(basePath, "STATE");
   await saveFile(path, buildStateMarkdown(state));
@@ -1142,8 +1144,31 @@ export async function runGSDDoctor(basePath: string, options?: { fix?: boolean;
             unitId: taskUnitId,
             message: `Task ${task.id} is marked done but summary is missing`,
             file: relTaskFile(basePath, milestoneId, slice.id, task.id, "SUMMARY"),
-            fixable: false,
+            fixable: true,
           });
+          // Write a stub summary so validate-milestone can proceed.
+          // This prevents infinite skip loops when tasks are marked done
+          // without summaries (#820).
+          if (shouldFix("task_done_missing_summary")) {
+            const stubPath = join(
+              basePath, ".gsd", "milestones", milestoneId, "slices", slice.id, "tasks",
+              `${task.id}-SUMMARY.md`,
+            );
+            const stubContent = [
+              `---`,
+              `status: done`,
+              `result: unknown`,
+              `doctor_generated: true`,
+              `---`,
+              ``,
+              `# ${task.id}: ${task.title || "Unknown"}`,
+              ``,
+              `Summary stub generated by \`/gsd doctor\` — task was marked done but no summary existed.`,
+              ``,
+            ].join("\n");
+            await saveFile(stubPath, stubContent);
+            fixesApplied.push(`created stub summary for ${taskUnitId}`);
+          }
         }
 
         if (!task.done && hasSummary) {