gsd-pi 2.79.0-dev.ece5fd8ba → 2.80.0

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

@@ -31,7 +31,7 @@ import { selectAndApplyModel, resolveModelId, clearToolBaseline } from "./auto-m
 import { resetRoutingHistory, recordOutcome } from "./routing-history.js";
 import { resetHookState, runPreDispatchHooks, restoreHookState, clearPersistedHookState, } from "./post-unit-hooks.js";
 import { runGSDDoctor, rebuildState } from "./doctor.js";
-import { preDispatchHealthGate, resetProactiveHealing, setLevelChangeCallback, } from "./doctor-proactive.js";
+import { preDispatchHealthGate, recordHealthSnapshot, resetProactiveHealing, setLevelChangeCallback, } from "./doctor-proactive.js";
 import { clearSkillSnapshot } from "./skill-discovery.js";
 import { captureAvailableSkills, resetSkillTelemetry, } from "./skill-telemetry.js";
 import { getRtkSessionSavings } from "../shared/rtk-session-stats.js";
@@ -43,7 +43,7 @@ import { isAbsolute, join } from "node:path";
 import { pathToFileURL } from "node:url";
 import { readFileSync, existsSync, mkdirSync } from "node:fs";
 import { atomicWriteSync } from "./atomic-write.js";
-import { autoCommitCurrentBranch, captureIntegrationBranch, detectWorktreeName, getCurrentBranch, getMainBranch, setActiveMilestoneId, } from "./worktree.js";
+import { autoCommitCurrentBranch, captureIntegrationBranch, detectWorktreeName, getCurrentBranch, getMainBranch, setActiveMilestoneId, resolveProjectRoot, } from "./worktree.js";
 import { GitServiceImpl } from "./git-service.js";
 import { getPriorSliceCompletionBlocker } from "./dispatch-guard.js";
 import { createAutoWorktree, enterAutoWorktree, enterBranchModeForMilestone, teardownAutoWorktree, isInAutoWorktree, getAutoWorktreePath, mergeMilestoneToMain, autoWorktreeBranch, syncWorktreeStateBack, syncProjectRootToWorktree, checkResourcesStale, escapeStaleWorktree, } from "./auto-worktree.js";
@@ -82,6 +82,7 @@ import { resolveAgentEnd, resolveAgentEndCancelled, _resetPendingResolve, isSess
 import { runAutoLoopWithUok } from "./uok/kernel.js";
 import { resolveUokFlags } from "./uok/flags.js";
 import { validateDirectory } from "./validate-directory.js";
+import { createAutoOrchestrator } from "./auto/orchestrator.js";
 import { WorktreeResolver, } from "./worktree-resolver.js";
 import { reorderForCaching } from "./prompt-ordering.js";
 export { STUB_RECOVERY_THRESHOLD, NEW_SESSION_TIMEOUT_MS, } from "./auto/session.js";
@@ -904,6 +905,12 @@ export async function stopAuto(ctx, pi, reason) {
         // changes the user made between sessions (#4959 / CodeRabbit).
         if (pi)
             clearToolBaseline(pi);
+        try {
+            await s.orchestration?.stop(reason ?? "stop");
+        }
+        catch (err) {
+            debugLog("stop-orchestration-stop", { error: err instanceof Error ? err.message : String(err) });
+        }
         // Reset all session state in one call
         s.reset();
     }
@@ -953,6 +960,7 @@ export async function pauseAuto(ctx, _pi, _errorContext) {
             activeRunDir: s.activeRunDir,
             autoStartTime: s.autoStartTime,
             milestoneLock: s.sessionMilestoneLock ?? undefined,
+            pauseReason: _errorContext?.message,
         };
         setRuntimeKv("global", "", PAUSED_SESSION_KV_KEY, pausedMeta);
     }
@@ -992,6 +1000,12 @@ export async function pauseAuto(ctx, _pi, _errorContext) {
     // Unblock pending unitPromise so autoLoop exits cleanly (#1799)
     resolveAgentEnd({ messages: [] });
     _resetPendingResolve();
+    try {
+        await s.orchestration?.stop("pause");
+    }
+    catch (err) {
+        debugLog("pause-orchestration-stop", { error: err instanceof Error ? err.message : String(err) });
+    }
     s.active = false;
     s.paused = true;
     deactivateGSD();
@@ -1041,6 +1055,132 @@ function buildResolverDeps() {
 function buildResolver() {
     return new WorktreeResolver(s, buildResolverDeps());
 }
+/**
+ * Thin entry glue for the new Auto Orchestration module.
+ *
+ * This intentionally wires only dispatch + error notification today, with
+ * no behavior changes to the existing auto loop. It provides a concrete seam
+ * the next refactor steps can adopt incrementally.
+ */
+export function createWiredAutoOrchestrationModule(ctx, _pi, dispatchBasePath, runtimeBasePath = resolveProjectRoot(dispatchBasePath)) {
+    const flowId = `auto-orchestrator-${Date.now()}`;
+    let seq = 0;
+    const deps = {
+        dispatch: {
+            async decideNextUnit() {
+                const state = await deriveState(dispatchBasePath);
+                const active = state.activeMilestone;
+                if (!active)
+                    return null;
+                const prefs = loadEffectiveGSDPreferences(dispatchBasePath)?.preferences;
+                const action = await resolveDispatch({
+                    basePath: dispatchBasePath,
+                    mid: active.id,
+                    midTitle: active.title,
+                    state,
+                    prefs,
+                });
+                if (action.action !== "dispatch")
+                    return null;
+                return {
+                    unitType: action.unitType,
+                    unitId: action.unitId,
+                    reason: action.matchedRule ?? "dispatch",
+                    preconditions: [],
+                };
+            },
+        },
+        recovery: {
+            async classifyAndRecover(input) {
+                const reason = input.error instanceof Error ? input.error.message : String(input.error ?? "unknown auto error");
+                return { action: "escalate", reason };
+            },
+        },
+        worktree: {
+            async prepareForUnit() { },
+            async syncAfterUnit() { },
+            async cleanupOnStop() { },
+        },
+        health: {
+            async preAdvanceGate() {
+                const gate = await preDispatchHealthGate(dispatchBasePath);
+                return {
+                    allow: gate.proceed,
+                    reason: gate.reason,
+                };
+            },
+            async postAdvanceRecord(result) {
+                if (result.kind === "error") {
+                    recordHealthSnapshot(1, 0, 0, [{
+                            code: "orchestration-error",
+                            message: result.reason ?? "orchestration error",
+                            severity: "error",
+                            unitId: "orchestration",
+                        }], [], "orchestration");
+                }
+                else if (result.kind === "blocked") {
+                    recordHealthSnapshot(0, 1, 0, [{
+                            code: "orchestration-blocked",
+                            message: result.reason ?? "orchestration blocked",
+                            severity: "warning",
+                            unitId: "orchestration",
+                        }], [], "orchestration");
+                }
+            },
+        },
+        runtime: {
+            async ensureLockOwnership() {
+                const status = getSessionLockStatus(runtimeBasePath);
+                if (!status.valid || status.failureReason === "pid-mismatch") {
+                    throw new Error("session lock held by another process");
+                }
+            },
+            async journalTransition(event) {
+                const eventType = event.name === "start"
+                    ? "iteration-start"
+                    : event.name === "resume"
+                        ? "iteration-start"
+                        : event.name === "advance"
+                            ? "dispatch-match"
+                            : event.name === "advance-blocked"
+                                ? "guard-block"
+                                : event.name === "advance-stopped"
+                                    ? "dispatch-stop"
+                                    : event.name === "advance-error"
+                                        ? "iteration-end"
+                                        : event.name === "advance-paused" || event.name === "advance-retry"
+                                            ? "guard-block"
+                                            : event.name === "stop"
+                                                ? "terminal"
+                                                : "iteration-end";
+                _emitJournalEvent(runtimeBasePath, {
+                    ts: new Date().toISOString(),
+                    flowId,
+                    seq: ++seq,
+                    eventType,
+                    data: {
+                        source: "auto-orchestrator",
+                        name: event.name,
+                        reason: event.reason,
+                        unitType: event.unitType,
+                        unitId: event.unitId,
+                    },
+                });
+            },
+        },
+        notifications: {
+            async notifyLifecycle(event) {
+                if (event.name === "error") {
+                    ctx.ui.notify(event.detail ?? "auto orchestration error", "error");
+                }
+            },
+        },
+    };
+    return createAutoOrchestrator(deps);
+}
+function ensureOrchestrationModule(ctx, pi, basePath) {
+    s.orchestration = createWiredAutoOrchestrationModule(ctx, pi, basePath, lockBase());
+}
 /**
  * Build the LoopDeps object from auto.ts private scope.
  * This bundles all private functions that autoLoop needs without exporting them.
@@ -1398,6 +1538,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
             // s.basePath may have been updated to a worktree path by enterMilestone.
             rebuildScope(s.basePath, s.currentMilestoneId);
         }
+        ensureOrchestrationModule(ctx, pi, s.basePath || base);
         registerSigtermHandler(lockBase());
         ctx.ui.setStatus("gsd-auto", s.stepMode ? "next" : "auto");
         ctx.ui.setWidget("gsd-health", undefined);
@@ -1457,6 +1598,12 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
             clearPausedSession("paused-session DB cleanup failed (resume activation)");
         }
         pi.events.emit(CMUX_CHANNELS.LOG, { preferences: loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences, message: s.stepMode ? "Step-mode resumed." : "Auto-mode resumed.", level: "progress" });
+        try {
+            await s.orchestration?.resume();
+        }
+        catch (err) {
+            debugLog("resume-orchestration-resume", { error: err instanceof Error ? err.message : String(err) });
+        }
         startAutoCommandPolling(s.basePath);
         await runAutoLoopWithUok({
             ctx,
@@ -1482,6 +1629,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
     // Build scope after bootstrap has populated s.basePath / s.originalBasePath /
     // s.currentMilestoneId (including worktree setup inside bootstrapAutoSession).
     rebuildScope(s.basePath, s.currentMilestoneId);
+    ensureOrchestrationModule(ctx, pi, s.basePath || base);
     captureProjectRootEnv(s.originalBasePath || s.basePath);
     registerAutoWorkerForSession(s);
     try {
@@ -1492,6 +1640,12 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         logWarning("engine", `cmux sync failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
     }
     pi.events.emit(CMUX_CHANNELS.LOG, { preferences: loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences, message: requestedStepMode ? "Step-mode started." : "Auto-mode started.", level: "progress" });
+    try {
+        await s.orchestration?.start({ basePath: s.basePath, trigger: "auto-loop" });
+    }
+    catch (err) {
+        debugLog("start-orchestration-start", { error: err instanceof Error ? err.message : String(err) });
+    }
     startAutoCommandPolling(s.basePath);
     // Dispatch the first unit
     await runAutoLoopWithUok({
@@ -1576,6 +1730,9 @@ export async function dispatchHookUnit(ctx, pi, hookName, triggerUnitType, trigg
         s.pendingQuickTasks = [];
     }
     s.basePath = targetBasePath;
+    if (!s.orchestration) {
+        ensureOrchestrationModule(ctx, pi, s.basePath);
+    }
     const hookUnitType = `hook/${hookName}`;
     const hookStartedAt = Date.now();
     s.currentUnit = {

package/dist/resources/extensions/gsd/bootstrap/agent-end-recovery.js

@@ -39,6 +39,14 @@ function resolveAgentEndBasePath() {
         return undefined;
     }
 }
+export function _buildAbortedPauseContext(lastMsg) {
+    const hasErrorMessage = Object.prototype.hasOwnProperty.call(lastMsg, "errorMessage") && !!lastMsg.errorMessage;
+    return {
+        message: hasErrorMessage ? String(lastMsg.errorMessage) : "Operation aborted",
+        category: "aborted",
+        isTransient: true,
+    };
+}
 async function pauseTransientWithBackoff(cls, pi, ctx, errorDetail, isRateLimit) {
     retryState.consecutiveTransientCount += 1;
     const baseRetryAfterMs = "retryAfterMs" in cls ? cls.retryAfterMs : 15_000;
@@ -134,7 +142,7 @@ export async function handleAgentEnd(pi, event, ctx) {
             }
             return;
         }
-        await pauseAuto(ctx, pi);
+        await pauseAuto(ctx, pi, _buildAbortedPauseContext(lastMsg));
         return;
     }
     if (lastMsg && "stopReason" in lastMsg && lastMsg.stopReason === "error") {

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

@@ -669,6 +669,10 @@ function columnExists(db, table, column) {
     const rows = db.prepare(`PRAGMA table_info(${table})`).all();
     return rows.some((row) => row["name"] === column);
 }
+function formatFtsUnavailableError(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return message.replace(/\bmoduel\s*:\s*/gi, "module: ");
+}
 /**
  * Create the FTS5 virtual table for memories plus the triggers that keep it
  * in sync with the base table. FTS5 may be unavailable on stripped-down
@@ -704,7 +708,7 @@ export function tryCreateMemoriesFts(db) {
         return true;
     }
     catch (err) {
-        logWarning("db", `FTS5 unavailable — memory queries will use LIKE fallback: ${err.message}`);
+        logWarning("db", `FTS5 unavailable — memory queries will use LIKE fallback: ${formatFtsUnavailableError(err)}`);
         return false;
     }
 }
@@ -1653,6 +1657,35 @@ export function closeDatabase() {
     _lastDbError = null;
     _lastDbPhase = null;
 }
+/**
+ * Re-open the active database connection from disk.
+ *
+ * Auto-mode can observe artifacts written by a workflow server running in a
+ * different process before its long-lived singleton has re-synchronized. The
+ * recovery path uses this to force the next state derivation to read from the
+ * current on-disk database instead of continuing with a possibly stale handle.
+ */
+export function refreshOpenDatabaseFromDisk() {
+    if (!currentDb || !currentPath)
+        return false;
+    if (currentPath === ":memory:")
+        return false;
+    const dbPath = currentPath;
+    const identityKey = _currentIdentityKey;
+    try {
+        closeDatabase();
+        const opened = openDatabase(dbPath);
+        if (opened && identityKey && currentDb) {
+            _dbCache.set(identityKey, { dbPath, db: currentDb });
+            _currentIdentityKey = identityKey;
+        }
+        return opened;
+    }
+    catch (e) {
+        logWarning("db", `database refresh failed: ${e.message}`);
+        return false;
+    }
+}
 /** Run a full VACUUM — call sparingly (e.g. after milestone completion). */
 export function vacuumDatabase() {
     if (!currentDb)

package/dist/resources/extensions/gsd/post-execution-checks.js

@@ -96,12 +96,25 @@ export function resolveImportPath(importPath, sourceFile, basePath) {
         if (existsSync(directPath)) {
             return { exists: true, resolvedPath: directPath };
         }
-        // Only .js/.jsx/.mjs/.cjs imports legitimately fall through for the TS
-        // ESM convention (.js → .ts). Any other explicit extension (.css, .json,
-        // .svg, images, fonts, .ts, .tsx, …) must stay unresolved when the direct
-        // path is missing — otherwise a stray `./missing.css.ts` could shadow a
-        // genuinely missing `./missing.css` import.
-        if (![".js", ".jsx", ".mjs", ".cjs"].includes(explicitExt)) {
+        // Known concrete extensions that should NOT fall through to code-shadow
+        // probing when missing. This preserves the "missing.css must stay missing"
+        // guarantee while still allowing dotted module stems like ./route.server
+        // to resolve as ./route.server.ts.
+        const nonFallbackExtensions = new Set([
+            ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs",
+            ".json", ".css", ".scss", ".sass", ".less", ".styl",
+            ".svg", ".png", ".jpg", ".jpeg", ".gif", ".webp", ".avif", ".ico", ".bmp",
+            ".woff", ".woff2", ".ttf", ".otf", ".eot",
+        ]);
+        const runtimeFallbackExtensions = new Set([".js", ".jsx", ".mjs", ".cjs"]);
+        const dottedStemFallbackExtensions = new Set([".server", ".client", ".webhook"]);
+        if (explicitExt !== "" &&
+            !runtimeFallbackExtensions.has(explicitExt) &&
+            !nonFallbackExtensions.has(explicitExt) &&
+            !dottedStemFallbackExtensions.has(explicitExt)) {
+            return { exists: false, resolvedPath: null };
+        }
+        if (nonFallbackExtensions.has(explicitExt) && !runtimeFallbackExtensions.has(explicitExt)) {
             return { exists: false, resolvedPath: null };
         }
     }
@@ -163,6 +176,12 @@ export function checkImportResolution(taskRow, _priorTasks, basePath) {
         }
         const imports = extractRelativeImports(source);
         for (const { importPath, lineNum } of imports) {
+            // React Router generated +types modules may not exist on disk during
+            // post-exec checks (generated during framework build). Don't block task
+            // completion on these imports.
+            if (/^\.{1,2}\/\+types\//.test(importPath)) {
+                continue;
+            }
             const resolution = resolveImportPath(importPath, file, basePath);
             if (!resolution.exists) {
                 results.push({

package/dist/resources/extensions/shared/interview-ui.js

@@ -1,3 +1,4 @@
+// GSD2 — Shared interview round UI widget
 /**
  * Shared interview round UI widget.
  *
@@ -128,14 +129,24 @@ export async function showInterviewRound(questions, opts, ctx) {
         let showingExitConfirm = false;
         let exitCursor = 0; // 0 = keep going (default), 1 = end interview
         let cachedLines;
+        let completed = false;
+        let removeAbortListener;
+        function finish(result) {
+            if (completed)
+                return;
+            completed = true;
+            removeAbortListener?.();
+            done(result);
+        }
         // External cancellation (e.g. remote channel won the race)
         if (opts.signal) {
-            const onAbort = () => done({ endInterview: false, answers: {} });
+            const onAbort = () => finish({ endInterview: false, answers: {} });
             if (opts.signal.aborted) {
                 onAbort();
             }
             else {
                 opts.signal.addEventListener("abort", onAbort, { once: true });
+                removeAbortListener = () => opts.signal?.removeEventListener("abort", onAbort);
             }
         }
         // Editor is created once; editorTheme comes from the design system
@@ -212,7 +223,7 @@ export async function showInterviewRound(questions, opts, ctx) {
         }
         function submit() {
             saveEditorToState();
-            done(buildResult());
+            finish(buildResult());
         }
         function goNextOrSubmit() {
             if (!isMultiSelect(currentIdx)) {
@@ -267,7 +278,7 @@ export async function showInterviewRound(questions, opts, ctx) {
                     return;
                 }
                 if (data === "2") {
-                    done({ endInterview: false, answers: {} });
+                    finish({ endInterview: false, answers: {} });
                     return;
                 }
                 if (matchesKey(data, Key.enter) || matchesKey(data, Key.space)) {
@@ -276,7 +287,7 @@ export async function showInterviewRound(questions, opts, ctx) {
                         refresh();
                     }
                     else {
-                        done({ endInterview: false, answers: {} });
+                        finish({ endInterview: false, answers: {} });
                     }
                     return;
                 }