gsd-pi 2.79.0-dev.ece5fd8ba → 2.80.0

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

@@ -0,0 +1,87 @@
+import type { GSDState } from "../types.js";
+
+export interface AutoSessionContext {
+  basePath: string;
+  trigger: "guided-flow" | "resume" | "auto-loop" | "manual";
+}
+
+export interface AutoStatus {
+  phase: "idle" | "running" | "paused" | "stopped" | "error";
+  activeUnit?: {
+    unitType: string;
+    unitId: string;
+  };
+  lastTransitionAt?: number;
+  transitionCount: number;
+}
+
+export interface AutoAdvanceResult {
+  kind: "advanced" | "blocked" | "paused" | "stopped" | "error";
+  reason?: string;
+  stateSnapshot?: GSDState;
+}
+
+export interface AutoOrchestrationModule {
+  start(sessionContext: AutoSessionContext): Promise<AutoAdvanceResult>;
+  advance(): Promise<AutoAdvanceResult>;
+  resume(): Promise<AutoAdvanceResult>;
+  stop(reason: string): Promise<AutoAdvanceResult>;
+  getStatus(): AutoStatus;
+}
+
+export interface DispatchAdapter {
+  decideNextUnit(): Promise<{
+    unitType: string;
+    unitId: string;
+    reason: string;
+    preconditions: string[];
+  } | null>;
+}
+
+export interface RecoveryAdapter {
+  classifyAndRecover(input: {
+    error: unknown;
+    unitType?: string;
+    unitId?: string;
+  }): Promise<{
+    action: "retry" | "escalate" | "stop";
+    reason: string;
+  }>;
+}
+
+export interface WorktreeAdapter {
+  prepareForUnit(unitType: string, unitId: string): Promise<void>;
+  syncAfterUnit(unitType: string, unitId: string): Promise<void>;
+  cleanupOnStop(reason: string): Promise<void>;
+}
+
+export interface HealthAdapter {
+  preAdvanceGate(): Promise<{ allow: boolean; reason?: string }>;
+  postAdvanceRecord(result: AutoAdvanceResult): Promise<void>;
+}
+
+export interface RuntimePersistenceAdapter {
+  ensureLockOwnership(): Promise<void>;
+  journalTransition(event: {
+    name: string;
+    reason?: string;
+    unitType?: string;
+    unitId?: string;
+  }): Promise<void>;
+}
+
+export interface NotificationAdapter {
+  notifyLifecycle(event: {
+    name: string;
+    detail?: string;
+  }): Promise<void>;
+}
+
+export interface AutoOrchestratorDeps {
+  dispatch: DispatchAdapter;
+  recovery: RecoveryAdapter;
+  worktree: WorktreeAdapter;
+  health: HealthAdapter;
+  runtime: RuntimePersistenceAdapter;
+  notifications: NotificationAdapter;
+}

package/src/resources/extensions/gsd/auto/loop-deps.ts

@@ -7,6 +7,7 @@
 import type { ExtensionAPI, ExtensionContext } from "@gsd/pi-coding-agent";
 
 import type { AutoSession } from "./session.js";
+import type { ErrorContext } from "./types.js";
 import type { GSDPreferences } from "../preferences.js";
 import type { GSDState } from "../types.js";
 import type { SessionLockStatus } from "../session-lock.js";
@@ -24,6 +25,12 @@ import type { MergeReconcileResult } from "../auto-recovery.js";
 import type { UokTurnObserver } from "../uok/contracts.js";
 import type { PreflightResult } from "../clean-root-preflight.js";
 
+type PauseAutoFn = (
+  ctx?: ExtensionContext,
+  pi?: ExtensionAPI,
+  errorContext?: ErrorContext,
+) => Promise<void>;
+
 /**
  * Dependencies injected by the caller (auto.ts startAuto) so autoLoop
  * can access private functions from auto.ts without exporting them.
@@ -39,7 +46,7 @@ export interface LoopDeps {
     pi?: ExtensionAPI,
     reason?: string,
   ) => Promise<void>;
-  pauseAuto: (ctx?: ExtensionContext, pi?: ExtensionAPI) => Promise<void>;
+  pauseAuto: PauseAutoFn;
   clearUnitTimeout: () => void;
   updateProgressWidget: (
     ctx: ExtensionContext,
@@ -245,7 +252,7 @@ export interface LoopDeps {
     prefs: GSDPreferences | undefined;
     buildSnapshotOpts: () => CloseoutOptions & Record<string, unknown>;
     buildRecoveryContext: () => unknown;
-    pauseAuto: (ctx?: ExtensionContext, pi?: ExtensionAPI) => Promise<void>;
+    pauseAuto: PauseAutoFn;
   }) => void;
 
   // Prompt helpers
@@ -271,7 +278,7 @@ export interface LoopDeps {
   ) => Promise<"dispatched" | "continue" | "retry">;
   runPostUnitVerification: (
     vctx: VerificationContext,
-    pauseAuto: (ctx?: ExtensionContext, pi?: ExtensionAPI) => Promise<void>,
+    pauseAuto: PauseAutoFn,
   ) => Promise<VerificationResult>;
   postUnitPostVerification: (
     pctx: PostUnitContext,

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

@@ -0,0 +1,161 @@
+import type { AutoAdvanceResult, AutoOrchestrationModule, AutoOrchestratorDeps, AutoSessionContext, AutoStatus } from "./contracts.js";
+
+function now(): number {
+  return Date.now();
+}
+
+export class AutoOrchestrator implements AutoOrchestrationModule {
+  private status: AutoStatus = {
+    phase: "idle",
+    transitionCount: 0,
+  };
+  private readonly deps: AutoOrchestratorDeps;
+  private lastAdvanceKey: string | null = null;
+
+  public constructor(deps: AutoOrchestratorDeps) {
+    this.deps = deps;
+  }
+
+  public async start(_sessionContext: AutoSessionContext): Promise<AutoAdvanceResult> {
+    this.lastAdvanceKey = null;
+    this.status.phase = "running";
+    this.bumpTransition();
+    await this.deps.runtime.journalTransition({ name: "start" });
+    await this.deps.notifications.notifyLifecycle({ name: "start" });
+    return this.advance();
+  }
+
+  public async advance(): Promise<AutoAdvanceResult> {
+    try {
+      await this.deps.runtime.ensureLockOwnership();
+      const gate = await this.deps.health.preAdvanceGate();
+      if (!gate.allow) {
+        const blocked: AutoAdvanceResult = { kind: "blocked", reason: gate.reason ?? "health gate blocked" };
+        await this.deps.runtime.journalTransition({ name: "advance-blocked", reason: blocked.reason });
+        await this.deps.health.postAdvanceRecord(blocked);
+        return blocked;
+      }
+
+      const decision = await this.deps.dispatch.decideNextUnit();
+      if (!decision) {
+        const stopped: AutoAdvanceResult = { kind: "stopped", reason: "no remaining units" };
+        this.status.phase = "stopped";
+        this.status.activeUnit = undefined;
+        this.lastAdvanceKey = null;
+        this.bumpTransition();
+        await this.deps.runtime.journalTransition({ name: "advance-stopped", reason: stopped.reason });
+        await this.deps.health.postAdvanceRecord(stopped);
+        return stopped;
+      }
+
+      const nextKey = `${decision.unitType}:${decision.unitId}`;
+      if (this.lastAdvanceKey === nextKey) {
+        const blocked: AutoAdvanceResult = { kind: "blocked", reason: "idempotent advance: unit already active" };
+        await this.deps.runtime.journalTransition({
+          name: "advance-blocked",
+          reason: blocked.reason,
+          unitType: decision.unitType,
+          unitId: decision.unitId,
+        });
+        await this.deps.health.postAdvanceRecord(blocked);
+        return blocked;
+      }
+
+      this.status.activeUnit = { unitType: decision.unitType, unitId: decision.unitId };
+      this.status.phase = "running";
+      this.lastAdvanceKey = nextKey;
+      this.bumpTransition();
+
+      await this.deps.runtime.journalTransition({
+        name: "advance",
+        reason: decision.reason,
+        unitType: decision.unitType,
+        unitId: decision.unitId,
+      });
+      await this.deps.worktree.prepareForUnit(decision.unitType, decision.unitId);
+      await this.deps.worktree.syncAfterUnit(decision.unitType, decision.unitId);
+
+      const advanced: AutoAdvanceResult = { kind: "advanced" };
+      await this.deps.health.postAdvanceRecord(advanced);
+      return advanced;
+    } catch (error) {
+      const recovery = await this.deps.recovery.classifyAndRecover({
+        error,
+        unitType: this.status.activeUnit?.unitType,
+        unitId: this.status.activeUnit?.unitId,
+      });
+      const result: AutoAdvanceResult = recovery.action === "retry"
+        ? { kind: "paused", reason: recovery.reason }
+        : recovery.action === "escalate"
+          ? { kind: "error", reason: recovery.reason }
+          : { kind: "stopped", reason: recovery.reason };
+
+      if (result.kind === "paused") {
+        this.status.phase = "paused";
+      } else if (result.kind === "stopped") {
+        this.status.phase = "stopped";
+      } else {
+        this.status.phase = "error";
+      }
+
+      if (result.kind === "stopped") {
+        this.lastAdvanceKey = null;
+        this.status.activeUnit = undefined;
+      }
+      this.bumpTransition();
+
+      const journalName = result.kind === "paused"
+        ? "advance-paused"
+        : result.kind === "stopped"
+          ? "advance-stopped"
+          : "advance-error";
+      await this.deps.runtime.journalTransition({ name: journalName, reason: recovery.reason });
+
+      if (result.kind === "paused") {
+        await this.deps.notifications.notifyLifecycle({ name: "pause", detail: recovery.reason });
+      } else if (result.kind === "stopped") {
+        await this.deps.notifications.notifyLifecycle({ name: "stopped", detail: recovery.reason });
+      } else if (result.kind === "error") {
+        await this.deps.notifications.notifyLifecycle({ name: "error", detail: recovery.reason });
+      }
+      await this.deps.health.postAdvanceRecord(result);
+      return result;
+    }
+  }
+
+  public async resume(): Promise<AutoAdvanceResult> {
+    this.lastAdvanceKey = null;
+    this.status.phase = "running";
+    this.bumpTransition();
+    await this.deps.runtime.journalTransition({ name: "resume" });
+    await this.deps.notifications.notifyLifecycle({ name: "resume" });
+    return this.advance();
+  }
+
+  public async stop(reason: string): Promise<AutoAdvanceResult> {
+    if (this.status.phase === "stopped") {
+      return { kind: "stopped", reason };
+    }
+    await this.deps.worktree.cleanupOnStop(reason);
+    this.status.phase = "stopped";
+    this.status.activeUnit = undefined;
+    this.lastAdvanceKey = null;
+    this.bumpTransition();
+    await this.deps.runtime.journalTransition({ name: "stop", reason });
+    await this.deps.notifications.notifyLifecycle({ name: "stop", detail: reason });
+    return { kind: "stopped", reason };
+  }
+
+  public getStatus(): AutoStatus {
+    return { ...this.status, activeUnit: this.status.activeUnit ? { ...this.status.activeUnit } : undefined };
+  }
+
+  private bumpTransition(): void {
+    this.status.transitionCount += 1;
+    this.status.lastTransitionAt = now();
+  }
+}
+
+export function createAutoOrchestrator(deps: AutoOrchestratorDeps): AutoOrchestrationModule {
+  return new AutoOrchestrator(deps);
+}

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

@@ -55,7 +55,7 @@ import { writeUnitRuntimeRecord } from "../unit-runtime.js";
 import { withTimeout, FINALIZE_PRE_TIMEOUT_MS, FINALIZE_POST_TIMEOUT_MS } from "./finalize-timeout.js";
 import { getEligibleSlices } from "../slice-parallel-eligibility.js";
 import { startSliceParallel } from "../slice-parallel-orchestrator.js";
-import { isDbAvailable, getMilestoneSlices } from "../gsd-db.js";
+import { isDbAvailable, getMilestoneSlices, refreshOpenDatabaseFromDisk } from "../gsd-db.js";
 import type { MinimalModelRegistry } from "../context-budget.js";
 import { ensurePlanV2Graph, isEmptyPlanV2GraphResult, isMissingFinalizedContextResult } from "../uok/plan-v2.js";
 import { resolveUokFlags } from "../uok/flags.js";
@@ -76,6 +76,12 @@ function isSamePathLocal(a: string, b: string): boolean {
   return normalizeWorktreePathForCompare(a) === normalizeWorktreePathForCompare(b);
 }
 
+function refreshPlanSliceRecoveryDbIfNeeded(unitType: string): boolean {
+  if (unitType !== "plan-slice") return true;
+  if (!isDbAvailable()) return true;
+  return refreshOpenDatabaseFromDisk();
+}
+
 // ─── Session timeout auto-resume state ────────────────────────────────────────
 
 let consecutiveSessionTimeouts = 0;
@@ -232,6 +238,33 @@ async function emitCancelledUnitEnd(
   });
 }
 
+export function _buildCancelledUnitStopReason(
+  unitType: string,
+  unitId: string,
+  errorContext?: { message: string; category: string },
+): {
+  notifyMessage: string;
+  stopReason: string;
+  loopReason: "session-failed" | "unit-aborted";
+} {
+  const cancellationMessage = errorContext?.message ?? "unknown";
+  const isSessionCreationFailure = errorContext?.category === "session-failed";
+
+  if (isSessionCreationFailure) {
+    return {
+      notifyMessage: `Session creation failed for ${unitType} ${unitId}: ${cancellationMessage}. Stopping auto-mode.`,
+      stopReason: `Session creation failed: ${cancellationMessage}`,
+      loopReason: "session-failed",
+    };
+  }
+
+  return {
+    notifyMessage: `Unit ${unitType} ${unitId} aborted after dispatch: ${cancellationMessage}. Stopping auto-mode.`,
+    stopReason: `Unit aborted: ${cancellationMessage}`,
+    loopReason: "unit-aborted",
+  };
+}
+
 async function failClosedOnFinalizeTimeout(
   ic: IterationContext,
   iterData: IterationData,
@@ -994,7 +1027,10 @@ export async function runDispatch(
     // See: https://github.com/gsd-build/gsd-2/issues/2474
     if (dispatchResult.level === "warning") {
       ctx.ui.notify(dispatchResult.reason, "warning");
-      await deps.pauseAuto(ctx, pi);
+      await deps.pauseAuto(ctx, pi, {
+        message: dispatchResult.reason,
+        category: "unknown",
+      });
     } else {
       await closeoutAndStop(ctx, pi, s, deps, dispatchResult.reason);
     }
@@ -1065,7 +1101,16 @@ export async function runDispatch(
             `Stuck recovery: artifact for ${unitType} ${unitId} found on disk. Invalidating caches.`,
             "info",
           );
+          if (!refreshPlanSliceRecoveryDbIfNeeded(unitType)) {
+            ctx.ui.notify(
+              `Stuck recovery found ${unitType} ${unitId} artifacts, but the DB refresh failed. Keeping stuck state for retry.`,
+              "warning",
+            );
+            return { action: "continue" };
+          }
           deps.invalidateAllCaches();
+          loopState.recentUnits.length = 0;
+          loopState.stuckRecoveryAttempts = 0;
           return { action: "continue" };
         }
         ctx.ui.notify(
@@ -1075,6 +1120,32 @@ export async function runDispatch(
         deps.invalidateAllCaches();
       } else {
         // Level 2: hard stop — genuinely stuck
+        deps.invalidateAllCaches();
+        const artifactExists = verifyExpectedArtifact(
+          unitType,
+          unitId,
+          s.basePath,
+        );
+        if (artifactExists && unitType !== "complete-milestone") {
+          debugLog("autoLoop", {
+            phase: "stuck-recovery",
+            level: 2,
+            action: "artifact-found",
+          });
+          ctx.ui.notify(
+            `Stuck recovery: artifact for ${unitType} ${unitId} found on disk after cache invalidation. Continuing.`,
+            "info",
+          );
+          if (refreshPlanSliceRecoveryDbIfNeeded(unitType)) {
+            loopState.recentUnits.length = 0;
+            loopState.stuckRecoveryAttempts = 0;
+            return { action: "continue" };
+          }
+          ctx.ui.notify(
+            `Stuck recovery found ${unitType} ${unitId} artifacts, but the DB refresh failed. Stopping for manual recovery.`,
+            "warning",
+          );
+        }
         debugLog("autoLoop", {
           phase: "stuck-detected",
           unitType,
@@ -1871,13 +1942,16 @@ export async function runUnitPhase(
     }
     await deps.autoCommitUnit?.(s.basePath, unitType, unitId, ctx);
     await emitCancelledUnitEnd(ic, unitType, unitId, unitStartSeq, unitResult.errorContext);
-    ctx.ui.notify(
-      `Session creation failed for ${unitType} ${unitId}: ${unitResult.errorContext?.message ?? "unknown"}. Stopping auto-mode.`,
-      "warning",
+
+    const cancelledStop = _buildCancelledUnitStopReason(
+      unitType,
+      unitId,
+      unitResult.errorContext,
     );
-    await deps.stopAuto(ctx, pi, `Session creation failed: ${unitResult.errorContext?.message ?? "unknown"}`);
-    debugLog("autoLoop", { phase: "exit", reason: "session-failed" });
-    return { action: "break", reason: "session-failed" };
+    ctx.ui.notify(cancelledStop.notifyMessage, "warning");
+    await deps.stopAuto(ctx, pi, cancelledStop.stopReason);
+    debugLog("autoLoop", { phase: "exit", reason: cancelledStop.loopReason });
+    return { action: "break", reason: cancelledStop.loopReason };
   }
 
   // ── Immediate unit closeout (metrics, activity log, memory) ────────

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

@@ -21,6 +21,7 @@ import type { ExtensionAPI, ExtensionCommandContext } from "@gsd/pi-coding-agent
 import type { GitServiceImpl } from "../git-service.js";
 import type { CaptureEntry } from "../captures.js";
 import type { BudgetAlertLevel } from "../auto-budget.js";
+import type { AutoOrchestrationModule } from "./contracts.js";
 import { resolveWorktreeProjectRoot } from "../worktree-root.js";
 import { normalizeRealPath } from "../paths.js";
 import type { MilestoneScope } from "../workspace.js";
@@ -229,6 +230,9 @@ export class AutoSession {
   /** Cleanup function returned by startCommandPolling(); null when not running. */
   commandPollingCleanup: (() => void) | null = null;
 
+  // ── Orchestration seam ───────────────────────────────────────────────────
+  orchestration: AutoOrchestrationModule | null = null;
+
   // ── Loop promise state ──────────────────────────────────────────────────
   // Per-unit resolve function and session-switch guard live at module level
   // in auto-loop.ts (_currentResolve, _sessionSwitchInFlight).
@@ -354,10 +358,14 @@ export class AutoSession {
     // Remote command polling — cleanup must be called before reset (auto.ts stopAuto)
     this.commandPollingCleanup = null;
 
+    // Orchestration seam
+    this.orchestration = null;
+
     // Loop promise state lives in auto-loop.ts module scope
   }
 
   toJSON(): Record<string, unknown> {
+    const orchestrationStatus = this.orchestration?.getStatus();
     return {
       active: this.active,
       paused: this.paused,
@@ -367,6 +375,9 @@ export class AutoSession {
       activeRunDir: this.activeRunDir,
       currentMilestoneId: this.currentMilestoneId,
       currentUnit: this.currentUnit,
+      orchestrationPhase: orchestrationStatus?.phase,
+      orchestrationTransitionCount: orchestrationStatus?.transitionCount,
+      orchestrationLastTransitionAt: orchestrationStatus?.lastTransitionAt,
       unitDispatchCount: Object.fromEntries(this.unitDispatchCount),
     };
   }

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

@@ -14,7 +14,7 @@ import { appendEvent } from "./workflow-events.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { clearParseCache } from "./files.js";
 import { parseRoadmap as parseLegacyRoadmap, parsePlan as parseLegacyPlan } from "./parsers-legacy.js";
-import { isDbAvailable, getTask, getSlice, getSliceTasks, getPendingGates, updateTaskStatus, updateSliceStatus, insertSlice, getMilestone } from "./gsd-db.js";
+import { isDbAvailable, getTask, getSlice, getSliceTasks, getPendingGates, updateTaskStatus, updateSliceStatus, insertSlice, getMilestone, refreshOpenDatabaseFromDisk } from "./gsd-db.js";
 import { isValidationTerminal } from "./state.js";
 import { getErrorMessage } from "./error-utils.js";
 import { logWarning, logError } from "./workflow-logger.js";
@@ -588,65 +588,32 @@ export function verifyExpectedArtifact(
     }
   }
 
-  // plan-slice must produce a plan with actual task entries, not just a scaffold.
-  // The plan file may exist from a prior discussion/context step with only headings
-  // but no tasks. Without this check the artifact is considered "complete" and the
-  // unit gets skipped — but deriveState still returns phase:"planning" because the
-  // plan has no tasks, creating an infinite skip loop (#699).
-  if (unitType === "plan-slice") {
-    const planContent = readFileSync(absPath, "utf-8");
-    // Accept checkbox-style (- [x] **T01: ...) or heading-style (### T01 -- / ### T01: / ### T01 —)
-    const hasCheckboxTask = /^- \[[xX ]\] \*\*T\d+:/m.test(planContent);
-    const hasHeadingTask = /^#{2,4}\s+T\d+\s*(?:--|—|:)/m.test(planContent);
-    if (!hasCheckboxTask && !hasHeadingTask) {
-      logWarning("recovery", `verify-fail ${unitType} ${unitId}: plan has no task checkbox/heading (len=${planContent.length}) at ${absPath}`);
-      return false;
-    }
-  }
-
-  // execute-task: DB status is authoritative. Fall back to checked-checkbox
-  // detection when the DB is unavailable (unmigrated projects), or when the
-  // disk artifacts already reflect completion but the DB replay is one beat
-  // behind the completion write.
-  if (unitType === "execute-task") {
-    const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
-    if (mid && sid && tid) {
-      const dbTask = getTask(mid, sid, tid);
-      if (dbTask) {
-        if (dbTask.status !== "complete" && dbTask.status !== "done" && !hasCheckedTaskCompletionOnDisk(base, mid, sid, tid)) {
-          return false;
-        }
-      } else if (!isDbAvailable()) {
-        // LEGACY: Pre-migration fallback for projects without DB.
-        // Require a CHECKED checkbox — a bare heading or unchecked checkbox
-        // does not prove gsd_complete_task ran. Summary file on disk alone
-        // is not sufficient evidence (could be a rogue write) (#3607).
-        if (!hasCheckedTaskCompletionOnDisk(base, mid, sid, tid)) return false;
-      } else {
-        // DB available but task row not found — completion tool never ran (#3607)
-        return false;
-      }
-    }
-  }
-
-  // plan-slice must also produce individual task plan files for every task listed
-  // in the slice plan. Without this check, a plan-slice that wrote S{sid}-PLAN.md
-  // but omitted T{tid}-PLAN.md files would be marked complete, causing execute-task
-  // to dispatch with a missing task plan (see issue #739).
+  // plan-slice verification is DB-primary. The slice plan is a projection, so
+  // DB task rows prove the slice was planned even if the rendered markdown no
+  // longer uses legacy checkbox/heading syntax.
   if (unitType === "plan-slice") {
     const { milestone: mid, slice: sid } = parseUnitId(unitId);
     if (mid && sid) {
       try {
-        // DB primary path — get task IDs to verify task plan files exist
         let taskIds: string[] | null = null;
         if (isDbAvailable()) {
-          const tasks = getSliceTasks(mid, sid);
-          if (tasks.length > 0) taskIds = tasks.map(t => t.id);
+          const refreshed = refreshOpenDatabaseFromDisk();
+          if (refreshed) {
+            const tasks = getSliceTasks(mid, sid);
+            if (tasks.length > 0) taskIds = tasks.map(t => t.id);
+          }
         }
 
         if (!taskIds) {
-          // LEGACY: DB unavailable or no tasks in DB — parse plan file for task IDs
+          // LEGACY: DB unavailable or no tasks in DB. Require actual task
+          // entries so an empty scaffold cannot advance the pipeline (#699).
           const planContent = readFileSync(absPath, "utf-8");
+          const hasCheckboxTask = /^\s*- \[[xX ]\] \*\*T\d+:/m.test(planContent);
+          const hasHeadingTask = /^\s*#{2,4}\s+T\d+\s*(?:--|—|:)/m.test(planContent);
+          if (!hasCheckboxTask && !hasHeadingTask) {
+            logWarning("recovery", `verify-fail ${unitType} ${unitId}: plan has no task checkbox/heading (len=${planContent.length}) at ${absPath}`);
+            return false;
+          }
           const plan = parseLegacyPlan(planContent);
           if (plan.tasks.length > 0) taskIds = plan.tasks.map((t: { id: string }) => t.id);
         }
@@ -672,6 +639,31 @@ export function verifyExpectedArtifact(
     }
   }
 
+  // execute-task: DB status is authoritative. Fall back to checked-checkbox
+  // detection when the DB is unavailable (unmigrated projects), or when the
+  // disk artifacts already reflect completion but the DB replay is one beat
+  // behind the completion write.
+  if (unitType === "execute-task") {
+    const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
+    if (mid && sid && tid) {
+      const dbTask = getTask(mid, sid, tid);
+      if (dbTask) {
+        if (dbTask.status !== "complete" && dbTask.status !== "done" && !hasCheckedTaskCompletionOnDisk(base, mid, sid, tid)) {
+          return false;
+        }
+      } else if (!isDbAvailable()) {
+        // LEGACY: Pre-migration fallback for projects without DB.
+        // Require a CHECKED checkbox — a bare heading or unchecked checkbox
+        // does not prove gsd_complete_task ran. Summary file on disk alone
+        // is not sufficient evidence (could be a rogue write) (#3607).
+        if (!hasCheckedTaskCompletionOnDisk(base, mid, sid, tid)) return false;
+      } else {
+        // DB available but task row not found — completion tool never ran (#3607)
+        return false;
+      }
+    }
+  }
+
   // complete-slice: DB status is authoritative for whether the slice is done.
   // Fall back to file-based check (roadmap [x]) when DB is unavailable.
   if (unitType === "complete-slice") {

package/src/resources/extensions/gsd/auto-runtime-state.ts

@@ -16,14 +16,21 @@ export type AutoRuntimeSnapshot = {
   paused: boolean;
   currentUnit: CurrentUnit | null;
   basePath: string;
+  orchestrationPhase?: "idle" | "running" | "paused" | "stopped" | "error";
+  orchestrationTransitionCount?: number;
+  orchestrationLastTransitionAt?: number;
 };
 
 export function getAutoRuntimeSnapshot(): AutoRuntimeSnapshot {
+  const orchestrationStatus = autoSession.orchestration?.getStatus();
   return {
     active: autoSession.active,
     paused: autoSession.paused,
     currentUnit: autoSession.currentUnit ? { ...autoSession.currentUnit } : null,
     basePath: autoSession.basePath,
+    orchestrationPhase: orchestrationStatus?.phase,
+    orchestrationTransitionCount: orchestrationStatus?.transitionCount,
+    orchestrationLastTransitionAt: orchestrationStatus?.lastTransitionAt,
   };
 }