gsd-pi 2.79.0 → 2.80.0

package/packages/pi-coding-agent/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gsd/pi-coding-agent",
-  "version": "2.79.0",
+  "version": "2.80.0",
   "description": "Coding agent CLI (vendored from pi-mono)",
   "type": "module",
   "gsd": {

package/packages/pi-tui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gsd/pi-tui",
-  "version": "2.79.0",
+  "version": "2.80.0",
   "description": "Terminal User Interface library (vendored from pi-mono)",
   "type": "module",
   "gsd": {

package/packages/rpc-client/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gsd-build/rpc-client",
-  "version": "2.79.0",
+  "version": "2.80.0",
   "description": "Standalone RPC client SDK for GSD — zero internal dependencies",
   "license": "MIT",
   "gsd": {

package/pkg/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glittercowboy/gsd",
-  "version": "2.79.0",
+  "version": "2.80.0",
   "piConfig": {
     "name": "gsd",
     "configDir": ".gsd"

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

@@ -0,0 +1,87 @@
+import type { GSDState } from "../types.js";
+
+export interface AutoSessionContext {
+  basePath: string;
+  trigger: "guided-flow" | "resume" | "auto-loop" | "manual";
+}
+
+export interface AutoStatus {
+  phase: "idle" | "running" | "paused" | "stopped" | "error";
+  activeUnit?: {
+    unitType: string;
+    unitId: string;
+  };
+  lastTransitionAt?: number;
+  transitionCount: number;
+}
+
+export interface AutoAdvanceResult {
+  kind: "advanced" | "blocked" | "paused" | "stopped" | "error";
+  reason?: string;
+  stateSnapshot?: GSDState;
+}
+
+export interface AutoOrchestrationModule {
+  start(sessionContext: AutoSessionContext): Promise<AutoAdvanceResult>;
+  advance(): Promise<AutoAdvanceResult>;
+  resume(): Promise<AutoAdvanceResult>;
+  stop(reason: string): Promise<AutoAdvanceResult>;
+  getStatus(): AutoStatus;
+}
+
+export interface DispatchAdapter {
+  decideNextUnit(): Promise<{
+    unitType: string;
+    unitId: string;
+    reason: string;
+    preconditions: string[];
+  } | null>;
+}
+
+export interface RecoveryAdapter {
+  classifyAndRecover(input: {
+    error: unknown;
+    unitType?: string;
+    unitId?: string;
+  }): Promise<{
+    action: "retry" | "escalate" | "stop";
+    reason: string;
+  }>;
+}
+
+export interface WorktreeAdapter {
+  prepareForUnit(unitType: string, unitId: string): Promise<void>;
+  syncAfterUnit(unitType: string, unitId: string): Promise<void>;
+  cleanupOnStop(reason: string): Promise<void>;
+}
+
+export interface HealthAdapter {
+  preAdvanceGate(): Promise<{ allow: boolean; reason?: string }>;
+  postAdvanceRecord(result: AutoAdvanceResult): Promise<void>;
+}
+
+export interface RuntimePersistenceAdapter {
+  ensureLockOwnership(): Promise<void>;
+  journalTransition(event: {
+    name: string;
+    reason?: string;
+    unitType?: string;
+    unitId?: string;
+  }): Promise<void>;
+}
+
+export interface NotificationAdapter {
+  notifyLifecycle(event: {
+    name: string;
+    detail?: string;
+  }): Promise<void>;
+}
+
+export interface AutoOrchestratorDeps {
+  dispatch: DispatchAdapter;
+  recovery: RecoveryAdapter;
+  worktree: WorktreeAdapter;
+  health: HealthAdapter;
+  runtime: RuntimePersistenceAdapter;
+  notifications: NotificationAdapter;
+}

package/src/resources/extensions/gsd/auto/loop-deps.ts

@@ -7,6 +7,7 @@
 import type { ExtensionAPI, ExtensionContext } from "@gsd/pi-coding-agent";
 
 import type { AutoSession } from "./session.js";
+import type { ErrorContext } from "./types.js";
 import type { GSDPreferences } from "../preferences.js";
 import type { GSDState } from "../types.js";
 import type { SessionLockStatus } from "../session-lock.js";
@@ -24,6 +25,12 @@ import type { MergeReconcileResult } from "../auto-recovery.js";
 import type { UokTurnObserver } from "../uok/contracts.js";
 import type { PreflightResult } from "../clean-root-preflight.js";
 
+type PauseAutoFn = (
+  ctx?: ExtensionContext,
+  pi?: ExtensionAPI,
+  errorContext?: ErrorContext,
+) => Promise<void>;
+
 /**
  * Dependencies injected by the caller (auto.ts startAuto) so autoLoop
  * can access private functions from auto.ts without exporting them.
@@ -39,7 +46,7 @@ export interface LoopDeps {
     pi?: ExtensionAPI,
     reason?: string,
   ) => Promise<void>;
-  pauseAuto: (ctx?: ExtensionContext, pi?: ExtensionAPI) => Promise<void>;
+  pauseAuto: PauseAutoFn;
   clearUnitTimeout: () => void;
   updateProgressWidget: (
     ctx: ExtensionContext,
@@ -245,7 +252,7 @@ export interface LoopDeps {
     prefs: GSDPreferences | undefined;
     buildSnapshotOpts: () => CloseoutOptions & Record<string, unknown>;
     buildRecoveryContext: () => unknown;
-    pauseAuto: (ctx?: ExtensionContext, pi?: ExtensionAPI) => Promise<void>;
+    pauseAuto: PauseAutoFn;
   }) => void;
 
   // Prompt helpers
@@ -271,7 +278,7 @@ export interface LoopDeps {
   ) => Promise<"dispatched" | "continue" | "retry">;
   runPostUnitVerification: (
     vctx: VerificationContext,
-    pauseAuto: (ctx?: ExtensionContext, pi?: ExtensionAPI) => Promise<void>,
+    pauseAuto: PauseAutoFn,
   ) => Promise<VerificationResult>;
   postUnitPostVerification: (
     pctx: PostUnitContext,

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

@@ -0,0 +1,161 @@
+import type { AutoAdvanceResult, AutoOrchestrationModule, AutoOrchestratorDeps, AutoSessionContext, AutoStatus } from "./contracts.js";
+
+function now(): number {
+  return Date.now();
+}
+
+export class AutoOrchestrator implements AutoOrchestrationModule {
+  private status: AutoStatus = {
+    phase: "idle",
+    transitionCount: 0,
+  };
+  private readonly deps: AutoOrchestratorDeps;
+  private lastAdvanceKey: string | null = null;
+
+  public constructor(deps: AutoOrchestratorDeps) {
+    this.deps = deps;
+  }
+
+  public async start(_sessionContext: AutoSessionContext): Promise<AutoAdvanceResult> {
+    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();
+  }
+
+  public async advance(): Promise<AutoAdvanceResult> {
+    try {
+      await this.deps.runtime.ensureLockOwnership();
+      const gate = await this.deps.health.preAdvanceGate();
+      if (!gate.allow) {
+        const blocked: AutoAdvanceResult = { 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: AutoAdvanceResult = { 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: AutoAdvanceResult = { 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: AutoAdvanceResult = { 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: AutoAdvanceResult = 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;
+    }
+  }
+
+  public async resume(): Promise<AutoAdvanceResult> {
+    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();
+  }
+
+  public async stop(reason: string): Promise<AutoAdvanceResult> {
+    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 };
+  }
+
+  public getStatus(): AutoStatus {
+    return { ...this.status, activeUnit: this.status.activeUnit ? { ...this.status.activeUnit } : undefined };
+  }
+
+  private bumpTransition(): void {
+    this.status.transitionCount += 1;
+    this.status.lastTransitionAt = now();
+  }
+}
+
+export function createAutoOrchestrator(deps: AutoOrchestratorDeps): AutoOrchestrationModule {
+  return new AutoOrchestrator(deps);
+}

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

@@ -55,7 +55,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 type { MinimalModelRegistry } from "../context-budget.js";
 import { ensurePlanV2Graph, isEmptyPlanV2GraphResult, isMissingFinalizedContextResult } from "../uok/plan-v2.js";
 import { resolveUokFlags } from "../uok/flags.js";
@@ -76,6 +76,12 @@ function isSamePathLocal(a: string, b: string): boolean {
   return normalizeWorktreePathForCompare(a) === normalizeWorktreePathForCompare(b);
 }
 
+function refreshPlanSliceRecoveryDbIfNeeded(unitType: string): boolean {
+  if (unitType !== "plan-slice") return true;
+  if (!isDbAvailable()) return true;
+  return refreshOpenDatabaseFromDisk();
+}
+
 // ─── Session timeout auto-resume state ────────────────────────────────────────
 
 let consecutiveSessionTimeouts = 0;
@@ -232,6 +238,33 @@ async function emitCancelledUnitEnd(
   });
 }
 
+export function _buildCancelledUnitStopReason(
+  unitType: string,
+  unitId: string,
+  errorContext?: { message: string; category: string },
+): {
+  notifyMessage: string;
+  stopReason: string;
+  loopReason: "session-failed" | "unit-aborted";
+} {
+  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: IterationContext,
   iterData: IterationData,
@@ -994,7 +1027,10 @@ export async function runDispatch(
     // 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);
     }
@@ -1065,7 +1101,16 @@ export async function runDispatch(
             `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(
@@ -1075,6 +1120,32 @@ export async function runDispatch(
         deps.invalidateAllCaches();
       } 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,
@@ -1470,7 +1541,12 @@ export async function runUnitPhase(
   s.lastGitActionFailure = null;
   s.lastGitActionStatus = null;
   s.lastUnitAgentEndMessages = null;
-  setCurrentPhase(unitType);
+  setCurrentPhase(unitType, {
+    basePath: s.basePath,
+    traceId: ic.flowId,
+    turnId: `iter-${ic.iteration}`,
+    causedBy: "unit-start",
+  });
   s.lastToolInvocationError = null; // #2883: clear stale error from previous unit
   const unitStartSeq = ic.nextSeq();
   deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: unitStartSeq, eventType: "unit-start", data: { unitType, unitId } });
@@ -1866,13 +1942,16 @@ export async function runUnitPhase(
     }
     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",
+
+    const cancelledStop = _buildCancelledUnitStopReason(
+      unitType,
+      unitId,
+      unitResult.errorContext,
     );
-    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" };
+    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) ────────

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

@@ -21,6 +21,7 @@ import type { ExtensionAPI, ExtensionCommandContext } from "@gsd/pi-coding-agent
 import type { GitServiceImpl } from "../git-service.js";
 import type { CaptureEntry } from "../captures.js";
 import type { BudgetAlertLevel } from "../auto-budget.js";
+import type { AutoOrchestrationModule } from "./contracts.js";
 import { resolveWorktreeProjectRoot } from "../worktree-root.js";
 import { normalizeRealPath } from "../paths.js";
 import type { MilestoneScope } from "../workspace.js";
@@ -229,6 +230,9 @@ export class AutoSession {
   /** Cleanup function returned by startCommandPolling(); null when not running. */
   commandPollingCleanup: (() => void) | null = null;
 
+  // ── Orchestration seam ───────────────────────────────────────────────────
+  orchestration: AutoOrchestrationModule | null = null;
+
   // ── Loop promise state ──────────────────────────────────────────────────
   // Per-unit resolve function and session-switch guard live at module level
   // in auto-loop.ts (_currentResolve, _sessionSwitchInFlight).
@@ -354,10 +358,14 @@ export class AutoSession {
     // 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(): Record<string, unknown> {
+    const orchestrationStatus = this.orchestration?.getStatus();
     return {
       active: this.active,
       paused: this.paused,
@@ -367,6 +375,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/src/resources/extensions/gsd/auto-artifact-paths.ts

@@ -159,9 +159,9 @@ export function diagnoseExpectedArtifact(
       }
       return `${relSliceFile(base, mid, sid!, "RESEARCH")} (slice research)`;
     case "plan-slice":
-      return `${relSliceFile(base, mid, sid!, "PLAN")} (slice plan)`;
+      return `${relSliceFile(base, mid, sid!, "PLAN")} plus tasks/T##-PLAN.md files (slice plan and task plans)`;
     case "refine-slice":
-      return `${relSliceFile(base, mid, sid!, "PLAN")} (refined slice plan from sketch)`;
+      return `${relSliceFile(base, mid, sid!, "PLAN")} plus tasks/T##-PLAN.md files (refined slice plan and task plans)`;
     case "execute-task": {
       return `Task ${tid} marked [x] in ${relSliceFile(base, mid, sid!, "PLAN")} + summary written`;
     }

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

@@ -692,6 +692,7 @@ export const DISPATCH_RULES: DispatchRule[] = [
       const contextFile = resolveMilestoneFile(basePath, mid, "CONTEXT");
       const hasContext = !!(contextFile && (await loadFile(contextFile)));
       if (hasContext) return null; // fall through to next rule
+      if (prefs?.planning_depth === "deep") return null;
       // H6 fix (#4973): keep the non-deep auto-mode bypass, but do not
       // pre-verify deep planning's user-facing milestone approval gate.
       if (shouldBypassMilestoneDepthGateInAuto(prefs)) {