@opengsd/gsd-pi 1.2.0-dev.fbdca60b → 1.3.0-dev.65546769

package/dist/resources/extensions/gsd/consent-question.js

@@ -170,6 +170,9 @@ export function classifyQuestion(input) {
 /**
  * THE single policy point for whether a question's answer counts as answered.
  *
+ * - timed_out rounds → "timeout" for every kind (host elicitation expired
+ *   before the user answered; fail-closed, but the caller pauses-and-waits
+ *   instead of re-asking into the same timeout loop, #852).
  * - cancelled rounds → "cancelled" for every kind.
  * - gate: delegates to evaluateGateAnswer in the consent-verdict leaf — the
  *   same verdict engine write-gate's applyAskUserQuestionsGateResult consumes;
@@ -181,6 +184,8 @@ export function classifyQuestion(input) {
  */
 export function evaluateAnswer(options) {
     const { question, details } = options;
+    if (details.timed_out)
+        return "timeout";
     if (details.cancelled)
         return "cancelled";
     const { kind } = classifyQuestion({ id: question.id, options: question.options });
@@ -203,6 +208,7 @@ export function evaluateAnswer(options) {
 }
 const OUTCOME_PRECEDENCE = [
     "cancelled",
+    "timeout",
     "waiting",
     "declined",
     "verified",
@@ -217,6 +223,12 @@ const OUTCOME_PRECEDENCE = [
  * a no-op, so it reports "answered" here.
  */
 export function evaluateAskUserQuestionsRound(questions, details) {
+    // timed_out is checked before cancelled: a host elicitation timeout is a
+    // more specific signal than the deliberate-dismissal cancelled it is also
+    // marked with, and callers must pause-and-wait instead of treating it as a
+    // re-ask-able cancel (#852).
+    if (details.timed_out)
+        return "timeout";
     if (details.cancelled)
         return "cancelled";
     let worst = "answered";

package/dist/resources/extensions/gsd/consent-verdict.js

@@ -44,13 +44,23 @@ export function hasNotesValue(notes) {
 /**
  * THE per-question verdict for gate questions (fail-closed):
  *
+ * - timed_out rounds → "timeout" (host elicitation expired before the user
+ *   answered; fail-closed — the gate stays pending — but the caller pauses
+ *   instead of re-asking into the same timeout loop, #852).
  * - cancelled rounds → "cancelled".
  * - the confirmation option (structural match) → "verified".
  * - any other real selection → "declined".
  * - empty/missing selection → "waiting" — an empty answer is NEVER an answer,
  *   so notes can never satisfy a gate either.
+ *
+ * `timed_out` is checked first: the handler marks a timed-out round with both
+ * `cancelled: true` and `timed_out: true` (see
+ * `askUserQuestionsHandler`), so the timeout must win to avoid the cancelled
+ * branch's re-ask semantics.
  */
 export function evaluateGateAnswer(question, details) {
+    if (details.timed_out)
+        return "timeout";
     if (details.cancelled)
         return "cancelled";
     const questionId = typeof question.id === "string" ? question.id : "";

package/dist/resources/extensions/gsd/dashboard-overlay.js

@@ -12,8 +12,10 @@ import { loadFile } from "./files.js";
 import { isDbAvailable, getMilestoneSlices, getSliceTasks } from "./gsd-db.js";
 import { resolveMilestoneFile } from "./paths.js";
 import { getAutoDashboardData } from "./auto.js";
+import { getAutoRuntimeSnapshot } from "./auto-runtime-state.js";
 import { getLedger, getProjectTotals, aggregateByPhase, aggregateBySlice, aggregateByModel, aggregateCacheHitRate, formatCost, formatTokenCount, formatCostProjection, getPromptSizeStats, } from "./metrics.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
+import { countPendingCaptures } from "./captures.js";
 import { getActiveWorktreeName } from "./worktree-session-state.js";
 import { getWorkerBatches, hasActiveWorkers } from "../subagent/worker-registry.js";
 import { formatDuration, padRight, joinColumns, centerLine, fitColumns, STATUS_GLYPH, STATUS_COLOR } from "../shared/mod.js";
@@ -102,20 +104,54 @@ export class GSDDashboardOverlay {
             currentUnit,
         ].join("|");
     }
+    refreshVolatileDashboardData(snapshot = getAutoRuntimeSnapshot()) {
+        let pendingCaptureCount = this.dashData.pendingCaptureCount;
+        try {
+            if (snapshot.basePath) {
+                pendingCaptureCount = countPendingCaptures(snapshot.basePath);
+            }
+        }
+        catch {
+            // Non-fatal — keep last known value
+        }
+        this.dashData = {
+            ...this.dashData,
+            active: snapshot.active,
+            paused: snapshot.paused,
+            currentUnit: snapshot.currentUnit
+                ? {
+                    type: snapshot.currentUnit.type,
+                    id: snapshot.currentUnit.id,
+                    startedAt: snapshot.currentUnit.startedAt,
+                }
+                : null,
+            basePath: snapshot.basePath,
+            elapsed: snapshot.active || snapshot.paused
+                ? (this.dashData.startTime > 0 ? Date.now() - this.dashData.startTime : 0)
+                : 0,
+            toolSurface: snapshot.toolSurface,
+            pendingCaptureCount,
+        };
+    }
     async refreshDashboard(initial = false) {
         if (this.disposed)
             return;
-        this.dashData = getAutoDashboardData();
-        const nextIdentity = this.computeDashboardIdentity(this.dashData);
+        const runtimeSnapshot = getAutoRuntimeSnapshot();
+        const nextIdentity = this.computeDashboardIdentity(runtimeSnapshot);
         const identityChanged = initial || nextIdentity !== this.loadedDashboardIdentity;
         if (identityChanged) {
+            this.dashData = getAutoDashboardData();
+            const loadedIdentity = this.computeDashboardIdentity(this.dashData);
             const loaded = await this.loadData();
             if (this.disposed)
                 return;
             if (loaded) {
-                this.loadedDashboardIdentity = nextIdentity;
+                this.loadedDashboardIdentity = loadedIdentity;
             }
         }
+        else {
+            this.refreshVolatileDashboardData(runtimeSnapshot);
+        }
         if (initial) {
             this.loading = false;
         }

package/dist/resources/extensions/gsd/db/engine.js

@@ -615,6 +615,33 @@ export function closeDatabase() {
     // failed open doesn't persist into the next open attempt or status check.
     _dbOpenState.reset();
 }
+/**
+ * Open an isolated database connection that does NOT touch the process-wide
+ * `currentDb` singleton. Intended for background observers (e.g. the parallel
+ * monitor overlay) that must read a database without displacing an active
+ * workflow session connection.
+ *
+ * The caller MUST call `adapter.close()` when done. Schema migrations are NOT
+ * run — the database must already exist and be fully migrated by the primary
+ * connection. Returns null if the connection cannot be opened.
+ */
+export function openIsolatedDatabase(path) {
+    try {
+        const rawDb = providerLoader.openRaw(path);
+        if (!rawDb)
+            return null;
+        const adapter = createDbAdapter(rawDb);
+        // Minimal pragmas for a short-lived read-only observer connection.
+        // WAL mode is already set file-wide by the primary connection; repeating
+        // it here is a no-op on an existing WAL file and safe to issue.
+        adapter.exec("PRAGMA journal_mode=WAL");
+        adapter.exec("PRAGMA busy_timeout = 5000");
+        return adapter;
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Re-open the active database connection from disk.
  *

package/dist/resources/extensions/gsd/db/queries.js

@@ -218,6 +218,46 @@ export function getMilestoneSlices(milestoneId) {
     const rows = getDbOrNull().prepare("SELECT * FROM slices WHERE milestone_id = :mid ORDER BY sequence, id").all({ ":mid": milestoneId });
     return rows.map(rowToSlice);
 }
+export function getParallelMonitorSliceProgress(milestoneId) {
+    const db = getDbOrNull();
+    if (!db)
+        return [];
+    const rows = db.prepare(`SELECT
+       s.id AS id,
+       s.status AS status,
+       COUNT(t.id) AS total,
+       COALESCE(SUM(CASE WHEN t.status='complete' THEN 1 ELSE 0 END), 0) AS done
+     FROM slices s
+     LEFT JOIN tasks t ON s.milestone_id=t.milestone_id AND s.id=t.slice_id
+     WHERE s.milestone_id=:mid
+     GROUP BY s.id
+     ORDER BY s.id`).all({ ":mid": milestoneId });
+    return rows.map((row) => ({
+        id: String(row["id"] ?? ""),
+        status: String(row["status"] ?? ""),
+        total: Number(row["total"] ?? 0),
+        done: Number(row["done"] ?? 0),
+    }));
+}
+export function getParallelMonitorRecentCompletions(milestoneId, limit = 5) {
+    const db = getDbOrNull();
+    if (!db)
+        return [];
+    const numericLimit = Number.isFinite(limit) ? Math.floor(limit) : 5;
+    const safeLimit = Math.max(1, Math.min(50, numericLimit));
+    const rows = db.prepare(`SELECT id, slice_id, one_liner
+     FROM tasks
+     WHERE milestone_id=:mid
+       AND status='complete'
+       AND completed_at IS NOT NULL
+     ORDER BY completed_at DESC
+     LIMIT ${safeLimit}`).all({ ":mid": milestoneId });
+    return rows.map((row) => ({
+        taskId: String(row["id"] ?? ""),
+        sliceId: String(row["slice_id"] ?? ""),
+        oneLiner: String(row["one_liner"] ?? ""),
+    }));
+}
 /**
  * Load slices for many milestones in a single query. Returns a Map keyed by
  * milestone_id, preserving `ORDER BY sequence, id` within each bucket.
@@ -281,6 +321,20 @@ export function getArtifact(path) {
         return null;
     return rowToArtifact(row);
 }
+/** Milestone-level artifacts (CONTEXT, RESEARCH, VALIDATION, etc.) from the artifacts table. */
+export function getMilestoneScopedArtifacts(milestoneId) {
+    if (!getDbOrNull())
+        return [];
+    const rows = getDbOrNull().prepare("SELECT * FROM artifacts WHERE milestone_id = :mid AND slice_id IS NULL AND task_id IS NULL ORDER BY path").all({ ":mid": milestoneId });
+    return rows.map(rowToArtifact);
+}
+/** Slice-level artifacts (CONTEXT, RESEARCH, CONTINUE, etc.) from the artifacts table. */
+export function getSliceScopedArtifacts(milestoneId, sliceId) {
+    if (!getDbOrNull())
+        return [];
+    const rows = getDbOrNull().prepare("SELECT * FROM artifacts WHERE milestone_id = :mid AND slice_id = :sid AND task_id IS NULL ORDER BY path").all({ ":mid": milestoneId, ":sid": sliceId });
+    return rows.map(rowToArtifact);
+}
 /** Fast milestone status check — avoids deserializing JSON planning fields. */
 export function getActiveMilestoneIdFromDb() {
     if (!getDbOrNull())

package/dist/resources/extensions/gsd/db/unit-dispatches.js

@@ -387,10 +387,31 @@ export function getRecentUnitKeysForWorker(workerId, limit = 20) {
     // Reverse so callers consume oldest-first (sliding-window semantics).
     return rows.reverse().map((r) => ({ key: r.unit_id }));
 }
-export function getRecentUnitKeysForProjectRoot(projectRootRealpath, limit = 20) {
+export function getRecentUnitKeysForProjectRoot(projectRootRealpath, limit = 20, traceId) {
     if (!isDbAvailable())
         return [];
     const db = _getAdapter();
+    // When a trace_id is provided, scope the window to the current session so
+    // stale finalize-retry entries from PREVIOUS sessions don't fire detectStuck
+    // Rule 1 on the first iteration of a new session — killing auto-mode before
+    // any new dispatch runs. Without this, a project that had two consecutive
+    // finalize-retry failures in a prior session is permanently stuck: every
+    // fresh session loads those stale errors and immediately declares stuck.
+    if (traceId) {
+        const rows = db.prepare(`SELECT ud.unit_type, ud.unit_id
+       FROM unit_dispatches ud
+       INNER JOIN workers w ON w.worker_id = ud.worker_id
+       WHERE w.project_root_realpath = :project_root_realpath
+         AND w.status != 'crashed'
+         AND ud.trace_id = :trace_id
+       ORDER BY ud.started_at DESC, ud.id DESC
+       LIMIT :limit`).all({
+            ":project_root_realpath": projectRootRealpath,
+            ":trace_id": traceId,
+            ":limit": limit,
+        });
+        return rows.reverse().map((r) => ({ key: `${r.unit_type}/${r.unit_id}` }));
+    }
     const rows = db.prepare(`SELECT ud.unit_type, ud.unit_id
      FROM unit_dispatches ud
      INNER JOIN workers w ON w.worker_id = ud.worker_id

package/dist/resources/extensions/gsd/db/writers/reconcile.js

@@ -10,6 +10,24 @@ import { createHash } from "node:crypto";
 import { logError, logWarning } from "../../workflow-logger.js";
 import { getDbOrNull, openDatabase } from "../engine.js";
 import { TERMINAL_STATUS_SQL } from "../sql-constants.js";
+/**
+ * Optional override for the project-root DB open inside reconcileWorktreeDb.
+ * Production leaves this null so the real engine.openDatabase runs; tests
+ * inject a function returning false to deterministically exercise the
+ * cannot-open-main-DB branch (reconcile.ts:82), which is otherwise unreachable
+ * without a contrived provider/OS fault (openDatabase rethrows on real failures
+ * rather than returning false across providers).
+ * @internal
+ */
+let _mainDbOpenerFn = null;
+export function _setMainDbOpenerFnForTests(fn) {
+    const previous = _mainDbOpenerFn;
+    _mainDbOpenerFn = fn;
+    return () => { _mainDbOpenerFn = previous; };
+}
+function openMainDb(mainDbPath) {
+    return _mainDbOpenerFn ? _mainDbOpenerFn(mainDbPath) : openDatabase(mainDbPath);
+}
 export function copyWorktreeDb(srcDbPath, destDbPath) {
     try {
         if (!existsSync(srcDbPath))
@@ -61,7 +79,7 @@ export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
         return zero;
     }
     if (!getDbOrNull()) {
-        const opened = openDatabase(mainDbPath);
+        const opened = openMainDb(mainDbPath);
         if (!opened) {
             logError("db", "worktree DB reconciliation failed: cannot open main DB");
             return zero;

package/dist/resources/extensions/gsd/db-workspace.js

@@ -2,7 +2,7 @@
 // File Purpose: Workspace-facing Interface for opening and maintaining the workflow database.
 import { existsSync } from "node:fs";
 import { dirname } from "node:path";
-import { backupDatabaseSnapshot, checkpointDatabase, closeAllDatabases, closeDatabase, closeDatabaseByWorkspace, getDbPath, getDbStatus, getDbProvider, isDbAvailable, openDatabase, openDatabaseByScope, openDatabaseByWorkspace, refreshOpenDatabaseFromDisk, vacuumDatabase, wasDbOpenAttempted, } from "./gsd-db.js";
+import { backupDatabaseSnapshot, checkpointDatabase, closeAllDatabases, closeDatabase, closeDatabaseByWorkspace, getDbPath, getDbStatus, getDbProvider, isDbAvailable, openDatabase, openDatabaseByScope, openDatabaseByWorkspace, openIsolatedDatabase, refreshOpenDatabaseFromDisk, vacuumDatabase, wasDbOpenAttempted, } from "./gsd-db.js";
 import { resolveGsdPathContract } from "./paths.js";
 import { setLogBasePath } from "./workflow-logger.js";
 export function resolveWorkflowDatabaseLocation(basePath) {
@@ -59,6 +59,18 @@ export function openExistingWorkflowDatabase(basePath) {
 export function openWorkflowDatabasePath(path) {
     return openDatabase(path);
 }
+/**
+ * Open an isolated database connection for read-only observation without
+ * displacing the active workflow session's global DB handle. The caller is
+ * responsible for calling `adapter.close()` when done.
+ *
+ * Use this for background observers (e.g. the parallel monitor overlay) that
+ * need to query a database on a 5s tick without interfering with the primary
+ * connection. Returns null if the connection cannot be opened.
+ */
+export function openWorkflowDatabaseIsolated(path) {
+    return openIsolatedDatabase(path);
+}
 export function openWorkflowDatabaseByWorkspace(workspace) {
     return openDatabaseByWorkspace(workspace);
 }

package/dist/resources/extensions/gsd/discussion-handoff.js

@@ -6,7 +6,7 @@ import { startAutoDetached } from "./auto.js";
 import { extractDepthVerificationMilestoneId, getPendingGate } from "./bootstrap/write-gate.js";
 import { getMilestone, insertMilestone, isDbAvailable } from "./gsd-db.js";
 import { assessMilestoneHandoffReadiness, formatAcceptedDiscussHandoffMessage, } from "./milestone-readiness.js";
-import { gsdRoot, resolveGsdRootFile, resolveMilestoneFile } from "./paths.js";
+import { clearPathCache, gsdRoot, resolveGsdRootFile, resolveMilestoneFile } from "./paths.js";
 import { _getPendingAutoStart, deletePendingAutoStart } from "./pending-auto-start.js";
 import { logWarning } from "./workflow-logger.js";
 import { readManifest } from "./workflow-manifest.js";
@@ -186,14 +186,18 @@ function cleanupAcceptedHandoffArtifacts(entry) {
 }
 /** Called from agent_end to check if auto-mode should start after discuss. */
 export function checkAutoStartAfterDiscuss(lookupBasePath) {
+    // Clear the path cache so layout-aware resolution sees fresh directory
+    // listings — the cache may have been primed before discuss wrote its
+    // artifacts (e.g. CONTEXT.md), causing resolveMilestoneFile to miss them.
+    clearPathCache();
     const entry = _getPendingAutoStart(lookupBasePath);
     if (!entry)
         return false;
     const { ctx, pi, basePath, milestoneId, step } = entry;
-    const contextFilePath = entry.scope.contextFile();
-    const roadmapFilePath = entry.scope.roadmapFile();
-    const contextFile = existsSync(contextFilePath) ? contextFilePath : null;
-    const roadmapFile = existsSync(roadmapFilePath) ? roadmapFilePath : null;
+    // Use layout-aware resolution so flat-phase projects (phases/NN-slug/)
+    // are found as well as legacy projects (milestones/MID/).
+    const contextFile = resolveMilestoneFile(basePath, milestoneId, "CONTEXT");
+    const roadmapFile = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
     if (!contextFile && !roadmapFile)
         return false;
     if (hasBlockingDepthGate(entry))

package/dist/resources/extensions/gsd/doctor-git-checks.js

@@ -6,13 +6,14 @@ import { loadFile } from "./files.js";
 import { resolveMilestoneFile } from "./paths.js";
 import { isCompletedMilestoneTerminal } from "./milestone-closeout.js";
 import { deriveState } from "./state.js";
+import { isClosedStatus } from "./status-guards.js";
 import { allWorktreesDirs, createWorktree, listWorktrees, resolveGitDir } from "./worktree-manager.js";
 import { abortAndReset } from "./git-self-heal.js";
 import { RUNTIME_EXCLUSION_PATHS, resolveMilestoneIntegrationBranch, writeIntegrationBranch } from "./git-service.js";
 import { nativeIsRepo, nativeWorktreeList, nativeWorktreeRemove, nativeBranchList, nativeBranchDelete, nativeLsFiles, nativeRmCached, nativeHasChanges, nativeLastCommitEpoch, nativeGetCurrentBranch, nativeAddTracked, nativeCommit } from "./native-git-bridge.js";
 import { getAllWorktreeHealth } from "./worktree-health.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
-import { listUnmergedGitPaths } from "./git-conflict-state.js";
+import { listUnmergedGitPaths, probeGitConflictState, reconcileGitConflictsOnSignal } from "./git-conflict-state.js";
 import { resolveWorktreeProjectRoot } from "./worktree-root.js";
 /**
  * Returns true if the directory contains only doctor artifacts
@@ -140,13 +141,13 @@ function getSnapshotDiffCheckFailure(basePath) {
     }
     return failures.length > 0 ? failures.join("\n") : null;
 }
-export async function checkGitHealth(basePath, issues, fixesApplied, shouldFix, isolationMode = "none") {
+export async function checkGitHealth(basePath, issues, fixesApplied, shouldFix, isolationMode = "none", dryRun = false) {
     // Degrade gracefully if not a git repo
     if (!nativeIsRepo(basePath)) {
         return; // Not a git repo — skip all git health checks
     }
     const gitDir = resolveGitDir(basePath);
-    const unmergedPaths = listUnmergedGitPaths(basePath);
+    let unmergedPaths = listUnmergedGitPaths(basePath);
     if (unmergedPaths === null) {
         issues.push({
             severity: "error",
@@ -158,6 +159,28 @@ export async function checkGitHealth(basePath, issues, fixesApplied, shouldFix,
         });
         return;
     }
+    // ── Auto-resolve safe conflicts before reporting ──────────────────────
+    // A failed worktree merge (e.g. during complete-slice) can leave conflict
+    // markers for paths that are always safe to accept from the milestone side
+    // (.gsd/ state and build artifacts). Run the same reconciliation the
+    // preflight/auto-worktree paths use before the doctor hard-blocks auto-mode,
+    // so only genuinely-manual conflicts remain. This also clears stale
+    // merge-state markers (e.g. MERGE_HEAD) in the same pass when auto-resolve
+    // empties the unmerged set (#849).
+    if (unmergedPaths.length > 0 && !dryRun) {
+        try {
+            const reconcileFixes = reconcileGitConflictsOnSignal(basePath, probeGitConflictState(basePath));
+            if (reconcileFixes.length > 0) {
+                fixesApplied.push(...reconcileFixes);
+                const refreshed = listUnmergedGitPaths(basePath);
+                if (refreshed !== null)
+                    unmergedPaths = refreshed;
+            }
+        }
+        catch {
+            // Non-fatal — fall through to report the unmerged paths as-is
+        }
+    }
     // ── Orphaned auto-worktrees & Stale milestone branches ────────────────
     // These checks only apply in worktree/branch modes — skip in none mode
     // where no milestone worktrees or branches are created.
@@ -174,7 +197,7 @@ export async function checkGitHealth(basePath, issues, fixesApplied, shouldFix,
                 const milestoneId = wt.branch.replace(/^milestone\//, "");
                 const milestoneEntry = state.registry.find(m => m.id === milestoneId);
                 const isComplete = milestoneEntry
-                    ? await isCompletedMilestoneTerminal(basePath, milestoneId)
+                    ? isClosedStatus(milestoneEntry.status)
                     : false;
                 if (!isComplete && !hasProjectContentOnDisk(wt.path) && hasProjectContentOnDisk(basePath)) {
                     issues.push({
@@ -269,6 +292,9 @@ export async function checkGitHealth(basePath, issues, fixesApplied, shouldFix,
                         const roadmapContent = roadmapPath ? await loadFile(roadmapPath) : null;
                         if (!roadmapContent)
                             continue;
+                        const milestoneEntry = state.registry.find(m => m.id === milestoneId);
+                        if (!milestoneEntry || !isClosedStatus(milestoneEntry.status))
+                            continue;
                         branchMilestoneComplete = await isCompletedMilestoneTerminal(basePath, milestoneId);
                         if (branchMilestoneComplete) {
                             issues.push({

package/dist/resources/extensions/gsd/doctor-providers.js

@@ -35,7 +35,7 @@ const CLI_AUTH_PROVIDERS = new Set([
 const PROVIDER_ROUTES = {
     anthropic: ["github-copilot", "claude-code"],
     openai: ["github-copilot", "openai-codex"],
-    google: ["google-gemini-cli"],
+    google: ["google-antigravity", "google-gemini-cli"],
 };
 // ── Model → Provider ID mapping ───────────────────────────────────────────────
 /**

package/dist/resources/extensions/gsd/doctor-runtime-checks.js

@@ -10,25 +10,12 @@ import { getActiveAutoWorkers } from "./db/auto-workers.js";
 import { normalizeRealPath } from "./paths.js";
 import { ensureGitignore, isGsdGitignored } from "./gitignore.js";
 import { readAllSessionStatuses, isSessionStale, removeSessionStatus } from "./session-status-io.js";
-import { recoverFailedMigration } from "./migrate-external.js";
+import { isCurrentGsdStateIntactForMigratingCleanup, recoverFailedMigration } from "./migrate-external.js";
 import { splitCompletedKey } from "./forensics.js";
 import { findMilestoneIds } from "./milestone-ids.js";
 import { getAllMilestones, isDbAvailable } from "./gsd-db.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 const MAX_UAT_ATTEMPTS = 3;
-function isCurrentGsdStateIntactForMigratingCleanup(basePath) {
-    try {
-        const stateFile = resolveGsdRootFile(basePath, "STATE");
-        const milestonesPath = milestonesDir(basePath);
-        const dbPath = join(gsdRoot(basePath), "gsd.db");
-        const hasDbFile = existsSync(dbPath);
-        const hasNonEmptyDb = hasDbFile && statSync(dbPath).size > 0;
-        return existsSync(stateFile) && existsSync(milestonesPath) && hasNonEmptyDb;
-    }
-    catch {
-        return false;
-    }
-}
 function hasAssessmentVerdict(basePath, mid, sid) {
     const assessmentPath = join(gsdRoot(basePath), "milestones", mid, "slices", sid, `${sid}-ASSESSMENT.md`);
     if (!existsSync(assessmentPath))
@@ -53,19 +40,21 @@ export async function checkRuntimeHealth(basePath, issues, fixesApplied, shouldF
         if (lock) {
             const alive = isLockProcessAlive(lock);
             if (!alive) {
-                issues.push({
-                    severity: "error",
-                    code: "stale_crash_lock",
-                    scope: "project",
-                    unitId: "project",
-                    message: `Stale auto-mode worker (PID ${lock.pid}, started ${lock.startedAt}, was executing ${lock.unitType} ${lock.unitId}) — process is no longer running`,
-                    file: "<workers table>",
-                    fixable: true,
-                });
                 if (shouldFix("stale_crash_lock")) {
                     clearStaleWorkerLock(basePath);
                     fixesApplied.push("cleared stale auto-mode worker state");
                 }
+                else {
+                    issues.push({
+                        severity: "error",
+                        code: "stale_crash_lock",
+                        scope: "project",
+                        unitId: "project",
+                        message: `Stale auto-mode worker (PID ${lock.pid}, started ${lock.startedAt}, was executing ${lock.unitType} ${lock.unitId}) — process is no longer running`,
+                        file: "<workers table>",
+                        fixable: true,
+                    });
+                }
             }
         }
     }
@@ -440,7 +429,7 @@ export async function checkRuntimeHealth(basePath, issues, fixesApplied, shouldF
                 });
                 if (shouldFix("failed_migration")) {
                     if (recoverFailedMigration(basePath)) {
-                        fixesApplied.push("recovered failed migration (.gsd.migrating → .gsd)");
+                        fixesApplied.push("recovered failed external state migration");
                     }
                     else if (isCurrentGsdStateIntactForMigratingCleanup(basePath)) {
                         try {

package/dist/resources/extensions/gsd/doctor.js

@@ -4,7 +4,8 @@ import { loadFile, parseSummary, saveFile, parseTaskPlanMustHaves, countMustHave
 import { parseRoadmap as parseLegacyRoadmap, parsePlan as parseLegacyPlan } from "./parsers-legacy.js";
 import { isDbAvailable, getMilestoneSlices, getSliceTasks } from "./gsd-db.js";
 import { openExistingWorkflowDatabase } from "./db-workspace.js";
-import { resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveTasksDir, milestonesDir, gsdRoot, relMilestoneFile, relSliceFile, relTaskFile, relSlicePath, relGsdRootFile, resolveGsdRootFile, relMilestonePath } from "./paths.js";
+import { resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveTasksDir, milestonesDir, legacyMilestonesDir, gsdRoot, relMilestoneFile, relSliceFile, relTaskFile, relSlicePath, relGsdRootFile, resolveGsdRootFile, relMilestonePath } from "./paths.js";
+import { findMilestoneIds } from "./milestone-ids.js";
 import { deriveState, isMilestoneComplete } from "./state.js";
 import { invalidateAllCaches } from "./cache.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
@@ -171,7 +172,8 @@ export async function selectDoctorScope(basePath, requestedScope) {
         return state.activeMilestone.id;
     }
     const milestonesPath = milestonesDir(basePath);
-    if (!existsSync(milestonesPath))
+    const legacyMilestonesPath = legacyMilestonesDir(basePath);
+    if (!existsSync(milestonesPath) && !existsSync(legacyMilestonesPath))
         return undefined;
     for (const milestone of state.registry) {
         const roadmapPath = resolveMilestoneFile(basePath, milestone.id, "ROADMAP");
@@ -333,7 +335,7 @@ export async function runGSDDoctor(basePath, options) {
     const isolationMode = options?.isolationMode ??
         (prefs?.preferences?.git?.isolation === "worktree" ? "worktree" :
             prefs?.preferences?.git?.isolation === "branch" ? "branch" : "none");
-    await checkGitHealth(basePath, issues, fixesApplied, shouldFix, isolationMode);
+    await checkGitHealth(basePath, issues, fixesApplied, shouldFix, isolationMode, dryRun);
     const gitMs = Date.now() - t0git;
     // Runtime health checks — timed
     const t0runtime = Date.now();
@@ -352,7 +354,8 @@ export async function runGSDDoctor(basePath, options) {
     // Engine health checks — DB constraints and projection drift
     await checkEngineHealth(basePath, issues, fixesApplied);
     const milestonesPath = milestonesDir(basePath);
-    if (!existsSync(milestonesPath)) {
+    const legacyMilestonesPath2 = legacyMilestonesDir(basePath);
+    if (!existsSync(milestonesPath) && !existsSync(legacyMilestonesPath2)) {
         const report = { ok: issues.every(i => i.severity !== "error"), basePath, issues, fixesApplied, timing: { git: gitMs, runtime: runtimeMs, environment: envMs, gsdState: 0 } };
         await appendDoctorHistory(basePath, report);
         return report;
@@ -396,7 +399,13 @@ export async function runGSDDoctor(basePath, options) {
             // Non-fatal — provider check failure should not block other checks
         }
     }
-    for (const milestone of state.registry) {
+    // When DB is unavailable, state.registry is empty. Fall back to a direct
+    // filesystem scan so the doctor can still report issues (e.g. missing ROADMAP)
+    // for milestone dirs that exist on disk.
+    const milestoneEntries = state.registry.length > 0
+        ? state.registry
+        : findMilestoneIds(basePath).map(id => ({ id, title: id }));
+    for (const milestone of milestoneEntries) {
         const milestoneId = milestone.id;
         const milestonePath = resolveMilestonePath(basePath, milestoneId);
         if (!milestonePath)
@@ -433,8 +442,17 @@ export async function runGSDDoctor(basePath, options) {
         }
         const roadmapPath = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
         const roadmapContent = roadmapPath ? await loadFile(roadmapPath) : null;
-        if (!roadmapContent)
+        if (!roadmapContent) {
+            issues.push({
+                severity: "error",
+                code: "missing_roadmap",
+                scope: "milestone",
+                unitId: milestoneId,
+                message: `Milestone ${milestoneId} is missing its ROADMAP.md file.`,
+                fixable: false,
+            });
             continue;
+        }
         let slices;
         if (isDbAvailable()) {
             const dbSlices = getMilestoneSlices(milestoneId);
@@ -574,6 +592,9 @@ export async function runGSDDoctor(basePath, options) {
                 // Skipped slices may legitimately never create tasks/.
                 if (slice.pending || slice.skipped)
                     continue;
+                // Flat-phase: tasks are embedded in plan files; no tasks/ subdir expected.
+                if (!existsSync(legacyMilestonesDir(basePath)))
+                    continue;
                 issues.push({
                     severity: slice.done ? "warning" : "error",
                     code: "missing_tasks_dir",
@@ -739,7 +760,7 @@ export async function runGSDDoctor(basePath, options) {
                 code: "all_slices_done_missing_milestone_validation",
                 scope: "milestone",
                 unitId: milestoneId,
-                message: `All slices are done but ${milestoneId}-VALIDATION.md is missing \u2014 milestone is in validating-milestone phase`,
+                message: `All slices are done but the milestone VALIDATION.md is missing \u2014 milestone is in validating-milestone phase`,
                 file: relMilestoneFile(basePath, milestoneId, "VALIDATION"),
                 fixable: false,
             });

package/dist/resources/extensions/gsd/error-classifier.js

@@ -9,7 +9,7 @@
  *
  * @see https://github.com/open-gsd/gsd-pi/issues/2577
  */
-import { TOOL_SURFACE_NOT_READY } from "./tool-surface-readiness.js";
+import { TOOL_SURFACE_NOT_READY, isTerminalToolSurfaceError } from "./tool-surface-readiness.js";
 export function createRetryState() {
     return { networkRetryCount: 0, consecutiveTransientCount: 0, currentRetryModelId: undefined };
 }
@@ -82,7 +82,19 @@ export function classifyError(errorMsg, retryAfterMs) {
     if (TOOL_SCHEMA_RE.test(errorMsg)) {
         return { kind: "tool-schema", retryAfterMs: 0 };
     }
+    // Terminal tool-surface failure: the workflow MCP server is in a
+    // non-self-healing status (failed / needs-auth / disabled). This is NOT
+    // transient — retrying the same model cannot repair a dead server, so it
+    // must escalate / pause rather than retrying every ~3s into the per-unit
+    // cost cap. Checked ahead of the transient readiness branch below, which
+    // shares the TOOL_SURFACE_NOT_READY prefix and would otherwise collapse the
+    // terminal case into a transient `network` retry. See #783.
+    if (isTerminalToolSurfaceError(errorMsg)) {
+        return { kind: "permanent" };
+    }
     // Tool-surface readiness abort — transient; retry the same model shortly.
+    // This covers the not-yet-connected variants (absent, pending, connected but
+    // not registered); terminal statuses were handled by the branch above.
     if (TOOL_SURFACE_NOT_READY_RE.test(errorMsg)) {
         return { kind: "network", retryAfterMs: retryAfterMs ?? 3_000 };
     }