gsd-pi 2.80.0 → 2.81.0

package/src/resources/extensions/gsd/auto/workflow-sidecar-queue.ts

@@ -0,0 +1,46 @@
+// Project/App: GSD-2
+// File Purpose: Sidecar queue scheduling and dequeue adapter for auto-mode loop.
+
+import type { SidecarItem } from "./session.js";
+
+export interface SidecarDequeuePayload extends Record<string, unknown> {
+  kind: SidecarItem["kind"];
+  unitType: string;
+  unitId: string;
+}
+
+export interface DequeueSidecarItemInput {
+  queue: SidecarItem[];
+  executionGraphEnabled: boolean;
+  scheduleQueue: (queue: SidecarItem[]) => Promise<SidecarItem[]>;
+  warnSchedulingFailure: (message: string) => void;
+  logDequeue: (payload: SidecarDequeuePayload) => void;
+  emitDequeue: (payload: SidecarDequeuePayload) => void;
+}
+
+export async function dequeueSidecarItem(
+  input: DequeueSidecarItemInput,
+): Promise<SidecarItem | undefined> {
+  if (input.queue.length === 0) return undefined;
+
+  if (input.executionGraphEnabled && input.queue.length > 1) {
+    try {
+      const scheduledQueue = await input.scheduleQueue(input.queue);
+      input.queue.splice(0, input.queue.length, ...scheduledQueue);
+    } catch (err) {
+      input.warnSchedulingFailure(err instanceof Error ? err.message : String(err));
+    }
+  }
+
+  const sidecarItem = input.queue.shift();
+  if (!sidecarItem) return undefined;
+
+  const payload = {
+    kind: sidecarItem.kind,
+    unitType: sidecarItem.unitType,
+    unitId: sidecarItem.unitId,
+  };
+  input.logDequeue(payload);
+  input.emitDequeue(payload);
+  return sidecarItem;
+}

package/src/resources/extensions/gsd/auto/workflow-turn-reporter.ts

@@ -0,0 +1,68 @@
+// Project/App: GSD-2
+// File Purpose: Thin adapter for workflow turn observer reporting.
+
+import type {
+  FailureClass,
+  TurnStatus,
+  UokTurnObserver,
+} from "../uok/contracts.js";
+
+export interface WorkflowTurnReporterInput {
+  observer?: UokTurnObserver;
+  traceId: string;
+  turnId: string;
+  iteration: number;
+  basePath: string;
+  startedAt: string;
+  clearCurrentTurn: () => void;
+  now?: () => string;
+}
+
+export interface WorkflowTurnFinishInput {
+  status: TurnStatus;
+  failureClass?: FailureClass;
+  error?: string;
+  unitType?: string;
+  unitId?: string;
+}
+
+export interface WorkflowTurnReporter {
+  start(): void;
+  finish(input: WorkflowTurnFinishInput): void;
+}
+
+export function createWorkflowTurnReporter(input: WorkflowTurnReporterInput): WorkflowTurnReporter {
+  let finished = false;
+  const now = input.now ?? (() => new Date().toISOString());
+
+  return {
+    start(): void {
+      input.observer?.onTurnStart({
+        traceId: input.traceId,
+        turnId: input.turnId,
+        iteration: input.iteration,
+        basePath: input.basePath,
+        startedAt: input.startedAt,
+      });
+    },
+
+    finish(finishInput: WorkflowTurnFinishInput): void {
+      if (finished) return;
+      finished = true;
+      input.observer?.onTurnResult({
+        traceId: input.traceId,
+        turnId: input.turnId,
+        iteration: input.iteration,
+        unitType: finishInput.unitType,
+        unitId: finishInput.unitId,
+        status: finishInput.status,
+        failureClass: finishInput.failureClass ?? "none",
+        phaseResults: [],
+        error: finishInput.error,
+        startedAt: input.startedAt,
+        finishedAt: now(),
+      });
+      input.clearCurrentTurn();
+    },
+  };
+}

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

@@ -0,0 +1,89 @@
+// Project/App: GSD-2
+// File Purpose: Unit dispatch contract adapter for auto-mode loop.
+
+import type { SidecarItem } from "./session.js";
+import type {
+  IterationContext,
+  IterationData,
+  LoopState,
+  PhaseResult,
+} from "./types.js";
+import { ExecutionGraphScheduler } from "../uok/execution-graph.js";
+import type { UokGraphNode } from "../uok/contracts.js";
+import { runUnitPhase } from "./phases.js";
+import { decideDispatchNodeKind } from "./workflow-kernel.js";
+
+export type DispatchContract = "legacy-direct" | "uok-scheduler";
+
+export type UnitPhaseResult = PhaseResult<{
+  unitStartedAt?: number;
+  requestDispatchedAt?: number;
+}>;
+
+export interface UnitDispatchScheduler {
+  registerHandler(
+    kind: UokGraphNode["kind"],
+    handler: (node: UokGraphNode) => Promise<void>,
+  ): void;
+  run(nodes: UokGraphNode[], options: { parallel: false; maxWorkers: 1 }): Promise<unknown>;
+}
+
+export interface RunUnitPhaseViaContractDeps {
+  runUnitPhase: (
+    ic: IterationContext,
+    iterData: IterationData,
+    loopState: LoopState,
+    sidecarItem?: SidecarItem,
+  ) => Promise<UnitPhaseResult>;
+  createScheduler: () => UnitDispatchScheduler;
+}
+
+export async function runUnitPhaseViaContract(
+  dispatchContract: DispatchContract,
+  ic: IterationContext,
+  iterData: IterationData,
+  loopState: LoopState,
+  sidecarItem: SidecarItem | undefined,
+  deps: RunUnitPhaseViaContractDeps,
+): Promise<UnitPhaseResult> {
+  if (dispatchContract === "legacy-direct") {
+    return deps.runUnitPhase(ic, iterData, loopState, sidecarItem);
+  }
+
+  const scheduler = deps.createScheduler();
+  let outcome: UnitPhaseResult | null = null;
+  const executeNode = async (): Promise<void> => {
+    outcome = await deps.runUnitPhase(ic, iterData, loopState, sidecarItem);
+  };
+  const kinds: UokGraphNode["kind"][] = [
+    "unit",
+    "hook",
+    "subagent",
+    "team-worker",
+    "verification",
+    "reprocess",
+  ];
+  for (const kind of kinds) scheduler.registerHandler(kind, executeNode);
+
+  const nodeId = `dispatch:${ic.iteration}:${iterData.unitType}:${iterData.unitId}`;
+  await scheduler.run([
+    {
+      id: nodeId,
+      kind: decideDispatchNodeKind(iterData.unitType, sidecarItem?.kind),
+      dependsOn: [],
+      metadata: {
+        unitType: iterData.unitType,
+        unitId: iterData.unitId,
+      },
+    },
+  ], { parallel: false, maxWorkers: 1 });
+
+  return outcome ?? { action: "break", reason: "scheduler-dispatch-missing-result" };
+}
+
+export function createExecutionGraphUnitDispatchDeps(): RunUnitPhaseViaContractDeps {
+  return {
+    runUnitPhase: async (...args) => runUnitPhase(...args),
+    createScheduler: () => new ExecutionGraphScheduler(),
+  };
+}

package/src/resources/extensions/gsd/auto/workflow-worker-heartbeat.ts

@@ -0,0 +1,51 @@
+// Project/App: GSD-2
+// File Purpose: Best-effort worker heartbeat adapter for auto-mode loop.
+
+export interface WorkerHeartbeatSession {
+  workerId?: string | null;
+  currentMilestoneId?: string | null;
+  milestoneLeaseToken?: number | null;
+}
+
+export interface MaintainWorkerHeartbeatDeps {
+  heartbeatAutoWorker: (workerId: string) => void;
+  refreshMilestoneLease: (
+    workerId: string,
+    milestoneId: string,
+    fencingToken: number,
+  ) => boolean;
+  logHeartbeatFailure: (err: unknown) => void;
+  logLeaseRefreshMiss?: (details: {
+    workerId: string;
+    milestoneId: string;
+    fencingToken: number;
+  }) => void;
+}
+
+export function maintainWorkerHeartbeat(
+  session: WorkerHeartbeatSession,
+  deps: MaintainWorkerHeartbeatDeps,
+): void {
+  if (!session.workerId) return;
+
+  try {
+    deps.heartbeatAutoWorker(session.workerId);
+    if (session.currentMilestoneId && session.milestoneLeaseToken) {
+      const refreshed = deps.refreshMilestoneLease(
+        session.workerId,
+        session.currentMilestoneId,
+        session.milestoneLeaseToken,
+      );
+      if (!refreshed) {
+        deps.logLeaseRefreshMiss?.({
+          workerId: session.workerId,
+          milestoneId: session.currentMilestoneId,
+          fencingToken: session.milestoneLeaseToken,
+        });
+        session.milestoneLeaseToken = null;
+      }
+    }
+  } catch (err) {
+    deps.logHeartbeatFailure(err);
+  }
+}

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

@@ -1,3 +1,5 @@
+// GSD-2 + src/resources/extensions/gsd/auto-dashboard.ts - Auto-mode progress widget rendering and dashboard helpers.
+
 /**
  * Auto-mode Dashboard — progress widget rendering, elapsed time formatting,
  * unit description helpers, and slice progress caching.
@@ -46,6 +48,7 @@ import {
 import { logWarning } from "./workflow-logger.js";
 import { formattedShortcutPair } from "./shortcut-defs.js";
 import { homedir } from "node:os";
+import { readUnitRuntimeRecord, type AutoUnitRuntimeRecord } from "./unit-runtime.js";
 
 // ─── UAT Slice Extraction ─────────────────────────────────────────────────────
 
@@ -215,6 +218,36 @@ export function formatWidgetTokens(count: number): string {
   return `${Math.round(count / 1000000)}M`;
 }
 
+export function formatRuntimeHealthSignal(
+  record: AutoUnitRuntimeRecord | null,
+  now = Date.now(),
+): { level: "green" | "yellow"; summary: string; detail?: string } | null {
+  if (!record) return null;
+  const idleMs = Math.max(0, now - record.lastProgressAt);
+  const idleMinutes = Math.floor(idleMs / 60_000);
+  if ((record.recoveryAttempts ?? 0) > 0 || record.phase === "recovered" || record.lastProgressKind.includes("recovery")) {
+    return {
+      level: "yellow",
+      summary: "Recovering",
+      detail: `retry ${record.recoveryAttempts ?? 1} after ${record.lastRecoveryReason ?? "idle"} stall`,
+    };
+  }
+  if (record.progressCount === 0 && idleMs >= 60_000) {
+    return {
+      level: "yellow",
+      summary: "Waiting on provider",
+      detail: `no output for ${idleMinutes}m`,
+    };
+  }
+  return null;
+}
+
+export function shouldRenderRoadmapProgress(
+  progress: { total: number; activeSliceTasks?: { total: number } | null } | null,
+): progress is { total: number; activeSliceTasks?: { total: number } | null } {
+  return !!progress && progress.total > 0;
+}
+
 // ─── ETA Estimation ──────────────────────────────────────────────────────────
 
 /**
@@ -569,6 +602,21 @@ export function updateProgressWidget(
 ): void {
   if (!ctx.hasUI) return;
 
+  // Welcome header is a startup-only banner — permanently suppress it once
+  // auto-mode activates. The dashboard widget owns all status from here.
+  // Note: setHeader(undefined) restores the built-in header (logo +
+  // instructions). To actually render zero lines, install an empty header.
+  if (typeof ctx.ui?.setHeader === "function") {
+    ctx.ui.setHeader(() => ({
+      render(): string[] { return []; },
+      invalidate(): void {},
+    }));
+  }
+  // Clear wizard step badge — auto-mode owns the UI from this point
+  if (typeof ctx.ui?.setStatus === "function") {
+    ctx.ui.setStatus("gsd-step", undefined);
+  }
+
   const verb = unitVerb(unitType);
   const phaseLabel = unitPhaseLabel(unitType);
   const mid = state.activeMilestone;
@@ -583,6 +631,10 @@ export function updateProgressWidget(
     : state.activeSlice;
   const task = state.activeTask;
 
+  if (mid) {
+    updateSliceProgressCache(accessors.getBasePath(), mid.id, slice?.id);
+  }
+
   // Cache git branch at widget creation time (not per render)
   let cachedBranch: string | null = null;
   try { cachedBranch = getCurrentBranch(accessors.getBasePath()); } catch (err) { /* not in git repo */
@@ -618,6 +670,7 @@ export function updateProgressWidget(
     let cachedLines: string[] | undefined;
     let cachedWidth: number | undefined;
     let cachedRtkLabel: string | null | undefined;
+    let cachedRuntimeRecord: AutoUnitRuntimeRecord | null = null;
 
     const refreshRtkLabel = (): void => {
       try {
@@ -630,7 +683,16 @@ export function updateProgressWidget(
       }
     };
 
+    const refreshRuntimeRecord = (): void => {
+      try {
+        cachedRuntimeRecord = readUnitRuntimeRecord(accessors.getBasePath(), unitType, unitId);
+      } catch {
+        cachedRuntimeRecord = null;
+      }
+    };
+
     refreshRtkLabel();
+    refreshRuntimeRecord();
 
     const pulseTimer = setInterval(() => {
       pulseBright = !pulseBright;
@@ -648,6 +710,7 @@ export function updateProgressWidget(
           updateSliceProgressCache(accessors.getBasePath(), mid.id, slice?.id);
         }
         refreshRtkLabel();
+        refreshRuntimeRecord();
         cachedLines = undefined;
       } catch (err) { /* non-fatal */
         logWarning("dashboard", `DB status update failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -681,13 +744,16 @@ export function updateProgressWidget(
 
         // Health indicator in header
         const score = computeProgressScore();
-        const healthColor = score.level === "green" ? "success"
-          : score.level === "yellow" ? "warning"
+        const runtimeSignal = formatRuntimeHealthSignal(cachedRuntimeRecord);
+        const healthLevel = runtimeSignal?.level ?? score.level;
+        const healthSummary = runtimeSignal?.summary ?? score.summary;
+        const healthColor = healthLevel === "green" ? "success"
+          : healthLevel === "yellow" ? "warning"
             : "error";
-        const healthIcon = score.level === "green" ? GLYPH.statusActive
-          : score.level === "yellow" ? "!"
+        const healthIcon = healthLevel === "green" ? GLYPH.statusActive
+          : healthLevel === "yellow" ? "!"
             : "x";
-        const healthStr = `  ${theme.fg(healthColor, healthIcon)} ${theme.fg(healthColor, score.summary)}`;
+        const healthStr = `  ${theme.fg(healthColor, healthIcon)} ${theme.fg(healthColor, healthSummary)}`;
 
         const headerLeft = `${pad}${dot} ${theme.fg("accent", theme.bold("GSD"))}  ${theme.fg("success", modeTag)}${healthStr}`;
 
@@ -702,7 +768,9 @@ export function updateProgressWidget(
         lines.push(rightAlign(headerLeft, headerRight, width));
 
         // Show health signal details when degraded (yellow/red)
-        if (score.level !== "green" && score.signals.length > 0 && widgetMode !== "min") {
+        if (runtimeSignal?.detail && widgetMode !== "min") {
+          lines.push(`${pad}  ${theme.fg("dim", runtimeSignal.detail)}`);
+        } else if (score.level !== "green" && score.signals.length > 0 && widgetMode !== "min") {
           // Show up to 3 most relevant signals in compact form
           const topSignals = score.signals
             .filter(s => s.kind === "negative")
@@ -781,7 +849,7 @@ export function updateProgressWidget(
 
           // Progress bar
           const roadmapSlices = mid ? getRoadmapSlicesSync() : null;
-          if (roadmapSlices) {
+          if (shouldRenderRoadmapProgress(roadmapSlices)) {
             const { done, total, activeSliceTasks } = roadmapSlices;
             const barWidth = Math.max(6, Math.min(18, Math.floor(width * 0.25)));
             const pct = total > 0 ? done / total : 0;
@@ -849,7 +917,7 @@ export function updateProgressWidget(
 
         const leftLines: string[] = [];
 
-        if (roadmapSlices) {
+        if (shouldRenderRoadmapProgress(roadmapSlices)) {
           const { done, total, activeSliceTasks } = roadmapSlices;
           const barWidth = Math.max(6, Math.min(18, Math.floor(leftColWidth * 0.4)));
           const pct = total > 0 ? done / total : 0;
@@ -975,6 +1043,11 @@ export function updateProgressWidget(
             ? lastCommit.message.slice(0, maxCommitLen - 1) + "…"
             : lastCommit.message
           : "";
+        // Step-mode guidance — shown above keyboard hints when auto is paused
+        if (accessors.isStepMode()) {
+          lines.push(`${pad}${theme.fg("accent", "→")} ${theme.fg("dim", "Ctrl+N to advance to next step  ·  /gsd status for overview")}`);
+        }
+
         // Hints line
         const hintParts: string[] = [];
         hintParts.push("esc pause");

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

@@ -31,7 +31,6 @@ import { loadEffectiveGSDPreferences } from "./preferences.js";
 import type { MinimalModelRegistry } from "./context-budget.js";
 import { pauseAuto } from "./auto.js";
 import { resolveCanonicalMilestoneRoot } from "./worktree-manager.js";
-import { logWarning } from "./workflow-logger.js";
 import {
   getWorkflowTransportSupportError,
   getRequiredWorkflowToolsForAutoUnit,
@@ -290,38 +289,13 @@ export async function dispatchDirectPhase(
 
   ctx.ui.notify(`Dispatching ${unitType} for ${unitId}...`, "info");
 
-  const originalCwd = process.cwd();
-
-  try {
-    // Ensure cwd matches dispatchBase BEFORE newSession() captures it. Synchronous —
-    // no awaits between chdir and newSession.
-    try {
-      if (process.cwd() !== dispatchBase) {
-        process.chdir(dispatchBase);
-      }
-    } catch (err) {
-      const msg = `Failed to chdir before direct-dispatch newSession (basePath: ${dispatchBase}): ${err instanceof Error ? err.message : String(err)}`;
-      logWarning("engine", msg, { file: "auto-direct-dispatch.ts", basePath: dispatchBase, error: err instanceof Error ? err.message : String(err) });
-      ctx.ui.notify(`${msg}. Cancelling dispatch to avoid running in the wrong directory.`, "error");
-      return;
-    }
-
-    const result = await ctx.newSession();
-    if (result.cancelled) {
-      ctx.ui.notify("Session creation cancelled.", "warning");
-      return;
-    }
-    pi.sendMessage(
-      { customType: "gsd-dispatch", content: prompt, display: false },
-      { triggerTurn: true },
-    );
-  } finally {
-    try {
-      if (process.cwd() !== originalCwd) {
-        process.chdir(originalCwd);
-      }
-    } catch (err) {
-      logWarning("engine", `Failed to restore cwd after direct dispatch: ${err instanceof Error ? err.message : String(err)}`, { file: "auto-direct-dispatch.ts", basePath: originalCwd });
-    }
+  const result = await ctx.newSession({ workspaceRoot: dispatchBase });
+  if (result.cancelled) {
+    ctx.ui.notify("Session creation cancelled.", "warning");
+    return;
   }
+  pi.sendMessage(
+    { customType: "gsd-dispatch", content: prompt, display: false },
+    { triggerTurn: true },
+  );
 }

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

@@ -211,6 +211,23 @@ export function hasPendingDeepStage(prefs: GSDPreferences | undefined, basePath:
   return gate.status === "pending" || gate.status === "blocked";
 }
 
+export function shouldRunDeepProjectSetup(
+  state: Pick<GSDState, "phase">,
+  prefs: GSDPreferences | undefined,
+  basePath: string,
+  options: { hasSurvivorBranch?: boolean } = {},
+): boolean {
+  if (options.hasSurvivorBranch === true) return false;
+  if (
+    state.phase !== "pre-planning" &&
+    state.phase !== "needs-discussion" &&
+    state.phase !== "planning"
+  ) {
+    return false;
+  }
+  return hasPendingDeepStage(prefs, basePath);
+}
+
 function missingSliceStop(mid: string, phase: string): DispatchAction {
   return {
     action: "stop",
@@ -921,6 +938,22 @@ export const DISPATCH_RULES: DispatchRule[] = [
       const unitId = `${mid}/${sid}`;
       let priorPreExecFailure: { blockingFindings: string[]; verdictExcerpt: string } | undefined;
       if (session?.lastPreExecFailure?.unitId === unitId) {
+        // Circuit breaker: stop re-dispatching after 2 failed retries. The
+        // planner has had multiple attempts with injected failure context and
+        // still cannot produce a valid plan — human review is required.
+        const MAX_PRE_EXEC_RETRIES = 2;
+        const retryCount = session.preExecRetryCount?.get(unitId) ?? 0;
+        if (retryCount >= MAX_PRE_EXEC_RETRIES) {
+          const findings = session.lastPreExecFailure.blockingFindings.join("; ");
+          session.lastPreExecFailure = null;
+          session.preExecRetryCount?.delete(unitId);
+          return {
+            action: "stop",
+            reason: `Pre-execution checks failed ${retryCount} times for ${unitId} — manual intervention required. Blocking findings: ${findings}. Fix the plan manually, then run /gsd auto to resume.`,
+            level: "error",
+            matchedRule: "planning → plan-slice",
+          };
+        }
         priorPreExecFailure = {
           blockingFindings: session.lastPreExecFailure.blockingFindings,
           verdictExcerpt: session.lastPreExecFailure.verdictExcerpt,