gsd-pi 2.79.0-dev.ece5fd8ba → 2.80.0-dev.4ea7d80e7

package/src/resources/extensions/gsd/auto/workflow-custom-engine-retry.ts

@@ -0,0 +1,90 @@
+// Project/App: GSD-2
+// File Purpose: Custom-engine verification retry adapter for auto-mode loop.
+
+import type { AutoSession } from "./session.js";
+import {
+  decideCustomEngineRecovery,
+  decideCustomEngineVerifyRetry,
+} from "./workflow-kernel.js";
+
+type RetrySession = Pick<AutoSession, "verificationRetryCount">;
+
+export type CustomEngineRecoverResult = {
+  outcome: "retry" | "skip" | "stop" | "pause";
+  reason?: string;
+};
+
+export type CustomEngineVerifyRetryOutcome =
+  | { action: "retry"; attempts: number }
+  | { action: "pause"; attempts: number; turnError: string }
+  | { action: "stop"; attempts: number; stopMessage: string; turnError: string };
+
+export interface HandleCustomEngineVerifyRetryDeps {
+  hydrateRetryCounts: () => Map<string, number>;
+  saveRetryCounts: () => void;
+  recover: (
+    unitType: string,
+    unitId: string,
+    options: { basePath: string },
+  ) => Promise<CustomEngineRecoverResult>;
+  logRetry: (details: { iteration: number; unitId: string; attempts: number }) => void;
+  reportRetry: (details: { unitType: string; unitId: string; attempts: number }) => void;
+}
+
+export async function handleCustomEngineVerifyRetry(input: {
+  session: RetrySession;
+  unitType: string;
+  unitId: string;
+  basePath: string;
+  iteration: number;
+  maxRetries: number;
+  deps: HandleCustomEngineVerifyRetryDeps;
+}): Promise<CustomEngineVerifyRetryOutcome> {
+  const recoveryKey = `${input.unitType}/${input.unitId}`;
+  const retryCounts = input.deps.hydrateRetryCounts();
+  const attempts = (retryCounts.get(recoveryKey) ?? 0) + 1;
+  input.session.verificationRetryCount.set(recoveryKey, attempts);
+  input.deps.saveRetryCounts();
+  input.deps.logRetry({
+    iteration: input.iteration,
+    unitId: input.unitId,
+    attempts,
+  });
+  input.deps.reportRetry({
+    unitType: input.unitType,
+    unitId: input.unitId,
+    attempts,
+  });
+
+  const retryDecision = decideCustomEngineVerifyRetry({
+    attempts,
+    maxRetries: input.maxRetries,
+  });
+  if (retryDecision.action === "retry") {
+    return { action: "retry", attempts };
+  }
+
+  const recovery = await input.deps.recover(input.unitType, input.unitId, {
+    basePath: input.basePath,
+  });
+  const recoveryDecision = decideCustomEngineRecovery({
+    outcome: recovery.outcome,
+    reason: recovery.reason,
+    unitId: input.unitId,
+    attempts,
+  });
+  if (recoveryDecision.action === "pause") {
+    return {
+      action: "pause",
+      attempts,
+      turnError: recoveryDecision.turnError,
+    };
+  }
+
+  return {
+    action: "stop",
+    attempts,
+    stopMessage: recoveryDecision.stopMessage,
+    turnError: recoveryDecision.turnError,
+  };
+}

package/src/resources/extensions/gsd/auto/workflow-custom-engine-verify-outcome.ts

@@ -0,0 +1,50 @@
+// Project/App: GSD-2
+// File Purpose: Applies custom-engine verification outcomes to auto-mode loop side effects.
+
+import type { CustomEngineVerifyRetryOutcome } from "./workflow-custom-engine-retry.js";
+
+export interface HandleCustomEngineVerifyOutcomeDeps {
+  pauseAuto: () => Promise<void>;
+  stopAuto: (reason: string) => Promise<void>;
+  reportPause: (details: { unitType: string; unitId: string }) => void;
+  finishTurn: (
+    status: "paused" | "stopped" | "retry",
+    failureClass?: "manual-attention",
+    error?: string,
+  ) => void;
+}
+
+export type CustomEngineVerifyFlow = { action: "break" } | { action: "continue" };
+
+export async function handleCustomEngineVerifyPause(input: {
+  unitType: string;
+  unitId: string;
+  deps: HandleCustomEngineVerifyOutcomeDeps;
+}): Promise<CustomEngineVerifyFlow> {
+  await input.deps.pauseAuto();
+  input.deps.reportPause({
+    unitType: input.unitType,
+    unitId: input.unitId,
+  });
+  input.deps.finishTurn("paused", "manual-attention", "custom-engine-verify-pause");
+  return { action: "break" };
+}
+
+export async function handleCustomEngineVerifyRetryOutcome(input: {
+  outcome: CustomEngineVerifyRetryOutcome;
+  deps: HandleCustomEngineVerifyOutcomeDeps;
+}): Promise<CustomEngineVerifyFlow> {
+  if (input.outcome.action === "pause") {
+    await input.deps.pauseAuto();
+    input.deps.finishTurn("paused", "manual-attention", input.outcome.turnError);
+    return { action: "break" };
+  }
+  if (input.outcome.action === "stop") {
+    await input.deps.stopAuto(input.outcome.stopMessage);
+    input.deps.finishTurn("stopped", "manual-attention", input.outcome.turnError);
+    return { action: "break" };
+  }
+
+  input.deps.finishTurn("retry");
+  return { action: "continue" };
+}

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

@@ -0,0 +1,97 @@
+// Project/App: GSD-2
+// File Purpose: Best-effort unit dispatch claim adapter for auto-mode loop.
+
+import type { AutoSession } from "./session.js";
+import type { IterationData } from "./types.js";
+
+export type DispatchClaimOutcome =
+  | { kind: "opened"; dispatchId: number }
+  | { kind: "skip"; reason: "already-active" | "stale-lease"; existingId?: number; existingWorker?: string }
+  | { kind: "degraded" };
+
+interface RecentDispatch {
+  attempt_n?: number | null;
+}
+
+interface RecordDispatchClaimInput {
+  traceId: string;
+  turnId?: string | null;
+  workerId: string;
+  milestoneLeaseToken: number;
+  milestoneId: string;
+  sliceId?: string | null;
+  taskId?: string | null;
+  unitType: string;
+  unitId: string;
+  attemptN?: number;
+}
+
+type RecordDispatchClaimResult =
+  | { ok: true; dispatchId: number }
+  | { ok: false; error: "already_active"; existingId: number; existingWorker: string }
+  | { ok: false; error: string; existingId?: number; existingWorker?: string };
+
+export interface OpenDispatchClaimDeps {
+  getRecentDispatchesForUnit: (unitId: string, limit: number) => RecentDispatch[];
+  recordDispatchClaim: (input: RecordDispatchClaimInput) => RecordDispatchClaimResult;
+  markDispatchRunning: (dispatchId: number) => void;
+  logClaimRejected: (details: {
+    unitId: string;
+    reason: string;
+    existingId?: number;
+    existingWorker?: string;
+  }) => void;
+  logClaimFailed: (err: unknown) => void;
+}
+
+export function openDispatchClaim(
+  s: AutoSession,
+  flowId: string,
+  turnId: string,
+  iterData: IterationData,
+  deps: OpenDispatchClaimDeps,
+): DispatchClaimOutcome {
+  if (!s.workerId || s.milestoneLeaseToken === null) return { kind: "degraded" };
+  const mid = iterData.mid;
+  if (!mid) return { kind: "degraded" };
+
+  const recent = deps.getRecentDispatchesForUnit(iterData.unitId, 1);
+  const attemptN = (recent[0]?.attempt_n ?? 0) + 1;
+
+  try {
+    const claim = deps.recordDispatchClaim({
+      traceId: flowId,
+      turnId,
+      workerId: s.workerId,
+      milestoneLeaseToken: s.milestoneLeaseToken,
+      milestoneId: mid,
+      sliceId: iterData.state.activeSlice?.id ?? null,
+      taskId: iterData.state.activeTask?.id ?? null,
+      unitType: iterData.unitType,
+      unitId: iterData.unitId,
+      attemptN,
+    });
+    if (!claim.ok) {
+      deps.logClaimRejected({
+        unitId: iterData.unitId,
+        reason: claim.error,
+        existingId: claim.existingId,
+        existingWorker: claim.existingWorker,
+      });
+      if (claim.error === "already_active") {
+        return {
+          kind: "skip",
+          reason: "already-active",
+          existingId: claim.existingId,
+          existingWorker: claim.existingWorker,
+        };
+      }
+      return { kind: "skip", reason: "stale-lease" };
+    }
+    deps.markDispatchRunning(claim.dispatchId);
+    return { kind: "opened", dispatchId: claim.dispatchId };
+  } catch (err) {
+    deps.logClaimFailed(err);
+    return { kind: "degraded" };
+  }
+}

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

@@ -0,0 +1,45 @@
+// Project/App: GSD-2
+// File Purpose: Best-effort dispatch ledger write helpers for auto-mode loop adapters.
+
+interface DispatchLedgerWriteDeps {
+  logWriteFailure: (err: unknown) => void;
+}
+
+interface DispatchLedgerFailDeps extends DispatchLedgerWriteDeps {
+  markFailed: (dispatchId: number, details: { errorSummary: string }) => void;
+}
+
+interface DispatchLedgerCompleteDeps extends DispatchLedgerWriteDeps {
+  markCompleted: (dispatchId: number) => void;
+}
+
+export function settleDispatchFailed(
+  dispatchId: number | null,
+  errorSummary: string,
+  deps: DispatchLedgerFailDeps,
+): boolean {
+  if (dispatchId === null) return false;
+
+  try {
+    deps.markFailed(dispatchId, { errorSummary });
+    return true;
+  } catch (err) {
+    deps.logWriteFailure(err);
+    return false;
+  }
+}
+
+export function settleDispatchCompleted(
+  dispatchId: number | null,
+  deps: DispatchLedgerCompleteDeps,
+): boolean {
+  if (dispatchId === null) return false;
+
+  try {
+    deps.markCompleted(dispatchId);
+    return true;
+  } catch (err) {
+    deps.logWriteFailure(err);
+    return false;
+  }
+}

package/src/resources/extensions/gsd/auto/workflow-iteration-completion.ts

@@ -0,0 +1,26 @@
+// Project/App: GSD-2
+// File Purpose: Successful auto-mode iteration cleanup helper.
+
+export interface WorkflowIterationRecoveryState {
+  consecutiveErrors: number;
+  consecutiveCooldowns: number;
+  recentErrorMessages: string[];
+}
+
+export interface CompleteWorkflowIterationDeps {
+  emitIterationEnd: () => void;
+  saveStuckState: () => void;
+  logIterationComplete: () => void;
+}
+
+export function completeWorkflowIteration(
+  state: WorkflowIterationRecoveryState,
+  deps: CompleteWorkflowIterationDeps,
+): void {
+  state.consecutiveErrors = 0;
+  state.consecutiveCooldowns = 0;
+  state.recentErrorMessages.length = 0;
+  deps.emitIterationEnd();
+  deps.saveStuckState();
+  deps.logIterationComplete();
+}

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

@@ -0,0 +1,33 @@
+// Project/App: GSD-2
+// File Purpose: Thin adapter for auto-mode workflow journal event emission.
+
+import type { JournalEntry, JournalEventType } from "../journal.js";
+
+export interface WorkflowJournalReporterInput {
+  emitJournalEvent: (entry: JournalEntry) => void;
+  flowId: string;
+  nextSeq: () => number;
+  now?: () => string;
+}
+
+export interface WorkflowJournalReporter {
+  emit(eventType: JournalEventType, data?: Record<string, unknown>): void;
+}
+
+export function createWorkflowJournalReporter(
+  input: WorkflowJournalReporterInput,
+): WorkflowJournalReporter {
+  const now = input.now ?? (() => new Date().toISOString());
+
+  return {
+    emit(eventType: JournalEventType, data?: Record<string, unknown>): void {
+      input.emitJournalEvent({
+        ts: now(),
+        flowId: input.flowId,
+        seq: input.nextSeq(),
+        eventType,
+        data,
+      });
+    },
+  };
+}