@abelxiaoxing/cadence 1.2.3 → 1.3.0

package/README.md

@@ -71,6 +71,46 @@ npm install -g @abelxiaoxing/cadence
 
 本包要求 Node.js `>=22.13.0`，以使用稳定可用的内置 `node:sqlite`；不从参考仓库源安装，也不维护 Pi 主机版本兼容矩阵。
 
+## OpenSpec 启动与平台范围
+
+Design finalization 和 Implement delivery 加载共用无 shell 的 OpenSpec 适配层：读取已安装 `@fission-ai/openspec` 的 `package.json` 中 `bin` 声明，再以 Node 执行 JS 入口；不直接执行 Windows npm 的 `.cmd`，也不调用 `npx`、自动下载或切换 CLI 版本。
+
+默认按宿主 `PATH` 定位 OpenSpec，支持 npm 全局默认/自定义 prefix，以及 Unix npm/Bun 的入口符号链接。
+不搜索当前目录，不自动信任 consumer repository 内的 CLI；第一个已发现安装损坏时明确失败，不偷偷选用后续版本。
+版本管理器的任意包装脚本、原生 exe 和 PowerShell 脚本不作为可执行回退。
+
+特殊安装可在**启动宿主之前**配置以下环境变量（不属于 Worker 请求参数）：
+
+| 变量                         | 含义                                                                                                                        |
+| ---------------------------- | --------------------------------------------------------------------------------------------------------------------------- |
+| `ABEL_OPENSPEC_PACKAGE_ROOT` | 已安装 `@fission-ai/openspec` 的绝对包目录，包含 `package.json`；不是 `.cmd` 或 JS 文件路径。显式配置代表操作者信任该安装。 |
+| `ABEL_OPENSPEC_NODE`         | Node 原生可执行文件的绝对路径，例如 `C:\Program Files\nodejs\node.exe`；默认复用 Node 宿主。非 Node 宿主必须显式配置。      |
+
+配置无效不会退回 PATH。
+Windows 环境变量名按不区分大小写读取。
+更换全局安装或 PATH 后应重启宿主，确保它继承新环境。
+
+两个 CLI 子进程各有 30 秒超时、每个输出流 4 MiB 上限，关闭 stdin、禁用 OpenSpec telemetry，并在返回检查结果前等待两者结束。
+校验报告的 exit 1 与 `valid: false` 被识别为 strict-invalid；无法启动、协议异常、超时、取消、输出超限分别给出安全诊断。
+诊断只暴露 command、phase、reason、允许列表中的 systemCode 和 exitCode，不返回原始 stderr、绝对路径或环境变量。
+inspection 不可用时不再级联误报 traceability 输入缺失，且绝不生成成功的 ready 收据。
+
+平台契约 CI 使用 Linux、Windows、macOS × Node 22.13.0/24.13.0，显式安装 OpenSpec 1.5.0，验证真实 npm 全局入口、严格校验、Design finalization、失败重试和 proof-bound delivery 加载。
+状态协议要求布尔字段 `isComplete`，用于判断 1.5.0 的规划产物是否齐全；若另有 `isPlanningComplete`，该字段也必须为布尔值，且两者均为 `true` 才视为规划完成。
+CLI 的其他版本必须满足相同 JSON 协议；新增支持版本应加入契约测试。
+
+**此矩阵不代表原生 Implement 隔离已全平台可用。**
+当前隔离后端仍为 Linux Bubblewrap；Windows/macOS 的原生隔离、ACL 与完整文件应用语义需要单独实现和验收，缺少隔离能力时保持暂停，不降级为主工作区直接执行。
+
+本地可用 `CADENCE_REAL_OPENSPEC=1` 启用真实 CLI 测试（Windows 可用 PowerShell 设置 `$env:CADENCE_REAL_OPENSPEC = "1"`），然后运行：
+
+```sh
+bun run test:target test/openspec-cli.test.ts test/design-delivery.integration.test.ts
+```
+
+未启用时，真实 CLI 用例明确跳过，其他适配层回归测试照常执行。
+`bun run check` 的 JS 语法扫描使用 Node 遍历，不依赖 Unix `find`/`xargs`。
+
 ## Worker 路由（Worker routes）
 
 路由配置是可选的：没有项目级或用户级文件时，三个包内 Agent 默认继承当前父模型，因此首次 Design、Implement 或 Diagnose 不需要预先配置 endpoint。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abelxiaoxing/cadence",
-  "version": "1.2.3",
+  "version": "1.3.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",
@@ -40,7 +40,7 @@
     "pack:check": "node scripts/pack-check.mjs",
     "traceability:check": "node scripts/traceability-check.mjs",
     "verify": "bun run check && bun run lint && bun run test && bun run pack:check",
-    "check": "find skills test scripts -name '*.mjs' -type f -print0 | xargs -0 -r -n1 node --check && tsc --noEmit",
+    "check": "node scripts/check-syntax.mjs && tsc --noEmit",
     "lint": "biome check . && rumdl check .",
     "test": "vitest run",
     "test:target": "vitest run",

package/src/design-control.ts

@@ -27,6 +27,7 @@ import {
   DesignJournal,
   type DesignStatusProjection,
 } from "./design-journal.ts";
+import { OpenSpecCliError, type OpenSpecDiagnostic } from "./openspec-cli.ts";
 import { RunStore } from "./run-store.ts";
 import { observeSafePath } from "./safe-path.ts";
 import type { ResolvedStateRoot } from "./state-root.ts";
@@ -131,11 +132,17 @@ export interface DesignControllerOptions {
 export class DesignFinalizationError extends Error {
   readonly diagnostics: readonly string[];
 
-  constructor(diagnostics: readonly string[]) {
+  readonly openSpecDiagnostic?: Readonly<OpenSpecDiagnostic>;
+
+  constructor(
+    diagnostics: readonly string[],
+    openSpecDiagnostic?: Readonly<OpenSpecDiagnostic>,
+  ) {
     const normalized = [...new Set(diagnostics)].sort();
     super("design-finalization-invalid");
     this.name = "DesignFinalizationError";
     this.diagnostics = Object.freeze(normalized);
+    this.openSpecDiagnostic = openSpecDiagnostic;
   }
 }
 
@@ -456,12 +463,21 @@ export class DesignController {
   private constructor(options: DesignControllerOptions) {
     this.consumerRoot = path.resolve(options.consumerRoot);
     this.#runs = RunStore.open(options.stateRoot);
-    this.#journal = DesignJournal.open(options.stateRoot, {
-      ...(options.now ? { now: options.now } : {}),
-      ...(options.finalizationLeaseMs !== undefined
-        ? { finalizationLeaseMs: options.finalizationLeaseMs }
-        : {}),
-    });
+    try {
+      this.#journal = DesignJournal.open(options.stateRoot, {
+        ...(options.now ? { now: options.now } : {}),
+        ...(options.finalizationLeaseMs !== undefined
+          ? { finalizationLeaseMs: options.finalizationLeaseMs }
+          : {}),
+      });
+    } catch (error) {
+      try {
+        this.#runs.close();
+      } catch {
+        // The Design journal initialization failure remains authoritative.
+      }
+      throw error;
+    }
     this.#inspectOpenSpec = options.inspectOpenSpec;
   }
 
@@ -588,18 +604,32 @@ export class DesignController {
 
   #start(request: Extract<DesignControlRequest, { operation: "start" }>) {
     const fromRequirement = "requirement" in request;
-    const run = this.#runs.startRun({
-      stage: "abel-design",
-      ...(fromRequirement
-        ? {
-            provisionalKey: transientHash(
-              "abel-design-requirement",
-              request.requirement,
-            ),
-          }
-        : { change: request.change }),
-      operationId: request.operationId,
-    });
+    let run: ReturnType<RunStore["startRun"]>;
+    try {
+      run = this.#runs.startRun({
+        stage: "abel-design",
+        ...(fromRequirement
+          ? {
+              provisionalKey: transientHash(
+                "abel-design-requirement",
+                request.requirement,
+              ),
+              provisionalAliases: [
+                transientHash(
+                  "abel-design-requirement-v1",
+                  request.requirement,
+                ),
+              ],
+            }
+          : { change: request.change }),
+        operationId: request.operationId,
+      });
+    } catch (error) {
+      if (error instanceof Error && error.message === "operation-id-conflict") {
+        throw new Error("design-operation-conflict", { cause: error });
+      }
+      throw error;
+    }
     if (run.state === "created") {
       this.#runs.transition({
         runId: run.runId,
@@ -911,9 +941,12 @@ export class DesignController {
       removeSafeFile(this.consumerRoot, readyPath);
       const diagnostics = new Set<string>();
       let inspection: DesignOpenSpecInspection | undefined;
+      let openSpecDiagnostic: Readonly<OpenSpecDiagnostic> | undefined;
       try {
         inspection = await this.#inspectOpenSpec(this.consumerRoot, change);
-      } catch {
+      } catch (error) {
+        if (error instanceof OpenSpecCliError)
+          openSpecDiagnostic = error.diagnostic;
         diagnostics.add("design-openspec-unavailable");
       }
       if (inspection) {
@@ -981,7 +1014,7 @@ export class DesignController {
       let traceability:
         | ReturnType<typeof assessDeliveryTraceability>
         | undefined;
-      if (compiled) {
+      if (compiled && inspection) {
         const tasks = artifactBytes.get("tasks.md");
         const specs = [...artifactBytes]
           .filter(
@@ -1012,7 +1045,7 @@ export class DesignController {
         !traceability?.ok ||
         diagnostics.size > 0
       ) {
-        throw new DesignFinalizationError([...diagnostics]);
+        throw new DesignFinalizationError([...diagnostics], openSpecDiagnostic);
       }
       const gateAReceipt = compileGateAReceipt({
         change,

package/src/design-journal.ts

@@ -317,12 +317,21 @@ export class DesignJournal {
     }
     const stateRoot = prepareStateRoot(unresolved);
     const database = new DatabaseSync(stateRoot.databasePath);
-    database.exec("PRAGMA foreign_keys = ON");
-    database.exec("PRAGMA journal_mode = WAL");
-    database.exec("PRAGMA synchronous = FULL");
-    database.exec("PRAGMA busy_timeout = 5000");
-    database.exec(SCHEMA);
-    return new DesignJournal(stateRoot, database, options);
+    try {
+      database.exec("PRAGMA foreign_keys = ON");
+      database.exec("PRAGMA journal_mode = WAL");
+      database.exec("PRAGMA synchronous = FULL");
+      database.exec("PRAGMA busy_timeout = 5000");
+      database.exec(SCHEMA);
+      return new DesignJournal(stateRoot, database, options);
+    } catch (error) {
+      try {
+        database.close();
+      } catch {
+        // The Design journal initialization failure remains authoritative.
+      }
+      throw error;
+    }
   }
 
   #assertOpen(): void {
@@ -337,7 +346,11 @@ export class DesignJournal {
       this.#database.exec("COMMIT");
       return result;
     } catch (error) {
-      this.#database.exec("ROLLBACK");
+      try {
+        this.#database.exec("ROLLBACK");
+      } catch {
+        // The original operation or commit failure remains authoritative.
+      }
       throw error;
     }
   }

package/src/index.ts

@@ -4,7 +4,6 @@
 // workflow routing (abel-design/implement/diagnose provenance) in the prompts
 // integration; abel-init and ordinary prompts never activate dispatch.
 import { AsyncLocalStorage } from "node:async_hooks";
-import { execFile } from "node:child_process";
 import { createHash } from "node:crypto";
 import {
   lstatSync,
@@ -17,7 +16,6 @@ import {
 import { homedir } from "node:os";
 import path, { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { promisify } from "node:util";
 import type {
   AgentToolResult,
   AgentToolUpdateCallback,
@@ -59,6 +57,10 @@ import {
 } from "./design-control.ts";
 import { canonicalJson, hashCanonicalValue } from "./implement-graph.ts";
 import { BubblewrapIsolationBackend } from "./isolation-backend.ts";
+import {
+  inspectOpenSpecDelivery,
+  type OpenSpecDeliveryInspection,
+} from "./openspec-cli.ts";
 import { PACKET_ACTIONS, PacketRuntime } from "./packet-runtime.ts";
 import { ParentPayloadBridge } from "./parent-payload-bridge.ts";
 import { runtimeForWorkerRoute } from "./parent-provider.ts";
@@ -69,9 +71,9 @@ import {
   unavailableRoutePolicy,
   type WorkerRoutePolicy,
 } from "./route-policy.ts";
-import { RunStoreFormatError } from "./run-store.ts";
+import { RunStoreFormatError, RunStoreMigrationError } from "./run-store.ts";
 import { observeSafePath } from "./safe-path.ts";
-import { resolveStateRoot } from "./state-root.ts";
+import { resolveStateRoot, StateRootError } from "./state-root.ts";
 import {
   ACTIVITY_DETAILS_KEY,
   ActivityController,
@@ -91,6 +93,11 @@ import {
   type WorkflowDeliverySource,
 } from "./workflow-engine.ts";
 
+export {
+  inspectOpenSpecDelivery,
+  type OpenSpecDeliveryInspection,
+} from "./openspec-cli.ts";
+
 export const DISPATCH_TOOL = "abel_dispatch";
 const DESIGN_PARENT_READ_TOOLS = new Set(["read", "grep", "find", "ls"]);
 
@@ -431,25 +438,174 @@ type SafeDesignFailure = {
   kind: "design-control-failure";
   operation: string;
   code: string;
-  diagnostics: ReadonlyArray<Record<string, string>>;
+  diagnostics: ReadonlyArray<Record<string, string | boolean>>;
 };
 
+type DesignFailureBoundary =
+  | "dispatch"
+  | "initialization"
+  | "execution"
+  | "serialization";
+
+function sqliteLocked(error: unknown): boolean {
+  return (
+    typeof error === "object" &&
+    error !== null &&
+    "errcode" in error &&
+    ((error as { errcode?: unknown }).errcode === 5 ||
+      (error as { errcode?: unknown }).errcode === 6)
+  );
+}
+
+function sqliteUnavailable(error: unknown): boolean {
+  if (typeof error !== "object" || error === null) return false;
+  const errcode = Number((error as { errcode?: unknown }).errcode);
+  const code = (error as { code?: unknown }).code;
+  return (
+    [8, 10, 13, 14, 23, 24].includes(errcode) ||
+    (typeof code === "string" &&
+      [
+        "EACCES",
+        "EBUSY",
+        "EMFILE",
+        "ENFILE",
+        "ENOSPC",
+        "EPERM",
+        "EROFS",
+      ].includes(code))
+  );
+}
+
+function classifyDesignFailure(
+  error: unknown,
+  operation: string,
+  boundary: DesignFailureBoundary,
+): {
+  code: string;
+  category: string;
+  retryable: boolean;
+  field?: string;
+} {
+  const message = error instanceof Error ? error.message : "";
+  if (error instanceof DesignPlanValidationError) {
+    return {
+      code: "design-plan-validation-invalid",
+      category: "validation",
+      retryable: false,
+    };
+  }
+  if (
+    error instanceof RunStoreMigrationError ||
+    error instanceof RunStoreFormatError
+  ) {
+    return {
+      code: "design-store-migration-failed",
+      category: "storage",
+      retryable: false,
+      field: "schemaVersion",
+    };
+  }
+  if (sqliteLocked(error)) {
+    return {
+      code: "design-store-locked",
+      category: "storage",
+      retryable: true,
+    };
+  }
+  if (sqliteUnavailable(error)) {
+    return {
+      code: "design-store-unavailable",
+      category: "storage",
+      retryable: false,
+    };
+  }
+  if (error instanceof StateRootError) {
+    return {
+      code: "design-store-unavailable",
+      category: "storage",
+      retryable: false,
+    };
+  }
+  if (
+    message === "design-operation-conflict" ||
+    message === "operation-id-conflict"
+  ) {
+    return {
+      code: "design-operation-conflict",
+      category: "control",
+      retryable: false,
+      field: "operationId",
+    };
+  }
+  if (message === "stage-control-mismatch") {
+    return {
+      code: "design-stage-inactive",
+      category: "stage",
+      retryable: false,
+    };
+  }
+  if (message === "invalid-design-control-request") {
+    return {
+      code: "invalid-design-control-request",
+      category: "validation",
+      retryable: false,
+    };
+  }
+  if (boundary === "serialization") {
+    return {
+      code: "design-receipt-serialization-failed",
+      category: "control",
+      retryable: false,
+    };
+  }
+  if (boundary === "initialization") {
+    return {
+      code: "design-store-unavailable",
+      category: "storage",
+      retryable: false,
+    };
+  }
+  if (
+    error instanceof DesignFinalizationError ||
+    error instanceof DeliveryValidationError ||
+    (message.startsWith("design-") && SAFE_DESIGN_ERROR_CODE.test(message))
+  ) {
+    return { code: message, category: "control", retryable: false };
+  }
+  if (operation === "start") {
+    return {
+      code: "design-run-create-failed",
+      category: "storage",
+      retryable: false,
+    };
+  }
+  return {
+    code: "design-control-internal",
+    category: "control",
+    retryable: false,
+  };
+}
+
 function safeDesignFailure(
   error: unknown,
   operation: string,
+  boundary: DesignFailureBoundary = "dispatch",
 ): SafeDesignFailure {
-  const message = error instanceof Error ? error.message : "";
-  const code =
-    error instanceof DesignPlanValidationError
-      ? "design-plan-validation-invalid"
-      : SAFE_DESIGN_ERROR_CODE.test(message)
-        ? message
-        : "design-control-failed";
+  const classified = classifyDesignFailure(error, operation, boundary);
   const rawDiagnostics: readonly unknown[] =
     error instanceof DesignFinalizationError ||
     error instanceof DesignPlanValidationError ||
     error instanceof DeliveryValidationError
-      ? error.diagnostics
+      ? error instanceof DesignFinalizationError
+        ? [
+            ...error.diagnostics.filter(
+              (code) =>
+                !error.openSpecDiagnostic ||
+                code !== "design-openspec-unavailable",
+            ),
+            ...(error.openSpecDiagnostic ? [error.openSpecDiagnostic] : []),
+          ]
+        : error.diagnostics
       : [];
   const diagnostics = rawDiagnostics
     .flatMap((candidate) => {
@@ -468,8 +624,11 @@ function safeDesignFailure(
       }
       const admitted = Object.fromEntries(
         Object.entries(candidate as Record<string, unknown>)
-          .filter(
-            (entry): entry is [string, string] =>
+          .filter((entry): entry is [string, string | boolean] => {
+            if (entry[0] === "retryable") {
+              return typeof entry[1] === "boolean";
+            }
+            return (
               [
                 "code",
                 "taskId",
@@ -482,10 +641,15 @@ function safeDesignFailure(
                 "dependencyTaskId",
                 "producerTaskId",
                 "producerPhase",
+                "command",
+                "reason",
+                "systemCode",
+                "exitCode",
               ].includes(entry[0]) &&
               typeof entry[1] === "string" &&
-              SAFE_DESIGN_ERROR_CODE.test(entry[1]),
-          )
+              SAFE_DESIGN_ERROR_CODE.test(entry[1])
+            );
+          })
           .sort(([left], [right]) => left.localeCompare(right)),
       );
       return typeof admitted.code === "string" ? [admitted] : [];
@@ -499,10 +663,18 @@ function safeDesignFailure(
         canonicalJson(candidate) !== canonicalJson(values[index - 1]),
     )
     .slice(0, MAX_DESIGN_ERROR_DIAGNOSTICS);
+  if (diagnostics.length === 0) {
+    diagnostics.push({
+      code: classified.code,
+      category: classified.category,
+      retryable: classified.retryable,
+      ...(classified.field ? { field: classified.field } : {}),
+    });
+  }
   return {
     kind: "design-control-failure",
     operation: SAFE_DESIGN_ERROR_CODE.test(operation) ? operation : "unknown",
-    code,
+    code: classified.code,
     diagnostics,
   };
 }
@@ -529,15 +701,6 @@ export type WorkflowControlEngineFactory = (
 ) => WorkflowControlEngine | Promise<WorkflowControlEngine>;
 
 const PACKAGE_DELIVERY_MAX_BYTES = 16 * 1024 * 1024;
-const execFileAsync = promisify(execFile);
-
-export interface OpenSpecDeliveryInspection {
-  change: string;
-  schema: string;
-  planningComplete: boolean;
-  strictValid: boolean;
-  artifactPaths: string[];
-}
 
 export interface PackageDeliverySourceOptions {
   inspectOpenSpec?: (
@@ -631,96 +794,6 @@ function readPackageDeliveryFile(
   return readFileSync(target);
 }
 
-function deliveryRecord(value: unknown): Record<string, unknown> | undefined {
-  return value && typeof value === "object" && !Array.isArray(value)
-    ? (value as Record<string, unknown>)
-    : undefined;
-}
-
-function parseCommandJson(
-  value: string,
-  code: string,
-): Record<string, unknown> {
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(value);
-  } catch {
-    throw new Error(code);
-  }
-  const record = deliveryRecord(parsed);
-  if (!record) throw new Error(code);
-  return record;
-}
-
-export async function inspectOpenSpecDelivery(
-  consumerRoot: string,
-  change: string,
-): Promise<OpenSpecDeliveryInspection> {
-  const [statusExecution, validationExecution] = await Promise.all([
-    execFileAsync("openspec", ["status", "--change", change, "--json"], {
-      cwd: consumerRoot,
-      encoding: "utf8",
-      maxBuffer: 4 * 1024 * 1024,
-    }),
-    execFileAsync(
-      "openspec",
-      ["validate", change, "--strict", "--json", "--no-interactive"],
-      {
-        cwd: consumerRoot,
-        encoding: "utf8",
-        maxBuffer: 4 * 1024 * 1024,
-      },
-    ),
-  ]);
-  const status = parseCommandJson(
-    statusExecution.stdout,
-    "delivery-openspec-status-invalid",
-  );
-  const validation = parseCommandJson(
-    validationExecution.stdout,
-    "delivery-openspec-validation-invalid",
-  );
-  const changeRoot = path.resolve(consumerRoot, "openspec", "changes", change);
-  const artifactPathsRecord = deliveryRecord(status.artifactPaths);
-  const artifactPaths = artifactPathsRecord
-    ? Object.values(artifactPathsRecord).flatMap((entry) => {
-        const record = deliveryRecord(entry);
-        if (!record || !Array.isArray(record.existingOutputPaths)) return [];
-        return record.existingOutputPaths.flatMap((candidate) => {
-          if (typeof candidate !== "string") return [];
-          const resolved = path.resolve(candidate);
-          const relative = path.relative(changeRoot, resolved);
-          return relative &&
-            !relative.startsWith(`..${path.sep}`) &&
-            relative !== ".." &&
-            !path.isAbsolute(relative)
-            ? [relative.split(path.sep).join("/")]
-            : [];
-        });
-      })
-    : [];
-  const items = Array.isArray(validation.items) ? validation.items : [];
-  const strictValid =
-    items.length === 1 &&
-    deliveryRecord(items[0])?.id === change &&
-    deliveryRecord(items[0])?.valid === true;
-  if (
-    status.changeName !== change ||
-    typeof status.schemaName !== "string" ||
-    artifactPaths.length === 0
-  ) {
-    throw new Error("delivery-openspec-status-invalid");
-  }
-  return {
-    change,
-    schema: status.schemaName,
-    planningComplete:
-      status.isPlanningComplete === true && status.isComplete === true,
-    strictValid,
-    artifactPaths: [...new Set(artifactPaths)].sort(),
-  };
-}
-
 export function packageDeliverySource(
   consumerRoot: string,
   options: PackageDeliverySourceOptions = {},
@@ -2082,18 +2155,19 @@ export function registerWorkflowControl(
             }
             const designRequest = validateDesignControlRequest(record.request);
             if (!designRequest.ok) throw new Error(designRequest.code);
-            let engine: WorkflowControlEngine;
-            try {
-              engine = await engineFor(ctx);
-            } catch (error) {
-              if (error instanceof RunStoreFormatError)
-                throw runStoreResetError(error);
-              throw error;
-            }
-            if (!engine.executeDesign)
-              throw new Error("design-control-unavailable");
+            let boundary: DesignFailureBoundary = "initialization";
             try {
+              const engine = await engineFor(ctx);
+              if (!engine.executeDesign)
+                throw new Error("design-control-unavailable");
+              boundary = "execution";
               const payload = await engine.executeDesign(designRequest.value);
+              boundary = "serialization";
+              const serialized = JSON.stringify(payload);
+              if (serialized === undefined) {
+                throw new Error("design-receipt-serialization-failed");
+              }
+              boundary = "execution";
               if (
                 designRequest.value.operation === "finalize-delivery" &&
                 payload.state === "completed"
@@ -2101,15 +2175,14 @@ export function registerWorkflowControl(
                 await deactivateStage();
               }
               return {
-                content: [
-                  { type: "text" as const, text: JSON.stringify(payload) },
-                ],
+                content: [{ type: "text" as const, text: serialized }],
                 details: payload,
               };
             } catch (error) {
               const failure = safeDesignFailure(
                 error,
                 designRequest.value.operation,
+                boundary,
               );
               designFailures.set(toolCallId, failure);
               const sanitized = new Error(failure.code);