gsd-pi 2.67.0-dev.fe39184 → 2.68.0-dev.4cf2433

package/src/resources/extensions/gsd/guided-flow.ts

@@ -16,7 +16,12 @@ import { buildSkillActivationBlock } from "./auto-prompts.js";
 import { deriveState } from "./state.js";
 import { invalidateAllCaches } from "./cache.js";
 import { startAuto } from "./auto.js";
-import { readCrashLock, clearLock, formatCrashInfo } from "./crash-recovery.js";
+import { clearLock } from "./crash-recovery.js";
+import {
+  assessInterruptedSession,
+  formatInterruptedSessionRunningMessage,
+  formatInterruptedSessionSummary,
+} from "./interrupted-session.js";
 import { listUnitRuntimeRecords, clearUnitRuntimeRecord } from "./unit-runtime.js";
 import { resolveExpectedArtifactPath } from "./auto.js";
 import {
@@ -215,17 +220,9 @@ export function checkAutoStartAfterDiscuss(): boolean {
 
   // Gate 4: Discussion manifest process verification (multi-milestone only)
   // The LLM writes DISCUSSION-MANIFEST.json after each Phase 3 gate decision.
-  // If the project is multi-milestone, the manifest is required. When it is
-  // missing, fail closed instead of assuming the discussion finished.
+  // When it exists, validate it before auto-starting. Project history alone is
+  // not a reliable signal for the current discussion mode.
   const manifestPath = join(gsdRoot(basePath), "DISCUSSION-MANIFEST.json");
-  const requiresManifest = projectIds.length > 1 || findMilestoneIds(basePath).length > 1;
-  if (requiresManifest && !existsSync(manifestPath)) {
-    ctx.ui.notify(
-      "Multi-milestone discussion manifest is missing. Auto-start will remain paused until the manifest is written.",
-      "warning",
-    );
-    return false;
-  }
   if (existsSync(manifestPath)) {
     try {
       const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
@@ -1322,36 +1319,45 @@ export async function showSmartEntry(
   // ── Self-heal stale runtime records from crashed auto-mode sessions ──
   selfHealRuntimeRecords(basePath, ctx);
 
-  // Check for crash from previous auto-mode session.
-  // Skip if the lock was written by the current process — acquireSessionLock()
-  // writes to the same file, so we'd always false-positive (#1398).
-  const crashLock = readCrashLock(basePath);
-  if (crashLock && crashLock.pid !== process.pid) {
-    clearLock(basePath);
+  const interrupted = await assessInterruptedSession(basePath);
+  if (interrupted.classification === "running") {
+    ctx.ui.notify(formatInterruptedSessionRunningMessage(interrupted), "error");
+    return;
+  }
 
-    // Bootstrap crash with zero completed units = no work was lost.
-    // Auto-discard instead of prompting the user — this commonly happens
-    // when the user exits during init wizard or discuss phase before any
-    // real auto-mode work begins.
-    const isBootstrapCrash = crashLock.unitType === "starting"
-      && crashLock.unitId === "bootstrap";
-
-    if (!isBootstrapCrash) {
-      const resume = await showNextAction(ctx, {
-        title: "GSD — Interrupted Session Detected",
-        summary: [formatCrashInfo(crashLock)],
-        actions: [
-          { id: "resume", label: "Resume with /gsd auto", description: "Pick up where it left off", recommended: true },
-          { id: "continue", label: "Continue manually", description: "Open the wizard as normal" },
-        ],
-      });
-      if (resume === "resume") {
-        await startAuto(ctx, pi, basePath, false);
-        return;
+  if (interrupted.classification === "stale") {
+    clearLock(basePath);
+    if (interrupted.pausedSession) {
+      try {
+        unlinkSync(join(gsdRoot(basePath), "runtime", "paused-session.json"));
+      } catch (e) {
+        logWarning("guided", `stale pause file cleanup failed: ${(e as Error).message}`, { file: "guided-flow.ts" });
       }
     }
+  } else if (interrupted.classification === "recoverable") {
+    if (interrupted.lock) clearLock(basePath);
+    const resumeLabel = interrupted.pausedSession?.stepMode
+      ? "Resume with /gsd next"
+      : "Resume with /gsd auto";
+    const resume = await showNextAction(ctx, {
+      title: "GSD — Interrupted Session Detected",
+      summary: formatInterruptedSessionSummary(interrupted),
+      actions: [
+        { id: "resume", label: resumeLabel, description: "Pick up where it left off", recommended: true },
+        { id: "continue", label: "Continue manually", description: "Open the wizard as normal" },
+      ],
+    });
+    if (resume === "resume") {
+      await startAuto(ctx, pi, basePath, false, {
+        interrupted,
+        step: interrupted.pausedSession?.stepMode ?? false,
+      });
+      return;
+    }
   }
 
+  // Always derive from the project root — the assessment may have derived
+  // state from a worktree path that was cleaned up in the stale branch above.
   const state = await deriveState(basePath);
 
   // Rebuild STATE.md from derived state before any dispatch (#3475).

package/src/resources/extensions/gsd/interrupted-session.ts

@@ -0,0 +1,224 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { verifyExpectedArtifact } from "./auto-recovery.js";
+import {
+  formatCrashInfo,
+  isLockProcessAlive,
+  readCrashLock,
+  type LockData,
+} from "./crash-recovery.js";
+import { gsdRoot } from "./paths.js";
+import {
+  synthesizeCrashRecovery,
+  type RecoveryBriefing,
+} from "./session-forensics.js";
+import { deriveState } from "./state.js";
+import type { GSDState } from "./types.js";
+
+export type InterruptedSessionClassification =
+  | "none"
+  | "running"
+  | "recoverable"
+  | "stale";
+
+export interface PausedSessionMetadata {
+  milestoneId?: string;
+  worktreePath?: string | null;
+  originalBasePath?: string;
+  stepMode?: boolean;
+  pausedAt?: string;
+  sessionFile?: string | null;
+  unitType?: string;
+  unitId?: string;
+  activeEngineId?: string;
+  activeRunDir?: string | null;
+  autoStartTime?: number;
+}
+
+export interface InterruptedSessionAssessment {
+  classification: InterruptedSessionClassification;
+  lock: LockData | null;
+  pausedSession: PausedSessionMetadata | null;
+  state: GSDState | null;
+  recovery: RecoveryBriefing | null;
+  recoveryPrompt: string | null;
+  recoveryToolCallCount: number;
+  artifactSatisfied: boolean;
+  hasResumableDiskState: boolean;
+  isBootstrapCrash: boolean;
+}
+
+export function readPausedSessionMetadata(
+  basePath: string,
+): PausedSessionMetadata | null {
+  const pausedPath = join(gsdRoot(basePath), "runtime", "paused-session.json");
+  if (!existsSync(pausedPath)) return null;
+
+  try {
+    return JSON.parse(readFileSync(pausedPath, "utf-8")) as PausedSessionMetadata;
+  } catch {
+    return null;
+  }
+}
+
+export function isBootstrapCrashLock(lock: LockData | null): boolean {
+  return !!(
+    lock &&
+    lock.unitType === "starting" &&
+    lock.unitId === "bootstrap"
+  );
+}
+
+export function hasResumableDerivedState(state: GSDState | null): boolean {
+  return !!(state?.activeMilestone && state.phase !== "complete");
+}
+
+export async function assessInterruptedSession(
+  basePath: string,
+): Promise<InterruptedSessionAssessment> {
+  const pausedSession = readPausedSessionMetadata(basePath);
+  const worktreeExists = pausedSession?.worktreePath
+    ? existsSync(pausedSession.worktreePath)
+    : false;
+  const assessmentBasePath = worktreeExists ? pausedSession!.worktreePath! : basePath;
+  const rawLock = readCrashLock(basePath);
+  const lock = rawLock && rawLock.pid !== process.pid ? rawLock : null;
+
+  if (!lock && !pausedSession) {
+    return {
+      classification: "none",
+      lock: null,
+      pausedSession: null,
+      state: null,
+      recovery: null,
+      recoveryPrompt: null,
+      recoveryToolCallCount: 0,
+      artifactSatisfied: false,
+      hasResumableDiskState: false,
+      isBootstrapCrash: false,
+    };
+  }
+
+  if (lock && isLockProcessAlive(lock)) {
+    return {
+      classification: "running",
+      lock,
+      pausedSession,
+      state: null,
+      recovery: null,
+      recoveryPrompt: null,
+      recoveryToolCallCount: 0,
+      artifactSatisfied: false,
+      hasResumableDiskState: false,
+      isBootstrapCrash: false,
+    };
+  }
+
+  const isBootstrapCrash = isBootstrapCrashLock(lock);
+  const state = await deriveState(assessmentBasePath);
+  const hasResumableDiskState = hasResumableDerivedState(state);
+  const artifactSatisfied = !!(
+    lock &&
+    !isBootstrapCrash &&
+    verifyExpectedArtifact(lock.unitType, lock.unitId, assessmentBasePath)
+  );
+
+  let recovery: RecoveryBriefing | null = null;
+  if (lock && !isBootstrapCrash && !artifactSatisfied) {
+    recovery = synthesizeCrashRecovery(
+      assessmentBasePath,
+      lock.unitType,
+      lock.unitId,
+      lock.sessionFile,
+      join(gsdRoot(assessmentBasePath), "activity"),
+    );
+  }
+
+  const recoveryToolCallCount = recovery?.trace.toolCallCount ?? 0;
+  const recoveryPrompt = recoveryToolCallCount > 0 ? recovery!.prompt : null;
+
+  if (isBootstrapCrash) {
+    return {
+      classification: pausedSession ? "recoverable" : "stale",
+      lock,
+      pausedSession,
+      state,
+      recovery,
+      recoveryPrompt,
+      recoveryToolCallCount,
+      artifactSatisfied,
+      hasResumableDiskState,
+      isBootstrapCrash: true,
+    };
+  }
+
+  if (!hasResumableDiskState && pausedSession && !lock && recoveryToolCallCount === 0) {
+    return {
+      classification: "stale",
+      lock,
+      pausedSession,
+      state,
+      recovery,
+      recoveryPrompt,
+      recoveryToolCallCount,
+      artifactSatisfied,
+      hasResumableDiskState,
+      isBootstrapCrash: false,
+    };
+  }
+
+  if (lock && artifactSatisfied && !hasResumableDiskState && recoveryToolCallCount === 0) {
+    return {
+      classification: "stale",
+      lock,
+      pausedSession,
+      state,
+      recovery,
+      recoveryPrompt,
+      recoveryToolCallCount,
+      artifactSatisfied,
+      hasResumableDiskState,
+      isBootstrapCrash: false,
+    };
+  }
+
+  const hasStrongRecoverySignal =
+    hasResumableDiskState || recoveryToolCallCount > 0;
+
+  return {
+    classification: hasStrongRecoverySignal ? "recoverable" : "stale",
+    lock,
+    pausedSession,
+    state,
+    recovery,
+    recoveryPrompt,
+    recoveryToolCallCount,
+    artifactSatisfied,
+    hasResumableDiskState,
+    isBootstrapCrash: false,
+  };
+}
+
+export function formatInterruptedSessionSummary(
+  assessment: InterruptedSessionAssessment,
+): string[] {
+  if (assessment.lock) return [formatCrashInfo(assessment.lock)];
+
+  if (assessment.pausedSession?.milestoneId) {
+    return [
+      `Paused auto-mode session detected for ${assessment.pausedSession.milestoneId}.`,
+    ];
+  }
+
+  return ["Paused auto-mode session detected."];
+}
+
+export function formatInterruptedSessionRunningMessage(
+  assessment: InterruptedSessionAssessment,
+): string {
+  const pid = assessment.lock?.pid;
+  return pid
+    ? `Another auto-mode session (PID ${pid}) appears to be running.\nStop it with \`kill ${pid}\` before starting a new session.`
+    : "Another auto-mode session appears to be running.";
+}

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

@@ -47,6 +47,7 @@ import { extractVerdict } from './verdict-parser.js';
 
 import {
   isDbAvailable,
+  wasDbOpenAttempted,
   getAllMilestones,
   getMilestone,
   getMilestoneSlices,
@@ -271,7 +272,12 @@ export async function deriveState(basePath: string): Promise<GSDState> {
       _telemetry.markdownDeriveCount++;
     }
   } else {
-    logWarning("state", "DB unavailable — using filesystem state derivation (degraded mode)");
+    // Only warn when DB initialization was attempted and failed — not when
+    // the DB simply hasn't been opened yet (e.g. during before_agent_start
+    // context injection which runs before any tool invocation opens the DB).
+    if (wasDbOpenAttempted()) {
+      logWarning("state", "DB unavailable — using filesystem state derivation (degraded mode)");
+    }
     result = await _deriveStateImpl(basePath);
     _telemetry.markdownDeriveCount++;
   }