@abelxiaoxing/cadence 1.7.0 → 1.8.0

package/README.md

@@ -10,7 +10,7 @@
 
 1. 安装 Node.js >=22.13、Git、Pi，以及 `@fission-ai/openspec@1.5.0`。
 2. 在 Pi 中安装：`pi install npm:@abelxiaoxing/cadence`。
-3. 默认 Implement 需要可用的 Linux Bubblewrap；Windows 请使用 WSL。
+3. 默认 Implement 使用 Linux Bubblewrap；Windows x64 可信项目可显式选择 `host-trusted`，构建与验收见 [Windows 原生执行](docs/windows-host-trusted.md)。
 4. 首次进入项目先运行 `/abel-init`，然后 `/abel-design <需求>`，确认集中呈现的目标与方案，设计完成后运行 `/abel-implement <change>`。
 5. 暂停时先查看原因和建议，不要靠反复 resume 或重启“碰运气”；未完成的工作会保留。
 
@@ -50,7 +50,9 @@ export ABEL_VERIFICATION_TIMEOUT_MS=900000
 可信模式仍在独立候选目录执行，并复制依赖以避免普通缓存写入修改 consumer 的依赖，但**不是沙箱**：测试可访问宿主文件、网络及显式继承的环境变量，产生的外部副作用不能回滚。
 HOME、临时目录和报告仍独立；PATH 复用宿主，仓库内 workspace 链接映射到候选代码。
 该模式仍要求 Linux Bubblewrap 的 PID namespace 管理后代进程（包括 detached 后代），但不隔离宿主文件和网络；缺少该能力时暂停，不回退到普通进程组。
-原生 macOS/Windows 不提供此执行模式，Windows 可使用 WSL。
+`local-trusted` 仅用于 Linux。
+Windows x64 使用独立的 `host-trusted` 后端，见 [配置、构建与验收说明](docs/windows-host-trusted.md)；macOS 暂不支持。
+包含原生 helper 的 Windows x64 安装包在 [GitHub Release](https://github.com/abelxiaoxing/cadence/releases/tag/v1.8.0) 下载；npm 通用包可显式构建 helper 后配置使用。
 依赖副本准备、替换与清理在 I/O Worker 中执行，复制支持取消并等待线程退出；大型依赖复制仍有额外成本；需要安装新依赖、宿主浏览器缓存或服务启动编排时仍需配置/准备，不会自动下载。
 
 可选宿主参数还包括 `ABEL_BWRAP_PATH`、`ABEL_FIRST_PROGRESS_MS` 和 `ABEL_STREAM_IDLE_MS`。
@@ -339,7 +341,9 @@ inspection 不可用时不再级联误报 traceability 输入缺失，且绝不
 CLI 的其他版本必须满足相同 JSON 协议；新增支持版本应加入契约测试。
 
 **此矩阵不代表原生 Implement 隔离已全平台可用。**
-默认隔离后端仍为 Linux Bubblewrap；Windows/macOS 的原生隔离、ACL 与完整文件应用语义需要单独实现和验收，缺少隔离能力时保持暂停，不降级为主工作区直接执行。
+默认隔离后端仍为 Linux Bubblewrap。
+Windows x64 的显式 `host-trusted` 使用 Job Object 管理验证进程，不提供文件或网络安全隔离；真实原生支持以 Windows CI 验收结果为准。
+缺少所选后端时保持暂停。
 
 目录持久化在 Windows 上单独处理：仅当已打开的目录句柄执行 `fsync` 返回 `EPERM` 时，标记为不支持目录刷新屏障。
 普通文件仍须在发布前成功 `fsync`；目录打开/关闭、权限、其他 I/O 及 POSIX 目录刷新错误不会被忽略。

package/config/.env.example

@@ -19,3 +19,9 @@ GROK_API_KEY=
 # TAVILY_ENABLED=true
 # TAVILY_API_URL=https://api.tavily.com
 # TAVILY_API_KEY=
+
+# Explicit Windows x64 trusted host verification (not a filesystem/network sandbox).
+# ABEL_EXECUTION_MODE=host-trusted
+# ABEL_WINDOWS_JOB_HELPER=C:\CadenceNative\windows-job.exe
+# ABEL_VERIFICATION_TIMEOUT_MS=600000
+# ABEL_VERIFICATION_ENV=DATABASE_URL,NODE_ENV

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abelxiaoxing/cadence",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "description": "Four explicit Abel workflow prompts with stage-isolated design and diagnosis, durable resumable implementation, and three package-owned professional Agents.",
   "license": "MIT",
   "type": "module",

package/src/apply-transaction.ts

@@ -13,7 +13,6 @@ import {
   realpathSync,
   renameSync,
   rmdirSync,
-  rmSync,
   unlinkSync,
   writeFileSync,
 } from "node:fs";
@@ -24,6 +23,8 @@ import type { ArtifactStore } from "./artifact-store.ts";
 import { compareCanonicalStrings } from "./canonical.ts";
 import { isValidRelativePath } from "./contracts.ts";
 import { syncDirectory } from "./directory-sync.ts";
+import { isExecutionRetained } from "./execution-retention.ts";
+import { removePathSync } from "./remove-path.ts";
 import { observeSafePath } from "./safe-path.ts";
 import { configureSqlite, ensureSqliteSchema } from "./sqlite-schema.ts";
 import { APPLY_SCHEMA } from "./storage-schema.ts";
@@ -161,6 +162,8 @@ export interface ApplyTransactionHooks {
     path: string;
     index: number;
   }) => void | Promise<void>;
+  /** Production executors settle their process scope before cancellation returns. */
+  awaitPostApplySettlement?: boolean;
   postApply?: (input: {
     transactionId: string;
     root: string;
@@ -412,10 +415,10 @@ function writeExclusiveFile(
     syncDirectory(directory);
     return true;
   } catch (error) {
-    rmSync(temporary, { force: true });
+    removePathSync(temporary, { force: true });
     throw error;
   } finally {
-    rmSync(temporary, { force: true });
+    removePathSync(temporary, { force: true });
   }
 }
 
@@ -587,7 +590,8 @@ export async function verifyCumulativeRevision(
       verificationId: input.verificationId,
     };
   } finally {
-    rmSync(temporary, { recursive: true, force: true });
+    if (!isExecutionRetained(temporary))
+      removePathSync(temporary, { recursive: true, force: true });
   }
 }
 
@@ -1247,11 +1251,13 @@ export class ApplyTransaction {
             }),
           );
           void execution.catch(() => undefined);
-          postApply = signal
-            ? await raceWithAbort(execution, signal)
-            : await execution;
+          postApply =
+            signal && !this.#hooks.awaitPostApplySettlement
+              ? await raceWithAbort(execution, signal)
+              : await execution;
         } finally {
-          rmSync(isolatedRoot, { recursive: true, force: true });
+          if (!isExecutionRetained(isolatedRoot))
+            removePathSync(isolatedRoot, { recursive: true, force: true });
         }
       }
     } catch (error) {
@@ -1260,6 +1266,13 @@ export class ApplyTransaction {
       if (settled) return settled;
       if (!journal.pendingIntent && !signal?.aborted) throw error;
     }
+    if (isExecutionRetained(this.root)) {
+      journal = this.#load(transactionId);
+      journal.state = "recovering";
+      journal.code = "isolation-termination-unconfirmed";
+      this.#save(journal);
+      return { ok: false, transactionId, state: "paused", code: journal.code };
+    }
     journal = this.#load(transactionId);
     const settled = this.#settledOutcome(journal);
     if (settled) return settled;
@@ -1350,6 +1363,13 @@ export class ApplyTransaction {
   ): Promise<ApplyTransactionOutcome> {
     const existing = this.#active.get(transactionId);
     if (existing) return existing.promise;
+    if (isExecutionRetained(this.root))
+      return Promise.resolve({
+        ok: false,
+        transactionId,
+        state: "paused",
+        code: "isolation-termination-unconfirmed",
+      });
     const controller = new AbortController();
     const forwardAbort = () => {
       if (!controller.signal.aborted) {

package/src/build-windows-job.mjs

@@ -0,0 +1,95 @@
+// Explicit operator/release build only. Never invoked on import, install or verification.
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+function main() {
+  const args = process.argv.slice(2);
+  if (
+    process.platform !== "win32" ||
+    process.arch !== "x64" ||
+    args.length !== 2 ||
+    args[0] !== "--output"
+  )
+    throw new Error(
+      "Windows x64 required; usage: node build-windows-job.mjs --output <directory>",
+    );
+  const output = path.resolve(args[1]);
+  const compiler = path.join(
+    process.env.VCToolsInstallDir ?? "",
+    "bin/Hostx64/x64/cl.exe",
+  );
+  if (!path.isAbsolute(compiler))
+    throw new Error(
+      "Select the installed MSVC x64 developer environment first",
+    );
+  const sdkVersion = process.env.WindowsSDKVersion?.replace(/[\\/]+$/u, "");
+  if (!sdkVersion || !/^10\.0\.\d+\.0$/u.test(sdkVersion))
+    throw new Error("Windows 10 SDK required");
+  const version = spawnSync(compiler, [], {
+    shell: false,
+    encoding: "utf8",
+    timeout: 10000,
+    maxBuffer: 16384,
+  });
+  const compilerVersion =
+    `${version.stdout ?? ""}${version.stderr ?? ""}`.match(
+      /19\.(?:3\d|4\d)\.\d+/u,
+    )?.[0];
+  if (!compilerVersion) throw new Error("MSVC 19.3x/19.4x required");
+  mkdirSync(output, { recursive: true });
+  const source = fileURLToPath(new URL("./windows-job.c", import.meta.url));
+  const helper = path.join(output, "windows-job.exe");
+  rmSync(`${helper}.json`, { force: true });
+  rmSync(helper, { force: true });
+  const result = spawnSync(
+    compiler,
+    [
+      "/nologo",
+      "/W4",
+      "/WX",
+      "/O2",
+      "/MT",
+      "/utf-8",
+      "/DUNICODE",
+      "/D_UNICODE",
+      source,
+      `/Fe:${helper}`,
+      `/Fo:${path.join(output, "windows-job.obj")}`,
+    ],
+    {
+      shell: false,
+      cwd: output,
+      encoding: "utf8",
+      timeout: 60000,
+      maxBuffer: 65536,
+    },
+  );
+  writeFileSync(
+    path.join(output, "build.log"),
+    `${result.stdout ?? ""}${result.stderr ?? ""}`,
+  );
+  if (result.error || result.status !== 0)
+    throw new Error("Native build failed; inspect build.log");
+  const hash = (file) =>
+    createHash("sha256").update(readFileSync(file)).digest("hex");
+  writeFileSync(
+    `${helper}.json`,
+    `${JSON.stringify({ version: 2, arch: "x64", sourceSha256: hash(source), helperSha256: hash(helper), compilerSha256: hash(compiler), compilerVersion, sdkVersion }, null, 2)}\n`,
+    { flag: "wx" },
+  );
+  console.log(`Built ${helper}`);
+}
+if (
+  process.argv[1] &&
+  path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)
+) {
+  try {
+    main();
+  } catch (error) {
+    console.error(error.message);
+    process.exitCode = 1;
+  }
+}

package/src/candidate-workspace.ts

@@ -21,6 +21,12 @@ export function runGitApply(
     const child = spawn(
       "git",
       [
+        // Candidate patches bind exact bytes, independent of host checkout
+        // preferences. Git's Windows autocrlf default must not rewrite them.
+        "-c",
+        "core.autocrlf=false",
+        "-c",
+        "core.eol=lf",
         "apply",
         ...(checkOnly ? ["--check"] : []),
         "--recount",

package/src/change-verification.ts

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { mkdtempSync, rmSync } from "node:fs";
+import { mkdtempSync } from "node:fs";
 import path from "node:path";
 import { verifyCumulativeRevision } from "./apply-transaction.ts";
 import type { ArtifactStore } from "./artifact-store.ts";
@@ -21,6 +21,8 @@ import type {
   DurableVerificationObservation,
   DurableWorkflowEngineOptions,
 } from "./durable-contracts.ts";
+import { isExecutionRetained } from "./execution-retention.ts";
+import { removePathSync } from "./remove-path.ts";
 
 import { observeSafePath } from "./safe-path.ts";
 
@@ -72,6 +74,7 @@ const BASELINE_CAPABILITY_CODES = new Set([
   "dependency-path-unsafe",
   "isolation-backend-launch-failed",
   "isolation-backend-unavailable",
+  "isolation-termination-unconfirmed",
   "local-executable-missing",
   "runner-missing",
   "sandbox-runtime-unavailable",
@@ -527,7 +530,8 @@ export class ChangeVerification {
         },
       };
     } finally {
-      rmSync(root, { recursive: true, force: true });
+      if (!isExecutionRetained(root))
+        removePathSync(root, { recursive: true, force: true });
     }
   }
 

package/src/durable-contracts.ts

@@ -173,6 +173,8 @@ export interface DurableWorkflowEngineOptions {
   leaseTtlMs?: number;
   workHardLimit?: number;
   verificationPolicy?: string;
+  /** Real process executors must settle cancellation before post-apply cleanup. */
+  awaitPostApplySettlement?: boolean;
   verificationEnvironment?(
     plan: ImplementPlan,
     signal: AbortSignal,

package/src/durable-workflow.ts

@@ -5,7 +5,9 @@ import type {
   DurableResourceInput,
   DurableWorkflowEngineOptions,
 } from "./durable-contracts.ts";
+import { assertExecutionsSettled } from "./execution-retention.ts";
 import { PhaseExecution } from "./phase-execution.ts";
+import { removePathSync } from "./remove-path.ts";
 
 export type {
   DurableChangeVerificationResult,
@@ -18,7 +20,7 @@ interface DurableRunResources extends DurableExecutionResources {
   closed: boolean;
 }
 
-import { lstatSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import { lstatSync, mkdirSync, readFileSync } from "node:fs";
 import path from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import { ApplyTransaction } from "./apply-transaction.ts";
@@ -276,6 +278,7 @@ class DurableWorkflowComposition
     signal: AbortSignal,
   ): Promise<DurableRunResources> {
     signal.throwIfAborted();
+    assertExecutionsSettled(this.#options.stateRoot.rootDir);
     const pending = this.#initializing.get(input.runId);
     if (pending) return pending;
     if (
@@ -325,6 +328,7 @@ class DurableWorkflowComposition
     baselineRevisionId?: string;
     currentWorkspaceRevisionId?: string;
   }): DurableRunResources {
+    assertExecutionsSettled(this.#options.stateRoot.rootDir);
     const existing = this.#runs.get(input.runId);
     if (existing) {
       if (
@@ -370,6 +374,7 @@ class DurableWorkflowComposition
       artifacts,
       workspaces,
       hooks: {
+        awaitPostApplySettlement: this.#options.awaitPostApplySettlement,
         postApply: ({ transactionId, root: verificationRoot, signal }) =>
           this.#verification.verifyPostApply(
             resources,
@@ -893,12 +898,13 @@ class DurableWorkflowComposition
   }
 
   cleanup(runId: string): void {
+    assertExecutionsSettled(this.#options.stateRoot.rootDir, true);
     const resources = this.#runs.get(runId);
     if (resources) {
       this.#closeResources(resources);
       this.#runs.delete(runId);
     }
-    rmSync(this.#runRoot(runId), { recursive: true, force: true });
+    removePathSync(this.#runRoot(runId), { recursive: true, force: true });
   }
 
   close(): void {

package/src/execution-profile.ts

@@ -1,8 +1,12 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
 export interface ExecutionProfile {
-  mode: "isolated" | "local-trusted";
+  mode: "isolated" | "local-trusted" | "host-trusted";
   timeoutMs: number;
   bwrapPath: string;
   inheritEnvironment: string[];
+  windowsHelperPath?: string;
 }
 
 /** Operator configuration only. Unknown modes never silently disable isolation. */
@@ -10,7 +14,11 @@ export function executionProfile(
   env: NodeJS.ProcessEnv = process.env,
 ): ExecutionProfile {
   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 ?? 600_000);
   if (
@@ -29,10 +37,28 @@ export function executionProfile(
     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("\0") ||
+      !(
+        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,
+    ...(mode === "host-trusted"
+      ? {
+          windowsHelperPath:
+            env.ABEL_WINDOWS_JOB_HELPER ??
+            fileURLToPath(new URL("./windows-job.exe", import.meta.url)),
+        }
+      : {}),
   };
 }

package/src/execution-retention.ts

@@ -0,0 +1,77 @@
+import { randomUUID } from "node:crypto";
+import {
+  closeSync,
+  fsyncSync,
+  lstatSync,
+  openSync,
+  readdirSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import path from "node:path";
+import { syncDirectory } from "./directory-sync.ts";
+
+const prefix = ".cadence-execution-";
+const active = new Set<string>();
+const retained = new Map<string, readonly string[]>();
+/** Written before launching a host process. Absence of a settlement receipt
+ * survives host loss; reopening must not infer ownership from a recycled PID. */
+export function retainExecution(ownerRoot: string, roots: readonly string[]) {
+  assertExecutionsSettled(ownerRoot);
+  const file = path.join(ownerRoot, `${prefix}${randomUUID()}.json`);
+  const fd = openSync(file, "wx", 0o600);
+  try {
+    writeFileSync(
+      fd,
+      JSON.stringify({
+        version: 1,
+        roots: roots.map((root) => path.resolve(root)),
+      }),
+    );
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+  syncDirectory(ownerRoot);
+  active.add(file);
+  retained.set(file, roots);
+  return {
+    settled() {
+      unlinkSync(file);
+      syncDirectory(ownerRoot);
+      active.delete(file);
+      retained.delete(file);
+    },
+    uncertain() {
+      active.delete(file);
+    },
+  };
+}
+export function assertExecutionsSettled(
+  ownerRoot: string,
+  includeActive = false,
+): void {
+  if (!lstatSync(ownerRoot, { throwIfNoEntry: false })) return;
+  if (
+    readdirSync(ownerRoot).some(
+      (name) =>
+        name.startsWith(prefix) &&
+        (includeActive || !active.has(path.join(ownerRoot, name))),
+    )
+  )
+    throw new Error("isolation-termination-unconfirmed");
+}
+export function isExecutionRetained(root: string): boolean {
+  const resolved = path.resolve(root);
+  return [...retained.values()].some((roots) =>
+    roots.some((candidate) => {
+      const relative = path.relative(resolved, path.resolve(candidate));
+      return (
+        relative === "" ||
+        (relative !== ".." &&
+          !relative.startsWith(`..${path.sep}`) &&
+          !path.isAbsolute(relative))
+      );
+    }),
+  );
+}

package/src/isolation-backend.ts

@@ -37,6 +37,7 @@ export type IsolationRunResult =
       code:
         | "isolation-backend-unavailable"
         | "isolation-backend-launch-failed"
+        | "isolation-termination-unconfirmed"
         | "isolation-execution-timeout";
     }
   | { ok: false; state: "cancelled"; code: "cancelled" };
@@ -72,7 +73,7 @@ function validEnvironmentName(name: string): boolean {
 }
 
 /** Retains independent head/tail copies; discarded chunks never stay referenced. */
-class BoundedLog {
+export class BoundedLog {
   bytes = 0;
   #head = Buffer.alloc(0);
   #tail = Buffer.alloc(0);