@abelxiaoxing/cadence 1.8.4 → 2.0.1

package/src/workflow-recovery-policy.ts

@@ -1,97 +0,0 @@
-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[];
-  /** Last observed baseline condition; execution/display renaming cannot refund failures. */
-  prerequisiteIdentity?: 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

@@ -1,105 +0,0 @@
-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 };
-}