gsd-pi 2.79.0 → 2.80.0-dev.4ea7d80e7

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,38 @@
+// 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;
+}
+
+export function maintainWorkerHeartbeat(
+  session: WorkerHeartbeatSession,
+  deps: MaintainWorkerHeartbeatDeps,
+): void {
+  if (!session.workerId) return;
+
+  try {
+    deps.heartbeatAutoWorker(session.workerId);
+    if (session.currentMilestoneId && session.milestoneLeaseToken) {
+      deps.refreshMilestoneLease(
+        session.workerId,
+        session.currentMilestoneId,
+        session.milestoneLeaseToken,
+      );
+    }
+  } catch (err) {
+    deps.logHeartbeatFailure(err);
+  }
+}

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-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 ──────────────────────────────────────────────────────────
 
 /**
@@ -583,6 +616,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 +655,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 +668,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 +695,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 +729,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 +753,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 +834,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 +902,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;

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",
@@ -692,6 +709,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)) {