@abelxiaoxing/cadence 1.6.0 → 1.8.0

package/src/operator-cli.mjs

@@ -1,17 +1,19 @@
 // Generated by scripts/build-workspace-io.mjs; edit operator-cli-entry.mjs and its source modules.
 // src/operator-cli-entry.mjs
-import path6 from "node:path";
+import path9 from "node:path";
 
 // src/operator-tools.ts
-import { spawnSync } from "node:child_process";
-import { lstatSync as lstatSync6, readdirSync as readdirSync4, readFileSync as readFileSync4, realpathSync as realpathSync4 } from "node:fs";
-import path5 from "node:path";
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { lstatSync as lstatSync8, readdirSync as readdirSync4, readFileSync as readFileSync5, realpathSync as realpathSync4 } from "node:fs";
+import path8 from "node:path";
 import { DatabaseSync } from "node:sqlite";
 
 // src/execution-profile.ts
+import path from "node:path";
+import { fileURLToPath } from "node:url";
 function executionProfile(env = process.env) {
   const mode = env.ABEL_EXECUTION_MODE ?? "isolated";
-  if (mode !== "isolated" && mode !== "local-trusted")
+  if (mode !== "isolated" && mode !== "local-trusted" && mode !== "host-trusted")
     throw new Error("execution-mode-invalid");
   const timeoutMs = Number(env.ABEL_VERIFICATION_TIMEOUT_MS ?? 600000);
   if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 86400000)
@@ -21,17 +23,22 @@ function executionProfile(env = process.env) {
     throw new Error("verification-environment-names-invalid");
   if (mode === "isolated" && inheritEnvironment.length)
     throw new Error("verification-environment-requires-trusted-mode");
+  if (mode === "host-trusted" && env.ABEL_WINDOWS_JOB_HELPER !== undefined && (!env.ABEL_WINDOWS_JOB_HELPER || env.ABEL_WINDOWS_JOB_HELPER.includes("\x00") || !(path.isAbsolute(env.ABEL_WINDOWS_JOB_HELPER) || path.win32.isAbsolute(env.ABEL_WINDOWS_JOB_HELPER))))
+    throw new Error("windows-job-helper-path-invalid");
   return {
     mode,
     timeoutMs,
     bwrapPath: env.ABEL_BWRAP_PATH ?? "/usr/bin/bwrap",
-    inheritEnvironment
+    inheritEnvironment,
+    ...mode === "host-trusted" ? {
+      windowsHelperPath: env.ABEL_WINDOWS_JOB_HELPER ?? fileURLToPath(new URL("./windows-job.exe", import.meta.url))
+    } : {}
   };
 }
 
 // src/openspec-cli.ts
 import { lstatSync, readdirSync, readFileSync, realpathSync } from "node:fs";
-import path from "node:path";
+import path2 from "node:path";
 var PACKAGE_NAME = "@fission-ai/openspec";
 var OPENSPEC_LIMITS = Object.freeze({
   timeoutMs: 30000,
@@ -57,8 +64,8 @@ function record(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : undefined;
 }
 function inside(root, target) {
-  const relative = path.relative(root, target);
-  return relative === "" || relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+  const relative = path2.relative(root, target);
+  return relative === "" || relative !== ".." && !relative.startsWith(`..${path2.sep}`) && !path2.isAbsolute(relative);
 }
 function envValue(environment, name) {
   const key = Object.keys(environment).sort().find((candidate) => process.platform === "win32" ? candidate.toUpperCase() === name.toUpperCase() : candidate === name);
@@ -66,15 +73,15 @@ function envValue(environment, name) {
 }
 function packageEntry(root) {
   const canonicalRoot = realpathSync(root);
-  const manifestPath = realpathSync(path.join(canonicalRoot, "package.json"));
+  const manifestPath = realpathSync(path2.join(canonicalRoot, "package.json"));
   const manifestStat = lstatSync(manifestPath);
   if (!inside(canonicalRoot, manifestPath) || !manifestStat.isFile() || manifestStat.size > 1024 * 1024)
     throw new Error("manifest-limit");
   const manifest = record(JSON.parse(readFileSync(manifestPath, "utf8")));
   const bin = typeof manifest?.bin === "string" ? manifest.bin : record(manifest?.bin)?.openspec;
-  if (manifest?.name !== PACKAGE_NAME || typeof bin !== "string" || path.isAbsolute(bin))
+  if (manifest?.name !== PACKAGE_NAME || typeof bin !== "string" || path2.isAbsolute(bin))
     throw new Error("manifest-invalid");
-  const entry = realpathSync(path.resolve(canonicalRoot, bin));
+  const entry = realpathSync(path2.resolve(canonicalRoot, bin));
   if (!inside(canonicalRoot, entry) || !/\.(?:cjs|mjs|js)$/iu.test(entry) || !lstatSync(entry).isFile())
     throw new Error("entry-invalid");
   return entry;
@@ -99,7 +106,7 @@ function commandIn(directory) {
     if (matches.length > 1)
       throw new Error("ambiguous-command");
     if (matches.length === 1) {
-      const candidate = path.join(directory, matches[0]);
+      const candidate = path2.join(directory, matches[0]);
       if (lstatSync(candidate, { throwIfNoEntry: false }))
         return candidate;
     }
@@ -112,7 +119,7 @@ function resolveOpenSpecInvocation(consumerRoot, environment = process.env) {
   const node = configuredNode ?? (process.release.name === "node" && !process.versions.bun ? process.execPath : undefined);
   let executable;
   try {
-    if (!node || !path.isAbsolute(node) || /\.(?:cmd|bat|ps1)$/iu.test(node)) {
+    if (!node || !path2.isAbsolute(node) || /\.(?:cmd|bat|ps1)$/iu.test(node)) {
       throw new Error("runtime-invalid");
     }
     executable = realpathSync(node);
@@ -123,7 +130,7 @@ function resolveOpenSpecInvocation(consumerRoot, environment = process.env) {
   }
   if (configuredRoot !== undefined) {
     try {
-      if (!path.isAbsolute(configuredRoot))
+      if (!path2.isAbsolute(configuredRoot))
         throw new Error("root-invalid");
       return { executable, entry: packageEntry(configuredRoot) };
     } catch {
@@ -131,9 +138,9 @@ function resolveOpenSpecInvocation(consumerRoot, environment = process.env) {
     }
   }
   const consumer = canonicalConsumerRoot(consumerRoot);
-  const directories = (envValue(environment, "PATH") ?? "").split(path.delimiter);
+  const directories = (envValue(environment, "PATH") ?? "").split(path2.delimiter);
   for (const directory of directories) {
-    if (!path.isAbsolute(directory))
+    if (!path2.isAbsolute(directory))
       continue;
     let command;
     let canonicalDirectory;
@@ -153,14 +160,14 @@ function resolveOpenSpecInvocation(consumerRoot, environment = process.env) {
         throw new OpenSpecCliError("resolve", "resolution", "unsafe-installation");
       }
       const layoutRoots = [
-        path.join(canonicalDirectory, "node_modules", PACKAGE_NAME),
-        path.resolve(canonicalDirectory, "../lib/node_modules", PACKAGE_NAME)
+        path2.join(canonicalDirectory, "node_modules", PACKAGE_NAME),
+        path2.resolve(canonicalDirectory, "../lib/node_modules", PACKAGE_NAME)
       ];
       const roots = [];
-      let ancestor = path.dirname(target);
+      let ancestor = path2.dirname(target);
       for (let depth = 0;depth < 8; depth++) {
         roots.push(ancestor);
-        const parent = path.dirname(ancestor);
+        const parent = path2.dirname(ancestor);
         if (parent === ancestor)
           break;
         ancestor = parent;
@@ -194,7 +201,7 @@ function resolveOpenSpecInvocation(consumerRoot, environment = process.env) {
 import { createHash } from "node:crypto";
 import { chmodSync, lstatSync as lstatSync2, mkdirSync, realpathSync as realpathSync2 } from "node:fs";
 import os from "node:os";
-import path2 from "node:path";
+import path3 from "node:path";
 class StateRootError extends Error {
   code;
   constructor(code) {
@@ -204,15 +211,15 @@ class StateRootError extends Error {
   }
 }
 function isContainedBy(parent, candidate) {
-  const relative = path2.relative(parent, candidate);
-  return relative === "" || !relative.startsWith("..") && !path2.isAbsolute(relative);
+  const relative = path3.relative(parent, candidate);
+  return relative === "" || !relative.startsWith("..") && !path3.isAbsolute(relative);
 }
 function inspectExistingComponents(absolutePath) {
-  const parsed = path2.parse(absolutePath);
-  const relativeParts = absolutePath.slice(parsed.root.length).split(path2.sep).filter(Boolean);
+  const parsed = path3.parse(absolutePath);
+  const relativeParts = absolutePath.slice(parsed.root.length).split(path3.sep).filter(Boolean);
   let current = parsed.root;
   for (const part of relativeParts) {
-    current = path2.join(current, part);
+    current = path3.join(current, part);
     let stat;
     try {
       stat = lstatSync2(current);
@@ -230,37 +237,37 @@ function inspectExistingComponents(absolutePath) {
   }
 }
 function canonicalFuturePath(input) {
-  const absolute = path2.resolve(input);
+  const absolute = path3.resolve(input);
   inspectExistingComponents(absolute);
   let cursor = absolute;
   const missing = [];
   for (;; ) {
     try {
-      return path2.join(realpathSync2.native(cursor), ...missing.reverse());
+      return path3.join(realpathSync2.native(cursor), ...missing.reverse());
     } catch (error) {
       if (error.code !== "ENOENT")
         throw error;
-      const parent = path2.dirname(cursor);
+      const parent = path3.dirname(cursor);
       if (parent === cursor)
         throw error;
-      missing.push(path2.basename(cursor));
+      missing.push(path3.basename(cursor));
       cursor = parent;
     }
   }
 }
 function requireAbsoluteDirectoryBase(xdgStateHome, homeDir) {
-  if (xdgStateHome && path2.isAbsolute(xdgStateHome)) {
+  if (xdgStateHome && path3.isAbsolute(xdgStateHome)) {
     return canonicalFuturePath(xdgStateHome);
   }
-  if (!path2.isAbsolute(homeDir)) {
+  if (!path3.isAbsolute(homeDir)) {
     throw new StateRootError("invalid-state-base");
   }
-  return canonicalFuturePath(path2.join(homeDir, ".local", "state"));
+  return canonicalFuturePath(path3.join(homeDir, ".local", "state"));
 }
 function resolveStateRoot(options) {
   let consumerRoot;
   try {
-    consumerRoot = realpathSync2.native(path2.resolve(options.consumerRoot));
+    consumerRoot = realpathSync2.native(path3.resolve(options.consumerRoot));
     if (!lstatSync2(consumerRoot).isDirectory()) {
       throw new StateRootError("consumer-root-unavailable");
     }
@@ -271,9 +278,9 @@ function resolveStateRoot(options) {
   }
   const stateBase = requireAbsoluteDirectoryBase(options.xdgStateHome, options.homeDir ?? os.homedir());
   const consumerRootHash = createHash("sha256").update(consumerRoot).digest("hex");
-  const productRoot = canonicalFuturePath(path2.join(stateBase, "abel-cadence"));
-  const rootsDir = canonicalFuturePath(path2.join(productRoot, "roots"));
-  const rootDir = canonicalFuturePath(path2.join(rootsDir, consumerRootHash));
+  const productRoot = canonicalFuturePath(path3.join(stateBase, "abel-cadence"));
+  const rootsDir = canonicalFuturePath(path3.join(productRoot, "roots"));
+  const rootDir = canonicalFuturePath(path3.join(rootsDir, consumerRootHash));
   if (isContainedBy(consumerRoot, rootDir)) {
     throw new StateRootError("state-root-inside-consumer");
   }
@@ -284,10 +291,10 @@ function resolveStateRoot(options) {
     productRoot,
     rootsDir,
     rootDir,
-    databasePath: path2.join(rootDir, "control.sqlite3"),
-    artifactsDir: path2.join(rootDir, "artifacts"),
-    workspacesDir: path2.join(rootDir, "workspaces"),
-    transactionsDir: path2.join(rootDir, "transactions")
+    databasePath: path3.join(rootDir, "control.sqlite3"),
+    artifactsDir: path3.join(rootDir, "artifacts"),
+    workspacesDir: path3.join(rootDir, "workspaces"),
+    transactionsDir: path3.join(rootDir, "transactions")
   };
 }
 
@@ -318,7 +325,7 @@ import {
   readFileSync as readFileSync3,
   realpathSync as realpathSync3
 } from "node:fs";
-import path4 from "node:path";
+import path5 from "node:path";
 
 // src/control-contracts.ts
 var CONTROL_SCHEMA_PROPERTIES = {
@@ -609,13 +616,13 @@ import { join, resolve } from "node:path";
 
 // src/safe-path.ts
 import { lstatSync as lstatSync3 } from "node:fs";
-import path3 from "node:path";
+import path4 from "node:path";
 function observeSafePath(root, relative) {
   if (!isValidRelativePath(relative)) {
     return { kind: "unsafe", reason: "invalid-path" };
   }
   try {
-    const resolvedRoot = path3.resolve(root);
+    const resolvedRoot = path4.resolve(root);
     const rootStat = lstatSync3(resolvedRoot, { throwIfNoEntry: false });
     if (!rootStat?.isDirectory() || rootStat.isSymbolicLink()) {
       return { kind: "unsafe", reason: "root-unavailable" };
@@ -625,8 +632,8 @@ function observeSafePath(root, relative) {
     let current = resolvedRoot;
     const parts = relative.split("/");
     for (const [index, part] of parts.entries()) {
-      current = path3.join(current, part);
-      if (!current.startsWith(`${resolvedRoot}${path3.sep}`)) {
+      current = path4.join(current, part);
+      if (!current.startsWith(`${resolvedRoot}${path4.sep}`)) {
         return { kind: "unsafe", reason: "invalid-path" };
       }
       const stat = lstatSync3(current, { throwIfNoEntry: false });
@@ -652,9 +659,6 @@ function observeSafePath(root, relative) {
   }
   return { kind: "unsafe", reason: "invalid-path" };
 }
-function isSafeRegularFile(root, relative) {
-  return observeSafePath(root, relative).kind === "file";
-}
 
 // src/file-snapshot.ts
 function sha256(bytes) {
@@ -697,10 +701,16 @@ function capabilitySuccess(verificationId, runnerBindings = []) {
     }))
   };
 }
-function adapterFailure(verificationId, code, message) {
+function adapterFailure(verificationId, code, message, inputObservation) {
   return {
     ok: false,
-    diagnostic: { kind: "verification-adapter", code, verificationId, message }
+    diagnostic: {
+      kind: "verification-adapter",
+      code,
+      verificationId,
+      message,
+      ...inputObservation ? { inputObservation } : {}
+    }
   };
 }
 function fileStatus(root, relative) {
@@ -713,11 +723,11 @@ function regularFile(root, relative) {
   return fileStatus(root, relative) === "regular";
 }
 function localExecutable(root, executable, dependencyOwner = root, environment = {}) {
-  const dependencyRoot = path4.resolve(dependencyOwner, "node_modules");
+  const dependencyRoot = path5.resolve(dependencyOwner, "node_modules");
   try {
     const canonicalDependencyRoot = realpathSync3(dependencyRoot);
     for (const name of localExecutableNames(executable, environment)) {
-      const unresolved = resolveCandidateName(path4.resolve(dependencyRoot, ".bin"), name, environment.platform ?? process.platform);
+      const unresolved = resolveCandidateName(path5.resolve(dependencyRoot, ".bin"), name, environment.platform ?? process.platform);
       if (!unresolved)
         continue;
       const canonical = realpathSync3(unresolved);
@@ -733,11 +743,11 @@ function localExecutable(root, executable, dependencyOwner = root, environment =
 }
 function pathApi(platform, ...values) {
   if (platform !== "win32")
-    return path4.posix;
+    return path5.posix;
   if (process.platform === "win32" || values.some((value) => /^[a-z]:[\\/]/iu.test(value) || value.startsWith("\\\\"))) {
-    return path4.win32;
+    return path5.win32;
   }
-  return path4.posix;
+  return path5.posix;
 }
 function pathWithin(root, candidate, platform) {
   const platformPath = pathApi(platform, root, candidate);
@@ -767,7 +777,7 @@ function runnerNames(command, environment) {
   if ((environment.platform ?? process.platform) !== "win32") {
     return [command];
   }
-  const extension = path4.extname(command).toLowerCase();
+  const extension = path5.extname(command).toLowerCase();
   if (extension) {
     return WINDOWS_EXECUTABLE_EXTENSIONS.has(extension) ? [command] : [];
   }
@@ -779,7 +789,7 @@ function localExecutableNames(executable, environment) {
   if ((environment.platform ?? process.platform) !== "win32") {
     return [executable];
   }
-  const extension = path4.extname(executable).toLowerCase();
+  const extension = path5.extname(executable).toLowerCase();
   if (extension) {
     return WINDOWS_EXECUTABLE_EXTENSIONS.has(extension) ? [executable] : [];
   }
@@ -789,18 +799,18 @@ function localExecutableNames(executable, environment) {
   ];
 }
 function resolveCandidateName(directory, name, platform) {
-  const exact = path4.join(directory, name);
+  const exact = path5.join(directory, name);
   if (platform !== "win32")
     return exact;
   try {
     const matches = readdirSync3(directory).filter((entry) => entry.toLowerCase() === name.toLowerCase());
-    return matches.length === 1 ? path4.join(directory, matches[0]) : null;
+    return matches.length === 1 ? path5.join(directory, matches[0]) : null;
   } catch {
     return null;
   }
 }
 function within(root, candidate) {
-  return candidate === root || candidate.startsWith(`${root}${path4.sep}`);
+  return candidate === root || candidate.startsWith(`${root}${path5.sep}`);
 }
 function commonDirectory(left, right, platform = process.platform) {
   const platformPath = pathApi(platform, left, right);
@@ -827,15 +837,15 @@ function commonDirectory(left, right, platform = process.platform) {
 function unsafeMountSource(source) {
   if (BROAD_MOUNT_ROOTS.has(source))
     return true;
-  if (path4.resolve(source) === path4.parse(path4.resolve(source)).root)
+  if (path5.resolve(source) === path5.parse(path5.resolve(source)).root)
     return true;
-  const parts = path4.relative(path4.parse(path4.resolve(source)).root, path4.resolve(source)).split(path4.sep).filter(Boolean).map((part) => part.toLowerCase());
+  const parts = path5.relative(path5.parse(path5.resolve(source)).root, path5.resolve(source)).split(path5.sep).filter(Boolean).map((part) => part.toLowerCase());
   return parts[0] === "home" && parts.length <= 2 || parts[0] === "users" && parts.length <= 2 || parts[0] === "root" && parts.length <= 1;
 }
 function safeRunnerSource(paths, platform) {
-  let source = path4.dirname(paths[0]);
+  let source = path5.dirname(paths[0]);
   for (const candidate of paths.slice(1)) {
-    source = commonDirectory(source, path4.dirname(candidate), platform);
+    source = commonDirectory(source, path5.dirname(candidate), platform);
   }
   if (unsafeMountSource(source))
     return null;
@@ -853,18 +863,18 @@ function resolvedRunnerEnvironment(environment) {
     platform: environment.platform ?? process.platform,
     path: environment.path ?? process.env.PATH ?? "",
     pathExt: environment.pathExt ?? process.env.PATHEXT ?? DEFAULT_WINDOWS_PATH_EXT,
-    pathDelimiter: environment.pathDelimiter ?? path4.delimiter
+    pathDelimiter: environment.pathDelimiter ?? path5.delimiter
   };
 }
 function windowsShimBinding(command, launcherPath, environment) {
-  const name = path4.basename(command, path4.extname(command)).toLowerCase();
+  const name = path5.basename(command, path5.extname(command)).toLowerCase();
   if (name !== "npm" && name !== "npx")
     return null;
   const node = resolveVerificationRunner("node", environment);
-  if (!node || node.fixedArgs || path4.extname(node.executablePath).toLowerCase() !== ".exe") {
+  if (!node || node.fixedArgs || path5.extname(node.executablePath).toLowerCase() !== ".exe") {
     return null;
   }
-  const cli = path4.join(path4.dirname(launcherPath), "node_modules", "npm", "bin", `${name}-cli.js`);
+  const cli = path5.join(path5.dirname(launcherPath), "node_modules", "npm", "bin", `${name}-cli.js`);
   try {
     const canonicalLauncher = realpathSync3(launcherPath);
     const canonicalCli = realpathSync3(cli);
@@ -889,14 +899,14 @@ function localPackageDirectories(dependencyRoot) {
     for (const entry of readdirSync3(dependencyRoot, { withFileTypes: true })) {
       if (!entry.isDirectory() || entry.name.startsWith("."))
         continue;
-      const candidate = path4.join(dependencyRoot, entry.name);
+      const candidate = path5.join(dependencyRoot, entry.name);
       if (!entry.name.startsWith("@")) {
         packages.push(candidate);
         continue;
       }
       for (const scoped of readdirSync3(candidate, { withFileTypes: true })) {
         if (scoped.isDirectory() && !scoped.name.startsWith(".")) {
-          packages.push(path4.join(candidate, scoped.name));
+          packages.push(path5.join(candidate, scoped.name));
         }
       }
     }
@@ -906,7 +916,7 @@ function localPackageDirectories(dependencyRoot) {
   return packages;
 }
 function localPackageBinTargets(dependencyOwner, executable, platform) {
-  const dependencyRoot = path4.resolve(dependencyOwner, "node_modules");
+  const dependencyRoot = path5.resolve(dependencyOwner, "node_modules");
   let canonicalDependencyRoot;
   try {
     canonicalDependencyRoot = realpathSync3(dependencyRoot);
@@ -924,7 +934,7 @@ function localPackageBinTargets(dependencyOwner, executable, platform) {
       if (!pathWithin(canonicalDependencyRoot, canonicalPackage, platform) || canonicalPackage === canonicalDependencyRoot) {
         continue;
       }
-      const manifestPath = path4.join(canonicalPackage, "package.json");
+      const manifestPath = path5.join(canonicalPackage, "package.json");
       const manifestStat = lstatSync5(manifestPath);
       if (!manifestStat.isFile() || manifestStat.isSymbolicLink())
         continue;
@@ -946,7 +956,7 @@ function localPackageBinTargets(dependencyOwner, executable, platform) {
       if (typeof relative !== "string" || relative.length === 0 || relative.includes("\x00")) {
         continue;
       }
-      const unresolved = path4.resolve(canonicalPackage, relative);
+      const unresolved = path5.resolve(canonicalPackage, relative);
       if (!pathWithin(canonicalPackage, unresolved, platform))
         continue;
       const canonical = realpathSync3(unresolved);
@@ -966,7 +976,7 @@ function resolveLocalVerificationRunner(dependencyOwner, executable, runnerEnvir
   if (targets.length !== 1)
     return null;
   const target = targets[0];
-  const extension = path4.extname(target).toLowerCase();
+  const extension = path5.extname(target).toLowerCase();
   if (extension === ".exe") {
     return { command: executable, executablePath: target };
   }
@@ -988,7 +998,7 @@ function resolveVerificationRunner(command, runnerEnvironment = {}) {
   const candidates = [
     ...command === "bun" && process.versions.bun && environment.platform === process.platform ? [process.execPath] : [],
     ...directories.flatMap((directory) => {
-      const resolvedDirectory = path4.resolve(directory);
+      const resolvedDirectory = path5.resolve(directory);
       const key = environment.platform === "win32" ? resolvedDirectory.toLowerCase() : resolvedDirectory;
       if (seenDirectories.has(key))
         return [];
@@ -1002,7 +1012,7 @@ function resolveVerificationRunner(command, runnerEnvironment = {}) {
   const seenCandidates = new Set;
   for (const candidate of candidates) {
     try {
-      const executablePath = path4.resolve(candidate);
+      const executablePath = path5.resolve(candidate);
       const candidateKey = environment.platform === "win32" ? executablePath.toLowerCase() : executablePath;
       if (seenCandidates.has(candidateKey))
         continue;
@@ -1012,7 +1022,7 @@ function resolveVerificationRunner(command, runnerEnvironment = {}) {
       if (!regularExecutableFile(stat, environment.platform))
         continue;
       if (environment.platform === "win32") {
-        const extension = path4.extname(executablePath).toLowerCase();
+        const extension = path5.extname(executablePath).toLowerCase();
         if (extension === ".cmd") {
           const shim = windowsShimBinding(command, executablePath, environment);
           if (shim)
@@ -1029,7 +1039,7 @@ function resolveVerificationRunner(command, runnerEnvironment = {}) {
       const systemVisible = SYSTEM_MOUNT_ROOTS.some((root) => within(root, executablePath) && within(root, canonical));
       if (systemVisible)
         return { command, executablePath };
-      const mountSource = commonDirectory(path4.dirname(executablePath), path4.dirname(canonical), environment.platform);
+      const mountSource = commonDirectory(path5.dirname(executablePath), path5.dirname(canonical), environment.platform);
       if (unsafeMountSource(mountSource))
         continue;
       const sourceStat = lstatSync5(mountSource);
@@ -1044,7 +1054,7 @@ function packageManifest(root) {
   if (!regularFile(root, "package.json"))
     return null;
   try {
-    const value = JSON.parse(readFileSync3(path4.join(root, "package.json"), "utf8"));
+    const value = JSON.parse(readFileSync3(path5.join(root, "package.json"), "utf8"));
     return value && typeof value === "object" && !Array.isArray(value) ? value : null;
   } catch {
     return null;
@@ -1166,7 +1176,7 @@ function validateAtomicCapability(root, step, dependencyOwner, runnerEnvironment
       "pnpm-workspace.yaml"
     ].includes(relative))
       continue;
-    if (lstatSync5(path4.join(root, relative)).size > 64 * 1024 || executionProfile().mode !== "local-trusted" && unsupportedExecutionConfiguration(readFileSync3(path4.join(root, relative), "utf8"))) {
+    if (lstatSync5(path5.join(root, relative)).size > 64 * 1024 || executionProfile().mode === "isolated" && unsupportedExecutionConfiguration(readFileSync3(path5.join(root, relative), "utf8"))) {
       return adapterFailure(step.id, "verification-config-unsafe", "Execution configuration requires unsupported credentials or host configuration");
     }
   }
@@ -1223,8 +1233,10 @@ function validateCapability(root, value, options, requireInputAvailability) {
 function validateAcceptedVerificationCapability(root, verification, dependencyOwner, runnerEnvironment, requireInputAvailability, executionWritePaths) {
   if (requireInputAvailability) {
     for (const input of verificationInputPaths(verification)) {
-      if (!isSafeRegularFile(root, input)) {
-        return adapterFailure(verification.id, "input-missing", `verification input ${input} is missing or unsafe`);
+      const status = fileStatus(root, input);
+      if (status !== "regular") {
+        const inputObservation = { path: input, kind: status };
+        return adapterFailure(verification.id, status === "absent" ? "input-missing" : "input-unsafe", `verification input ${input} is ${status}`, inputObservation);
       }
     }
   }
@@ -1238,6 +1250,549 @@ function validateAcceptedVerificationCapability(root, verification, dependencyOw
   return capabilitySuccess(verification.id, runnerBindings);
 }
 
+// src/windows-job-backend.ts
+import { spawn as spawn2, spawnSync } from "node:child_process";
+import { createHash as createHash3 } from "node:crypto";
+import { lstatSync as lstatSync7, readFileSync as readFileSync4 } from "node:fs";
+import path7 from "node:path";
+
+// src/isolation-backend.ts
+import { spawn } from "node:child_process";
+import { accessSync, constants, lstatSync as lstatSync6 } from "node:fs";
+import path6 from "node:path";
+var ISOLATION_RUN_LIMITS = Object.freeze({
+  timeoutMs: 10 * 60000,
+  maxOutputBytes: 256 * 1024,
+  terminateGraceMs: 1000
+});
+function defaultProbe(executable) {
+  try {
+    accessSync(executable, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function validEnvironmentName(name) {
+  return /^[A-Za-z_][A-Za-z0-9_]*$/u.test(name);
+}
+
+class BoundedLog {
+  bytes = 0;
+  #head = Buffer.alloc(0);
+  #tail = Buffer.alloc(0);
+  limit;
+  #witness;
+  #witnessTail = Buffer.alloc(0);
+  witnessMatched = false;
+  constructor(limit, witness) {
+    this.limit = limit;
+    if (witness)
+      this.#witness = Buffer.from(witness);
+  }
+  append(chunk) {
+    const input = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    this.bytes += input.byteLength;
+    if (this.#witness && !this.witnessMatched) {
+      const searchable = Buffer.concat([this.#witnessTail, input]);
+      this.witnessMatched = searchable.includes(this.#witness);
+      this.#witnessTail = this.witnessMatched ? Buffer.alloc(0) : Buffer.from(searchable.subarray(Math.max(0, searchable.length - this.#witness.length + 1)));
+    }
+    const headLimit = Math.ceil(this.limit / 2);
+    const take = Math.min(input.length, headLimit - this.#head.length);
+    if (take > 0)
+      this.#head = Buffer.concat([this.#head, input.subarray(0, take)]);
+    const rest = input.subarray(take);
+    const tailLimit = this.limit - headLimit;
+    if (rest.length && tailLimit) {
+      this.#tail = rest.length >= tailLimit ? Buffer.from(rest.subarray(-tailLimit)) : Buffer.concat([
+        this.#tail.subarray(Math.max(0, this.#tail.length + rest.length - tailLimit)),
+        rest
+      ]);
+    }
+  }
+  text() {
+    return Buffer.concat([this.#head, this.#tail]).toString("utf8");
+  }
+  metadata() {
+    return { bytes: this.bytes, truncated: this.bytes > this.limit };
+  }
+}
+
+class BubblewrapIsolationBackend {
+  #localTrusted;
+  #bwrapPath;
+  #probe;
+  #spawn;
+  #timeoutMs;
+  #maxOutputBytes;
+  #terminateGraceMs;
+  constructor(options = {}) {
+    this.#localTrusted = options.localTrusted === true;
+    this.#bwrapPath = options.bwrapPath ?? "/usr/bin/bwrap";
+    this.#probe = options.probe ?? defaultProbe;
+    this.#spawn = options.spawnProcess ?? spawn;
+    this.#timeoutMs = options.timeoutMs ?? ISOLATION_RUN_LIMITS.timeoutMs;
+    this.#maxOutputBytes = options.maxOutputBytes ?? ISOLATION_RUN_LIMITS.maxOutputBytes;
+    this.#terminateGraceMs = options.terminateGraceMs ?? ISOLATION_RUN_LIMITS.terminateGraceMs;
+    if (!Number.isSafeInteger(this.#timeoutMs) || this.#timeoutMs < 1 || !Number.isSafeInteger(this.#maxOutputBytes) || this.#maxOutputBytes < 1 || !Number.isSafeInteger(this.#terminateGraceMs) || this.#terminateGraceMs < 1) {
+      throw new Error("isolation-run-limits-invalid");
+    }
+  }
+  async available() {
+    try {
+      if (this.#localTrusted && process.platform !== "linux")
+        return false;
+      return Boolean(await this.#probe(this.#bwrapPath));
+    } catch {
+      return false;
+    }
+  }
+  async run(input) {
+    if (input.outputWitness !== undefined && (typeof input.outputWitness !== "string" || input.outputWitness.length < 1 || input.outputWitness.length > 512))
+      throw new Error("isolation-output-witness-invalid");
+    if (!await this.available()) {
+      return {
+        ok: false,
+        state: "paused",
+        code: "isolation-backend-unavailable"
+      };
+    }
+    if (input.signal?.aborted) {
+      return { ok: false, state: "cancelled", code: "cancelled" };
+    }
+    const root = path6.resolve(input.root);
+    const rootStat = lstatSync6(root, { throwIfNoEntry: false });
+    if (!rootStat?.isDirectory() || rootStat.isSymbolicLink()) {
+      throw new Error("isolation-root-invalid");
+    }
+    const argv = this.#localTrusted ? [
+      "--die-with-parent",
+      "--new-session",
+      "--unshare-pid",
+      "--bind",
+      "/",
+      "/",
+      "--proc",
+      "/proc",
+      "--dev",
+      "/dev",
+      "--chdir",
+      root,
+      "--clearenv"
+    ] : [
+      "--die-with-parent",
+      "--new-session",
+      "--unshare-all",
+      "--proc",
+      "/proc",
+      "--dev",
+      "/dev",
+      "--tmpfs",
+      "/tmp",
+      "--bind",
+      root,
+      "/workspace",
+      "--chdir",
+      "/workspace",
+      "--clearenv",
+      "--setenv",
+      "PATH",
+      "/usr/local/bin:/usr/bin:/bin"
+    ];
+    if (!this.#localTrusted) {
+      for (const systemRoot of ["/usr", "/bin", "/lib", "/lib64"]) {
+        if (lstatSync6(systemRoot, { throwIfNoEntry: false }))
+          argv.push("--ro-bind", systemRoot, systemRoot);
+      }
+      for (const mount of input.mounts ?? []) {
+        if (!path6.isAbsolute(mount.source) || !path6.isAbsolute(mount.target))
+          throw new Error("isolation-mount-invalid");
+        argv.push(mount.writable ? "--bind" : "--ro-bind", mount.source, mount.target);
+      }
+    }
+    for (const [name, value] of Object.entries(input.environment ?? {}).sort()) {
+      if (!validEnvironmentName(name) || value.includes("\x00"))
+        throw new Error("isolation-environment-invalid");
+      argv.push("--setenv", name, value);
+    }
+    argv.push("--", input.executable, ...input.args ?? []);
+    return new Promise((resolve2) => {
+      let settled = false;
+      const stdout = new BoundedLog(this.#maxOutputBytes, input.outputWitness);
+      const stderr = new BoundedLog(this.#maxOutputBytes, input.outputWitness);
+      let child;
+      let executionTimer;
+      let killTimer;
+      let terminationResult;
+      const settle = (result) => {
+        if (settled)
+          return;
+        settled = true;
+        if (executionTimer)
+          clearTimeout(executionTimer);
+        input.signal?.removeEventListener("abort", abort);
+        resolve2(result);
+      };
+      const kill = (signal) => {
+        child?.kill(signal);
+      };
+      const terminate = (result) => {
+        if (settled || terminationResult)
+          return;
+        terminationResult = result;
+        if (executionTimer)
+          clearTimeout(executionTimer);
+        killTimer = setTimeout(() => kill("SIGKILL"), this.#terminateGraceMs);
+        killTimer.unref?.();
+        kill("SIGTERM");
+      };
+      const abort = () => {
+        terminate({ ok: false, state: "cancelled", code: "cancelled" });
+      };
+      try {
+        child = this.#spawn(this.#bwrapPath, argv, {
+          cwd: root,
+          shell: false,
+          stdio: ["ignore", "pipe", "pipe"]
+        });
+      } catch {
+        settle({
+          ok: false,
+          state: "paused",
+          code: "isolation-backend-launch-failed"
+        });
+        return;
+      }
+      const capture = (destination, chunk) => {
+        if (!settled && !terminationResult)
+          destination.append(chunk);
+      };
+      child.stdout?.on("data", (chunk) => {
+        capture(stdout, chunk);
+      });
+      child.stderr?.on("data", (chunk) => {
+        capture(stderr, chunk);
+      });
+      child.once("error", () => {
+        if (terminationResult)
+          return;
+        settle({
+          ok: false,
+          state: "paused",
+          code: "isolation-backend-launch-failed"
+        });
+      });
+      child.once("close", (code) => {
+        if (killTimer)
+          clearTimeout(killTimer);
+        settle(terminationResult ?? {
+          ok: true,
+          state: "completed",
+          exitCode: code ?? 1,
+          stdout: stdout.text(),
+          stderr: stderr.text(),
+          logs: { stdout: stdout.metadata(), stderr: stderr.metadata() },
+          ...input.outputWitness ? {
+            outputWitnessMatched: stdout.witnessMatched || stderr.witnessMatched
+          } : {}
+        });
+      });
+      input.signal?.addEventListener("abort", abort, { once: true });
+      if (input.signal?.aborted) {
+        abort();
+        return;
+      }
+      executionTimer = setTimeout(() => terminate({
+        ok: false,
+        state: "paused",
+        code: "isolation-execution-timeout"
+      }), this.#timeoutMs);
+      executionTimer.unref?.();
+    });
+  }
+}
+
+// src/windows-job-backend.ts
+var SHUTDOWN_MS = 5000;
+var invalid = () => {
+  throw new Error("windows-job-request-invalid");
+};
+var text = (value) => typeof value === "string" && value.length <= 16384 && !value.includes("\x00") && !/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/u.test(value);
+var absolute = (value) => text(value) && /^[A-Za-z]:\\/u.test(value) && path7.win32.isAbsolute(value);
+function encodeWindowsJobRequest(input, timeoutMs) {
+  if (!absolute(input.root) || !absolute(input.executable) || !input.executable.toLowerCase().endsWith(".exe") || input.mounts?.length || !Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 86400000)
+    invalid();
+  const args = input.args ?? [];
+  if (args.length > 128 || !args.every(text))
+    invalid();
+  const seen = new Set;
+  const env = Object.entries(input.environment ?? {});
+  for (const [name, value] of env) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/u.test(name) || !text(value) || seen.has(name.toUpperCase()))
+      invalid();
+    seen.add(name.toUpperCase());
+  }
+  const quote = (value) => `"${value.replace(/(\\*)"/gu, "$1$1\\\"").replace(/(\\+)$/gu, "$1$1")}"`;
+  const command = [input.executable, ...args].map(quote).join(" ");
+  if (command.length >= 32767)
+    invalid();
+  const environment = `${env.sort(([a], [b]) => a.toUpperCase() < b.toUpperCase() ? -1 : 1).map(([k, v]) => `${k}=${v}`).join("\x00")}\x00\x00`;
+  const parts = [
+    `${input.executable}\x00`,
+    `${command}\x00`,
+    `${input.root}\x00`,
+    environment
+  ].map((s) => Buffer.from(s, "utf16le"));
+  const header = Buffer.alloc(36);
+  [2, timeoutMs, SHUTDOWN_MS, 0, ...parts.map((p) => p.length), 0].forEach((n, i) => {
+    header.writeUInt32LE(n, i * 4);
+  });
+  const wire = Buffer.concat([header, ...parts]);
+  if (wire.length > 65536 || parts.some((p) => p.length > 60000))
+    invalid();
+  return wire;
+}
+function verifyWindowsJobHelper(helper) {
+  try {
+    if (!path7.isAbsolute(helper))
+      return false;
+    const files = [helper, `${helper}.json`];
+    if (files.some((file) => {
+      const s = lstatSync7(file);
+      return !s.isFile() || s.isSymbolicLink() || s.size > 8 * 1024 * 1024;
+    }))
+      return false;
+    const bytes = readFileSync4(helper);
+    const pe = bytes.length >= 64 ? bytes.readUInt32LE(60) : -1;
+    if (bytes.toString("ascii", 0, 2) !== "MZ" || pe < 64 || pe + 6 > bytes.length || bytes.readUInt32LE(pe) !== 17744 || bytes.readUInt16LE(pe + 4) !== 34404)
+      return false;
+    const hash = (data) => createHash3("sha256").update(data).digest("hex");
+    const manifest = JSON.parse(readFileSync4(`${helper}.json`, "utf8"));
+    return manifest.version === 2 && manifest.arch === "x64" && manifest.helperSha256 === hash(bytes) && manifest.sourceSha256 === hash(readFileSync4(new URL("./windows-job.c", import.meta.url)));
+  } catch {
+    return false;
+  }
+}
+function observation(value) {
+  if (!value || typeof value !== "object")
+    return;
+  const v = value;
+  if (Object.keys(v).sort().join(",") !== "exitCode,managedSettled,outcome,reason,rootExited,version" || v.version !== 2 || !["complete", "failed", "uncertain"].includes(v.outcome) || ![
+    "exit",
+    "timeout",
+    "cancelled",
+    "launch-failed",
+    "termination-unconfirmed"
+  ].includes(v.reason) || typeof v.rootExited !== "boolean" || typeof v.managedSettled !== "boolean" || !(v.exitCode === null || Number.isInteger(v.exitCode) && v.exitCode >= 0 && v.exitCode <= 4294967295))
+    return;
+  if (v.outcome === "complete" && (v.reason !== "exit" || !v.rootExited || !v.managedSettled || v.exitCode === null))
+    return;
+  if (v.outcome === "failed" && (!v.managedSettled || !["timeout", "cancelled", "launch-failed"].includes(v.reason)))
+    return;
+  return v;
+}
+var uncertain = () => ({
+  ok: false,
+  state: "paused",
+  code: "isolation-termination-unconfirmed"
+});
+function classify(v, helperExit, output, cancelled) {
+  if (!v?.managedSettled || v.outcome === "uncertain" || helperExit !== 0)
+    return uncertain();
+  if (cancelled || v.reason === "cancelled")
+    return { ok: false, state: "cancelled", code: "cancelled" };
+  if (v.reason === "timeout")
+    return { ok: false, state: "paused", code: "isolation-execution-timeout" };
+  if (v.reason === "launch-failed")
+    return {
+      ok: false,
+      state: "paused",
+      code: "isolation-backend-launch-failed"
+    };
+  if (v.outcome !== "complete" || v.exitCode === null)
+    return uncertain();
+  return {
+    ok: true,
+    state: "completed",
+    exitCode: v.exitCode,
+    stdout: output.text(),
+    stderr: "",
+    outputWitnessMatched: output.witnessMatched,
+    logs: { stdout: output.metadata(), stderr: { bytes: 0, truncated: false } }
+  };
+}
+
+class WindowsJobBackend {
+  #options;
+  constructor(options) {
+    for (const [value, maximum] of [
+      [options.timeoutMs ?? ISOLATION_RUN_LIMITS.timeoutMs, 86400000],
+      [
+        options.maxOutputBytes ?? ISOLATION_RUN_LIMITS.maxOutputBytes,
+        1024 * 1024
+      ]
+    ])
+      if (!Number.isSafeInteger(value) || value < 1 || value > maximum)
+        throw new Error("isolation-run-limits-invalid");
+    this.#options = options;
+  }
+  available() {
+    return (this.#options.platform ?? process.platform) === "win32" && (this.#options.arch ?? process.arch) === "x64" && (this.#options.probe ?? verifyWindowsJobHelper)(this.#options.helperPath);
+  }
+  async run(input) {
+    if (!this.available())
+      return {
+        ok: false,
+        state: "paused",
+        code: "isolation-backend-unavailable"
+      };
+    if (input.signal?.aborted)
+      return { ok: false, state: "cancelled", code: "cancelled" };
+    if (input.outputWitness !== undefined && (!text(input.outputWitness) || input.outputWitness.length < 1 || input.outputWitness.length > 512))
+      return {
+        ok: false,
+        state: "paused",
+        code: "isolation-backend-launch-failed"
+      };
+    const timeoutMs = this.#options.timeoutMs ?? ISOLATION_RUN_LIMITS.timeoutMs;
+    let wire;
+    try {
+      wire = encodeWindowsJobRequest(input, timeoutMs);
+    } catch {
+      return {
+        ok: false,
+        state: "paused",
+        code: "isolation-backend-launch-failed"
+      };
+    }
+    const output = new BoundedLog(this.#options.maxOutputBytes ?? ISOLATION_RUN_LIMITS.maxOutputBytes, input.outputWitness);
+    return new Promise((resolve2) => {
+      let child;
+      let line = "", final, bad = false, closed = false, launchFailed = false;
+      let timer;
+      let stopping = false;
+      const armDeadline = (duration) => {
+        clearTimeout(timer);
+        timer = setTimeout(() => {
+          bad = true;
+          child.kill();
+          finish(uncertain());
+        }, duration);
+        timer.unref?.();
+      };
+      const cancel = () => {
+        if (stopping || closed)
+          return;
+        stopping = true;
+        child.stdin?.end();
+        armDeadline(SHUTDOWN_MS + 5000);
+      };
+      const finish = (result) => {
+        if (closed)
+          return;
+        closed = true;
+        clearTimeout(timer);
+        input.signal?.removeEventListener("abort", cancel);
+        resolve2(result);
+      };
+      try {
+        child = (this.#options.spawnProcess ?? spawn2)(this.#options.helperPath, [], {
+          cwd: input.root,
+          shell: false,
+          windowsHide: true,
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+      } catch {
+        finish({
+          ok: false,
+          state: "paused",
+          code: "isolation-backend-launch-failed"
+        });
+        return;
+      }
+      const malformed = () => {
+        bad = true;
+        cancel();
+      };
+      child.stdout?.on("data", (chunk) => {
+        if (closed || bad)
+          return;
+        line += chunk.toString("utf8");
+        while (line.includes(`
+`)) {
+          const end = line.indexOf(`
+`);
+          const row = line.slice(0, end);
+          line = line.slice(end + 1);
+          if (row.length > 4096 || final) {
+            malformed();
+            return;
+          }
+          try {
+            const value = JSON.parse(row);
+            if (Object.keys(value).length === 1 && typeof value.outputHex === "string" && /^(?:[a-f0-9]{2}){1,1024}$/u.test(value.outputHex))
+              output.append(Buffer.from(value.outputHex, "hex"));
+            else {
+              final = observation(value);
+              if (!final) {
+                malformed();
+                return;
+              }
+            }
+          } catch {
+            malformed();
+            return;
+          }
+        }
+        if (line.length > 4096)
+          malformed();
+      });
+      child.stderr?.on("data", () => {});
+      child.stdin?.on("error", () => {
+        bad = true;
+      });
+      child.once("error", () => {
+        bad = true;
+        launchFailed = child.pid === undefined;
+      });
+      child.once("close", (code) => finish(launchFailed ? {
+        ok: false,
+        state: "paused",
+        code: "isolation-backend-launch-failed"
+      } : bad || line.length ? uncertain() : classify(final, code, output, input.signal?.aborted === true)));
+      armDeadline(timeoutMs + SHUTDOWN_MS + 1e4);
+      input.signal?.addEventListener("abort", cancel, { once: true });
+      child.stdin?.write(wire);
+      if (input.signal?.aborted)
+        cancel();
+    });
+  }
+}
+function probeWindowsJob(helper) {
+  if (process.platform !== "win32" || process.arch !== "x64" || !verifyWindowsJobHelper(helper))
+    return false;
+  const wire = encodeWindowsJobRequest({
+    root: process.cwd(),
+    executable: process.execPath,
+    args: ["-e", "process.exit(0)"],
+    environment: { SystemRoot: process.env.SystemRoot ?? "C:\\Windows" }
+  }, 5000);
+  const result = spawnSync(helper, ["--probe"], {
+    input: wire,
+    shell: false,
+    encoding: "utf8",
+    timeout: 15000,
+    maxBuffer: 65536
+  });
+  try {
+    const v = observation(JSON.parse(result.stdout.trim()));
+    return !result.error && result.status === 0 && v?.outcome === "complete" && v.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+
 // src/operator-tools.ts
 var PACKAGE_LOCKS = {
   bun: ["bun.lock", "bun.lockb"],
@@ -1247,7 +1802,7 @@ var PACKAGE_LOCKS = {
 };
 function packageManagerSelection(root, declaration) {
   const managers = Object.keys(PACKAGE_LOCKS);
-  const lockfiles = managers.flatMap((manager) => PACKAGE_LOCKS[manager].filter((file) => lstatSync6(path5.join(root, file), { throwIfNoEntry: false })?.isFile()));
+  const lockfiles = managers.flatMap((manager) => PACKAGE_LOCKS[manager].filter((file) => lstatSync8(path8.join(root, file), { throwIfNoEntry: false })?.isFile()));
   const inferred = managers.filter((manager) => PACKAGE_LOCKS[manager].some((file) => lockfiles.includes(file)));
   const declared = typeof declaration === "string" ? managers.find((manager) => new RegExp(`^${manager}@[0-9]+\\.[0-9]+\\.[0-9]+(?:[-+][a-z0-9._+-]+)?$`, "iu").test(declaration)) : undefined;
   const selectedPackageManager = declaration !== undefined ? declared ?? null : inferred.length === 1 ? inferred[0] ?? null : inferred.length > 1 ? null : "npm";
@@ -1280,7 +1835,7 @@ function inspectConsumer(root) {
     return process.versions.node;
   }, "Install Node >=22.13.");
   check("git", () => {
-    const result = spawnSync("git", ["rev-parse", "--show-toplevel"], {
+    const result = spawnSync2("git", ["rev-parse", "--show-toplevel"], {
       cwd: root,
       encoding: "utf8",
       timeout: 5000,
@@ -1296,9 +1851,14 @@ function inspectConsumer(root) {
   }, "Install @fission-ai/openspec@1.5.0, or configure ABEL_OPENSPEC_PACKAGE_ROOT / ABEL_OPENSPEC_NODE before launching the host.");
   check("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");
-    const result = spawnSync(profile.bwrapPath, [
+    const result = spawnSync2(profile.bwrapPath, [
       "--ro-bind",
       "/",
       "/",
@@ -1309,45 +1869,45 @@ function inspectConsumer(root) {
     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", () => JSON.stringify(requestBounds()), "Set ABEL_FIRST_PROGRESS_MS and ABEL_STREAM_IDLE_MS to positive milliseconds <=1200000.");
   check("state-root", () => resolveStateRoot({
     consumerRoot: root,
     xdgStateHome: process.env.XDG_STATE_HOME
   }).rootDir, "Use an absolute repository-external XDG_STATE_HOME.");
   check("workspace-dependencies", () => {
-    const dependencies = path5.join(root, "node_modules");
-    if (!lstatSync6(dependencies, { throwIfNoEntry: false }))
+    const dependencies = path8.join(root, "node_modules");
+    if (!lstatSync8(dependencies, { throwIfNoEntry: false }))
       return "no node_modules; prepare dependencies before verification";
-    const names = readdirSync4(dependencies).flatMap((name) => name.startsWith("@") && lstatSync6(path5.join(dependencies, name)).isDirectory() ? readdirSync4(path5.join(dependencies, name)).map((child) => `${name}/${child}`) : [name]);
+    const names = readdirSync4(dependencies).flatMap((name) => name.startsWith("@") && lstatSync8(path8.join(dependencies, name)).isDirectory() ? readdirSync4(path8.join(dependencies, name)).map((child) => `${name}/${child}`) : [name]);
     if (names.length > 20000)
       throw new Error("dependency-view-too-large");
     let links = 0;
     for (const name of names) {
-      const file = path5.join(dependencies, name);
-      if (!lstatSync6(file).isSymbolicLink())
+      const file = path8.join(dependencies, name);
+      if (!lstatSync8(file).isSymbolicLink())
         continue;
       const resolved = realpathSync4(file);
-      const relative = path5.relative(root, resolved);
-      if (relative === ".." || relative.startsWith(`..${path5.sep}`) || path5.isAbsolute(relative))
+      const relative = path8.relative(root, resolved);
+      if (relative === ".." || relative.startsWith(`..${path8.sep}`) || path8.isAbsolute(relative))
         throw new Error("dependency-link-outside-consumer");
-      if (!resolved.startsWith(`${dependencies}${path5.sep}`))
+      if (!resolved.startsWith(`${dependencies}${path8.sep}`))
         links++;
     }
     return `${links} repository workspace link(s); their targets must be included in the candidate baseline`;
   }, "Repair dangling/external workspace links and ensure local package sources are tracked or admitted in the candidate.");
-  const manifest = path5.join(root, "package.json");
+  const manifest = path8.join(root, "package.json");
   let selection = packageManagerSelection(root, undefined);
-  if (lstatSync6(manifest, { throwIfNoEntry: false })?.isFile()) {
+  if (lstatSync8(manifest, { throwIfNoEntry: false })?.isFile()) {
     check("manifest", () => {
-      const parsed2 = JSON.parse(readFileSync4(manifest, "utf8"));
+      const parsed2 = JSON.parse(readFileSync5(manifest, "utf8"));
       if (!parsed2 || typeof parsed2 !== "object")
         throw new Error("manifest-invalid");
       return Object.keys(parsed2.scripts ?? {}).join(", ") || "no package scripts";
     }, "Repair package.json.");
     const parsed = (() => {
       try {
-        const value = JSON.parse(readFileSync4(manifest, "utf8"));
+        const value = JSON.parse(readFileSync5(manifest, "utf8"));
         return value && typeof value === "object" && !Array.isArray(value) ? value : {};
       } catch {
         return {};
@@ -1390,7 +1950,7 @@ function storageUsage(root, maximum = 1e5) {
       truncated = true;
       return;
     }
-    const stat = lstatSync6(file, { throwIfNoEntry: false });
+    const stat = lstatSync8(file, { throwIfNoEntry: false });
     if (!stat)
       return;
     entries++;
@@ -1398,7 +1958,7 @@ function storageUsage(root, maximum = 1e5) {
       bytes += stat.size;
     else if (stat.isDirectory())
       for (const name of readdirSync4(file)) {
-        visit(path5.join(file, name));
+        visit(path8.join(file, name));
         if (truncated)
           break;
       }
@@ -1412,7 +1972,7 @@ function inspectRuns(root) {
     xdgStateHome: process.env.XDG_STATE_HOME
   });
   const usage = storageUsage(state.rootDir);
-  if (!lstatSync6(state.databasePath, { throwIfNoEntry: false }))
+  if (!lstatSync8(state.databasePath, { throwIfNoEntry: false }))
     return { stateRoot: state.rootDir, usage, runs: [], truncated: false };
   const db = new DatabaseSync(state.databasePath, { readOnly: true });
   try {
@@ -1433,7 +1993,7 @@ var [command = "doctor", root = process.cwd()] = process.argv.slice(2);
 try {
   if (!["doctor", "runs"].includes(command))
     throw new Error("Usage: node --experimental-strip-types <cadence>/src/operator-cli.mjs doctor|runs [consumer-root]");
-  const result = command === "doctor" ? inspectConsumer(path6.resolve(root)) : inspectRuns(path6.resolve(root));
+  const result = command === "doctor" ? inspectConsumer(path9.resolve(root)) : inspectRuns(path9.resolve(root));
   console.log(JSON.stringify(result, null, 2));
   if (command === "doctor" && !result.ok)
     process.exitCode = 1;