@opengsd/gsd-pi 1.9.0-dev.5c1a3ff2 → 1.9.0-dev.d2070876

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

@@ -88,6 +88,7 @@ import { classifyMilestoneSummaryContent } from "./milestone-summary-classifier.
 import { extractVerdict } from "./verdict-parser.js";
 import { auditOrphanedPreflightStashes } from "./orphan-stash-audit.js";
 import { parseProject } from "./schemas/parsers.js";
+import { LAYOUT_SEGMENTS } from "./layout-policy.js";
 
 import {
   debugLog,
@@ -152,6 +153,33 @@ export function hasGitIndexLockForTest(basePath: string): boolean {
   return existsSync(join(basePath, ".git", "index.lock"));
 }
 
+function isEmptyDirectory(dirPath: string): boolean {
+  try {
+    return existsSync(dirPath) && readdirSync(dirPath).length === 0;
+  } catch {
+    return false;
+  }
+}
+
+export function reconcileFlatPhaseBootstrapLayout(basePath: string): boolean {
+  const gsdDir = join(basePath, ".gsd");
+  const phasesPath = join(gsdDir, LAYOUT_SEGMENTS.level1);
+  const milestonesPath = join(gsdDir, "milestones");
+
+  if (isEmptyDirectory(milestonesPath)) {
+    if (!existsSync(phasesPath)) mkdirSync(phasesPath, { recursive: true });
+    rmSync(milestonesPath, { recursive: true, force: true });
+    return true;
+  }
+
+  if (!existsSync(phasesPath) && !existsSync(milestonesPath)) {
+    mkdirSync(phasesPath, { recursive: true });
+    return true;
+  }
+
+  return false;
+}
+
 export function _shouldAbortBootstrapForUnavailableDbForTest(
   gsdDbPath: string,
   dbAvailable: boolean,
@@ -1152,19 +1180,14 @@ export async function bootstrapAutoSession(
     ensureGitignore(base, { manageGitignore });
     if (manageGitignore !== false) untrackRuntimeFiles(base);
 
-    // Bootstrap milestones/ if it doesn't exist.
-    // Check milestones/ directly — ensureGsdSymlink above already created .gsd/,
-    // so checking .gsd/ existence would be dead code (#2942).
-    const gsdDir = join(base, ".gsd");
-    const milestonesPath = join(gsdDir, "milestones");
-    if (!existsSync(milestonesPath)) {
-      mkdirSync(milestonesPath, { recursive: true });
+    // Bootstrap the flat-phase projection root and clean empty legacy scaffolds.
+    if (reconcileFlatPhaseBootstrapLayout(base)) {
       try {
         nativeAddAll(base);
         nativeCommit(base, "chore: init gsd");
       } catch (err) {
         /* nothing to commit */
-        logWarning("engine", `mkdir failed: ${err instanceof Error ? err.message : String(err)}`);
+        logWarning("engine", `layout bootstrap commit failed: ${err instanceof Error ? err.message : String(err)}`);
       }
     }
 

package/src/resources/extensions/gsd/auto-tool-tracking.ts

@@ -132,6 +132,8 @@ export function clearInFlightTools(): void {
  */
 const TOOL_INVOCATION_ERROR_RE = /Validation failed for tool|Input validation error|Invalid arguments for tool|MCP error -32602|No such tool available|Expected ',' or '\}'(?: after property value)?(?: in JSON)?|Unexpected end of JSON|Unexpected token.*in JSON|does not provide an export named|Named export .* not found|Cannot find module|ERR_MODULE_NOT_FOUND|ERR_MODULE_NOT_EXPORTED|ERR_PACKAGE_PATH_NOT_EXPORTED/i;
 const DETERMINISTIC_POLICY_ERROR_RE = /(?:^|\b)(?:HARD BLOCK:|Blocked: \/gsd queue is a planning tool|Direct writes to \.gsd\/STATE\.md and \.gsd\/gsd\.db are blocked|This is a mechanical gate)/i;
+const SCHEDULE_WAKEUP_TOOL_NAME = "ScheduleWakeup";
+const SCHEDULE_WAKEUP_CONTINUATION_ERROR = "`prompt` is required when `stop` is not true";
 
 /**
  * Matches the runtime's "tool not registered" error. Unlike the deterministic
@@ -151,6 +153,60 @@ export function isToolInvocationError(errorMsg: string): boolean {
   return TOOL_INVOCATION_ERROR_RE.test(errorMsg) || isDeterministicPolicyError(errorMsg);
 }
 
+/**
+ * Claude Code validates its native ScheduleWakeup tool outside GSD's schema.
+ * Keep this exact and tool-scoped so similarly worded business validation from
+ * unrelated tools does not pause auto-mode.
+ */
+export function isScheduleWakeupContinuationError(toolName: string, errorMsg: string): boolean {
+  return stripMcpToolPrefix(toolName) === SCHEDULE_WAKEUP_TOOL_NAME
+    && errorMsg.trim() === SCHEDULE_WAKEUP_CONTINUATION_ERROR;
+}
+
+function shouldRecordToolInvocationError(toolName: string, errorMsg: string): boolean {
+  return isScheduleWakeupContinuationError(toolName, errorMsg)
+    || isToolInvocationError(errorMsg)
+    || isQueuedUserMessageSkip(errorMsg);
+}
+
+function isRecordedScheduleWakeupContinuationError(recordedError: string | null): boolean {
+  if (!recordedError) return false;
+
+  const separator = recordedError.indexOf(": ");
+  return separator >= 0 && isScheduleWakeupContinuationError(
+    recordedError.slice(0, separator),
+    recordedError.slice(separator + 2),
+  );
+}
+
+export function updateToolInvocationError(
+  recordedError: string | null,
+  toolName: string,
+  errorMsg: string,
+): string | null {
+  if (!shouldRecordToolInvocationError(toolName, errorMsg)) return recordedError;
+  if (
+    isRecordedScheduleWakeupContinuationError(recordedError)
+    && !isScheduleWakeupContinuationError(toolName, errorMsg)
+  ) return recordedError;
+
+  return `${toolName}: ${errorMsg}`;
+}
+
+/**
+ * A failed continuation must survive successful diagnostic/read calls in the
+ * same turn. Only a later successful ScheduleWakeup proves the continuation
+ * was armed; all other invocation errors retain their existing clear-on-success
+ * behavior.
+ */
+export function shouldClearToolInvocationErrorAfterSuccess(
+  recordedError: string | null,
+  successfulToolName?: string,
+): boolean {
+  return !isRecordedScheduleWakeupContinuationError(recordedError)
+    || stripMcpToolPrefix(successfulToolName ?? "") === SCHEDULE_WAKEUP_TOOL_NAME;
+}
+
 /**
  * Returns true if the error message indicates the called tool was not on the
  * session's tool surface (MCP startup race — see TOOL_UNAVAILABLE_ERROR_RE).

package/src/resources/extensions/gsd/auto-worktree-sync.ts

@@ -16,7 +16,7 @@ import {
   _isSamePath as isSamePath,
   _shouldReconcileWorktreeDb,
 } from "./auto-worktree-cleanup.js";
-import { resolveGsdPathContract } from "./paths.js";
+import { dirIsContentBearingLegacyMilestone, resolveGsdPathContract } from "./paths.js";
 import type { MilestoneScope } from "./workspace.js";
 import { WorktreeStateProjection } from "./worktree-state-projection.js";
 import { logWarning } from "./workflow-logger.js";
@@ -211,10 +211,17 @@ function syncMilestoneLayout(
   if (!existsSync(mainMilestonesDir)) return;
 
   try {
-    mkdirSync(wtMilestonesDir, { recursive: true });
     const mainMilestones = readdirSync(mainMilestonesDir, { withFileTypes: true })
       .filter((entry) => entry.isDirectory())
-      .map((entry) => entry.name);
+      .map((entry) => entry.name)
+      .filter((name) =>
+        layoutSegment !== "milestones" ||
+        dirIsContentBearingLegacyMilestone(join(mainMilestonesDir, name)),
+      );
+
+    if (mainMilestones.length === 0) return;
+
+    mkdirSync(wtMilestonesDir, { recursive: true });
 
     for (const milestoneId of mainMilestones) {
       syncMilestoneDirectory(

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

@@ -110,9 +110,7 @@ import {
   getOldestInFlightToolStart,
   hasInteractiveToolInFlight,
   clearInFlightTools,
-  isToolInvocationError,
-  isQueuedUserMessageSkip,
-  isDeterministicPolicyError,
+  updateToolInvocationError,
 } from "./auto-tool-tracking.js";
 import { closeoutUnit } from "./auto-unit-closeout.js";
 import { recoverTimedOutUnit } from "./auto-timeout-recovery.js";
@@ -1001,14 +999,17 @@ export function markToolEnd(toolCallId: string): void {
  * Called from tool_execution_end when a GSD tool fails with isError.
  * Stores the error if it matches:
  *   - tool-invocation-error pattern (malformed/truncated JSON)
+ *   - failed ScheduleWakeup continuation validation (#1379)
  *   - queued-user-message skip pattern
  *   - deterministic policy rejection (#4973, e.g. context_write_blocked)
  */
 export function recordToolInvocationError(toolName: string, errorMsg: string): void {
   if (!s.active) return;
-  if (isToolInvocationError(errorMsg) || isQueuedUserMessageSkip(errorMsg) || isDeterministicPolicyError(errorMsg)) {
-    s.lastToolInvocationError = `${toolName}: ${errorMsg}`;
-  }
+  s.lastToolInvocationError = updateToolInvocationError(
+    s.lastToolInvocationError,
+    toolName,
+    errorMsg,
+  );
 }
 
 export function getOldestInFlightToolAgeMs(): number {
@@ -3162,7 +3163,19 @@ export async function dispatchHookUnit(
     workspaceRoot: s.basePath,
   });
 
-  const result = await s.cmdCtx!.newSession({ workspaceRoot: s.basePath });
+  const cmdCtx = s.cmdCtx;
+  if (typeof cmdCtx?.newSession !== "function") {
+    const message = "Auto-mode has no command context for dispatch.";
+    ctx.ui.notify(message, "error");
+    const unitToCommit = previousCurrentUnit ?? s.currentUnit;
+    if (unitToCommit) {
+      await autoCommitUnit(s.basePath, unitToCommit.type, unitToCommit.id, ctx);
+    }
+    await stopAuto(ctx, pi, message, { preserveWorktree: true });
+    return false;
+  }
+
+  const result = await cmdCtx.newSession({ workspaceRoot: s.basePath });
   if (result.cancelled) {
     await stopAuto(ctx, pi);
     return false;

package/src/resources/extensions/gsd/bootstrap/register-hooks.ts

@@ -1769,7 +1769,7 @@ export function registerHooks(
       recordToolInvocationError(event.toolName, errorText);
       recordRetryableHarnessToolError(toolName, resultPayload, errorText);
     } else if (isAutoActive()) {
-      clearToolInvocationError();
+      clearToolInvocationError(event.toolName);
     }
     // Interactive Closeout adapter (ADR-032): auto-mode owns closeout for its
     // own units; interactive completions get the durable git subset (commit +
@@ -1980,7 +1980,7 @@ export function registerHooks(
       recordToolInvocationError(event.toolName, errorText);
       recordRetryableHarnessToolError(toolName, event.result, errorText);
     } else if (isAutoActive()) {
-      clearToolInvocationError();
+      clearToolInvocationError(event.toolName);
     }
     // Safety harness: record tool execution results for evidence cross-referencing
     if (isAutoActive()) {

package/src/resources/extensions/gsd/commands-verdict.ts

@@ -11,6 +11,7 @@ import { executeValidateMilestone } from "./tools/workflow-tool-executors.js";
 import { ensureDbOpen } from "./bootstrap/dynamic-tools.js";
 import { getLatestAssessmentByScope } from "./gsd-db.js";
 import { checkpointWorkflowDatabase } from "./db-workspace.js";
+import { formatVerdictRecordedNotice, formatVerdictRejectedNotice } from "./stop-notice.js";
 import {
   VALIDATION_VERDICTS,
   extractVerdict,
@@ -165,17 +166,17 @@ export async function handleVerdict(
   basePath: string,
 ): Promise<void> {
   if (!rawArgs.trim()) {
-    ctx.ui.notify(USAGE, "warning");
+    ctx.ui.notify(formatVerdictRejectedNotice(USAGE), "warning");
     return;
   }
 
   const parsed = parseArgs(rawArgs);
   if ("error" in parsed) {
-    ctx.ui.notify(`${parsed.error}\n${USAGE}`, "warning");
+    ctx.ui.notify(formatVerdictRejectedNotice(`${parsed.error}\n${USAGE}`), "warning");
     return;
   }
   if (!parsed.verdict) {
-    ctx.ui.notify(USAGE, "warning");
+    ctx.ui.notify(formatVerdictRejectedNotice(USAGE), "warning");
     return;
   }
 
@@ -184,7 +185,7 @@ export async function handleVerdict(
     const state = await deriveState(basePath);
     if (!state.activeMilestone) {
       ctx.ui.notify(
-        "No active milestone — pass --milestone Mxxx to target a specific milestone.",
+        formatVerdictRejectedNotice("No active milestone — pass --milestone Mxxx to target a specific milestone."),
         "warning",
       );
       return;
@@ -195,7 +196,9 @@ export async function handleVerdict(
   const existingValidation = await loadExistingValidation(basePath, milestoneId);
   if (!existingValidation) {
     ctx.ui.notify(
-      `No milestone validation found for ${milestoneId}. Run /gsd auto to validate first, then retry /gsd verdict.`,
+      formatVerdictRejectedNotice(
+        `No milestone validation found for ${milestoneId}. Run /gsd auto to validate first, then retry /gsd verdict.`,
+      ),
       "warning",
     );
     return;
@@ -205,7 +208,7 @@ export async function handleVerdict(
 
   if (parsed.verdict !== "pass" && !parsed.rationale) {
     ctx.ui.notify(
-      `--rationale is required when overriding to ${parsed.verdict}.`,
+      formatVerdictRejectedNotice(`--rationale is required when overriding to ${parsed.verdict}.`),
       "warning",
     );
     return;
@@ -234,7 +237,7 @@ export async function handleVerdict(
   if (result.isError) {
     const msg =
       result.content[0]?.type === "text" ? result.content[0].text : "Unknown error";
-    ctx.ui.notify(msg, "error");
+    ctx.ui.notify(formatVerdictRejectedNotice(msg), "error");
     return;
   }
 
@@ -244,12 +247,16 @@ export async function handleVerdict(
   const effectiveVerdict = extractEffectiveVerdict(result.details, parsed.verdict);
   if (effectiveVerdict !== parsed.verdict) {
     ctx.ui.notify(
-      `Milestone ${milestoneId} verdict requested: ${parsed.verdict}, effective: ${effectiveVerdict} (${existingValidation.source})`,
+      formatVerdictRecordedNotice(
+        `Milestone ${milestoneId} verdict requested: ${parsed.verdict}, effective: ${effectiveVerdict} (${existingValidation.source})`,
+      ),
       "warning",
     );
   } else {
     ctx.ui.notify(
-      `Milestone ${milestoneId} verdict: ${prevVerdict} -> ${effectiveVerdict} (${existingValidation.source})`,
+      formatVerdictRecordedNotice(
+        `Milestone ${milestoneId} verdict: ${prevVerdict} -> ${effectiveVerdict} (${existingValidation.source})`,
+      ),
       "success",
     );
   }

package/src/resources/extensions/gsd/compat/compat-marker.ts

@@ -6,8 +6,8 @@
 // (drift to import). gsd-core is oblivious to this file and ignores it.
 
 import { createHash } from "node:crypto";
-import { existsSync, readFileSync, renameSync, unlinkSync, writeFileSync, mkdirSync } from "node:fs";
-import { dirname, join, isAbsolute, normalize } from "node:path";
+import { existsSync, readFileSync, realpathSync, renameSync, unlinkSync, writeFileSync, mkdirSync } from "node:fs";
+import { dirname, join, isAbsolute, normalize, relative, resolve } from "node:path";
 
 /** Current marker schema version. Bump on breaking format changes + migrate. */
 export const COMPAT_MARKER_SCHEMA = 2;
@@ -54,6 +54,13 @@ export interface CompatMarker {
   piVersion: string;
 }
 
+export interface ReadCompatMarkerOptions {
+  /** Rewrite invalid-but-derivable marker keys back to safe root-relative keys. */
+  healInvalidKeys?: boolean;
+  /** Quarantine malformed/unsafe markers. Disable only for read-only previews. */
+  quarantineInvalid?: boolean;
+}
+
 /** Marker returned when no marker exists yet (fresh project, first gsd-pi run). */
 export const EMPTY_MARKER: CompatMarker = {
   schema: COMPAT_MARKER_SCHEMA,
@@ -81,6 +88,37 @@ export function computeProjectionSha(content: string): string {
   return createHash("sha256").update(normalizeForHash(content)).digest("hex").slice(0, 16);
 }
 
+function normalizeRealPath(p: string): string {
+  try {
+    return realpathSync.native(p);
+  } catch {
+    return resolve(p);
+  }
+}
+
+function rootRelativeKey(rootPath: string, absPath: string): string | null {
+  const root = normalizeRealPath(rootPath);
+  const abs = normalizeRealPath(absPath);
+  const rel = relative(root, abs);
+  if (!rel || rel === ".." || rel.startsWith(`..${sepForRelative(rel)}`) || isAbsolute(rel)) {
+    return null;
+  }
+  return rel.replace(/\\/g, "/");
+}
+
+function sepForRelative(rel: string): string {
+  return rel.includes("\\") ? "\\" : "/";
+}
+
+export function deriveCompatProjectionKey(absPath: string, roots: readonly string[]): string {
+  for (const root of roots) {
+    const key = rootRelativeKey(root, absPath);
+    if (key) return key;
+  }
+  const fallbackRoot = roots[roots.length - 1] ?? dirname(absPath);
+  return relative(fallbackRoot, absPath).replace(/\\/g, "/");
+}
+
 /**
  * Read & validate the marker. A missing marker → EMPTY_MARKER (treat every
  * projection as external on next reconcile). A malformed marker is quarantined
@@ -88,7 +126,12 @@ export function computeProjectionSha(content: string): string {
  * EMPTY_MARKER. A schema-mismatch returns EMPTY_MARKER (forward-compat: refuse
  * to act on a future format we don't understand).
  */
-export function readCompatMarker(basePath: string): CompatMarker {
+export function readCompatMarker(
+  basePath: string,
+  options: ReadCompatMarkerOptions = {},
+): CompatMarker {
+  const healInvalidKeys = options.healInvalidKeys ?? true;
+  const quarantineInvalid = options.quarantineInvalid ?? true;
   const path = compatMarkerPath(basePath);
   if (!existsSync(path)) return emptyMarker();
 
@@ -103,12 +146,16 @@ export function readCompatMarker(basePath: string): CompatMarker {
   try {
     parsed = JSON.parse(raw);
   } catch {
-    quarantine(basePath, raw);
+    if (quarantineInvalid) quarantine(basePath, raw);
     return emptyMarker();
   }
 
+  if (healInvalidKeys && healMarkerProjectionKeys(basePath, parsed) && isValidMarker(parsed)) {
+    writeCompatMarker(basePath, parsed);
+  }
+
   if (!isValidMarker(parsed)) {
-    quarantine(basePath, raw);
+    if (quarantineInvalid) quarantine(basePath, raw);
     return emptyMarker();
   }
   // Promote older markers by defaulting absent fields. Schema 1 → 2 only adds
@@ -245,6 +292,53 @@ function isValidProjectionMap(x: unknown): boolean {
   return true;
 }
 
+function healMarkerProjectionKeys(basePath: string, marker: unknown): marker is CompatMarker {
+  if (typeof marker !== "object" || marker === null) return false;
+  const m = marker as Record<string, unknown>;
+  let changed = false;
+
+  if (typeof m.projections === "object" && m.projections !== null) {
+    changed = healProjectionMapKeys(basePath, ".gsd", m.projections as Record<string, ProjectionEntry>) || changed;
+  }
+
+  const planning = m.planning;
+  if (typeof planning === "object" && planning !== null) {
+    const p = planning as Record<string, unknown>;
+    if (typeof p.projections === "object" && p.projections !== null) {
+      changed = healProjectionMapKeys(basePath, ".planning", p.projections as Record<string, ProjectionEntry>) || changed;
+    }
+    if (typeof p.passthrough === "object" && p.passthrough !== null) {
+      changed = healProjectionMapKeys(basePath, ".planning", p.passthrough as Record<string, ProjectionEntry>) || changed;
+    }
+  }
+
+  return changed;
+}
+
+function healProjectionMapKeys(
+  basePath: string,
+  rootName: ".gsd" | ".planning",
+  map: Record<string, ProjectionEntry>,
+): boolean {
+  let changed = false;
+  const root = join(basePath, rootName);
+
+  for (const key of Object.keys(map)) {
+    if (isSafeProjectionKey(key)) continue;
+    if (key.includes("\0") || isAbsolute(key) || /^[A-Za-z]:/.test(key)) continue;
+    const healedKey = rootRelativeKey(root, resolve(root, key));
+    if (!healedKey || !isSafeProjectionKey(healedKey)) continue;
+
+    if (!map[healedKey]) {
+      map[healedKey] = map[key]!;
+    }
+    delete map[key];
+    changed = true;
+  }
+
+  return changed;
+}
+
 function isValidPlanningMarker(x: unknown): x is PlanningMarker {
   if (typeof x !== "object" || x === null) return false;
   const p = x as Record<string, unknown>;

package/src/resources/extensions/gsd/db/engine.ts

@@ -10,7 +10,7 @@
 // writer layer.
 import { createRequire } from "node:module";
 import { existsSync, copyFileSync, mkdirSync, realpathSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { GSDError, GSD_STALE_STATE } from "../errors.js";
 import type { GsdWorkspace, MilestoneScope } from "../workspace.js";
 import { logError, logWarning } from "../workflow-logger.js";
@@ -71,7 +71,10 @@ let _gsdRequire: ReturnType<typeof createRequire> | null | undefined;
 function getGsdRequire(): ReturnType<typeof createRequire> | null {
   if (_gsdRequire !== undefined) return _gsdRequire;
   try {
-    _gsdRequire = createRequire(import.meta.url);
+    // Next.js may emit this module into a CommonJS chunk. Avoid ESM-only module
+    // metadata syntax here; it is a hard parse error there.
+    const packageRoot = process.env.GSD_WEB_PACKAGE_ROOT || process.env.GSD_PKG_ROOT || process.cwd();
+    _gsdRequire = createRequire(resolve(packageRoot, "package.json"));
   } catch {
     _gsdRequire = null;
   }

package/src/resources/extensions/gsd/doctor-engine-checks.ts

@@ -95,6 +95,25 @@ function reportCheckboxDbStatusDivergence(
   });
 }
 
+function bareDuplicateMilestoneId(milestoneId: string): string | null {
+  const match = milestoneId.match(/^(M\d{3})-[a-z0-9]{6}$/i);
+  return match?.[1]?.toUpperCase() ?? null;
+}
+
+function checkboxDbStatusMilestoneIds(basePath: string, milestoneIds: string[]): string[] {
+  if (!hasFlatPhaseLayout(basePath)) return milestoneIds;
+
+  // Flat-phase directories are keyed by phase number. A restored
+  // M003-xxxxxx row alongside M003 is a stale duplicate for the same
+  // phases/03-* projection, so checking both can compare DB status against two
+  // competing PLAN files and report a persistent false divergence.
+  const allIds = new Set(milestoneIds.map((id) => id.toUpperCase()));
+  return milestoneIds.filter((milestoneId) => {
+    const bareId = bareDuplicateMilestoneId(milestoneId);
+    return !bareId || !allIds.has(bareId);
+  });
+}
+
 function checkProjectionCheckboxDbStatus(basePath: string, milestoneIds: string[], issues: DoctorIssue[]): void {
   for (const milestoneId of milestoneIds) {
     const roadmapPath = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
@@ -434,7 +453,9 @@ function staleMilestonesArtifactRowFixable(basePath: string, row: ArtifactRow, a
 
 function stalePhasesArtifactRowFixable(basePath: string, row: ArtifactRow, artifactRows: ArtifactRow[]): boolean {
   const issuePath = artifactPathRelativeToGsd(row.path);
-  return issuePath.startsWith(`${LAYOUT_SEGMENTS.level1}/`) && hasPresentMilestonesReplacement(basePath, row, artifactRows);
+  return issuePath.startsWith(`${LAYOUT_SEGMENTS.level1}/`) &&
+    (hasPresentFlatPhaseReplacement(basePath, row, artifactRows) ||
+      hasPresentMilestonesReplacement(basePath, row, artifactRows));
 }
 
 function staleArtifactRowFixable(basePath: string, row: ArtifactRow, artifactRows: ArtifactRow[]): boolean {
@@ -807,7 +828,11 @@ export async function checkEngineHealth(
   // block doctor.
   try {
     if (isDbAvailable()) {
-      checkProjectionCheckboxDbStatus(basePath, getAllMilestones().map((milestone) => milestone.id), issues);
+      checkProjectionCheckboxDbStatus(
+        basePath,
+        checkboxDbStatusMilestoneIds(basePath, getAllMilestones().map((milestone) => milestone.id)),
+        issues,
+      );
     }
   } catch {
     // Non-fatal: checkbox-vs-DB divergence check must never block doctor

package/src/resources/extensions/gsd/error-classifier.ts

@@ -65,8 +65,12 @@ const NETWORK_RE = /network|ECONNRESET|ETIMEDOUT|ECONNREFUSED|socket hang up|web
 // transient errors so auto-mode can retry with reduced budget or fall back to a larger-context model.
 // See: https://github.com/open-gsd/gsd-pi/issues/4528
 const SERVER_RE = /internal(?: server)?[ _-]?error|server[ _-]?error|500|502|503|overloaded|server_error|api_error|service.?unavailable|context (?:window|length) exceed|context window exceed/i;
+// Provider adapters throw this when an upstream stop reason reaches Pi before
+// the adapter knows how to map it. Keep the match scoped so plain "unknown"
+// runtime errors still pause for inspection instead of being retried forever.
+const PROVIDER_STOP_REASON_RE = /unhandled stop reason:\s*(?:abort|unknown)\b/i;
 // ECONNRESET/ECONNREFUSED are in NETWORK_RE (same-model retry first).
-const CONNECTION_RE = /terminated|connection.?(?:refused|error)|other side closed|EPIPE|network.?(?:is\s+)?unavailable|stream_exhausted(?:_without_result)?/i;
+const CONNECTION_RE = /terminated|\babort\b|connection.?(?:refused|error)|other side closed|EPIPE|network.?(?:is\s+)?unavailable|stream_exhausted(?:_without_result)?/i;
 // Catch-all for V8 JSON.parse errors: all modern variants end with "in JSON at position \d+".
 // This eliminates the need to enumerate every error message variant individually.
 const STREAM_RE = /in JSON at position \d+|Unexpected end of JSON|SyntaxError.*JSON/i;
@@ -103,7 +107,7 @@ const UNSUPPORTED_MODEL_SCOPE_RE = /\b(?:account|plan|tier|subscription)\b/i;
  *  3. Network (ECONNRESET, ETIMEDOUT, socket hang up, fetch failed, dns)
  *  4. Stream truncation (malformed JSON from mid-stream cut)
  *  5. Server (500/502/503, overloaded, server_error)
- *  6. Connection (terminated, ECONNREFUSED, EPIPE, other side closed)
+ *  6. Connection (terminated, abort/unknown stop reason, ECONNREFUSED, EPIPE, other side closed)
  *  7. Model error (400 invalid argument / payload rejected for this model)
  *  8. Unknown
  */
@@ -163,6 +167,13 @@ export function classifyError(errorMsg: string, retryAfterMs?: number): ErrorCla
     return { kind: "rate-limit", retryAfterMs: delayMs };
   }
 
+  // Provider stop-reason adapter gaps are usually request/stream failures from
+  // the current model. Treat the scoped adapter message as fallback-eligible,
+  // but keep generic unknown errors on the indefinite pause path.
+  if (PROVIDER_STOP_REASON_RE.test(errorMsg)) {
+    return { kind: "connection", retryAfterMs: retryAfterMs ?? 15_000 };
+  }
+
   // 3. Network errors — same-model retry candidate
   if (NETWORK_RE.test(errorMsg)) {
     // Exclude if also matches permanent signals (already handled above for

package/src/resources/extensions/gsd/exec-sandbox.ts

@@ -111,6 +111,7 @@ export const EXEC_DEFAULTS = {
     "LOGNAME",
     "TMPDIR",
     "NODE_OPTIONS",
+    "NODE_PATH",
     "PYTHONPATH",
     "PYTHONIOENCODING",
   ] as const,

package/src/resources/extensions/gsd/flat-phase-migration.ts

@@ -155,6 +155,19 @@ function isInsideFlatProjectionBackup(backupDir: string, src: string): boolean {
   return src === phaseBackupDir || src.startsWith(`${phaseBackupDir}/`) || src.startsWith(`${phaseBackupDir}\\`);
 }
 
+function removeFlatProjectionBackup(backupDir: string): void {
+  const phaseBackupDir = join(backupDir, "__phases");
+  if (!existsSync(phaseBackupDir)) return;
+  try {
+    removePathWithRetries(phaseBackupDir);
+  } catch (err) {
+    logWarning(
+      "migration",
+      `flat-phase migration succeeded but could not remove temporary ${LAYOUT_SEGMENTS.level1}/ backup: ${(err as Error).message}`,
+    );
+  }
+}
+
 function restoreFlatProjectionFromBackup(basePath: string, backupDir: string): void {
   const phaseBackupDir = join(backupDir, "__phases");
   if (!existsSync(phaseBackupDir)) return;
@@ -494,4 +507,5 @@ export async function migrateToFlatPhase(basePath: string): Promise<void> {
       `flat-phase migration succeeded but could not remove ${LEGACY_MIGRATING_SEGMENT}: ${(err as Error).message}`,
     );
   }
+  removeFlatProjectionBackup(backupDir);
 }