@abelxiaoxing/cadence 1.5.3 → 1.7.0

package/src/package-workflow.ts

@@ -14,6 +14,7 @@ import type { PackageContext } from "./model-source.ts";
 import { inspectOpenSpecDelivery } from "./openspec-cli.ts";
 import { proposePackageCandidate } from "./package-candidate.ts";
 import { packageDeliverySource } from "./package-delivery.ts";
+import { acquirePackageState } from "./package-state.ts";
 import {
   changeVerificationResult,
   executePackageVerification,
@@ -79,6 +80,42 @@ function affectedVerification(
 
 export function openPackageWorkflowService(
   initialContext: PackageContext,
+): PackageWorkflowService {
+  const state = acquirePackageState(
+    resolveStateRoot({
+      consumerRoot: path.resolve(initialContext.cwd),
+      xdgStateHome: process.env.XDG_STATE_HOME,
+    }),
+  );
+  try {
+    const service = openPreparedPackageWorkflowService(initialContext);
+    const notice = (result: Record<string, unknown>) =>
+      state.notice ? { ...result, packageStateReset: state.notice } : result;
+    return {
+      ...service,
+      async execute(...args) {
+        return notice(await service.execute(...args));
+      },
+      async executeDesign(...args) {
+        return notice(await service.executeDesign(...args));
+      },
+      async executeAmendment(...args) {
+        return notice(await service.executeAmendment(...args));
+      },
+      async close() {
+        // Never release ownership while an executor or storage connection may survive.
+        await service.close();
+        state.close();
+      },
+    };
+  } catch (error) {
+    state.close();
+    throw error;
+  }
+}
+
+function openPreparedPackageWorkflowService(
+  initialContext: PackageContext,
 ): PackageWorkflowService {
   const consumerRoot = path.resolve(initialContext.cwd);
   const routeResolution = loadRoutePolicy({
@@ -102,180 +139,191 @@ export function openPackageWorkflowService(
     stateRoot,
     inspectOpenSpec: inspectOpenSpecDelivery,
   });
-  const implementationAgent = loadAgentDefinitions().find(
-    (agent) => agent.role === "implementation-worker",
-  );
-  if (!implementationAgent) {
-    throw new Error("implementation-worker-agent-unavailable");
-  }
-  const hostLimit = (name: string, fallback: number): number => {
-    const value =
-      process.env[name] === undefined ? fallback : Number(process.env[name]);
-    if (!Number.isSafeInteger(value) || value < 1)
-      throw new Error("verification-host-limit-invalid");
-    return value;
-  };
-  const maxReportBytes = hostLimit(
-    "ABEL_VERIFICATION_MAX_REPORT_BYTES",
-    64 * 1024 * 1024,
-  );
-  const workHardLimit = hostLimit("ABEL_WORK_MAX_UNITS", 512);
-  const engine = openDurableWorkflowEngine({
-    workHardLimit,
-    verificationPolicy: `report-file-v5:${JSON.stringify(executionProfile())}`,
-    verificationEnvironment: coalesceVerificationScans(
-      (plan: import("./implement-plan.ts").ImplementPlan, signal) =>
-        captureVerificationEnvironmentIdentity(
-          consumerRoot,
-          [
-            ...plan.tasks.flatMap((task) => [
-              ...Object.values(task.phases).map((phase) => phase.verification),
-              task.affectedVerification,
-              task.repairVerification,
-            ]),
-            plan.verification.baseline.fullSuite,
-            plan.verification.change.fullSuite,
-            plan.verification.change.postApply,
-            ...(plan.verification.agentsCheckpoint.verification
-              ? [plan.verification.agentsCheckpoint.verification]
-              : []),
-          ],
-          signal,
-        ),
-    ),
-    consumerRoot,
-    stateRoot,
-    deliverySource: packageDeliverySource(consumerRoot, {
-      verifyGateProof: (input) => design.verifyGateProof(input),
-      verifyFinalizedDelivery: (input) => design.verifyFinalizedDelivery(input),
-    }),
-    routePolicy: routeResolution.ok
-      ? routeResolution.policy
-      : unavailableRoutePolicy(),
-    proposeCandidate: (input) =>
-      proposePackageCandidate(
-        input,
-        contexts.getStore(),
-        implementationAgent,
-        feedback.getStore()?.current(),
-      ),
-    verifyPhase: async (input) =>
-      phaseVerificationResult(
-        await verify({
-          maxReportBytes,
-          executionWritePaths: input.executionWritePaths,
-          root: input.root,
-          dependencyOwner: consumerRoot,
-          verification: input.verification,
-          signal: input.signal,
-        }),
-      ),
-    verifyChange: async (input) => {
-      const verifications = input.verification
-        ? [input.verification]
-        : input.plan.tasks.map((task) => affectedVerification(task));
-      let failure: ReturnType<typeof changeVerificationResult> | undefined;
-      for (const verification of verifications) {
-        const result = await verify({
-          maxReportBytes,
-          executionWritePaths: input.plan.tasks.flatMap((task) =>
-            Object.values(task.phases).flatMap((phase) => [
-              ...phase.write,
-              ...phase.delete,
-            ]),
+  try {
+    const implementationAgent = loadAgentDefinitions().find(
+      (agent) => agent.role === "implementation-worker",
+    );
+    if (!implementationAgent) {
+      throw new Error("implementation-worker-agent-unavailable");
+    }
+    const hostLimit = (name: string, fallback: number): number => {
+      const value =
+        process.env[name] === undefined ? fallback : Number(process.env[name]);
+      if (!Number.isSafeInteger(value) || value < 1)
+        throw new Error("verification-host-limit-invalid");
+      return value;
+    };
+    const maxReportBytes = hostLimit(
+      "ABEL_VERIFICATION_MAX_REPORT_BYTES",
+      64 * 1024 * 1024,
+    );
+    const workHardLimit = hostLimit("ABEL_WORK_MAX_UNITS", 512);
+    const engine = openDurableWorkflowEngine({
+      workHardLimit,
+      verificationPolicy: `report-file-v5:${JSON.stringify(executionProfile())}`,
+      verificationEnvironment: coalesceVerificationScans(
+        (plan: import("./implement-plan.ts").ImplementPlan, signal) =>
+          captureVerificationEnvironmentIdentity(
+            consumerRoot,
+            [
+              ...plan.tasks.flatMap((task) => [
+                ...Object.values(task.phases).map(
+                  (phase) => phase.verification,
+                ),
+                task.affectedVerification,
+                ...(task.baselineVerification
+                  ? [task.baselineVerification]
+                  : []),
+                task.repairVerification,
+              ]),
+              plan.verification.baseline.fullSuite,
+              plan.verification.change.fullSuite,
+              plan.verification.change.postApply,
+              ...(plan.verification.agentsCheckpoint.verification
+                ? [plan.verification.agentsCheckpoint.verification]
+                : []),
+            ],
+            signal,
           ),
-          root: input.root,
-          dependencyOwner: consumerRoot,
-          verification,
-          signal: input.signal,
-        });
-        const observed = changeVerificationResult(result);
-        if (!observed.ok) {
-          if (observed.kind !== "verification") return observed;
-          if (failure && !failure.ok && failure.kind === "verification") {
-            failure.failureIdentities = [
-              ...new Set([
-                ...(failure.failureIdentities ?? []),
-                ...(observed.failureIdentities ?? []),
+      ),
+      consumerRoot,
+      stateRoot,
+      deliverySource: packageDeliverySource(consumerRoot, {
+        verifyGateProof: (input) => design.verifyGateProof(input),
+        verifyFinalizedDelivery: (input) =>
+          design.verifyFinalizedDelivery(input),
+      }),
+      routePolicy: routeResolution.ok
+        ? routeResolution.policy
+        : unavailableRoutePolicy(),
+      proposeCandidate: (input) =>
+        proposePackageCandidate(
+          input,
+          contexts.getStore(),
+          implementationAgent,
+          feedback.getStore()?.current(),
+        ),
+      verifyPhase: async (input) =>
+        phaseVerificationResult(
+          await verify({
+            maxReportBytes,
+            executionWritePaths: input.executionWritePaths,
+            root: input.root,
+            dependencyOwner: consumerRoot,
+            verification: input.verification,
+            signal: input.signal,
+          }),
+        ),
+      verifyChange: async (input) => {
+        const verifications = input.verification
+          ? [input.verification]
+          : input.plan.tasks.map((task) => affectedVerification(task));
+        let failure: ReturnType<typeof changeVerificationResult> | undefined;
+        for (const verification of verifications) {
+          const result = await verify({
+            maxReportBytes,
+            executionWritePaths: input.plan.tasks.flatMap((task) =>
+              Object.values(task.phases).flatMap((phase) => [
+                ...phase.write,
+                ...phase.delete,
               ]),
-            ];
-            failure.attributionReliable =
-              failure.attributionReliable !== false &&
-              observed.attributionReliable !== false;
-          } else failure = observed;
+            ),
+            root: input.root,
+            dependencyOwner: consumerRoot,
+            verification,
+            signal: input.signal,
+          });
+          const observed = changeVerificationResult(result);
+          if (!observed.ok) {
+            if (observed.kind !== "verification") return observed;
+            if (failure && !failure.ok && failure.kind === "verification") {
+              failure.failureIdentities = [
+                ...new Set([
+                  ...(failure.failureIdentities ?? []),
+                  ...(observed.failureIdentities ?? []),
+                ]),
+              ];
+              failure.attributionReliable =
+                failure.attributionReliable !== false &&
+                observed.attributionReliable !== false;
+            } else failure = observed;
+          }
         }
-      }
-      if (failure) return failure;
-      return {
-        ok: true,
-        exitCode: 0,
-        classification: "expected-green",
-      };
-    },
-  });
-  return {
-    async execute(
-      command: unknown,
-      context = initialContext,
-      signal,
-      onActivity,
-    ) {
-      const operationRouteResolution = loadRoutePolicy({
-        cwd: consumerRoot,
-        home: homedir(),
-        ...(context.model ? { parentModel: context.model } : {}),
-      });
-      engine.updateRoutePolicy(
-        operationRouteResolution.ok
-          ? operationRouteResolution.policy
-          : unavailableRoutePolicy(),
-      );
-      const validation = validateControlCommand(command);
-      if (!validation.ok) {
-        const error = new Error(validation.code);
-        error.name = "ControlCommandError";
-        throw error;
-      }
-      return feedback.run(new VerificationFeedback(), () =>
-        contexts.run(context, async () => {
-          const outcome = await engine.execute(
-            validation.value,
-            signal,
-            onActivity,
-          );
-          const routePolicy = visibleRoutePolicyStatus(
-            operationRouteResolution,
-            engine.routePolicyStatus(),
-          );
-          return {
-            ...outcome,
-            routePolicy,
-            verificationDiagnostics: feedback.getStore()?.current() ?? [],
-          };
-        }),
-      );
-    },
-    executeDesign(request: unknown) {
-      return design.execute(request);
-    },
-    executeAmendment(change: string, batchId: string, request: unknown) {
-      return engine.amend(change, batchId, request, (assertAuthority) =>
-        design.executeWithAuthority(request, assertAuthority),
-      );
-    },
-    assertDesignRun(runId: string) {
-      design.assertDesignRun(runId);
-    },
-    recordDesignEvidence(input) {
-      return design.recordEvidence(input);
-    },
-    async close() {
-      contexts.disable();
-      await engine.close();
-      feedback.disable();
-      design.close();
-    },
-  };
+        if (failure) return failure;
+        return {
+          ok: true,
+          exitCode: 0,
+          classification: "expected-green",
+        };
+      },
+    });
+    return {
+      async execute(
+        command: unknown,
+        context = initialContext,
+        signal,
+        onActivity,
+      ) {
+        const operationRouteResolution = loadRoutePolicy({
+          cwd: consumerRoot,
+          home: homedir(),
+          ...(context.model ? { parentModel: context.model } : {}),
+        });
+        engine.updateRoutePolicy(
+          operationRouteResolution.ok
+            ? operationRouteResolution.policy
+            : unavailableRoutePolicy(),
+        );
+        const validation = validateControlCommand(command);
+        if (!validation.ok) {
+          const error = new Error(validation.code);
+          error.name = "ControlCommandError";
+          throw error;
+        }
+        return feedback.run(new VerificationFeedback(), () =>
+          contexts.run(context, async () => {
+            const outcome = await engine.execute(
+              validation.value,
+              signal,
+              onActivity,
+            );
+            const routePolicy = visibleRoutePolicyStatus(
+              operationRouteResolution,
+              engine.routePolicyStatus(),
+            );
+            return {
+              ...outcome,
+              routePolicy,
+              verificationDiagnostics: feedback.getStore()?.current() ?? [],
+            };
+          }),
+        );
+      },
+      executeDesign(request: unknown) {
+        return design.execute(request);
+      },
+      executeAmendment(change: string, batchId: string, request: unknown) {
+        return engine.amend(change, batchId, request, (assertAuthority) =>
+          design.executeWithAuthority(request, assertAuthority),
+        );
+      },
+      assertDesignRun(runId: string) {
+        design.assertDesignRun(runId);
+      },
+      recordDesignEvidence(input) {
+        return design.recordEvidence(input);
+      },
+      async close() {
+        contexts.disable();
+        await engine.close();
+        feedback.disable();
+        design.close();
+      },
+    };
+  } catch (error) {
+    design.close();
+    throw error;
+  }
 }
 
 function visibleRoutePolicyStatus(

package/src/phase-execution.ts

@@ -43,6 +43,7 @@ import {
   LOCKFILES,
   SHA256,
   semanticRouteFailure,
+  taskExecutionContract,
   type WorkflowAttemptOutcome,
   type WorkflowRouteFacts,
   type WorkflowWorker,
@@ -60,6 +61,7 @@ export interface PhaseExecutionServices {
     resources: PhaseResources;
     ledger: TaskLedger;
     signal: AbortSignal;
+    taskId?: string;
   }): Promise<DurableBaselineResult>;
   verifyTaskAffected(input: {
     resources: PhaseResources;
@@ -197,7 +199,10 @@ export class PhaseExecution {
       runId: input.runId,
       deliveryRevision: input.deliveryRevision,
       taskId: input.taskId,
-      boundaryHash: hash("durable-task-boundary", JSON.stringify(input.task)),
+      boundaryHash: hash(
+        "durable-task-boundary",
+        JSON.stringify(taskExecutionContract(input.task)),
+      ),
       objective: input.task.objective,
       contextRefs,
       initialPhase:
@@ -1562,6 +1567,7 @@ export class PhaseExecution {
         resources,
         ledger,
         signal: input.signal,
+        taskId: input.taskId,
       });
       if (!captured.ok) {
         const outcome = captured.outcome;