@abelxiaoxing/cadence 1.6.0 → 1.8.0

package/src/operator-tools.ts

@@ -7,6 +7,7 @@ import { resolveOpenSpecInvocation } from "./openspec-cli.ts";
 import { resolveStateRoot } from "./state-root.ts";
 import { requestBounds } from "./transport-budget.ts";
 import { validateVerificationAdapterCapability } from "./verification-capability.ts";
+import { probeWindowsJob } from "./windows-job-backend.ts";
 
 export interface DoctorCheck {
   name: string;
@@ -121,6 +122,11 @@ export function inspectConsumer(root: string) {
     "execution",
     () => {
       const profile = executionProfile();
+      if (profile.mode === "host-trusted") {
+        if (!probeWindowsJob(profile.windowsHelperPath ?? ""))
+          throw new Error("windows-job-backend-unavailable");
+        return "host-trusted: Windows x64 Job probe passed; host files/network accessible";
+      }
       if (process.platform !== "linux")
         throw new Error("linux-pid-isolation-required");
 
@@ -139,7 +145,7 @@ export function inspectConsumer(root: string) {
       if (result.status !== 0) throw new Error("bubblewrap-probe-failed");
       return `${profile.mode}: Bubblewrap PID namespace probe passed`;
     },
-    "On Linux install/enable Bubblewrap; set ABEL_BWRAP_PATH for a custom install. Trusted Linux projects may explicitly set ABEL_EXECUTION_MODE=local-trusted; Windows should use WSL.",
+    "On Linux install/enable Bubblewrap; set ABEL_BWRAP_PATH for a custom install. Trusted Linux projects may explicitly set ABEL_EXECUTION_MODE=local-trusted; Windows x64 trusted projects may explicitly select ABEL_EXECUTION_MODE=host-trusted and install the matching native Job helper (ABEL_WINDOWS_JOB_HELPER).",
   );
   check(
     "request-budgets",

package/src/package-state.ts

@@ -15,6 +15,7 @@ import {
 import path from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import { syncDirectory } from "./directory-sync.ts";
+import { assertExecutionsSettled } from "./execution-retention.ts";
 import { RunStore } from "./run-store.ts";
 import { prepareStateRoot, type ResolvedStateRoot } from "./state-root.ts";
 
@@ -160,6 +161,16 @@ export function acquirePackageState(
 ): { notice?: PackageStateNotice; close(): void } {
   versionParts(version);
   const state = prepareStateRoot(unresolved);
+  try {
+    assertExecutionsSettled(state.rootDir);
+  } catch (error) {
+    if (
+      error instanceof Error &&
+      error.message === "isolation-termination-unconfirmed"
+    )
+      fail(error.message);
+    throw error;
+  }
   for (const suffix of ["-wal", "-shm", "-journal"])
     regular(state.databasePath + suffix);
   const coordinator = path.join(

package/src/package-verification.ts

@@ -4,10 +4,12 @@ import path from "node:path";
 import {
   type AtomicVerificationContract,
   type StructuredVerificationContract,
+  type VerificationInputObservation,
   type VerificationObservation,
   verificationSteps,
 } from "./contracts.ts";
 import { executionProfile } from "./execution-profile.ts";
+import { retainExecution } from "./execution-retention.ts";
 import { canonicalJson } from "./implement-graph.ts";
 import { BubblewrapIsolationBackend } from "./isolation-backend.ts";
 import { observeSafePath } from "./safe-path.ts";
@@ -18,6 +20,7 @@ import {
 } from "./verification-capability.ts";
 import { diagnosticText } from "./verification-diagnostics.ts";
 import { prepareVerificationEnvironment } from "./verification-environment.ts";
+import { WindowsJobBackend } from "./windows-job-backend.ts";
 
 function sha256(value: Uint8Array | string): string {
   return createHash("sha256").update(value).digest("hex");
@@ -310,6 +313,7 @@ function readReport(root: string, relative: string, maximum: number): string {
 export async function executePackageVerification(input: {
   root: string;
   dependencyOwner: string;
+  executionOwnerRoot?: string;
   verification: StructuredVerificationContract;
   signal: AbortSignal;
   maxReportBytes?: number;
@@ -321,11 +325,13 @@ export async function executePackageVerification(input: {
   const unavailable = (
     code: string,
     category: "environment" | "adapter" | "resource" = "adapter",
+    inputObservation?: VerificationInputObservation,
   ): VerificationObservation => ({
     kind: "unavailable",
     category,
     code,
     verificationId: input.verification.id,
+    ...(inputObservation ? { inputObservation } : {}),
     ...(executionDiagnostic
       ? {
           diagnostic: {
@@ -349,7 +355,14 @@ export async function executePackageVerification(input: {
       executionWritePaths: input.executionWritePaths,
     },
   );
-  if (!capability.ok) return unavailable(capability.diagnostic.code);
+  if (!capability.ok)
+    return unavailable(
+      capability.diagnostic.code,
+      "adapter",
+      capability.diagnostic.kind === "verification-adapter"
+        ? capability.diagnostic.inputObservation
+        : undefined,
+    );
   let environment: Awaited<ReturnType<typeof prepareVerificationEnvironment>>;
   try {
     environment = await prepareVerificationEnvironment(
@@ -366,6 +379,7 @@ export async function executePackageVerification(input: {
         "workspace-dependency-missing",
         "dependency-path-unsafe",
         "execution-mode-invalid",
+        "windows-job-helper-path-invalid",
         "verification-timeout-invalid",
         "verification-environment-names-invalid",
         "verification-environment-requires-trusted-mode",
@@ -374,13 +388,20 @@ export async function executePackageVerification(input: {
         : "verification-environment-unavailable";
     return unavailable(code, "environment");
   }
+  let retained = false;
   try {
     const profile = executionProfile();
-    const isolation = new BubblewrapIsolationBackend({
-      bwrapPath: profile.bwrapPath,
-      timeoutMs: profile.timeoutMs,
-      localTrusted: profile.mode === "local-trusted",
-    });
+    const isolation =
+      profile.mode === "host-trusted"
+        ? new WindowsJobBackend({
+            helperPath: profile.windowsHelperPath ?? "",
+            timeoutMs: profile.timeoutMs,
+          })
+        : new BubblewrapIsolationBackend({
+            bwrapPath: profile.bwrapPath,
+            timeoutMs: profile.timeoutMs,
+            localTrusted: profile.mode === "local-trusted",
+          });
     let final: VerificationObservation | undefined;
     let sequence = 0;
     for (const step of verificationSteps(input.verification)) {
@@ -391,7 +412,7 @@ export async function executePackageVerification(input: {
         `${environment.reportRoot}/${relative}`,
       );
       if (!invocation) return unavailable("runner-missing");
-      if (profile.mode === "local-trusted") {
+      if (profile.mode !== "isolated") {
         const translate = (value: string) =>
           value.startsWith("/workspace/")
             ? path.join(input.root, value.slice(11))
@@ -399,16 +420,37 @@ export async function executePackageVerification(input: {
         invocation.executable = translate(invocation.executable);
         invocation.args = invocation.args.map(translate);
       }
-      const executed = await isolation.run({
-        root: input.root,
-        ...invocation,
-        mounts: environment.mounts,
-        environment: environment.environment,
-        ...(step.kind !== "vitest" && step.classification === "expected-red"
-          ? { outputWitness: step.expectedFailure }
-          : {}),
-        signal: input.signal,
-      });
+      const lease =
+        profile.mode === "host-trusted"
+          ? retainExecution(
+              input.executionOwnerRoot ?? path.dirname(input.root),
+              [input.root, environment.privateRoot],
+            )
+          : undefined;
+      let executed: Awaited<ReturnType<typeof isolation.run>>;
+      try {
+        executed = await isolation.run({
+          root: input.root,
+          ...invocation,
+          mounts: profile.mode === "host-trusted" ? [] : environment.mounts,
+          environment: environment.environment,
+          ...(step.kind !== "vitest" && step.classification === "expected-red"
+            ? { outputWitness: step.expectedFailure }
+            : {}),
+          signal: input.signal,
+        });
+        if (
+          !executed.ok &&
+          executed.code === "isolation-termination-unconfirmed"
+        ) {
+          retained = true;
+          lease?.uncertain();
+        } else lease?.settled();
+      } catch (error) {
+        retained = !!lease;
+        lease?.uncertain();
+        throw error;
+      }
       if (!executed.ok) {
         if (executed.state === "cancelled") return { kind: "cancelled" };
         return unavailable(
@@ -524,7 +566,7 @@ export async function executePackageVerification(input: {
     }
     return final ?? unavailable("verification-contract-unsupported");
   } finally {
-    await environment.cleanup();
+    if (!retained) await environment.cleanup();
   }
 }
 
@@ -552,6 +594,9 @@ export function phaseVerificationResult(result: VerificationObservation) {
     kind: "paused" as const,
     code: result.code,
     category: result.category,
+    ...(result.inputObservation
+      ? { inputObservation: result.inputObservation }
+      : {}),
   };
 }
 
@@ -583,5 +628,8 @@ export function changeVerificationResult(result: VerificationObservation) {
         ? ("verification-adapter" as const)
         : ("environment" as const),
     code: result.code,
+    ...(result.inputObservation
+      ? { inputObservation: result.inputObservation }
+      : {}),
   };
 }

package/src/package-workflow.ts

@@ -160,6 +160,7 @@ function openPreparedPackageWorkflowService(
     const workHardLimit = hostLimit("ABEL_WORK_MAX_UNITS", 512);
     const engine = openDurableWorkflowEngine({
       workHardLimit,
+      awaitPostApplySettlement: true,
       verificationPolicy: `report-file-v5:${JSON.stringify(executionProfile())}`,
       verificationEnvironment: coalesceVerificationScans(
         (plan: import("./implement-plan.ts").ImplementPlan, signal) =>
@@ -171,6 +172,9 @@ function openPreparedPackageWorkflowService(
                   (phase) => phase.verification,
                 ),
                 task.affectedVerification,
+                ...(task.baselineVerification
+                  ? [task.baselineVerification]
+                  : []),
                 task.repairVerification,
               ]),
               plan.verification.baseline.fullSuite,
@@ -207,6 +211,7 @@ function openPreparedPackageWorkflowService(
             executionWritePaths: input.executionWritePaths,
             root: input.root,
             dependencyOwner: consumerRoot,
+            executionOwnerRoot: stateRoot.rootDir,
             verification: input.verification,
             signal: input.signal,
           }),
@@ -227,6 +232,7 @@ function openPreparedPackageWorkflowService(
             ),
             root: input.root,
             dependencyOwner: consumerRoot,
+            executionOwnerRoot: stateRoot.rootDir,
             verification,
             signal: input.signal,
           });

package/src/phase-execution.ts

@@ -1,12 +1,11 @@
 import { randomUUID } from "node:crypto";
-import { mkdtempSync, rmSync } from "node:fs";
+import { mkdtempSync } from "node:fs";
 import path from "node:path";
 import {
   inspectCandidateArtifact,
   sealCandidateArtifact,
 } from "./candidate-artifact.ts";
 import { revisionChanges, runGitApply } from "./candidate-workspace.ts";
-
 import type { StructuredVerificationContract } from "./contracts.ts";
 import type { PlanTaskDraft } from "./delivery-compiler.ts";
 import type {
@@ -20,6 +19,8 @@ import type {
   DurableWorkflowEngineOptions,
   PhaseResources,
 } from "./durable-contracts.ts";
+import { isExecutionRetained } from "./execution-retention.ts";
+import { removePathSync } from "./remove-path.ts";
 import type {
   BeginCandidateInput,
   TaskLedger,
@@ -43,6 +44,7 @@ import {
   LOCKFILES,
   SHA256,
   semanticRouteFailure,
+  taskExecutionContract,
   type WorkflowAttemptOutcome,
   type WorkflowRouteFacts,
   type WorkflowWorker,
@@ -60,6 +62,7 @@ export interface PhaseExecutionServices {
     resources: PhaseResources;
     ledger: TaskLedger;
     signal: AbortSignal;
+    taskId?: string;
   }): Promise<DurableBaselineResult>;
   verifyTaskAffected(input: {
     resources: PhaseResources;
@@ -197,7 +200,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:
@@ -303,7 +309,8 @@ export class PhaseExecution {
           policy: this.#options.verificationPolicy ?? "legacy",
         });
       } finally {
-        rmSync(root, { recursive: true, force: true });
+        if (!isExecutionRetained(root))
+          removePathSync(root, { recursive: true, force: true });
       }
     }
     return undefined;
@@ -975,7 +982,8 @@ export class PhaseExecution {
         },
       };
     } finally {
-      rmSync(proposalRoot, { recursive: true, force: true });
+      if (!isExecutionRetained(proposalRoot))
+        removePathSync(proposalRoot, { recursive: true, force: true });
     }
   }
 
@@ -1160,7 +1168,8 @@ export class PhaseExecution {
           signal: request.signal,
         });
       } finally {
-        rmSync(root, { recursive: true, force: true });
+        if (!isExecutionRetained(root))
+          removePathSync(root, { recursive: true, force: true });
       }
     };
     emitWorkflowActivity(request.onActivity, { state: "verifying" });
@@ -1562,6 +1571,7 @@ export class PhaseExecution {
         resources,
         ledger,
         signal: input.signal,
+        taskId: input.taskId,
       });
       if (!captured.ok) {
         const outcome = captured.outcome;
@@ -2242,7 +2252,8 @@ export class PhaseExecution {
         baselineRevisionId: resources.baselineRevisionId,
       });
     } finally {
-      rmSync(proposalRoot, { recursive: true, force: true });
+      if (!isExecutionRetained(proposalRoot))
+        removePathSync(proposalRoot, { recursive: true, force: true });
     }
   }
 }