@abelxiaoxing/cadence 1.7.0 → 1.8.1

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

@@ -9,6 +9,7 @@ import {
   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";
@@ -19,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");
@@ -311,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;
@@ -376,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",
@@ -384,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)) {
@@ -401,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))
@@ -409,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(
@@ -534,7 +566,7 @@ export async function executePackageVerification(input: {
     }
     return final ?? unavailable("verification-contract-unsupported");
   } finally {
-    await environment.cleanup();
+    if (!retained) await environment.cleanup();
   }
 }
 

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) =>
@@ -210,6 +211,7 @@ function openPreparedPackageWorkflowService(
             executionWritePaths: input.executionWritePaths,
             root: input.root,
             dependencyOwner: consumerRoot,
+            executionOwnerRoot: stateRoot.rootDir,
             verification: input.verification,
             signal: input.signal,
           }),
@@ -230,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,
@@ -308,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;
@@ -980,7 +982,8 @@ export class PhaseExecution {
         },
       };
     } finally {
-      rmSync(proposalRoot, { recursive: true, force: true });
+      if (!isExecutionRetained(proposalRoot))
+        removePathSync(proposalRoot, { recursive: true, force: true });
     }
   }
 
@@ -1165,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" });
@@ -2248,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 });
     }
   }
 }

package/src/remove-path.ts

@@ -0,0 +1,32 @@
+import { lstatSync, readdirSync, rmdirSync, rmSync, unlinkSync } from "node:fs";
+import path from "node:path";
+
+/** Remove owned paths without following directory links. Node 24.13's Windows
+ * rmSync uses narrow std::filesystem paths and can silently miss Unicode names.
+ * The libuv-backed unlink/rmdir APIs preserve the original UTF-16 path. */
+export function removePathSync(
+  target: string,
+  options: { recursive?: boolean; force?: boolean } = {},
+): void {
+  if (process.platform !== "win32") {
+    rmSync(target, options);
+    return;
+  }
+  let stat: import("node:fs").Stats;
+  try {
+    stat = lstatSync(target);
+  } catch (error) {
+    if (options.force && (error as NodeJS.ErrnoException).code === "ENOENT")
+      return;
+    throw error;
+  }
+  if (stat.isDirectory() && !stat.isSymbolicLink()) {
+    if (!options.recursive)
+      throw Object.assign(new Error("Path is a directory"), {
+        code: "ERR_FS_EISDIR",
+      });
+    for (const name of readdirSync(target))
+      removePathSync(path.join(target, name), options);
+    rmdirSync(target);
+  } else unlinkSync(target);
+}

package/src/verification-capability.ts

@@ -838,7 +838,7 @@ function validateAtomicCapability(
       continue;
     if (
       lstatSync(path.join(root, relative)).size > 64 * 1024 ||
-      (executionProfile().mode !== "local-trusted" &&
+      (executionProfile().mode === "isolated" &&
         unsupportedExecutionConfiguration(
           readFileSync(path.join(root, relative), "utf8"),
         ))

package/src/verification-environment-io.ts

@@ -4,14 +4,15 @@ import {
   lstatSync,
   mkdirSync,
   readdirSync,
+  readlinkSync,
   realpathSync,
-  rmSync,
   symlinkSync,
   writeFileSync,
 } from "node:fs";
 import path from "node:path";
 import type { ExecutionProfile } from "./execution-profile.ts";
 import type { IsolationMount } from "./isolation-backend.ts";
+import { removePathSync } from "./remove-path.ts";
 import type { VerificationRunnerBinding } from "./verification-capability.ts";
 
 const CACHES = [".vite", ".vite-temp"];
@@ -34,9 +35,11 @@ export function prepareVerificationEnvironmentIo(
   checkCancelled: () => void,
   privateRoot: string,
 ) {
-  const cleanup = () => rmSync(privateRoot, { recursive: true, force: true });
+  const cleanup = () =>
+    removePathSync(privateRoot, { recursive: true, force: true });
   try {
-    const local = profile.mode === "local-trusted";
+    const local = profile.mode !== "isolated";
+    const native = profile.mode === "host-trusted";
     if (local && realpathSync(root) === realpathSync(dependencyOwner))
       throw new Error("trusted-candidate-required");
     const mounts: IsolationMount[] = [
@@ -51,11 +54,19 @@ export function prepareVerificationEnvironmentIo(
     ]) {
       mkdirSync(path.join(privateRoot, directory), { mode: 0o700 });
     }
+    if (native) {
+      mkdirSync(path.join(privateRoot, "home/AppData/Roaming"), {
+        recursive: true,
+      });
+      mkdirSync(path.join(privateRoot, "home/AppData/Local"), {
+        recursive: true,
+      });
+    }
     writeFileSync(path.join(privateRoot, "home/user.npmrc"), "");
     writeFileSync(path.join(privateRoot, "home/global.npmrc"), "");
     const dependencies = path.join(dependencyOwner, "node_modules");
     const stat = lstatSync(dependencies, { throwIfNoEntry: false });
-    if (stat) {
+    if (stat && !native) {
       const target = path.join(root, "node_modules");
       const targetStat = lstatSync(target, { throwIfNoEntry: false });
       if (
@@ -133,7 +144,7 @@ export function prepareVerificationEnvironmentIo(
         });
       }
     }
-    if (local && stat) {
+    if (local && stat && !native) {
       // Private copies keep package caches/writes away from consumer dependencies.
       const copyEntry = (name: string) => {
         checkCancelled();
@@ -177,8 +188,77 @@ export function prepareVerificationEnvironmentIo(
         copyEntry(name);
     }
 
+    if (native && stat) {
+      const target = path.join(root, "node_modules");
+      const targetStat = lstatSync(target, { throwIfNoEntry: false });
+      if (
+        !stat.isDirectory() ||
+        stat.isSymbolicLink() ||
+        (targetStat &&
+          (!targetStat.isDirectory() || targetStat.isSymbolicLink()))
+      )
+        throw new Error("dependency-path-unsafe");
+      const owner = realpathSync(dependencyOwner);
+      let count = 0;
+      const copy = (source: string, destination: string) => {
+        checkCancelled();
+        if (++count > 500_000) throw new Error("dependency-view-too-large");
+        const entry = lstatSync(source);
+        if (entry.isSymbolicLink()) {
+          const resolved = realpathSync(source);
+          if (!within(owner, resolved))
+            throw new Error("dependency-path-unsafe");
+          const candidate = path.join(root, path.relative(owner, resolved));
+          if (
+            !within(realpathSync(dependencies), resolved) &&
+            !lstatSync(candidate, { throwIfNoEntry: false })
+          )
+            throw new Error("workspace-dependency-missing");
+          const linked = lstatSync(resolved);
+          if (linked.isDirectory()) {
+            // Junctions do not require Windows Developer Mode/admin privileges.
+            symlinkSync(
+              candidate,
+              destination,
+              process.platform === "win32" ? "junction" : "dir",
+            );
+          } else if (linked.isFile()) {
+            const file = within(realpathSync(dependencies), resolved)
+              ? resolved
+              : candidate;
+            cpSync(file, destination, { mode: constants.COPYFILE_FICLONE });
+          } else throw new Error("dependency-path-unsafe");
+        } else if (entry.isDirectory()) {
+          mkdirSync(destination, { recursive: true });
+          for (const name of readdirSync(source)) {
+            if (source === dependencies && CACHES.includes(name)) {
+              mkdirSync(path.join(destination, name));
+              continue;
+            }
+            copy(path.join(source, name), path.join(destination, name));
+          }
+        } else if (entry.isFile())
+          cpSync(source, destination, { mode: constants.COPYFILE_FICLONE });
+        else throw new Error("dependency-path-unsafe");
+      };
+      removeEntry(target, checkCancelled);
+      copy(dependencies, target);
+    }
     const sources = new Map<string, string>();
     const bindings = runnerBindings.map((binding) => {
+      if (native) {
+        const translate = (value: string) =>
+          path.isAbsolute(value) && within(dependencyOwner, value)
+            ? path.join(root, path.relative(dependencyOwner, value))
+            : value;
+        return {
+          ...binding,
+          executablePath: translate(binding.executablePath),
+          ...(binding.fixedArgs
+            ? { fixedArgs: binding.fixedArgs.map(translate) }
+            : {}),
+        };
+      }
       if (local || !binding.mountSource) return { ...binding };
       const source = path.resolve(binding.mountSource);
       const stat = lstatSync(source);
@@ -200,7 +280,15 @@ export function prepareVerificationEnvironmentIo(
         path.posix.join(target, ...path.relative(source, file).split(path.sep));
       return {
         ...binding,
-        executablePath: translate(executable),
+        // Preserve an installation's relative launcher link (e.g. bin/npm).
+        // Exposing lib/node_modules/npm/bin on PATH selects npm's Windows
+        // installer shell shim during a nested `npm run` on Linux.
+        executablePath: translate(
+          lstatSync(binding.executablePath).isSymbolicLink() &&
+            !path.isAbsolute(readlinkSync(binding.executablePath))
+            ? binding.executablePath
+            : executable,
+        ),
         ...(binding.fixedArgs
           ? {
               fixedArgs: binding.fixedArgs.map((arg) =>
@@ -215,7 +303,7 @@ export function prepareVerificationEnvironmentIo(
     checkCancelled();
     return {
       privateRoot,
-      mounts,
+      mounts: native ? [] : mounts,
       bindings,
       reportRoot: local ? privateRoot : "/cadence",
       environment: {
@@ -228,6 +316,24 @@ export function prepareVerificationEnvironmentIo(
               ),
             )
           : {}),
+        ...(native
+          ? Object.fromEntries(
+              Object.entries(environment).filter(([key]) =>
+                ["SYSTEMROOT", "WINDIR", "COMSPEC", "PATHEXT"].includes(
+                  key.toUpperCase(),
+                ),
+              ),
+            )
+          : {}),
+        ...(native
+          ? {
+              USERPROFILE: path.join(privateRoot, "home"),
+              APPDATA: path.join(privateRoot, "home", "AppData", "Roaming"),
+              LOCALAPPDATA: path.join(privateRoot, "home", "AppData", "Local"),
+              TEMP: path.join(privateRoot, "tmp"),
+              TMP: path.join(privateRoot, "tmp"),
+            }
+          : {}),
         CI: "1",
         HOME: local ? path.join(privateRoot, "home") : "/cadence/home",
         XDG_CACHE_HOME: local
@@ -249,13 +355,13 @@ export function prepareVerificationEnvironmentIo(
             [
               ...bindings.filter((binding) => binding.mountSource),
               ...bindings.filter((binding) => !binding.mountSource),
-            ].map((binding) => path.posix.dirname(binding.executablePath)),
+            ].map((binding) =>
+              (local ? path : path.posix).dirname(binding.executablePath),
+            ),
           ),
           ...(local ? (environment.PATH ?? "").split(path.delimiter) : []),
-          "/usr/local/bin",
-          "/usr/bin",
-          "/bin",
-        ].join(":"),
+          ...(native ? [] : ["/usr/local/bin", "/usr/bin", "/bin"]),
+        ].join(local ? path.delimiter : ":"),
       },
     };
   } catch (error) {
@@ -273,8 +379,11 @@ function removeEntry(file: string, checkCancelled: () => void): void {
   checkCancelled();
   const stat = lstatSync(file, { throwIfNoEntry: false });
   if (!stat) return;
-  if (stat.isDirectory())
+  if (stat.isDirectory() && !stat.isSymbolicLink())
     for (const name of readdirSync(file))
       removeEntry(path.join(file, name), checkCancelled);
-  rmSync(file, { recursive: stat.isDirectory(), force: true });
+  removePathSync(file, {
+    recursive: stat.isDirectory() && !stat.isSymbolicLink(),
+    force: true,
+  });
 }

package/src/verification-environment.ts

@@ -25,7 +25,18 @@ export async function captureVerificationEnvironmentIdentity(
   const roots = [path.join(dependencyOwner, "node_modules")];
   const unavailable: string[] = [];
   const profile = executionProfile();
-  roots.push(path.resolve(profile.bwrapPath));
+  if (profile.mode === "host-trusted")
+    roots.push(
+      path.resolve(profile.windowsHelperPath ?? ""),
+      path.resolve(`${profile.windowsHelperPath}.json`),
+    );
+  else roots.push(path.resolve(profile.bwrapPath));
+  if (
+    profile.mode === "host-trusted" &&
+    process.env.ComSpec &&
+    path.isAbsolute(process.env.ComSpec)
+  )
+    roots.push(process.env.ComSpec);
   const node = resolveVerificationRunner("node");
   if (node) roots.push(realpathSync(node.executablePath));
   for (const verification of verifications) {
@@ -72,6 +83,18 @@ export async function captureVerificationEnvironmentIdentity(
     .update(installed)
     .update(JSON.stringify(unavailable.sort()))
     .update(JSON.stringify(profile))
+    .update(
+      profile.mode === "host-trusted"
+        ? JSON.stringify([
+            process.platform,
+            process.arch,
+            process.versions.node,
+            ["PATH", "SystemRoot", "WINDIR", "ComSpec", "PATHEXT"].map(
+              (name) => [name, process.env[name] ?? null],
+            ),
+          ])
+        : "",
+    )
     .update(
       JSON.stringify(
         profile.inheritEnvironment.map((name) => [
@@ -116,7 +139,13 @@ export async function prepareVerificationEnvironment(
         runnerBindings,
         profile,
         Object.fromEntries(
-          ["PATH", ...profile.inheritEnvironment].flatMap((name) =>
+          [
+            "PATH",
+            ...(profile.mode === "host-trusted"
+              ? ["SystemRoot", "WINDIR", "ComSpec", "PATHEXT"]
+              : []),
+            ...profile.inheritEnvironment,
+          ].flatMap((name) =>
             process.env[name] === undefined ? [] : [[name, process.env[name]]],
           ),
         ),