gsd-pi 2.79.0-dev.ece5fd8ba → 2.80.0-dev.710c06e97

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-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-prompts.ts

@@ -275,6 +275,171 @@ export async function inlineFileSmart(
   return `### ${label}\nSource: \`${relPath}\`\n\n${truncated}`;
 }
 
+function inlineCompactTemplate(name: "plan" | "task-summary" | "slice-summary", label: string): string {
+  const compact: Record<typeof name, string> = {
+    plan: [
+      "# {{sliceId}}: {{sliceTitle}}",
+      "",
+      "**Goal:** {{goal}}",
+      "**Demo:** {{demo}}",
+      "",
+      "## Must-Haves",
+      "- {{mustHave}}",
+      "",
+      "## Threat Surface",
+      "- Abuse: {{abuseScenarios}}",
+      "- Data exposure: {{sensitiveDataAccessible}}",
+      "- Input trust: {{untrustedInput}}",
+      "",
+      "## Requirement Impact",
+      "- Requirements touched: {{requirementIds}}",
+      "- Re-verify: {{whatMustBeRetested}}",
+      "- Decisions revisited: {{decisionIds}}",
+      "",
+      "## Proof Level",
+      "- This slice proves: {{contract | integration | operational | final-assembly}}",
+      "- Real runtime required: {{yes/no}}",
+      "- Human/UAT required: {{yes/no}}",
+      "",
+      "## Verification",
+      "- {{testFileOrCommand}}",
+      "",
+      "## Observability / Diagnostics",
+      "- Runtime signals: {{signalOrNone}}",
+      "- Inspection surfaces: {{surfaceOrNone}}",
+      "- Failure visibility: {{failureSignalOrNone}}",
+      "- Redaction constraints: {{secretOrPiiBoundaryOrNone}}",
+      "",
+      "## Integration Closure",
+      "- Upstream surfaces consumed: {{filesModulesContracts}}",
+      "- New wiring introduced: {{entrypointOrNone}}",
+      "- Remaining end-to-end work: {{listOrNothing}}",
+      "",
+      "## Tasks",
+      "- [ ] **T01: {{taskTitle}}** `est:{{estimate}}`",
+      "  - Why: {{whyThisTaskExists}}",
+      "  - Files: `{{filePath}}`",
+      "  - Do: {{specificImplementationStepsAndConstraints}}",
+      "  - Verify: {{testCommandOrRuntimeCheck}}",
+      "  - Done when: {{measurableAcceptanceCondition}}",
+      "",
+      "## Files Likely Touched",
+      "- `{{filePath}}`",
+    ].join("\n"),
+    "task-summary": [
+      "---",
+      "id: {{taskId}}",
+      "parent: {{sliceId}}",
+      "milestone: {{milestoneId}}",
+      "provides: [{{whatThisTaskProvides}}]",
+      "key_files: [{{filePath}}]",
+      "key_decisions: [{{decision}}]",
+      "patterns_established: [{{pattern}}]",
+      "observability_surfaces: [{{diagnosticOrNone}}]",
+      "duration: {{duration}}",
+      "verification_result: passed",
+      "completed_at: {{date}}",
+      "blocker_discovered: false",
+      "---",
+      "",
+      "# {{taskId}}: {{taskTitle}}",
+      "**{{oneLiner}}**",
+      "",
+      "## What Happened",
+      "{{narrative}}",
+      "",
+      "## Verification",
+      "{{whatWasVerifiedAndHow}}",
+      "",
+      "## Verification Evidence",
+      "| # | Command | Exit Code | Verdict | Duration |",
+      "|---|---------|-----------|---------|----------|",
+      "| {{row}} | {{command}} | {{exitCode}} | {{verdict}} | {{duration}} |",
+      "",
+      "## Diagnostics",
+      "{{diagnosticsOrNone}}",
+      "",
+      "## Deviations",
+      "{{deviationsFromPlan_OR_none}}",
+      "",
+      "## Known Issues",
+      "{{issuesDiscoveredButNotFixed_OR_none}}",
+      "",
+      "## Files Created/Modified",
+      "- `{{filePath}}` - {{description}}",
+    ].join("\n"),
+    "slice-summary": [
+      "---",
+      "id: {{sliceId}}",
+      "parent: {{milestoneId}}",
+      "milestone: {{milestoneId}}",
+      "provides: [{{whatThisSliceProvides}}]",
+      "requires: []",
+      "affects: []",
+      "key_files: [{{filePath}}]",
+      "key_decisions: [{{decision}}]",
+      "patterns_established: [{{pattern}}]",
+      "observability_surfaces: [{{diagnosticOrNone}}]",
+      "drill_down_paths: [{{pathToTaskSummary}}]",
+      "duration: {{duration}}",
+      "verification_result: passed",
+      "completed_at: {{date}}",
+      "---",
+      "",
+      "# {{sliceId}}: {{sliceTitle}}",
+      "**{{oneLiner}}**",
+      "",
+      "## What Happened",
+      "{{narrative}}",
+      "",
+      "## Verification",
+      "{{whatWasVerifiedAcrossAllTasks}}",
+      "",
+      "## Requirements Advanced",
+      "- {{requirementId}} - {{howThisSliceAdvancedIt}}",
+      "",
+      "## Requirements Validated",
+      "- {{requirementId}} - {{whatProofNowMakesItValidated}}",
+      "",
+      "## New Requirements Surfaced",
+      "- {{newRequirementOr_none}}",
+      "",
+      "## Requirements Invalidated or Re-scoped",
+      "- {{requirementIdOr_none}} - {{whatChanged}}",
+      "",
+      "## Operational Readiness",
+      "- Health signal: {{healthSignalOrNA}}",
+      "- Failure signal: {{failureSignalOrNA}}",
+      "- Recovery: {{recoveryOrNA}}",
+      "- Monitoring gaps: {{gapsOrNone}}",
+      "",
+      "## Deviations",
+      "{{deviationsFromPlan_OR_none}}",
+      "",
+      "## Known Limitations",
+      "{{whatDoesntWorkYet_OR_whatWasDeferredToLaterSlices}}",
+      "",
+      "## Follow-ups",
+      "{{workDeferredOrDiscoveredDuringExecution_OR_none}}",
+      "",
+      "## Files Created/Modified",
+      "- `{{filePath}}` - {{description}}",
+      "",
+      "## Forward Intelligence",
+      "### What the next slice should know",
+      "- {{insightThatWouldHelpDownstreamWork}}",
+      "### What's fragile",
+      "- {{fragileAreaOrThinImplementation}} - {{whyItMatters}}",
+      "### Authoritative diagnostics",
+      "- {{whereAFutureAgentShouldLookFirst}} - {{whyThisSignalIsTrustworthy}}",
+      "### What assumptions changed",
+      "- {{originalAssumption}} - {{whatActuallyHappened}}",
+    ].join("\n"),
+  };
+
+  return `${compact[name]}\n\n### Output Template: ${label}\nSource: \`templates/${name}.md\``;
+}
+
 /**
  * Compact slice-summary excerpt for milestone-level closers (#4780).
  *
@@ -1717,7 +1882,7 @@ async function renderSlicePrompt(options: {
   const graphBlock = await inlineGraphSubgraph(base, `${sid} ${sTitle}`, { budget: 3000 });
   if (graphBlock) inlined.push(graphBlock);
 
-  inlined.push(inlineTemplate("plan", "Slice Plan"));
+  inlined.push(level === "minimal" ? inlineCompactTemplate("plan", "Slice Plan") : inlineTemplate("plan", "Slice Plan"));
   if (level === "full") {
     inlined.push(inlineTemplate("task-plan", "Task Plan"));
   }
@@ -1945,7 +2110,7 @@ export async function buildExecuteTaskPrompt(
   const graphBlockET = await inlineGraphSubgraph(base, `${tid} ${tTitle}`, { budget: 2000 });
 
   const inlinedTemplates = inlineLevel === "minimal"
-    ? inlineTemplate("task-summary", "Task Summary")
+    ? inlineCompactTemplate("task-summary", "Task Summary")
     : [
         inlineTemplate("task-summary", "Task Summary"),
         inlineTemplate("decisions", "Decisions"),
@@ -2091,7 +2256,9 @@ export async function buildCompleteSlicePrompt(
         return blocks.length > 0 ? blocks.join("\n\n---\n\n") : null;
       }
       case "templates": {
-        const parts = [inlineTemplate("slice-summary", "Slice Summary")];
+        const parts = [inlineLevel === "minimal"
+          ? inlineCompactTemplate("slice-summary", "Slice Summary")
+          : inlineTemplate("slice-summary", "Slice Summary")];
         if (inlineLevel !== "minimal") {
           parts.push(inlineTemplate("uat", "UAT"));
         }