@abelxiaoxing/cadence 1.3.0 → 1.4.1

package/src/workflow-recovery-policy.ts

@@ -0,0 +1,95 @@
+import type { ImplementPlan } from "./implement-plan.ts";
+
+export type RecoveryActionRequest = {
+  kind: "affected-repair" | "cumulative-repair" | "red-correction";
+  attempt: number;
+};
+export type RecoveryActionDecision =
+  | { allowed: true }
+  | {
+      allowed: false;
+      code: "repair-attempts-exhausted" | "artifact-attempts-exhausted";
+    };
+
+/** One policy for every nested recovery action; execution services supply facts only. */
+export function decideRecoveryAction(
+  plan: ImplementPlan,
+  request: RecoveryActionRequest,
+  authority: { additionalAttempt?: boolean; verificationOnly?: boolean } = {},
+): RecoveryActionDecision {
+  const correction = request.kind === "red-correction";
+  const limit =
+    authority.additionalAttempt || authority.verificationOnly
+      ? 1
+      : correction
+        ? plan.verification.artifactCorrection.maxAttempts
+        : plan.verification.repair.maxAttempts;
+  return Number.isSafeInteger(request.attempt) &&
+    request.attempt > 0 &&
+    request.attempt <= limit
+    ? { allowed: true }
+    : {
+        allowed: false,
+        code: correction
+          ? "artifact-attempts-exhausted"
+          : "repair-attempts-exhausted",
+      };
+}
+
+export interface WorkflowRecoveryFeedback {
+  code: string;
+  attempt: number;
+  maxAttempts: number;
+  strategy:
+    | "revise-candidate"
+    | "refresh-candidate"
+    | "repair-verification"
+    | "compact-patch";
+  failureIdentities?: string[];
+}
+
+export interface WorkflowRecoveryFact {
+  key: string;
+  failures: number;
+  feedback: WorkflowRecoveryFeedback;
+}
+
+export function recoveryExhausted(
+  incident: WorkflowRecoveryFact | undefined,
+  maximum: number,
+  granted: boolean,
+): boolean {
+  return !granted && incident !== undefined && incident.failures >= maximum;
+}
+
+/** A grant is a recommendation until the state machine validates and records it in its lease transaction. */
+export function assessRecoveryGrant(input: {
+  current: boolean;
+  incident?: WorkflowRecoveryFact;
+  failureSequence: number;
+  requestedSequence: number;
+  reason: string;
+  previous: { route?: string | null; context?: string | null };
+  observed: { route?: string | null; context?: string | null };
+  budget?: { used: number; max_work: number };
+}): string | undefined {
+  if (
+    !input.current ||
+    !input.incident ||
+    input.incident.failures < input.incident.feedback.maxAttempts ||
+    input.failureSequence !== input.requestedSequence
+  )
+    return "recovery-request-stale";
+  if (
+    (input.reason === "route-changed" &&
+      (!input.previous.route ||
+        input.previous.route === input.observed.route)) ||
+    (input.reason === "context-extended" &&
+      (!input.previous.context ||
+        input.previous.context === input.observed.context))
+  )
+    return "recovery-evidence-unavailable";
+  if (!input.budget || input.budget.used >= input.budget.max_work)
+    return "change-work-budget-exhausted";
+  return undefined;
+}

package/src/workflow-scheduling.ts

@@ -0,0 +1,105 @@
+import type { PlanTaskDraft } from "./implement-plan.ts";
+import { type EngineTaskRow, taskConflicts } from "./workflow-policy.ts";
+
+function taskPlan(row: EngineTaskRow): PlanTaskDraft {
+  return JSON.parse(row.plan_json) as PlanTaskDraft;
+}
+export function hasTaskConflict(
+  row: EngineTaskRow,
+  rows: EngineTaskRow[],
+  selectedTaskIds: ReadonlySet<string>,
+): boolean {
+  const candidate = taskPlan(row);
+  return rows.some((other) => {
+    if (other.task_id === row.task_id || other.state === "verified") {
+      return false;
+    }
+    if (other.state === "queued") {
+      if (row.state !== "queued") return false;
+      const candidatePosition = row.queue_position ?? Number.MAX_SAFE_INTEGER;
+      const otherPosition = other.queue_position ?? Number.MAX_SAFE_INTEGER;
+      if (
+        otherPosition > candidatePosition ||
+        (otherPosition === candidatePosition &&
+          other.task_order > row.task_order)
+      ) {
+        return false;
+      }
+    }
+    if (other.task_order > row.task_order && other.state === "pending") {
+      return false;
+    }
+    if (other.state === "pending" && !dependenciesVerified(other, rows)) {
+      return false;
+    }
+    const conflict = taskConflicts(candidate, taskPlan(other));
+    return (
+      conflict.taskLifetime ||
+      (conflict.verification &&
+        ([
+          "pending",
+          "phase-ready",
+          "phase-running",
+          "validating",
+          "queued",
+        ].includes(other.state) ||
+          selectedTaskIds.has(other.task_id)))
+    );
+  });
+}
+
+export function dependenciesVerified(
+  row: EngineTaskRow,
+  rows: EngineTaskRow[],
+): boolean {
+  const byId = new Map(rows.map((candidate) => [candidate.task_id, candidate]));
+  return taskPlan(row).dependsOn.every(
+    (dependency) => byId.get(dependency)?.state === "verified",
+  );
+}
+
+/** Simulate ordered queue decisions without storage access or launch authority. */
+export function selectRunnableTasks(input: {
+  rows: readonly EngineTaskRow[];
+  attempted: ReadonlySet<string>;
+  activeTasks: number;
+  capacity: number;
+  nextQueuePosition: number;
+}) {
+  const rows = input.rows.map((row) => ({ ...row }));
+  const runnable: string[] = [];
+  const selected = new Set<string>();
+  const updates: Array<
+    | { kind: "pending"; taskId: string }
+    | { kind: "queue"; taskId: string; reason: "conflict" | "capacity" }
+  > = [];
+  let position = input.nextQueuePosition;
+  let capacityBlocked = false;
+  for (const row of rows) {
+    if (row.state === "verified" || input.attempted.has(row.task_id)) continue;
+    if (!dependenciesVerified(row, rows)) {
+      if (row.state !== "pending") {
+        updates.push({ kind: "pending", taskId: row.task_id });
+        row.state = "pending";
+        row.pause_code = null;
+        row.queue_position = null;
+      }
+      continue;
+    }
+    const conflict = hasTaskConflict(row, rows, selected);
+    const capacity = input.activeTasks + runnable.length >= input.capacity;
+    if (conflict || capacity) {
+      const reason = conflict ? "conflict" : "capacity";
+      updates.push({ kind: "queue", taskId: row.task_id, reason });
+      if (row.state !== "queued" || row.queue_position === null)
+        row.queue_position = position++;
+      row.state = "queued";
+      row.pause_code = reason === "capacity" ? "worker-capacity" : null;
+      if (!conflict) capacityBlocked = true;
+      continue;
+    }
+    runnable.push(row.task_id);
+    selected.add(row.task_id);
+  }
+  return { runnable, updates, capacityBlocked };
+}