weaver-work-cli 0.1.28 → 0.1.31

package/dist/chunks/chunk-EZALDOQH.js

@@ -0,0 +1,383 @@
+import { createRequire as __esbuildCreateRequire } from 'node:module';
+const require = __esbuildCreateRequire(import.meta.url);
+import {
+  workflowAlreadyAppliedError,
+  workflowPartialError,
+  workflowValidationError
+} from "./chunk-FMPJJYYI.js";
+
+// src/shortcuts/workflow/continuation.ts
+import { createHash, createHmac, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
+import { existsSync } from "node:fs";
+import { chmod, mkdir, readFile, readdir, unlink, writeFile } from "node:fs/promises";
+import { homedir, hostname } from "node:os";
+import { resolve } from "node:path";
+var DEFAULT_TTL_MS = 10 * 6e4;
+var RECLAIM_GRACE_MS = 3e4;
+var HANDLE_PATTERN = /^wc-[0-9a-f]{16}$/;
+var SWEEP_THRESHOLD = 200;
+async function shouldSweep(dir) {
+  try {
+    return (await readdir(dir)).length > SWEEP_THRESHOLD;
+  } catch {
+    return false;
+  }
+}
+function stateRoot(ctx) {
+  const configured = ctx?.config?.path();
+  if (configured) return resolve(configured, "..");
+  return process.env.WEAVER_WORK_CLI_HOME || process.env.WORK_CLI_HOME || resolve(homedir(), ".weaver-work-cli");
+}
+async function loadKey(ctx) {
+  const keysDir = resolve(stateRoot(ctx), "keys");
+  const filename = resolve(keysDir, "workflow-continuation.key");
+  await mkdir(keysDir, { recursive: true, mode: 448 });
+  if (existsSync(filename)) return readFile(filename);
+  const key = randomBytes(32);
+  try {
+    await writeFile(filename, key, { flag: "wx", mode: 384 });
+    if (process.platform !== "win32") await chmod(filename, 384).catch(() => void 0);
+    return key;
+  } catch {
+    return readFile(filename);
+  }
+}
+function signature(payload, key) {
+  return createHmac("sha256", key).update(payload).digest("base64url");
+}
+function referenceFingerprint(reference) {
+  return createHash("sha256").update(reference).digest("hex");
+}
+function pendingDir(ctx) {
+  return resolve(stateRoot(ctx), "state", "workflow", "continuation-pending");
+}
+function consumedDir(ctx) {
+  return resolve(stateRoot(ctx), "state", "workflow", "continuation-consumed");
+}
+async function sweepConsumed(dir) {
+  let names;
+  try {
+    names = await readdir(dir);
+  } catch {
+    return;
+  }
+  const now = Date.now();
+  for (const name of names) {
+    const file = resolve(dir, name);
+    try {
+      const content = await readFile(file, "utf8");
+      let expiresAt = Number(content);
+      if (!Number.isFinite(expiresAt)) {
+        try {
+          expiresAt = Number(JSON.parse(content)?.expiresAt);
+        } catch {
+        }
+      }
+      if (Number.isFinite(expiresAt) && expiresAt < now) await unlink(file);
+    } catch {
+    }
+  }
+}
+async function readConsumedMarker(ctx, reference) {
+  const file = resolve(consumedDir(ctx), referenceFingerprint(reference));
+  let raw;
+  try {
+    raw = await readFile(file, "utf8");
+  } catch {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+  } catch {
+  }
+  return { state: "unknown" };
+}
+function markerProcessAlive(marker) {
+  const pid = Number(marker.pid);
+  if (!Number.isFinite(pid) || pid <= 0) return true;
+  if (typeof marker.hostname === "string" && marker.hostname && marker.hostname !== hostname()) return true;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error?.code !== "ESRCH";
+  }
+}
+function replayOf(marker) {
+  let state = "unknown";
+  if (marker.state === "succeeded") {
+    state = "succeeded";
+  } else if (marker.state === "running") {
+    state = marker.stage === "claimed" ? "claimed" : marker.stage === "committed" ? "committed" : "saving";
+  }
+  const stage = marker.stage === "claimed" || marker.stage === "saving" || marker.stage === "committed" ? marker.stage : void 0;
+  return {
+    state,
+    ...stage ? { stage } : {},
+    ...typeof marker.operation === "string" ? { operation: marker.operation } : {},
+    ...Number.isFinite(Number(marker.consumedAt)) ? { consumedAt: Number(marker.consumedAt) } : {},
+    ...Number.isFinite(Number(marker.finishedAt)) ? { finishedAt: Number(marker.finishedAt) } : {},
+    ...typeof marker.requestId === "string" && marker.requestId ? { requestId: marker.requestId } : {},
+    ...state === "succeeded" ? { result: marker.result ?? null } : {}
+  };
+}
+function continuationReplayError(replay, expectedOperation) {
+  const operation = replay.operation ?? expectedOperation;
+  if (replay.state === "succeeded") {
+    return workflowAlreadyAppliedError(operation, replay);
+  }
+  if (replay.state === "committed") {
+    return workflowAlreadyAppliedError(operation, replay);
+  }
+  if (replay.state === "saving") {
+    const recovery = operation === "workflow.createForm" ? "\u8981\u91CD\u65B0\u53D1\u8D77\uFF0C\u8BF7**\u91CD\u65B0\u6267\u884C workflow.createForm \u83B7\u53D6\u65B0\u53E5\u67C4**\uFF08\u672C\u6B21\u53E5\u67C4\u5DF2\u6D88\u8D39\uFF0C\u91CD\u53D1\u540C\u4E00\u53E5\u67C4\u65E0\u6548\uFF09\u3002" : /Apply$/u.test(operation) ? "\u786E\u8BA4\u672A\u751F\u6548\u540E\uFF0C\u91CD\u8DD1\u5BF9\u5E94\u7684 Prepare \u83B7\u53D6\u65B0\u53E5\u67C4\u3002" : "\u8BE5\u547D\u4EE4\u6CA1\u6709\u53EF\u91CD\u8DD1\u7684 Prepare\uFF0C\u4E5F**\u4E0D\u8981\u539F\u6837\u91CD\u8DD1**\uFF1B\u8BF7\u628A\u7ED3\u679C\u5982\u5B9E\u544A\u77E5\u7528\u6237\u3002";
+    return workflowPartialError(
+      '\u8BE5 continuation \u5BF9\u5E94\u7684\u4E0A\u4E00\u6B21\u6267\u884C**\u5DF2\u7ECF\u53D1\u51FA\u5199\u5165\u8BF7\u6C42\uFF0C\u4F46\u7ED3\u679C\u672A\u786E\u8BA4**\uFF08\u8FDB\u7A0B\u88AB\u4E2D\u6B62\u6216\u56DE\u6267\u4E22\u5931\uFF09\uFF0C\u672C\u6B21\u672A\u6267\u884C\u3002**\u8BF7\u628A"\u4E0A\u4E00\u6B21\u7ED3\u679C\u672A\u786E\u8BA4"\u5982\u5B9E\u544A\u77E5\u7528\u6237\u5E76\u505C\u4E0B\uFF0C\u4E0D\u8981\u81EA\u884C\u7EE7\u7EED**\uFF08\u4E0D\u8981\u91CD\u8BD5\u3001\u4E0D\u8981\u6539\u7528\u5176\u5B83\u547D\u4EE4\u53CD\u590D\u63A8\u65AD\u3001\u4E0D\u8981\u66FF\u7528\u6237\u4E0B\u7ED3\u8BBA\uFF09\u3002' + recovery,
+      replay,
+      { stage: "continuation_replay", ...replay }
+    );
+  }
+  if (replay.state === "claimed") {
+    return workflowValidationError(
+      "continuation_busy",
+      "\u8BE5 continuation \u6B63\u88AB\u53E6\u4E00\u6B21\u6267\u884C\u5360\u7528\uFF08\u4E0A\u4E00\u6B21\u53EA\u62A2\u5230\u53E5\u67C4\u3001\u5C1A\u672A\u53D1\u51FA\u5199\u5165\u8BF7\u6C42\uFF09\uFF0C\u672C\u6B21\u672A\u6267\u884C\u3002\u8BF7\u7A0D\u540E\u91CD\u8BD5\u540C\u4E00\u6761\u547D\u4EE4\uFF1B\u82E5\u4E0A\u4E00\u6B21\u6267\u884C\u5176\u5B9E\u5DF2\u7ECF\u5B8C\u6210\uFF0C\u76F4\u63A5\u770B\u8FD4\u56DE\u7ED3\u679C\u5373\u53EF\u3002",
+      replay
+    );
+  }
+  return workflowValidationError(
+    "continuation_consumed",
+    "continuation \u5DF2\u4F7F\u7528\uFF08\u4E00\u6B21\u6027\uFF09\uFF0C\u7981\u6B62\u91CD\u590D\u63D0\u4EA4\u3002\u82E5\u6000\u7591\u4E0A\u4E00\u6B21\u6CA1\u751F\u6548\uFF0C\u8BF7\u5148\u53EA\u8BFB\u6838\u5BF9\u76EE\u6807\u6D41\u7A0B\u662F\u5426\u5DF2\u5B58\u5728\uFF08workflow.search --category done/mine --requestId <\u76EE\u6807ID>\uFF09\uFF0C\u786E\u8BA4\u672A\u751F\u6548\u518D\u91CD\u8DD1\u5BF9\u5E94\u7684 Prepare\u3002",
+    replay
+  );
+}
+async function sweepPending(dir) {
+  let names;
+  try {
+    names = await readdir(dir);
+  } catch {
+    return;
+  }
+  const now = Date.now();
+  for (const name of names) {
+    const file = resolve(dir, name);
+    try {
+      const value = JSON.parse(await readFile(file, "utf8"));
+      const expiresAt = Number(value?.expiresAt);
+      if (Number.isFinite(expiresAt) && expiresAt < now) await unlink(file);
+    } catch {
+    }
+  }
+}
+async function readPendingPayload(ctx, handle) {
+  let content;
+  try {
+    content = await readFile(resolve(pendingDir(ctx), handle), "utf8");
+  } catch {
+    throw workflowValidationError(
+      "continuation_expired",
+      "continuation \u5728\u672C\u673A\u72B6\u6001\u76EE\u5F55\u4E2D\u4E0D\u5B58\u5728\uFF08\u5DF2\u88AB\u4F7F\u7528\u3001\u5DF2\u8FC7\u671F\uFF0C\u6216\u4E0D\u662F\u672C\u673A\u7B7E\u53D1\u7684\u53E5\u67C4\uFF09\u3002\u8BF7\u91CD\u65B0\u6267\u884C\u5BF9\u5E94\u7684 Prepare \u547D\u4EE4\u540E\u518D apply\uFF0C\u4E0D\u8981\u590D\u7528\u65E7\u53E5\u67C4\u3002"
+    );
+  }
+  try {
+    return JSON.parse(content);
+  } catch {
+    throw workflowValidationError("continuation_invalid", "continuation \u672C\u673A\u8F7D\u8377\u65E0\u6CD5\u89E3\u6790\uFF0C\u8BF7\u91CD\u65B0\u6267\u884C\u5BF9\u5E94\u7684 Prepare \u547D\u4EE4");
+  }
+}
+async function verifyLegacyToken(ctx, token) {
+  const [body, provided] = token.split(".");
+  const expected = signature(body, await loadKey(ctx));
+  const valid = typeof provided === "string" && provided.length === expected.length && timingSafeEqual(Buffer.from(provided), Buffer.from(expected));
+  if (!valid) throw workflowValidationError("continuation_invalid", "continuation \u7B7E\u540D\u6821\u9A8C\u5931\u8D25");
+  try {
+    return JSON.parse(Buffer.from(body, "base64url").toString("utf8"));
+  } catch {
+    throw workflowValidationError("continuation_invalid", "continuation \u5185\u5BB9\u65E0\u6CD5\u89E3\u6790");
+  }
+}
+async function tryReclaim(ctx, reference, marker, record) {
+  const age = Date.now() - Number(marker.consumedAt);
+  const claimable = marker.state === "running" && marker.stage === "claimed";
+  if (!claimable || !Number.isFinite(age) || age < RECLAIM_GRACE_MS || markerProcessAlive(marker)) {
+    return replayOf(marker);
+  }
+  const file = resolve(consumedDir(ctx), referenceFingerprint(reference));
+  try {
+    await writeFile(file, JSON.stringify(record), { mode: 384 });
+  } catch {
+    return replayOf(marker);
+  }
+  const after = await readConsumedMarker(ctx, reference);
+  if (after && after.owner === record.owner) return null;
+  return replayOf(after ?? marker);
+}
+async function tryTakeoverExpiredWindow(ctx, reference, marker, record) {
+  const expiresAt = Number(marker.expiresAt);
+  if (!Number.isFinite(expiresAt) || expiresAt >= Date.now()) return false;
+  if (marker.state !== "succeeded") return false;
+  const file = resolve(consumedDir(ctx), referenceFingerprint(reference));
+  try {
+    await writeFile(file, JSON.stringify(record), { mode: 384 });
+  } catch {
+    return false;
+  }
+  const after = await readConsumedMarker(ctx, reference);
+  return Boolean(after && after.owner === record.owner);
+}
+function createWorkflowContinuationSigner(ctx) {
+  return {
+    async issue(payload, ttlMs = DEFAULT_TTL_MS) {
+      const issuedAt = Date.now();
+      const ttl = Number.isFinite(ttlMs) ? Math.trunc(ttlMs) : DEFAULT_TTL_MS;
+      const record = JSON.stringify({ ...payload, issuedAt, expiresAt: issuedAt + ttl });
+      const dir = pendingDir(ctx);
+      await mkdir(dir, { recursive: true, mode: 448 });
+      for (let attempt = 0; attempt < 5; attempt += 1) {
+        const handle = `wc-${randomBytes(8).toString("hex")}`;
+        try {
+          await writeFile(resolve(dir, handle), record, { flag: "wx", mode: 384 });
+          if (await shouldSweep(dir)) await sweepPending(dir);
+          return handle;
+        } catch (error) {
+          if (error?.code !== "EEXIST") {
+            throw workflowValidationError(
+              "continuation_unavailable",
+              `\u672C\u673A\u72B6\u6001\u76EE\u5F55\u4E0D\u53EF\u5199\uFF0C\u65E0\u6CD5\u6258\u7BA1 continuation\uFF1A${dir}`
+            );
+          }
+        }
+      }
+      throw workflowValidationError("continuation_unavailable", "\u7B7E\u53D1 continuation \u5931\u8D25\uFF08\u53E5\u67C4\u8FDE\u7EED\u51B2\u7A81\uFF09\uFF0C\u8BF7\u91CD\u8BD5");
+    },
+    async verify(reference, expectedOperation) {
+      if (typeof reference !== "string" || !reference.trim()) {
+        throw workflowValidationError("continuation_invalid", "continuation \u65E0\u6548\uFF08\u7F3A\u5C11\u5165\u53C2\uFF09");
+      }
+      const ref = reference.trim();
+      if (ref.startsWith("wc-") && !HANDLE_PATTERN.test(ref)) {
+        throw workflowValidationError(
+          "continuation_invalid",
+          "continuation \u53E5\u67C4\u683C\u5F0F\u65E0\u6548\uFF1A\u5FC5\u987B\u539F\u6837\u56DE\u4F20 Prepare \u8FD4\u56DE\u7684 wc-\u2026 \u503C\uFF0C\u7981\u6B62\u624B\u5DE5\u6784\u9020\u6216\u62FC\u63A5\u3002"
+        );
+      }
+      const marker = await readConsumedMarker(ctx, ref);
+      if (marker) {
+        const replay = replayOf(marker);
+        if (replay.state !== "claimed") throw continuationReplayError(replay, expectedOperation);
+      }
+      const handle = HANDLE_PATTERN.test(ref);
+      const value = handle ? await readPendingPayload(ctx, ref) : await verifyLegacyToken(ctx, ref);
+      if (value.operation !== expectedOperation) {
+        throw workflowValidationError("continuation_mismatch", "continuation \u4E0D\u5C5E\u4E8E\u5F53\u524D\u64CD\u4F5C");
+      }
+      if (!Number.isSafeInteger(value.expiresAt) || value.expiresAt < Date.now()) {
+        throw workflowValidationError("continuation_expired", "continuation \u5DF2\u8FC7\u671F");
+      }
+      return value;
+    },
+    async consume(reference, operation, ttlMs) {
+      if (typeof reference !== "string" || !reference.trim()) return { claimed: true };
+      const ref = reference.trim();
+      const handle = HANDLE_PATTERN.test(ref);
+      const window = Number.isFinite(ttlMs) && Number(ttlMs) > 0 ? Math.trunc(Number(ttlMs)) : 0;
+      let expiresAt = Date.now() + (window || DEFAULT_TTL_MS);
+      let prepared;
+      try {
+        const value = handle ? JSON.parse(await readFile(resolve(pendingDir(ctx), ref), "utf8")) : JSON.parse(Buffer.from(ref.split(".")[0], "base64url").toString("utf8"));
+        if (!window && Number.isSafeInteger(value.expiresAt)) expiresAt = value.expiresAt;
+        prepared = value.prepared;
+      } catch {
+      }
+      const dir = consumedDir(ctx);
+      const file = resolve(dir, referenceFingerprint(ref));
+      const record = {
+        state: "running",
+        stage: "claimed",
+        ...operation ? { operation } : {},
+        // owner/pid/hostname 只服务于"上一次死在写入之前"的安全重占判定（见 tryReclaim）。
+        owner: randomUUID(),
+        pid: process.pid,
+        hostname: hostname(),
+        consumedAt: Date.now(),
+        expiresAt,
+        ...prepared === void 0 ? {} : { prepared }
+      };
+      try {
+        await mkdir(dir, { recursive: true, mode: 448 });
+        await writeFile(file, JSON.stringify(record), { flag: "wx", mode: 384 });
+      } catch (error) {
+        if (error?.code === "EEXIST") {
+          const existing = await readConsumedMarker(ctx, ref);
+          if (!existing) return { claimed: false, previous: { state: "unknown" } };
+          if (window && await tryTakeoverExpiredWindow(ctx, ref, existing, record)) {
+            if (await shouldSweep(dir)) await sweepConsumed(dir);
+            return { claimed: true };
+          }
+          const blocker = await tryReclaim(ctx, ref, existing, record);
+          if (!blocker) return { claimed: true };
+          return { claimed: false, previous: blocker };
+        }
+      }
+      if (await shouldSweep(dir)) await sweepConsumed(dir);
+      return { claimed: true };
+    },
+    async markStage(reference, stage, extra) {
+      if (typeof reference !== "string" || !reference.trim()) return;
+      const file = resolve(consumedDir(ctx), referenceFingerprint(reference.trim()));
+      let raw;
+      try {
+        raw = await readFile(file, "utf8");
+      } catch {
+        return;
+      }
+      let marker;
+      try {
+        marker = JSON.parse(raw);
+      } catch {
+        return;
+      }
+      if (!marker || typeof marker !== "object" || Array.isArray(marker)) return;
+      try {
+        await writeFile(
+          file,
+          JSON.stringify({ ...marker, stage, ...extra ?? {} }),
+          { mode: 384 }
+        );
+      } catch {
+        throw workflowValidationError(
+          "continuation_unavailable",
+          "\u672C\u673A\u65E0\u6CD5\u8BB0\u5F55\u672C\u6B21\u5199\u5165\u7684\u8FDB\u5EA6\uFF08\u72B6\u6001\u76EE\u5F55\u4E0D\u53EF\u5199\uFF09\uFF0C\u4E3A\u907F\u514D\u7559\u4E0B\u65E0\u6CD5\u5224\u5B9A\u7ED3\u679C\u7684\u4E00\u6B21\u6027\u5199\u5165\uFF0C\u5DF2\u505C\u6B62\u672C\u6B21\u64CD\u4F5C\u3002"
+        );
+      }
+    },
+    async settle(reference, result, operation) {
+      if (typeof reference !== "string" || !reference.trim()) return;
+      const ref = reference.trim();
+      const file = resolve(consumedDir(ctx), referenceFingerprint(ref));
+      try {
+        const raw = await readFile(file, "utf8");
+        const marker = JSON.parse(raw);
+        if (marker && typeof marker === "object" && !Array.isArray(marker)) {
+          await writeFile(
+            file,
+            JSON.stringify({
+              ...marker,
+              state: "succeeded",
+              ...operation ? { operation } : {},
+              finishedAt: Date.now(),
+              result: result ?? null
+            }),
+            { mode: 384 }
+          );
+        }
+      } catch {
+      }
+    }
+  };
+}
+
+export {
+  continuationReplayError,
+  createWorkflowContinuationSigner
+};

package/dist/chunks/chunk-FMPJJYYI.js

@@ -0,0 +1,106 @@
+import { createRequire as __esbuildCreateRequire } from 'node:module';
+const require = __esbuildCreateRequire(import.meta.url);
+import {
+  CliError
+} from "./chunk-LUSPKZKY.js";
+
+// src/shortcuts/workflow/errors.ts
+var WorkflowCliError = class extends CliError {
+  type;
+  subtype;
+  code;
+  retryable;
+  stage;
+  details;
+  partialData;
+  constructor(type, subtype, message, options = {}) {
+    super(message, options.exitCode ?? 5 /* InternalError */);
+    this.name = "WorkflowCliError";
+    this.type = type;
+    this.subtype = subtype;
+    this.code = options.code;
+    this.retryable = options.retryable ?? false;
+    this.stage = options.stage;
+    this.details = options.details;
+    this.partialData = options.partialData;
+  }
+};
+function workflowValidationError(subtype, message, details) {
+  return new WorkflowCliError("validation", subtype, message, {
+    details,
+    exitCode: 2 /* UsageError */
+  });
+}
+function workflowAuthError(subtype, message, details) {
+  return new WorkflowCliError("authentication", subtype, message, {
+    details,
+    exitCode: 3 /* AuthError */
+  });
+}
+function workflowApiError(subtype, message, options = {}) {
+  return new WorkflowCliError("api", subtype, message, {
+    ...options,
+    exitCode: 1 /* GeneralError */
+  });
+}
+function workflowNetworkError(subtype, message, options = {}) {
+  return new WorkflowCliError("network", subtype, message, {
+    ...options,
+    retryable: options.retryable ?? true,
+    exitCode: 4 /* NetworkError */
+  });
+}
+function workflowConfirmationError(action, details) {
+  return new WorkflowCliError("confirmation", "required", "\u8BE5\u64CD\u4F5C\u9700\u8981\u660E\u786E\u786E\u8BA4", {
+    details: { action, ...details },
+    exitCode: 10 /* ConfirmationRequired */
+  });
+}
+function workflowPartialError(message, partialData, details) {
+  return new WorkflowCliError("partial", "write_uncertain", message, {
+    details,
+    partialData,
+    exitCode: 11 /* Partial */
+  });
+}
+function workflowAlreadyAppliedError(operation, details) {
+  return new WorkflowCliError(
+    "validation",
+    "continuation_already_applied",
+    `\u8BE5 continuation \u5DF2\u7ECF\u6267\u884C\u8FC7\u4E14\u5DF2\u6210\u529F\uFF08${operation}\uFF09\uFF0C\u672C\u6B21\u672A\u91CD\u590D\u5199\u5165\u3002\u8BF7\u4E0D\u8981\u91CD\u8DD1 Prepare\uFF0C\u4E5F\u4E0D\u8981\u518D\u6B21\u63D0\u4EA4\u2014\u2014\u5982\u9700\u786E\u8BA4\u7ED3\u679C\uFF0C\u76F4\u63A5\u770B\u672C\u6B21\u8FD4\u56DE\u7684\u4E0A\u4E00\u6B21\u6267\u884C\u7ED3\u679C\u3002`,
+    { details, exitCode: 2 /* UsageError */ }
+  );
+}
+function workflowPolicyError(subtype, message, details) {
+  return new WorkflowCliError("policy", subtype, message, {
+    details,
+    exitCode: 6 /* PolicyError */
+  });
+}
+var CLARIFICATION_SUBTYPE = "needs_clarification";
+function workflowClarificationError(clarificationType, keyword, question, candidates = [], extra = {}) {
+  return new WorkflowCliError("validation", CLARIFICATION_SUBTYPE, question, {
+    details: {
+      clarificationType,
+      clarificationKeyword: keyword,
+      clarificationQuestion: question,
+      candidates,
+      ...extra
+    },
+    exitCode: 2 /* UsageError */
+  });
+}
+
+export {
+  WorkflowCliError,
+  workflowValidationError,
+  workflowAuthError,
+  workflowApiError,
+  workflowNetworkError,
+  workflowConfirmationError,
+  workflowPartialError,
+  workflowAlreadyAppliedError,
+  workflowPolicyError,
+  CLARIFICATION_SUBTYPE,
+  workflowClarificationError
+};