gsd-pi 2.79.0-dev.ece5fd8ba → 2.80.0

package/dist/resources/.managed-resources-content-hash

@@ -1 +1 @@
-76e1a0d39c0a27d8
+63159c1114dd0d48

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

@@ -0,0 +1 @@
+export {};

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

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

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

@@ -28,7 +28,7 @@ import { writeUnitRuntimeRecord } from "../unit-runtime.js";
 import { withTimeout, FINALIZE_PRE_TIMEOUT_MS, FINALIZE_POST_TIMEOUT_MS } from "./finalize-timeout.js";
 import { getEligibleSlices } from "../slice-parallel-eligibility.js";
 import { startSliceParallel } from "../slice-parallel-orchestrator.js";
-import { isDbAvailable, getMilestoneSlices } from "../gsd-db.js";
+import { isDbAvailable, getMilestoneSlices, refreshOpenDatabaseFromDisk } from "../gsd-db.js";
 import { ensurePlanV2Graph, isEmptyPlanV2GraphResult, isMissingFinalizedContextResult } from "../uok/plan-v2.js";
 import { resolveUokFlags } from "../uok/flags.js";
 import { UokGateRunner } from "../uok/gate-runner.js";
@@ -42,6 +42,13 @@ import { getWorkflowTransportSupportError, getRequiredWorkflowToolsForAutoUnit,
 function isSamePathLocal(a, b) {
     return normalizeWorktreePathForCompare(a) === normalizeWorktreePathForCompare(b);
 }
+function refreshPlanSliceRecoveryDbIfNeeded(unitType) {
+    if (unitType !== "plan-slice")
+        return true;
+    if (!isDbAvailable())
+        return true;
+    return refreshOpenDatabaseFromDisk();
+}
 // ─── Session timeout auto-resume state ────────────────────────────────────────
 let consecutiveSessionTimeouts = 0;
 const MAX_SESSION_TIMEOUT_AUTO_RESUMES = 3;
@@ -145,6 +152,22 @@ async function emitCancelledUnitEnd(ic, unitType, unitId, unitStartSeq, errorCon
         causedBy: { flowId: ic.flowId, seq: unitStartSeq },
     });
 }
+export function _buildCancelledUnitStopReason(unitType, unitId, errorContext) {
+    const cancellationMessage = errorContext?.message ?? "unknown";
+    const isSessionCreationFailure = errorContext?.category === "session-failed";
+    if (isSessionCreationFailure) {
+        return {
+            notifyMessage: `Session creation failed for ${unitType} ${unitId}: ${cancellationMessage}. Stopping auto-mode.`,
+            stopReason: `Session creation failed: ${cancellationMessage}`,
+            loopReason: "session-failed",
+        };
+    }
+    return {
+        notifyMessage: `Unit ${unitType} ${unitId} aborted after dispatch: ${cancellationMessage}. Stopping auto-mode.`,
+        stopReason: `Unit aborted: ${cancellationMessage}`,
+        loopReason: "unit-aborted",
+    };
+}
 async function failClosedOnFinalizeTimeout(ic, iterData, loopState, stage, startedAt) {
     const { ctx, pi, s, deps } = ic;
     const now = Date.now();
@@ -710,7 +733,10 @@ export async function runDispatch(ic, preData, loopState) {
         // See: https://github.com/gsd-build/gsd-2/issues/2474
         if (dispatchResult.level === "warning") {
             ctx.ui.notify(dispatchResult.reason, "warning");
-            await deps.pauseAuto(ctx, pi);
+            await deps.pauseAuto(ctx, pi, {
+                message: dispatchResult.reason,
+                category: "unknown",
+            });
         }
         else {
             await closeoutAndStop(ctx, pi, s, deps, dispatchResult.reason);
@@ -770,7 +796,13 @@ export async function runDispatch(ic, preData, loopState) {
                         action: "artifact-found",
                     });
                     ctx.ui.notify(`Stuck recovery: artifact for ${unitType} ${unitId} found on disk. Invalidating caches.`, "info");
+                    if (!refreshPlanSliceRecoveryDbIfNeeded(unitType)) {
+                        ctx.ui.notify(`Stuck recovery found ${unitType} ${unitId} artifacts, but the DB refresh failed. Keeping stuck state for retry.`, "warning");
+                        return { action: "continue" };
+                    }
                     deps.invalidateAllCaches();
+                    loopState.recentUnits.length = 0;
+                    loopState.stuckRecoveryAttempts = 0;
                     return { action: "continue" };
                 }
                 ctx.ui.notify(`Stuck on ${unitType} ${unitId} (${stuckSignal.reason}). Invalidating caches and retrying.`, "warning");
@@ -778,6 +810,22 @@ export async function runDispatch(ic, preData, loopState) {
             }
             else {
                 // Level 2: hard stop — genuinely stuck
+                deps.invalidateAllCaches();
+                const artifactExists = verifyExpectedArtifact(unitType, unitId, s.basePath);
+                if (artifactExists && unitType !== "complete-milestone") {
+                    debugLog("autoLoop", {
+                        phase: "stuck-recovery",
+                        level: 2,
+                        action: "artifact-found",
+                    });
+                    ctx.ui.notify(`Stuck recovery: artifact for ${unitType} ${unitId} found on disk after cache invalidation. Continuing.`, "info");
+                    if (refreshPlanSliceRecoveryDbIfNeeded(unitType)) {
+                        loopState.recentUnits.length = 0;
+                        loopState.stuckRecoveryAttempts = 0;
+                        return { action: "continue" };
+                    }
+                    ctx.ui.notify(`Stuck recovery found ${unitType} ${unitId} artifacts, but the DB refresh failed. Stopping for manual recovery.`, "warning");
+                }
                 debugLog("autoLoop", {
                     phase: "stuck-detected",
                     unitType,
@@ -1384,10 +1432,11 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         }
         await deps.autoCommitUnit?.(s.basePath, unitType, unitId, ctx);
         await emitCancelledUnitEnd(ic, unitType, unitId, unitStartSeq, unitResult.errorContext);
-        ctx.ui.notify(`Session creation failed for ${unitType} ${unitId}: ${unitResult.errorContext?.message ?? "unknown"}. Stopping auto-mode.`, "warning");
-        await deps.stopAuto(ctx, pi, `Session creation failed: ${unitResult.errorContext?.message ?? "unknown"}`);
-        debugLog("autoLoop", { phase: "exit", reason: "session-failed" });
-        return { action: "break", reason: "session-failed" };
+        const cancelledStop = _buildCancelledUnitStopReason(unitType, unitId, unitResult.errorContext);
+        ctx.ui.notify(cancelledStop.notifyMessage, "warning");
+        await deps.stopAuto(ctx, pi, cancelledStop.stopReason);
+        debugLog("autoLoop", { phase: "exit", reason: cancelledStop.loopReason });
+        return { action: "break", reason: cancelledStop.loopReason };
     }
     // ── Immediate unit closeout (metrics, activity log, memory) ────────
     // Run right after runUnit() returns so telemetry is never lost to a

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

@@ -148,6 +148,8 @@ export class AutoSession {
     // ── Remote command polling ───────────────────────────────────────────────
     /** Cleanup function returned by startCommandPolling(); null when not running. */
     commandPollingCleanup = null;
+    // ── Orchestration seam ───────────────────────────────────────────────────
+    orchestration = null;
     // ── Loop promise state ──────────────────────────────────────────────────
     // Per-unit resolve function and session-switch guard live at module level
     // in auto-loop.ts (_currentResolve, _sessionSwitchInFlight).
@@ -268,9 +270,12 @@ export class AutoSession {
         this.sigtermHandler = null;
         // Remote command polling — cleanup must be called before reset (auto.ts stopAuto)
         this.commandPollingCleanup = null;
+        // Orchestration seam
+        this.orchestration = null;
         // Loop promise state lives in auto-loop.ts module scope
     }
     toJSON() {
+        const orchestrationStatus = this.orchestration?.getStatus();
         return {
             active: this.active,
             paused: this.paused,
@@ -280,6 +285,9 @@ export class AutoSession {
             activeRunDir: this.activeRunDir,
             currentMilestoneId: this.currentMilestoneId,
             currentUnit: this.currentUnit,
+            orchestrationPhase: orchestrationStatus?.phase,
+            orchestrationTransitionCount: orchestrationStatus?.transitionCount,
+            orchestrationLastTransitionAt: orchestrationStatus?.lastTransitionAt,
             unitDispatchCount: Object.fromEntries(this.unitDispatchCount),
         };
     }

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

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

package/dist/resources/extensions/gsd/auto-runtime-state.js

@@ -3,11 +3,15 @@ import { AutoSession } from "./auto/session.js";
 import { isDeterministicPolicyError, isQueuedUserMessageSkip, isToolInvocationError, markToolEnd as markTrackedToolEnd, markToolStart as markTrackedToolStart, } from "./auto-tool-tracking.js";
 export const autoSession = new AutoSession();
 export function getAutoRuntimeSnapshot() {
+    const orchestrationStatus = autoSession.orchestration?.getStatus();
     return {
         active: autoSession.active,
         paused: autoSession.paused,
         currentUnit: autoSession.currentUnit ? { ...autoSession.currentUnit } : null,
         basePath: autoSession.basePath,
+        orchestrationPhase: orchestrationStatus?.phase,
+        orchestrationTransitionCount: orchestrationStatus?.transitionCount,
+        orchestrationLastTransitionAt: orchestrationStatus?.lastTransitionAt,
     };
 }
 export function isAutoActive() {