@abelxiaoxing/cadence 1.5.3 → 1.7.0

package/src/workflow-status.ts

@@ -8,10 +8,14 @@ import {
   type EngineRunRow,
   type EngineTaskRow,
   hash,
+  normalizeVerificationPrerequisite,
   normalizeWorkflowContextRequest,
   normalizeWorkflowVerificationStatus,
+  parentRecoveryStrategy,
   parseDeliveryDiagnostics,
   permitsPlanAmendment,
+  permitsPrerequisiteAmendment,
+  permitsRecoveryAmendment,
   type SafeAttemptDiagnostic,
 } from "./workflow-policy.ts";
 
@@ -60,6 +64,9 @@ export function projectWorkflowStatus({
           (right.queue_position ?? Number.MAX_SAFE_INTEGER) ||
         left.task_order - right.task_order,
     );
+  const activeRows = rows.filter((row) =>
+    ["approval-needed", "paused", "retryable"].includes(row.state),
+  );
   const firstPaused = firstPausedTask(rows);
   const contextRequest = firstPaused?.context_request_json
     ? normalizeWorkflowContextRequest(
@@ -71,6 +78,10 @@ export function projectWorkflowStatus({
     firstPaused?.state === "approval-needed"
       ? (firstPaused.pause_code ?? projection.pauseCode ?? "task-paused")
       : (projection.pauseCode ?? firstPaused?.pause_code ?? "task-paused");
+  const taskPauseSuperseded =
+    projection.state === "paused" &&
+    projection.pauseCode !== undefined &&
+    !activeRows.some((row) => row.pause_code === projection.pauseCode);
   const approval =
     projection.state === "approval-needed"
       ? approvalRequirement(pauseCode, contextRequest)
@@ -78,36 +89,75 @@ export function projectWorkflowStatus({
   const attemptDiagnostic = firstPaused
     ? attemptDiagnostics.get(firstPaused.task_id)
     : undefined;
-  const recovery =
-    rows
-      .map((row) => attemptDiagnostics.get(row.task_id)?.recovery)
-      .find((fact) => fact && fact.failures >= fact.feedback.maxAttempts) ??
-    attemptDiagnostic?.recovery;
+  const recovery = taskPauseSuperseded
+    ? undefined
+    : attemptDiagnostic?.recovery;
   const recoveryExhausted =
     recovery && recovery.failures >= recovery.feedback.maxAttempts;
-  const blockers = rows
-    .filter((row) =>
-      ["approval-needed", "paused", "retryable"].includes(row.state),
-    )
-    .map((row) => {
-      const context = row.context_request_json
-        ? normalizeWorkflowContextRequest(JSON.parse(row.context_request_json))
+  const selectedPrerequisite = normalizeVerificationPrerequisite(
+    taskPauseSuperseded ? undefined : attemptDiagnostic?.prerequisite,
+  );
+  const selectedRecoveryStrategy = parentRecoveryStrategy(
+    pauseCode,
+    taskPauseSuperseded ? undefined : attemptDiagnostic,
+  );
+  const selectedPauseActionable =
+    (projection.state === "approval-needed" && approval !== undefined) ||
+    (projection.state === "paused" &&
+      (permitsPlanAmendment(pauseCode) ||
+        selectedRecoveryStrategy !== undefined ||
+        permitsPrerequisiteAmendment(selectedPrerequisite)));
+  const blockers = activeRows.map((row) => {
+    const context = row.context_request_json
+      ? normalizeWorkflowContextRequest(JSON.parse(row.context_request_json))
+      : undefined;
+    const code = row.pause_code ?? "task-paused";
+    const diagnostic = attemptDiagnostics.get(row.task_id);
+    const prerequisite = normalizeVerificationPrerequisite(
+      diagnostic?.prerequisite,
+    );
+    const requirement =
+      row.state === "approval-needed"
+        ? approvalRequirement(code, context)
         : undefined;
-      const code = row.pause_code ?? "task-paused";
-      const requirement =
-        row.state === "approval-needed"
-          ? approvalRequirement(code, context)
-          : undefined;
-      return {
-        id: hash(runId, row.task_id, code, canonicalJson(context ?? {})),
-        taskId: row.task_id,
-        phase: row.phase,
-        code,
-        kind: requirement ? "decision" : "execution",
-        ...(requirement ?? {}),
-        ...(context ? { contextRequest: context } : {}),
-      };
-    });
+    return {
+      id: hash(runId, row.task_id, code, canonicalJson(context ?? {})),
+      taskId: row.task_id,
+      phase: row.phase,
+      code,
+      kind: requirement ? "decision" : "execution",
+      ...(requirement ?? {}),
+      ...(context ? { contextRequest: context } : {}),
+      ...(prerequisite
+        ? {
+            prerequisite,
+            scope:
+              prerequisite.scope === "baseline-full-suite" ? "change" : "task",
+            minimumRecovery: permitsPrerequisiteAmendment(prerequisite)
+              ? "Revise the baseline contract to read safe inputs from the retained original revision, then recompile within the existing authority."
+              : prerequisite.cause === "capability"
+                ? "Restore the required runner or external capability; a changed environment identity permits a bounded check."
+                : "Restore trusted verification prerequisites; the retained failure does not authorize plan changes.",
+          }
+        : {}),
+      ...(diagnostic?.recovery
+        ? {
+            recovery: {
+              code: diagnostic.recovery.feedback.code,
+              attempts: diagnostic.recovery.failures,
+              maxAttempts: diagnostic.recovery.feedback.maxAttempts,
+              strategy: diagnostic.recovery.feedback.strategy,
+              ...(diagnostic.recovery.feedback.failureIdentities
+                ? {
+                    failureIdentities:
+                      diagnostic.recovery.feedback.failureIdentities,
+                  }
+                : {}),
+            },
+          }
+        : {}),
+    };
+  });
   if (
     projection.state === "approval-needed" &&
     !blockers.some((item) => item.kind === "decision") &&
@@ -123,9 +173,19 @@ export function projectWorkflowStatus({
     });
   }
   const decisions = blockers.filter((item) => item.kind === "decision");
-  const amendments = blockers.filter(
-    (item) => item.kind === "decision" || permitsPlanAmendment(item.code),
-  );
+  const amendments = !selectedPauseActionable
+    ? []
+    : blockers.filter(
+        (item) =>
+          item.kind === "decision" ||
+          permitsPlanAmendment(item.code) ||
+          permitsRecoveryAmendment(
+            item.code,
+            attemptDiagnostics.get(item.taskId),
+          ) ||
+          ("prerequisite" in item &&
+            permitsPrerequisiteAmendment(item.prerequisite)),
+      );
   if (
     projection.state === "paused" &&
     permitsPlanAmendment(pauseCode) &&
@@ -147,6 +207,16 @@ export function projectWorkflowStatus({
     remaining: 64 - amendmentUsed,
     exhausted: amendmentUsed >= 64,
   };
+  const budgetCode = [
+    "change-work-budget-exhausted",
+    "change-recovery-budget-exhausted",
+  ].includes(pauseCode)
+    ? pauseCode
+    : undefined;
+  const budgetExhausted = budgetCode !== undefined;
+  const hasWorkCapacity =
+    !budgetExhausted &&
+    (!resourceBudget || resourceBudget.used < resourceBudget.maximum);
   const decisionBatch =
     amendments.length &&
     pauseCode !== "operation-cancelled" &&
@@ -179,12 +249,139 @@ export function projectWorkflowStatus({
           ].sort(),
         }
       : undefined;
-  const budgetCode = rows.find(
-    (row) =>
-      row.pause_code === "change-work-budget-exhausted" ||
-      row.pause_code === "change-recovery-budget-exhausted",
-  )?.pause_code;
-  const budgetExhausted = budgetCode !== undefined;
+  const guidanceRow = taskPauseSuperseded ? undefined : firstPaused;
+  const guidanceDiagnostic = taskPauseSuperseded
+    ? undefined
+    : attemptDiagnostic;
+  const guidanceCode = pauseCode;
+  const guidanceStrategy = selectedRecoveryStrategy;
+  const failureSequence = recovery
+    ? failureSequences.get(recovery.key)
+    : undefined;
+  const recoveryGrant =
+    recoveryExhausted &&
+    guidanceStrategy !== undefined &&
+    projection.state === "paused" &&
+    hasWorkCapacity &&
+    resourceBudget &&
+    failureSequence !== undefined &&
+    Number.isSafeInteger(failureSequence) &&
+    failureSequence > 0
+      ? {
+          incidentKey: recovery.key,
+          failureSequence,
+          reason: "parent-directed-retry" as const,
+        }
+      : undefined;
+  const recoveryContinuation =
+    projection.state === "paused" &&
+    hasWorkCapacity &&
+    guidanceStrategy &&
+    (!recoveryExhausted || recoveryGrant)
+      ? {
+          owner: "parent" as const,
+          automatic: true,
+          kind: "inspect-recovery" as const,
+          reason: guidanceCode,
+          stage: projection.stage,
+          change: projection.change,
+          metadata: {
+            ...(guidanceRow
+              ? { taskId: guidanceRow.task_id, phase: guidanceRow.phase }
+              : {}),
+            diagnostic: {
+              code: guidanceCode,
+              strategy:
+                guidanceDiagnostic?.recovery?.feedback.strategy ??
+                guidanceStrategy,
+              ...(guidanceDiagnostic?.recovery
+                ? {
+                    inspection: guidanceStrategy,
+                    attempts: guidanceDiagnostic.recovery.failures,
+                    maxAttempts:
+                      guidanceDiagnostic.recovery.feedback.maxAttempts,
+                    ...(guidanceDiagnostic.recovery.feedback.failureIdentities
+                      ? {
+                          failureIdentities:
+                            guidanceDiagnostic.recovery.feedback
+                              .failureIdentities,
+                        }
+                      : {}),
+                  }
+                : {}),
+              ...(guidanceDiagnostic?.prerequisite
+                ? {
+                    prerequisite: normalizeVerificationPrerequisite(
+                      guidanceDiagnostic.prerequisite,
+                    ),
+                  }
+                : {}),
+              ...(guidanceRow?.route_id || engineRun?.route_id
+                ? {
+                    route: {
+                      routeId:
+                        guidanceRow?.route_id ?? engineRun?.route_id ?? "",
+                      ...((guidanceRow?.route_fingerprint ??
+                      engineRun?.route_fingerprint)
+                        ? {
+                            routeFingerprint:
+                              guidanceRow?.route_fingerprint ??
+                              engineRun?.route_fingerprint,
+                          }
+                        : {}),
+                    },
+                  }
+                : {}),
+            },
+            ...(recoveryGrant
+              ? {
+                  recommendation: {
+                    kind: "bounded-additional-attempt" as const,
+                    resume: { recovery: recoveryGrant },
+                  },
+                }
+              : {}),
+          },
+        }
+      : undefined;
+  const amendmentContinuation =
+    decisionBatch && !amendmentBudget.exhausted && hasWorkCapacity
+      ? {
+          owner: "parent" as const,
+          automatic: true,
+          ...decisionBatch.continuation,
+        }
+      : undefined;
+  const interruptedContinuation =
+    projection.stage === "abel-implement" &&
+    projection.change &&
+    projection.pauseCode === "operation-interrupted" &&
+    legalControlCommands(projection.state).includes("resume") &&
+    (projection.state === "recovering" ||
+      (projection.state === "paused" && hasWorkCapacity))
+      ? {
+          owner: "parent" as const,
+          automatic: true,
+          command: "resume" as const,
+          kind:
+            projection.state === "recovering"
+              ? ("settle-apply-recovery" as const)
+              : ("resume-interrupted-operation" as const),
+          reason: "operation-interrupted" as const,
+          stage: projection.stage,
+          change: projection.change,
+          ...(guidanceRow?.pause_code === "operation-interrupted"
+            ? {
+                metadata: {
+                  taskId: guidanceRow.task_id,
+                  phase: guidanceRow.phase,
+                },
+              }
+            : {}),
+        }
+      : undefined;
+  const continuation =
+    interruptedContinuation ?? recoveryContinuation ?? amendmentContinuation;
   const currentRevision = projection.deliveryRevision ?? 0;
   return {
     runId: projection.runId,
@@ -220,17 +417,6 @@ export function projectWorkflowStatus({
       ? {
           decisionBatch,
           amendmentBudget,
-          ...(!amendmentBudget.exhausted &&
-          !budgetExhausted &&
-          (!resourceBudget || resourceBudget.used < resourceBudget.maximum)
-            ? {
-                continuation: {
-                  owner: "parent",
-                  automatic: true,
-                  ...decisionBatch.continuation,
-                },
-              }
-            : {}),
         }
       : {}),
     ...(recoveryExhausted
@@ -242,20 +428,11 @@ export function projectWorkflowStatus({
             attempts: recovery.failures,
             maxAttempts: recovery.feedback.maxAttempts,
             automaticRetryExhausted: true,
-            ...(!budgetExhausted &&
-            resourceBudget &&
-            resourceBudget.used < resourceBudget.maximum
-              ? {
-                  additionalAttempt: {
-                    incidentKey: recovery.key,
-                    failureSequence: failureSequences.get(recovery.key) ?? 0,
-                    reason: "parent-directed-retry",
-                  },
-                }
-              : {}),
+            ...(recoveryGrant ? { additionalAttempt: recoveryGrant } : {}),
           },
         }
       : {}),
+    ...(continuation ? { continuation } : {}),
     ...(projection.terminal ? { terminal: projection.terminal } : {}),
     ...(projection.pauseCode || firstPaused?.pause_code
       ? {
@@ -298,6 +475,10 @@ export function projectWorkflowStatus({
               receiptHash: "matching-ready-receipt",
             },
           },
+        }
+      : {}),
+    ...(approval && projection.change
+      ? {
           conditionalCommands: [
             {
               command: "resume",
@@ -310,7 +491,18 @@ export function projectWorkflowStatus({
             },
           ],
         }
-      : {}),
+      : recoveryGrant && projection.change
+        ? {
+            conditionalCommands: [
+              {
+                command: "resume",
+                stage: "abel-implement",
+                change: projection.change,
+                requires: { recovery: recoveryGrant },
+              },
+            ],
+          }
+        : {}),
     tasks: rows.map((row) => ({
       taskId: row.task_id,
       state: row.state,

package/src/workspace-io-worker.mjs

@@ -7,19 +7,41 @@ import { parentPort, workerData } from "node:worker_threads";
 import { createHash, randomUUID } from "node:crypto";
 import {
   chmodSync,
-  closeSync,
-  constants,
+  closeSync as closeSync2,
+  constants as constants2,
   copyFileSync,
-  fsyncSync,
+  fsyncSync as fsyncSync2,
   lstatSync,
   mkdirSync,
-  openSync,
+  openSync as openSync2,
   readFileSync,
   renameSync,
   unlinkSync,
   writeFileSync
 } from "node:fs";
 import path from "node:path";
+
+// src/directory-sync.ts
+import { closeSync, constants, fstatSync, fsyncSync, openSync } from "node:fs";
+function syncDirectory(directory) {
+  const descriptor = openSync(directory, constants.O_RDONLY);
+  try {
+    try {
+      fsyncSync(descriptor);
+      return "synced";
+    } catch (error) {
+      const failure = error;
+      if (process.platform === "win32" && failure?.code === "EPERM" && failure.syscall === "fsync" && fstatSync(descriptor).isDirectory()) {
+        return "unsupported-directory-barrier";
+      }
+      throw error;
+    }
+  } finally {
+    closeSync(descriptor);
+  }
+}
+
+// src/artifact-store.ts
 var SHA256 = /^[a-f0-9]{64}$/u;
 function digest(bytes) {
   return createHash("sha256").update(bytes).digest("hex");
@@ -55,24 +77,16 @@ function ensureDirectory(directory) {
   }
   chmodSync(directory, 448);
 }
-function syncDirectory(directory) {
-  const descriptor = openSync(directory, constants.O_RDONLY);
-  try {
-    fsyncSync(descriptor);
-  } finally {
-    closeSync(descriptor);
-  }
-}
 function writeAtomic(target, bytes) {
   const directory = path.dirname(target);
   ensureDirectory(directory);
   const temporary = path.join(directory, `.${path.basename(target)}.${process.pid}.${randomUUID()}.tmp`);
-  const descriptor = openSync(temporary, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, 384);
+  const descriptor = openSync2(temporary, constants2.O_CREAT | constants2.O_EXCL | constants2.O_WRONLY, 384);
   try {
     writeFileSync(descriptor, bytes);
-    fsyncSync(descriptor);
+    fsyncSync2(descriptor);
   } finally {
-    closeSync(descriptor);
+    closeSync2(descriptor);
   }
   try {
     renameSync(temporary, target);
@@ -148,7 +162,7 @@ class ArtifactStore {
     const stat = lstatSync(source, { throwIfNoEntry: false });
     if (!stat?.isFile() || stat.isSymbolicLink())
       throw new Error("artifact-unavailable");
-    copyFileSync(source, destination, constants.COPYFILE_EXCL | constants.COPYFILE_FICLONE);
+    copyFileSync(source, destination, constants2.COPYFILE_EXCL | constants2.COPYFILE_FICLONE);
     const bytes = readFileSync(destination);
     if (digest(bytes) !== hash)
       throw new Error("artifact-integrity-invalid");
@@ -199,7 +213,7 @@ class ArtifactStore {
 
 // src/verification-environment-io.ts
 import {
-  constants as constants2,
+  constants as constants3,
   cpSync,
   lstatSync as lstatSync2,
   mkdirSync as mkdirSync2,
@@ -329,7 +343,7 @@ function prepareVerificationEnvironmentIo(root, dependencyOwner, runnerBindings,
               checkCancelled();
               return true;
             },
-            mode: constants2.COPYFILE_FICLONE,
+            mode: constants3.COPYFILE_FICLONE,
             verbatimSymlinks: true
           });
       };
@@ -410,11 +424,11 @@ function removeEntry(file, checkCancelled) {
 // src/verification-identity.ts
 import { createHash as createHash2 } from "node:crypto";
 import {
-  closeSync as closeSync2,
-  constants as constants3,
-  fstatSync,
+  closeSync as closeSync3,
+  constants as constants4,
+  fstatSync as fstatSync2,
   lstatSync as lstatSync3,
-  openSync as openSync2,
+  openSync as openSync3,
   readdirSync as readdirSync2,
   readlinkSync,
   readSync
@@ -451,9 +465,9 @@ function verificationEnvironmentDigest(roots, checkCancelled = () => {}) {
     }
     if (!stat.isFile())
       throw new Error("verification-environment-unsafe");
-    const fd = openSync2(file, constants3.O_RDONLY | constants3.O_NOFOLLOW);
+    const fd = openSync3(file, constants4.O_RDONLY | constants4.O_NOFOLLOW);
     try {
-      const before = fstatSync(fd);
+      const before = fstatSync2(fd);
       if (before.ino !== stat.ino || before.dev !== stat.dev)
         throw new Error("verification-environment-changed");
       const content = createHash2("sha256");
@@ -467,12 +481,12 @@ function verificationEnvironmentDigest(roots, checkCancelled = () => {}) {
           throw new Error("verification-environment-limit");
         content.update(buffer.subarray(0, count));
       }
-      const after = fstatSync(fd);
+      const after = fstatSync2(fd);
       if (before.size !== after.size || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs)
         throw new Error("verification-environment-changed");
       digest2.update(JSON.stringify(["file", content.digest("hex")]));
     } finally {
-      closeSync2(fd);
+      closeSync3(fd);
     }
   };
   for (const root of [...new Set(roots)].sort())
@@ -485,12 +499,12 @@ import { execFile, execFileSync } from "node:child_process";
 import { createHash as createHash3, randomUUID as randomUUID2 } from "node:crypto";
 import {
   chmodSync as chmodSync2,
-  closeSync as closeSync3,
-  constants as constants4,
-  fsyncSync as fsyncSync2,
+  closeSync as closeSync4,
+  constants as constants5,
+  fsyncSync as fsyncSync3,
   lstatSync as lstatSync5,
   mkdirSync as mkdirSync3,
-  openSync as openSync3,
+  openSync as openSync4,
   readFileSync as readFileSync2,
   renameSync as renameSync2,
   unlinkSync as unlinkSync2,
@@ -765,29 +779,21 @@ function ensureDirectory2(directory) {
   }
   chmodSync2(directory, 448);
 }
-function syncDirectory2(directory) {
-  const descriptor = openSync3(directory, constants4.O_RDONLY);
-  try {
-    fsyncSync2(descriptor);
-  } finally {
-    closeSync3(descriptor);
-  }
-}
 function writeAtomic2(target, bytes) {
   const directory = path5.dirname(target);
   ensureDirectory2(directory);
   const temporary = path5.join(directory, `.${path5.basename(target)}.${process.pid}.${randomUUID2()}.tmp`);
-  const descriptor = openSync3(temporary, constants4.O_CREAT | constants4.O_EXCL | constants4.O_WRONLY, 384);
+  const descriptor = openSync4(temporary, constants5.O_CREAT | constants5.O_EXCL | constants5.O_WRONLY, 384);
   try {
     writeFileSync3(descriptor, bytes);
-    fsyncSync2(descriptor);
+    fsyncSync3(descriptor);
   } finally {
-    closeSync3(descriptor);
+    closeSync4(descriptor);
   }
   try {
     renameSync2(temporary, target);
     chmodSync2(target, 384);
-    syncDirectory2(directory);
+    syncDirectory(directory);
   } catch (error) {
     try {
       unlinkSync2(temporary);

package/src/workspace-store.ts

@@ -18,6 +18,7 @@ import { promisify } from "node:util";
 import type { ArtifactStore } from "./artifact-store.ts";
 import { compareCanonicalStrings } from "./canonical.ts";
 import { isValidRelativePath } from "./contracts.ts";
+import { syncDirectory } from "./directory-sync.ts";
 import { observeSafePath } from "./safe-path.ts";
 import { runWorkspaceIo, type WorkspaceIoMetrics } from "./workspace-io.ts";
 
@@ -127,15 +128,6 @@ function ensureDirectory(directory: string): void {
   chmodSync(directory, 0o700);
 }
 
-function syncDirectory(directory: string): void {
-  const descriptor = openSync(directory, constants.O_RDONLY);
-  try {
-    fsyncSync(descriptor);
-  } finally {
-    closeSync(descriptor);
-  }
-}
-
 function writeAtomic(target: string, bytes: Uint8Array): void {
   const directory = path.dirname(target);
   ensureDirectory(directory);