gate-evm-tools 1.0.28 → 1.2.0

package/dist-runtime/vendor/plan-codec/index.cjs

@@ -0,0 +1,897 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key2 of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key2) && key2 !== except)
+        __defProp(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// builtin-skills/gateflow-plan/scripts/lib/read-only.mjs
+var read_only_exports = {};
+__export(read_only_exports, {
+  DEFINITION_CONTRACT: () => DEFINITION_CONTRACT,
+  FAILURE_CATEGORIES: () => FAILURE_CATEGORIES,
+  PlanError: () => PlanError,
+  SAFE_KEY: () => SAFE_KEY,
+  SCHEMA: () => SCHEMA,
+  SCHEMA_V1: () => SCHEMA_V1,
+  SKILL_NAME: () => SKILL_NAME,
+  TASK_STATUSES: () => TASK_STATUSES,
+  deploymentPurpose: () => deploymentPurpose,
+  deploymentRequirementIssue: () => deploymentRequirementIssue,
+  detectSchema: () => detectSchema,
+  parsePlan: () => parsePlan,
+  productionActionAllowed: () => productionActionAllowed,
+  projectDefinitions: () => projectDefinitions,
+  skillNames: () => skillNames,
+  toolRefs: () => toolRefs,
+  validateEvmContracts: () => validateEvmContracts
+});
+module.exports = __toCommonJS(read_only_exports);
+
+// builtin-skills/gateflow-plan/scripts/lib/evm-contract.mjs
+var PROJECT_FIELDS = ["chainFamily", "framework", "projectRoot", "templateProfile", "templateVersion", "mode"];
+var DEPLOYMENT_FIELDS = ["purpose", "chainFamily", "framework", "projectRoot", "deploymentId", "specPath", "sourceCodeRef", "requiredOperations", "developmentNetwork", "releaseTargetNetworks", "environment", "targetNetwork", "allowedActions", "releaseRef", "requirementRef", "productionRequirementRef", "referenceDeploymentId"];
+var ANALYSIS_STEPS = ["deployment-request", "deployment-plan", "script"];
+var STEP_ACTIONS = {
+  deploy: ["simulate", "execute", "reconcile", "verify"],
+  "check-code": ["verify"],
+  "deploy-test": ["simulate", "verify"],
+  "release-prepare": ["simulate"],
+  "release-execute": ["execute", "export-calldata", "reconcile"],
+  "release-verify": ["verify"]
+};
+var PURPOSE_ACTIONS = {
+  "dev-execution": ["simulate", "execute", "reconcile", "verify"],
+  "prod-qualification": ["simulate", "verify"],
+  "prod-execution": ["simulate", "execute", "export-calldata", "reconcile", "verify"]
+};
+function deploymentPurpose(task) {
+  const explicit = task.scope?.deployment?.purpose;
+  if (explicit !== void 0) return explicit;
+  if (ANALYSIS_STEPS.includes(task.step)) return "analysis";
+  if (["deploy", "check-code"].includes(task.step)) return "dev-execution";
+  if (task.step === "deploy-test") return "prod-qualification";
+  if (["release-prepare", "release-execute", "release-verify"].includes(task.step)) return "prod-execution";
+  return void 0;
+}
+function productionActionAllowed(task, intent) {
+  const d = task.scope?.deployment;
+  const action = intent === "prepare" ? "simulate" : intent;
+  return deploymentPurpose(task) === "prod-execution" && d?.environment === "prod" && !!d.releaseRef && Array.isArray(d.allowedActions) && d.allowedActions.includes(action);
+}
+var OPERATIONS = ["deploy", "upgrade", "call", "view", "check", "custom"];
+var isObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+function deploymentRequirementIssue(plan, task) {
+  const d = task.scope?.deployment;
+  if (!d || deploymentPurpose(task) === "analysis") return null;
+  const ref = d.requirementRef;
+  if (!ref) return "部署实施前必须引用本轮已确认的需求（requirementRef）";
+  const request = Object.values(plan.tasks).flat().find((t) => t.planKey === ref.planKey);
+  if (!request || request.status === "cancelled" || deploymentPurpose(request) !== "analysis" || request.scope?.deployment?.projectRoot !== d.projectRoot || request.rev !== ref.rev || request.requirementConfirmation?.rev !== ref.rev) return "本轮部署需求尚未确认或确认修订已失效";
+  const r = request.scope.deployment;
+  if (d.productionRequirementRef !== void 0) {
+    if (!["prod-qualification", "prod-execution"].includes(deploymentPurpose(task))) return "生产补充确认只用于 prod 资格或执行任务";
+    const extra = d.productionRequirementRef;
+    const production = Object.values(plan.tasks).flat().find((t) => t.planKey === extra.planKey);
+    const p = production?.scope?.deployment;
+    if (!production || production.status === "cancelled" || deploymentPurpose(production) !== "analysis" || production.rev !== extra.rev || production.requirementConfirmation?.rev !== extra.rev || p?.projectRoot !== d.projectRoot || p?.deploymentId !== d.deploymentId || JSON.stringify(p.requirementRef) !== JSON.stringify(ref)) return "本轮生产补充需求尚未确认或绑定已失效";
+    if (!task.dependsOn.includes(production.planKey)) return "生产任务必须依赖其补充需求确认任务";
+    if (p.developmentNetwork !== r.developmentNetwork || d.developmentNetwork !== r.developmentNetwork || p.sourceCodeRef !== d.sourceCodeRef || JSON.stringify(p.releaseTargetNetworks) !== JSON.stringify(d.releaseTargetNetworks) || !d.requiredOperations?.every((operation) => p.requiredOperations?.includes(operation) && r.requiredOperations?.includes(operation))) return "生产补充需求只能扩充 prod 网络与参数，不能改变原部署动作或源码";
+    return null;
+  }
+  if (r.developmentNetwork !== d.developmentNetwork || JSON.stringify(r.releaseTargetNetworks) !== JSON.stringify(d.releaseTargetNetworks) || !d.requiredOperations?.every((operation) => r.requiredOperations?.includes(operation))) return "部署动作或网络超出本轮确认范围";
+  return null;
+}
+function validateEvmContracts(plan, fail3) {
+  const releases = /* @__PURE__ */ new Map();
+  const projects = /* @__PURE__ */ new Map();
+  const requirementRounds = /* @__PURE__ */ new Map();
+  const roundRequirements = /* @__PURE__ */ new Map();
+  const object = (value, where, fields) => {
+    if (!isObject(value)) fail3(`${where} 必须是对象`);
+    for (const field of Object.keys(value)) if (!fields.includes(field)) fail3(`${where}.${field} 是未知字段`);
+    return value;
+  };
+  const text = (value, where) => {
+    if (typeof value !== "string" || !value.trim()) fail3(`${where} 必须是非空字符串`);
+    return value;
+  };
+  const identifier = (value, where, network = false) => {
+    const id = text(value, where);
+    const pattern = network ? /^[A-Za-z0-9][A-Za-z0-9._-]*$/ : /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
+    if (!pattern.test(id) || Object.hasOwn(Object.prototype, id) || id === "prototype") fail3(`${where} 必须是安全标识符`);
+    return id;
+  };
+  const relativePath = (value, where, root = false) => {
+    const path = text(value, where);
+    if (root && path === ".") return path;
+    if (path !== path.trim() || /[\\\0]/.test(path) || /^(?:\/|~\/|[a-z][a-z0-9+.-]*:)/i.test(path) || path.split("/").some((part) => !part || part === "." || part === "..")) {
+      fail3(`${where} 必须是无穿越的相对 POSIX 路径`);
+    }
+    return path;
+  };
+  const strings = (value, where, allowed, min = 0) => {
+    if (!Array.isArray(value) || value.length < min) fail3(`${where} 必须是至少 ${min} 项的数组`);
+    for (const item of value) {
+      text(item, where);
+      if (allowed && !allowed.includes(item)) fail3(`${where} 不允许 ${item}`);
+    }
+    if (new Set(value).size !== value.length) fail3(`${where} 不能重复`);
+  };
+  const identity = (value, where) => {
+    if (value.chainFamily !== "evm") fail3(`${where}.chainFamily 必须是 evm`);
+    if (value.framework !== "hardhat2") fail3(`${where}.framework 必须是 hardhat2`);
+    relativePath(value.projectRoot, `${where}.projectRoot`, true);
+  };
+  for (const [laneId, tasks] of Object.entries(plan.tasks)) {
+    const lane = plan.lanes[laneId];
+    const evmProject = plan.flow === "contract-delivery@3" || ["contract-development-lane", "gateflow-project-evm"].includes(lane?.skill?.split("@")[0] ?? "");
+    const newDeployment = plan.flow === "contract-delivery@3" && laneId === "deployment" || lane?.skill?.split("@")[0] === "gateflow-deploy-evm";
+    for (const task of tasks) {
+      const where = `任务 ${task.planKey}.scope`;
+      const project = task.scope?.project;
+      const explicitEvmProject = isObject(project) && project.chainFamily === "evm";
+      if (explicitEvmProject || evmProject && (project !== void 0 || task.step === "project-setup")) {
+        const p = object(project, `${where}.project`, PROJECT_FIELDS);
+        identity(p, `${where}.project`);
+        if (p.templateProfile !== "full") fail3(`${where}.project.templateProfile 必须是 full`);
+        if (p.templateVersion !== 1) fail3(`${where}.project.templateVersion 必须是 1`);
+        if (!["create", "resume"].includes(p.mode)) fail3(`${where}.project.mode 必须是 create 或 resume`);
+        const metadata2 = JSON.stringify([p.chainFamily, p.framework, p.templateProfile, p.templateVersion]);
+        const previous2 = projects.get(p.projectRoot);
+        if (previous2 && previous2 !== metadata2) fail3(`${where}.project 与同一 projectRoot 的模板身份不一致`);
+        projects.set(p.projectRoot, metadata2);
+      }
+      if (task.scope?.deployment === void 0 && !newDeployment) continue;
+      const w = `${where}.deployment`;
+      const d = object(task.scope?.deployment, w, DEPLOYMENT_FIELDS);
+      identity(d, w);
+      const initialAnalysis = d.purpose === "analysis" || d.purpose === void 0 && task.step === "deployment-request";
+      if (!initialAnalysis || d.deploymentId !== void 0) identifier(d.deploymentId, `${w}.deploymentId`);
+      if (!initialAnalysis || d.specPath !== void 0) relativePath(d.specPath, `${w}.specPath`);
+      if (!initialAnalysis || d.sourceCodeRef !== void 0) text(d.sourceCodeRef, `${w}.sourceCodeRef`);
+      if (!initialAnalysis || d.requiredOperations !== void 0) strings(d.requiredOperations, `${w}.requiredOperations`, OPERATIONS, 1);
+      if (!initialAnalysis || d.developmentNetwork !== void 0) identifier(d.developmentNetwork, `${w}.developmentNetwork`, true);
+      if (!initialAnalysis || d.releaseTargetNetworks !== void 0) strings(d.releaseTargetNetworks, `${w}.releaseTargetNetworks`);
+      for (const network of d.releaseTargetNetworks ?? []) identifier(network, `${w}.releaseTargetNetworks`, true);
+      if (d.referenceDeploymentId !== void 0) identifier(d.referenceDeploymentId, `${w}.referenceDeploymentId`);
+      for (const field of ["requirementRef", "productionRequirementRef"]) if (d[field] !== void 0) {
+        const ref2 = object(d[field], `${w}.${field}`, ["planKey", "rev"]);
+        identifier(ref2.planKey, `${w}.${field}.planKey`);
+        if (!Number.isSafeInteger(ref2.rev) || ref2.rev < 1) fail3(`${w}.${field}.rev 必须是正整数`);
+      }
+      const purpose = deploymentPurpose(task);
+      if (d.productionRequirementRef !== void 0 && !["prod-qualification", "prod-execution"].includes(purpose)) fail3(`${w}.productionRequirementRef 只用于 prod 任务`);
+      if (!["analysis", ...Object.keys(PURPOSE_ACTIONS)].includes(purpose)) fail3(`${w} 不支持步骤 ${task.step}；purpose 必须明确部署用途`);
+      if (purpose === "analysis") {
+        for (const field of ["environment", "targetNetwork", "allowedActions", "releaseRef"]) {
+          if (d[field] !== void 0) fail3(`${w}.${field} 只能用于执行任务`);
+        }
+        continue;
+      }
+      const actions = d.purpose === void 0 ? STEP_ACTIONS[task.step] : PURPOSE_ACTIONS[purpose];
+      const environment = purpose === "dev-execution" ? "dev" : "prod";
+      if (d.environment !== environment) fail3(`${w}.environment 在 ${task.step} 中必须是 ${environment}`);
+      identifier(d.targetNetwork, `${w}.targetNetwork`, true);
+      if (environment === "dev" ? d.targetNetwork !== d.developmentNetwork : !d.releaseTargetNetworks.includes(d.targetNetwork)) {
+        fail3(`${w}.targetNetwork 与已声明的 ${environment} 网络不一致`);
+      }
+      strings(d.allowedActions, `${w}.allowedActions`, actions, 1);
+      if (purpose !== "prod-execution") {
+        if (d.releaseRef !== void 0) fail3(`${w}.releaseRef 只用于正式发布任务`);
+        continue;
+      }
+      const ref = object(d.releaseRef, `${w}.releaseRef`, ["path", "releaseId", "inputsHash"]);
+      relativePath(ref.path, `${w}.releaseRef.path`);
+      identifier(ref.releaseId, `${w}.releaseRef.releaseId`);
+      if (typeof ref.inputsHash !== "string" || !/^[a-f0-9]{64}$/.test(ref.inputsHash)) fail3(`${w}.releaseRef.inputsHash 必须是 64 位小写十六进制`);
+      const releaseKey = JSON.stringify([d.projectRoot, ref.releaseId]);
+      const metadata = JSON.stringify([d.deploymentId, d.specPath, d.sourceCodeRef, d.developmentNetwork, [...d.releaseTargetNetworks].sort(), ref.path, ref.inputsHash]);
+      const previous = releases.get(releaseKey);
+      if (previous && previous !== metadata) fail3(`${w}.releaseRef 与同一发布的任务身份不一致`);
+      releases.set(releaseKey, metadata);
+    }
+  }
+  for (const task of Object.values(plan.tasks).flat()) {
+    const d = task.scope?.deployment;
+    if (!d?.requirementRef || deploymentPurpose(task) === "analysis") continue;
+    const requirement = JSON.stringify([d.projectRoot, d.requirementRef.planKey, d.requirementRef.rev]);
+    const round = JSON.stringify([d.projectRoot, d.deploymentId]);
+    const existingRound = requirementRounds.get(requirement);
+    if (existingRound !== void 0 && existingRound !== d.deploymentId) fail3(`任务 ${task.planKey}.scope.deployment 同一需求修订必须复用 deploymentId=${existingRound}，不能因脚本准备、模拟或执行阶段另建部署轮次`);
+    const existingRequirement = roundRequirements.get(round);
+    if (existingRequirement !== void 0 && existingRequirement !== requirement) fail3(`任务 ${task.planKey}.scope.deployment 同一 deploymentId 必须引用同一需求修订；新业务轮次使用新 deploymentId`);
+    requirementRounds.set(requirement, d.deploymentId);
+    roundRequirements.set(round, requirement);
+  }
+}
+
+// builtin-skills/gateflow-plan/scripts/lib/yaml-lite.mjs
+var YamlLiteError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "YamlLiteError";
+  }
+};
+var fail = (message, line) => {
+  throw new YamlLiteError(line ? `line ${line}: ${message}` : message);
+};
+var put = (object, key2, value) => Object.defineProperty(object, key2, {
+  value,
+  enumerable: true,
+  configurable: true,
+  writable: true
+});
+function stripComment(raw) {
+  let quote = null;
+  for (let i = 0; i < raw.length; i++) {
+    const c = raw[i];
+    if (quote) {
+      if (c === "\\" && quote === '"') i++;
+      else if (c === quote) quote = null;
+    } else if (c === '"' || c === "'") {
+      quote = c;
+    } else if (c === "#" && (i === 0 || /\s/.test(raw[i - 1]))) {
+      return raw.slice(0, i);
+    }
+  }
+  return raw;
+}
+function scalar(text, line) {
+  const s = text.trim();
+  if (s === "" || s === "~" || s === "null") return null;
+  if (s === "true") return true;
+  if (s === "false") return false;
+  if (/^-?\d+$/.test(s)) return Number(s);
+  if (/^-?\d+\.\d+$/.test(s)) return Number(s);
+  if (/^[&*!|>%@`]/.test(s)) fail(`unsupported YAML syntax: ${s}`, line);
+  return s;
+}
+function parseFlow(text, line) {
+  let i = 0;
+  const ws = () => {
+    while (i < text.length && /\s/.test(text[i])) i++;
+  };
+  const quoted = () => {
+    const q = text[i];
+    if (q === '"') {
+      let j2 = i + 1;
+      while (j2 < text.length && text[j2] !== '"') j2 += text[j2] === "\\" ? 2 : 1;
+      if (j2 >= text.length) fail("unterminated string", line);
+      const value2 = JSON.parse(text.slice(i, j2 + 1));
+      i = j2 + 1;
+      return value2;
+    }
+    let out = "";
+    let j = i + 1;
+    for (; ; ) {
+      if (j >= text.length) fail("unterminated string", line);
+      if (text[j] === "'") {
+        if (text[j + 1] === "'") {
+          out += "'";
+          j += 2;
+          continue;
+        }
+        break;
+      }
+      out += text[j++];
+    }
+    i = j + 1;
+    return out;
+  };
+  const plain = (stops) => {
+    const start = i;
+    while (i < text.length && !stops.includes(text[i])) {
+      if (text[i] === ":" && stops.includes(":")) break;
+      i++;
+    }
+    return text.slice(start, i);
+  };
+  const value = (inFlow) => {
+    ws();
+    const c = text[i];
+    if (c === "{") {
+      i++;
+      const out = {};
+      ws();
+      if (text[i] === "}") {
+        i++;
+        return out;
+      }
+      for (; ; ) {
+        ws();
+        const key2 = text[i] === '"' || text[i] === "'" ? quoted() : plain([":", ",", "}"]).trim();
+        ws();
+        if (text[i] !== ":") fail(`expected ":" after "${key2}"`, line);
+        i++;
+        if (!key2) fail("empty key in flow mapping", line);
+        if (Object.hasOwn(out, key2)) fail(`duplicate key "${key2}"`, line);
+        put(out, key2, value(true));
+        ws();
+        if (text[i] === ",") {
+          i++;
+          continue;
+        }
+        if (text[i] === "}") {
+          i++;
+          return out;
+        }
+        fail('expected "," or "}" in flow mapping', line);
+      }
+    }
+    if (c === "[") {
+      i++;
+      const out = [];
+      ws();
+      if (text[i] === "]") {
+        i++;
+        return out;
+      }
+      for (; ; ) {
+        out.push(value(true));
+        ws();
+        if (text[i] === ",") {
+          i++;
+          continue;
+        }
+        if (text[i] === "]") {
+          i++;
+          return out;
+        }
+        fail('expected "," or "]" in flow sequence', line);
+      }
+    }
+    if (c === '"' || c === "'") return quoted();
+    if (!inFlow) {
+      const rest = text.slice(i);
+      i = text.length;
+      return scalar(rest, line);
+    }
+    return scalar(plain([",", "}", "]"]), line);
+  };
+  const result = value(false);
+  ws();
+  if (i < text.length) fail(`unexpected trailing text: ${text.slice(i)}`, line);
+  return result;
+}
+function splitKey(text, line) {
+  let key2;
+  let rest;
+  if (text.startsWith('"')) {
+    let j = 1;
+    while (j < text.length && text[j] !== '"') j += text[j] === "\\" ? 2 : 1;
+    key2 = JSON.parse(text.slice(0, j + 1));
+    rest = text.slice(j + 1);
+    if (!rest.startsWith(":")) fail('expected ":" after key', line);
+    rest = rest.slice(1);
+  } else {
+    const m = text.match(/^([^\s:{}[\],"'#][^:]*?):(?:\s+|$)(.*)$/);
+    if (!m) return null;
+    key2 = m[1];
+    rest = m[2];
+  }
+  if (rest && !/^\s/.test(rest) && text.startsWith('"')) fail('expected space after ":"', line);
+  return { key: key2, rest: rest.trim() };
+}
+function parseYaml(source) {
+  const lines = [];
+  source.split("\n").forEach((raw, index) => {
+    const text = stripComment(raw.replace(/\r$/, ""));
+    if (!text.trim()) return;
+    const lead = text.match(/^[ \t]*/)[0];
+    if (lead.includes("	")) fail("tabs are not allowed for indentation", index + 1);
+    lines.push({ indent: lead.length, text: text.trim(), no: index + 1 });
+  });
+  if (lines.length === 0) return null;
+  let pos = 0;
+  const isItem = (l) => l.text === "-" || l.text.startsWith("- ");
+  const block = (indent) => isItem(lines[pos]) ? seq(indent) : map(indent);
+  const map = (indent) => {
+    const out = {};
+    while (pos < lines.length && lines[pos].indent === indent && !isItem(lines[pos])) {
+      const l = lines[pos];
+      const kv = splitKey(l.text, l.no);
+      if (!kv) fail(`expected "key: value", got: ${l.text}`, l.no);
+      if (Object.hasOwn(out, kv.key)) fail(`duplicate key "${kv.key}"`, l.no);
+      pos++;
+      if (kv.rest !== "") {
+        put(out, kv.key, parseFlow(kv.rest, l.no));
+      } else if (pos < lines.length && lines[pos].indent > indent) {
+        put(out, kv.key, block(lines[pos].indent));
+      } else if (pos < lines.length && lines[pos].indent === indent && isItem(lines[pos])) {
+        put(out, kv.key, seq(indent));
+      } else {
+        put(out, kv.key, null);
+      }
+    }
+    if (pos < lines.length && lines[pos].indent > indent) fail("bad indentation", lines[pos].no);
+    return out;
+  };
+  const seq = (indent) => {
+    const out = [];
+    while (pos < lines.length && lines[pos].indent === indent && isItem(lines[pos])) {
+      const l = lines[pos];
+      const after = l.text === "-" ? "" : l.text.slice(1);
+      const rest = after.trimStart();
+      pos++;
+      if (rest === "") {
+        out.push(pos < lines.length && lines[pos].indent > indent ? block(lines[pos].indent) : null);
+      } else if (!/^[{["']/.test(rest) && splitKey(rest, l.no)) {
+        const column = indent + 1 + (after.length - rest.length);
+        lines.splice(pos, 0, { indent: column, text: rest, no: l.no });
+        out.push(map(column));
+      } else {
+        out.push(parseFlow(rest, l.no));
+      }
+    }
+    if (pos < lines.length && lines[pos].indent > indent) fail("bad indentation", lines[pos].no);
+    return out;
+  };
+  const result = block(lines[0].indent);
+  if (pos < lines.length) fail("unexpected content", lines[pos].no);
+  return result;
+}
+
+// builtin-skills/gateflow-plan/scripts/lib/handoff-v2.mjs
+var SCHEMA = "gateflow-plan/v2";
+var SCHEMA_V1 = "gateflow-plan/v1";
+var SAFE_KEY = /^[a-z0-9][a-z0-9-]{0,199}$/;
+var TASK_STATUSES = ["pending", "running", "blocked", "completed", "failed", "cancelled"];
+var FAILURE_CATEGORIES = ["execution_error", "acceptance_failed", "review_rejected", "input_missing"];
+var CONTRACT_FIELDS = ["objective", "acceptance", "dependsOn", "step", "scope", "parameters", "expectedArtifacts", "allowedChanges"];
+var TOOL_FIELDS = ["tools", "toolsOptional", "skills"];
+var DEF_FIELDS = [...CONTRACT_FIELDS, ...TOOL_FIELDS, "executionNotes"];
+var PROGRESS_FIELDS = ["status", "adoptedRev", "blockedReason", "cancelReason", "result", "previousResult", "requirementConfirmation"];
+var TASK_ORDER = ["no", "planKey", "rev", "title", ...DEF_FIELDS, ...PROGRESS_FIELDS];
+var PlanError = class extends Error {
+  constructor(message, code = "invalid") {
+    super(message);
+    this.name = "PlanError";
+    this.code = code;
+  }
+};
+var fail2 = (message, code) => {
+  throw new PlanError(message, code);
+};
+var FORBIDDEN_FIELDS = [
+  "sessionid",
+  "runtimerunid",
+  "stageid",
+  "attemptid",
+  "workspacepath",
+  "authorizationid",
+  "executionlock",
+  "localstate",
+  "planid",
+  "workspacerelativepath",
+  "executionintent",
+  "parameteroverrides",
+  "credentials",
+  "credential",
+  "privatekey",
+  "mnemonic",
+  "secret",
+  "secretkey",
+  "password",
+  "accesstoken",
+  "apikey",
+  "signer",
+  "localsigner",
+  "signerbinding",
+  "signeraddress",
+  "walletbinding",
+  "authorization",
+  "authbinding",
+  "lockid",
+  "runtimebindings",
+  "executionlockid",
+  "runtimebinding",
+  "signerconfig",
+  "walletid",
+  "authorizationref",
+  "simulationlock",
+  "keystore"
+];
+var ABSOLUTE = /^(?:\/|\\|[A-Za-z]:[\\/]|~\/)/;
+var normalizeFieldName = (key2) => key2.replace(/[_-]/g, "").toLowerCase();
+function assertPortable(value, where) {
+  if (typeof value === "string") {
+    if (ABSOLUTE.test(value)) fail2(`${where} 不能是绝对路径`);
+    if (/-----BEGIN .*PRIVATE KEY-----/.test(value)) fail2(`${where} 不能包含私钥`);
+    if (/\bBearer\s+\S+/.test(value)) fail2(`${where} 不能包含 bearer token`);
+    if (/[a-z][a-z0-9+.-]*:\/\/[^\s/@]+:[^\s/@]+@/i.test(value)) fail2(`${where} 不能包含带凭证的 URL`);
+    if (/[?&](?:api[_-]?key|token|secret)=\S+/i.test(value)) fail2(`${where} 不能包含带凭证的 URL`);
+    return;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((item, i) => assertPortable(item, `${where}[${i}]`));
+    return;
+  }
+  if (!value || typeof value !== "object") return;
+  for (const [key2, child] of Object.entries(value)) {
+    if (FORBIDDEN_FIELDS.includes(normalizeFieldName(key2))) fail2(`${where}.${key2} 是本地绑定字段，不能写进 handoff`);
+    assertPortable(child, `${where}.${key2}`);
+  }
+}
+var isObject2 = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+var str = (v, where) => {
+  if (typeof v !== "string" || !v.trim()) fail2(`${where} 必须是非空字符串`);
+  return v;
+};
+var key = (v, where) => {
+  str(v, where);
+  if (!SAFE_KEY.test(v)) fail2(`${where} 只能用小写字母、数字和连字符："${v}"`);
+  return v;
+};
+var strArray = (v, where, min = 0) => {
+  if (!Array.isArray(v)) fail2(`${where} 必须是数组`);
+  v.forEach((item, i) => str(item, `${where}[${i}]`));
+  if (v.length < min) fail2(`${where} 至少需要 ${min} 项`);
+  return v;
+};
+var posInt = (v, where, min = 1) => {
+  if (!Number.isInteger(v) || v < min) fail2(`${where} 必须是 ≥${min} 的整数`);
+  return v;
+};
+function parseEvidence(v, where) {
+  if (v === void 0) return void 0;
+  if (!Array.isArray(v)) fail2(`${where} 必须是数组`);
+  return v.map((e, i) => {
+    if (!isObject2(e)) fail2(`${where}[${i}] 必须是 { kind, ref }`);
+    return { kind: str(e.kind, `${where}[${i}].kind`), ref: str(e.ref, `${where}[${i}].ref`) };
+  });
+}
+function parseResult(v, where) {
+  if (v === void 0 || v === null) return void 0;
+  if (!isObject2(v)) fail2(`${where} 必须是对象`);
+  if (v.kind === "success") {
+    const out = { kind: "success", summary: str(v.summary, `${where}.summary`) };
+    const evidence = parseEvidence(v.evidence, `${where}.evidence`);
+    if (evidence) out.evidence = evidence;
+    if (v.codeRef !== void 0) out.codeRef = str(v.codeRef, `${where}.codeRef`);
+    return out;
+  }
+  if (v.kind === "failure") {
+    if (!FAILURE_CATEGORIES.includes(v.category)) fail2(`${where}.category 必须是 ${FAILURE_CATEGORIES.join(" / ")}`);
+    const out = { kind: "failure", category: v.category, message: str(v.message, `${where}.message`) };
+    const evidence = parseEvidence(v.evidence, `${where}.evidence`);
+    if (evidence) out.evidence = evidence;
+    if (v.suggestion !== void 0) out.suggestion = str(v.suggestion, `${where}.suggestion`);
+    if (v.codeRef !== void 0) out.codeRef = str(v.codeRef, `${where}.codeRef`);
+    return out;
+  }
+  fail2(`${where}.kind 必须是 success 或 failure`);
+}
+var TOOL_REF = /^(?:plugin:[A-Za-z0-9][A-Za-z0-9._-]{0,99}|mcp:[A-Za-z0-9][A-Za-z0-9._-]{0,99}(?:\/[A-Za-z0-9][A-Za-z0-9._-]{0,99})?|host:[A-Za-z0-9][A-Za-z0-9._-]{0,99})$/;
+function toolRefs(v, where) {
+  const refs = strArray(v, where);
+  refs.forEach((ref, i) => {
+    if (!TOOL_REF.test(ref)) fail2(`${where}[${i}] 不是有效的工具引用："${ref}"（plugin:<id>、mcp:<服务器>[/<工具>] 或 host:<本机 Codex 的 MCP>）`);
+  });
+  if (new Set(refs).size !== refs.length) fail2(`${where} 有重复的工具`);
+  return refs;
+}
+var SKILL_NAME = /^(?:[A-Za-z0-9][A-Za-z0-9._-]{0,99}|local:(?:codex|pi):[A-Za-z0-9][A-Za-z0-9._-]{0,99}:[a-f0-9]{24})$/;
+function skillNames(v, where) {
+  const names = strArray(v, where);
+  names.forEach((name, i) => {
+    if (!SKILL_NAME.test(name)) fail2(`${where}[${i}] 不是有效的 skill 名称："${name}"（skill 目录名或完整的 local: 来源引用）`);
+  });
+  if (new Set(names).size !== names.length) fail2(`${where} 有重复的 skill`);
+  return names;
+}
+function parseTaskDef(raw, where) {
+  const t = {
+    planKey: key(raw.planKey, `${where}.planKey`),
+    title: str(raw.title, `${where}.title`),
+    objective: str(raw.objective, `${where}.objective`),
+    acceptance: strArray(raw.acceptance, `${where}.acceptance`, 1),
+    dependsOn: raw.dependsOn === void 0 ? [] : strArray(raw.dependsOn, `${where}.dependsOn`)
+  };
+  if (raw.step !== void 0) t.step = key(raw.step, `${where}.step`);
+  if (raw.scope !== void 0) {
+    if (!isObject2(raw.scope)) fail2(`${where}.scope 必须是对象`);
+    t.scope = raw.scope;
+  }
+  if (raw.parameters !== void 0) {
+    if (!Array.isArray(raw.parameters)) fail2(`${where}.parameters 必须是数组`);
+    t.parameters = raw.parameters;
+  }
+  if (raw.expectedArtifacts !== void 0) t.expectedArtifacts = strArray(raw.expectedArtifacts, `${where}.expectedArtifacts`);
+  if (raw.executionNotes !== void 0) t.executionNotes = strArray(raw.executionNotes, `${where}.executionNotes`);
+  if (raw.allowedChanges !== void 0) t.allowedChanges = strArray(raw.allowedChanges, `${where}.allowedChanges`);
+  if (raw.tools !== void 0) t.tools = toolRefs(raw.tools, `${where}.tools`);
+  if (raw.toolsOptional !== void 0) t.toolsOptional = toolRefs(raw.toolsOptional, `${where}.toolsOptional`);
+  for (const ref of t.toolsOptional ?? []) if (t.tools?.includes(ref)) fail2(`${where} 的 ${ref} 同时出现在 tools 和 toolsOptional 里`);
+  if (raw.skills !== void 0) t.skills = skillNames(raw.skills, `${where}.skills`);
+  return t;
+}
+function parseTask(raw, where) {
+  if (!isObject2(raw)) fail2(`${where} 必须是对象`);
+  assertPortable(raw, where);
+  const known = new Set(TASK_ORDER);
+  for (const k of Object.keys(raw)) if (!known.has(k)) fail2(`${where} 有未知字段 "${k}"${["steps", "currentStep", "stepStatus"].includes(k) ? "；可能是旧版多步骤任务，请由规划运行 plan migrate --json 预览格式迁移（不会自动写入）" : ""}`);
+  const t = parseTaskDef(raw, where);
+  t.rev = posInt(raw.rev, `${where}.rev`);
+  t.no = posInt(raw.no, `${where}.no`);
+  t.status = raw.status ?? "pending";
+  if (!TASK_STATUSES.includes(t.status)) fail2(`${where}.status 必须是 ${TASK_STATUSES.join(" / ")}`);
+  if (raw.adoptedRev !== void 0 && raw.adoptedRev !== null) {
+    t.adoptedRev = posInt(raw.adoptedRev, `${where}.adoptedRev`);
+    if (t.adoptedRev > t.rev) fail2(`${where}.adoptedRev 不能大于 rev`);
+  }
+  if (raw.blockedReason !== void 0) t.blockedReason = str(raw.blockedReason, `${where}.blockedReason`);
+  if (raw.cancelReason !== void 0) t.cancelReason = str(raw.cancelReason, `${where}.cancelReason`);
+  if (raw.requirementConfirmation !== void 0) {
+    const c = raw.requirementConfirmation;
+    if (!isObject2(c) || Object.keys(c).some((k) => !["rev", "confirmedAt"].includes(k))) fail2(`${where}.requirementConfirmation 无效`);
+    t.requirementConfirmation = { rev: posInt(c.rev, `${where}.requirementConfirmation.rev`), confirmedAt: str(c.confirmedAt, `${where}.requirementConfirmation.confirmedAt`) };
+    if (c.rev > t.rev || !Number.isFinite(Date.parse(c.confirmedAt))) fail2(`${where}.requirementConfirmation 修订或时间无效`);
+  }
+  const result = parseResult(raw.result, `${where}.result`);
+  if (result) t.result = result;
+  const previous = parseResult(raw.previousResult, `${where}.previousResult`);
+  if (previous) t.previousResult = previous;
+  if (t.status === "running" && t.adoptedRev === void 0) fail2(`${where} 状态为 running 但没有 adoptedRev`);
+  if (t.status === "blocked" && !t.blockedReason) fail2(`${where} 状态为 blocked 时必须有 blockedReason`);
+  if (t.status === "cancelled" && !t.cancelReason) fail2(`${where} 状态为 cancelled 时必须有 cancelReason`);
+  if (t.status === "completed" && t.result?.kind !== "success") fail2(`${where} 状态为 completed 时 result 必须是 success`);
+  if (t.status === "failed" && t.result?.kind !== "failure") fail2(`${where} 状态为 failed 时 result 必须是 failure`);
+  return t;
+}
+function parseLane(raw, id) {
+  const where = `lanes.${id}`;
+  key(id, `lane id "${id}"`);
+  if (!isObject2(raw)) fail2(`${where} 必须是对象`);
+  const lane = { name: str(raw.name, `${where}.name`) };
+  if (raw.state !== "enabled" && raw.state !== "disabled") fail2(`${where}.state 必须是 enabled 或 disabled`);
+  lane.state = raw.state;
+  if (lane.state === "disabled") {
+    lane.reason = str(raw.reason, `${where}.reason`);
+  } else if (raw.reason !== void 0) {
+    lane.reason = str(raw.reason, `${where}.reason`);
+  }
+  if (raw.skill !== void 0) lane.skill = str(raw.skill, `${where}.skill`);
+  if (raw.steps !== void 0 || lane.state === "enabled" && lane.skill) {
+    if (!Array.isArray(raw.steps) || raw.steps.length === 0) fail2(`${where}.steps 至少需要一个步骤`);
+    const seen = /* @__PURE__ */ new Set();
+    lane.steps = raw.steps.map((s, i) => {
+      if (!isObject2(s)) fail2(`${where}.steps[${i}] 必须是 { id, name }`);
+      const id2 = key(s.id, `${where}.steps[${i}].id`);
+      if (seen.has(id2)) fail2(`${where}.steps 有重复的步骤 id "${id2}"`);
+      seen.add(id2);
+      return { id: id2, name: str(s.name, `${where}.steps[${i}].name`) };
+    });
+  }
+  return lane;
+}
+function validatePlan(plan) {
+  validateEvmContracts(plan, fail2);
+  const laneIds = Object.keys(plan.lanes);
+  if (!laneIds.some((id) => plan.lanes[id].state === "enabled")) fail2("至少要启用一条链路");
+  const byKey = /* @__PURE__ */ new Map();
+  for (const id of laneIds) {
+    const lane = plan.lanes[id];
+    const tasks = plan.tasks[id] ?? [];
+    if (lane.state === "disabled" && tasks.some((t) => t.status !== "cancelled")) {
+      fail2(`链路 ${id} 已关闭，但还有未取消的任务；先 cancel 这些任务`);
+    }
+    if (lane.state === "enabled" && tasks.length === 0) fail2(`链路 ${id} 已启用但没有任务；不需要就关闭它并写明 reason`);
+    const stepIds = new Set((lane.steps ?? []).map((s) => s.id));
+    for (const t of tasks) {
+      if (byKey.has(t.planKey)) fail2(`planKey 重复："${t.planKey}"`);
+      byKey.set(t.planKey, { task: t, lane: id });
+      if (!lane.steps?.length) {
+        if (t.step !== void 0) fail2(`任务 ${t.planKey} 写了步骤 "${t.step}"，但链路 ${id} 没有定义步骤`);
+      } else if (t.step === void 0) {
+        fail2(`任务 ${t.planKey} 缺少 step：链路 ${id} 的任务要写明属于哪个步骤（${[...stepIds].join(" / ")}）`);
+      } else if (!stepIds.has(t.step)) fail2(`任务 ${t.planKey} 的步骤 "${t.step}" 不在链路 ${id} 的步骤里`);
+    }
+  }
+  for (const id of Object.keys(plan.tasks)) if (!Object.hasOwn(plan.lanes, id)) fail2(`任务所在的链路 "${id}" 没有在 lanes 里定义`);
+  if (byKey.size === 0) fail2("计划里没有任何任务");
+  const numbers = /* @__PURE__ */ new Map();
+  for (const { task } of byKey.values()) {
+    if (numbers.has(task.no)) fail2(`任务编号 #${task.no} 重复：${numbers.get(task.no)} 和 ${task.planKey}`);
+    numbers.set(task.no, task.planKey);
+  }
+  for (const { task } of byKey.values()) {
+    for (const dep of task.dependsOn) {
+      if (dep === task.planKey) fail2(`任务 ${task.planKey} 依赖了自己`);
+      const d = byKey.get(dep);
+      if (!d) fail2(`任务 ${task.planKey} 依赖了不存在的任务 "${dep}"`);
+      if (d.task.no > task.no && task.status !== "cancelled") fail2(`任务 ${task.planKey}（#${task.no}）依赖排在它后面的 ${dep}（#${d.task.no}）；调整顺序时依赖必须排在前面`);
+      if (d.task.status === "cancelled" && task.status !== "cancelled") {
+        fail2(`任务 ${task.planKey} 依赖已取消的任务 ${dep}；先修改它的 dependsOn 或一并取消`);
+      }
+    }
+  }
+  const state = /* @__PURE__ */ new Map();
+  const visit = (k, trail) => {
+    if (state.get(k) === "done") return;
+    if (state.get(k) === "visiting") fail2(`依赖成环：${[...trail, k].join(" -> ")}`);
+    state.set(k, "visiting");
+    for (const dep of byKey.get(k).task.dependsOn) visit(dep, [...trail, k]);
+    state.set(k, "done");
+  };
+  for (const k of byKey.keys()) visit(k, []);
+  return plan;
+}
+var FRONTMATTER = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/;
+var BLOCK = /```(gateflow-task|gateflow-progress)\r?\n([\s\S]*?)\r?\n```/g;
+var HEADING = /^## (.+)$/gm;
+function detectSchema(text) {
+  const m = text.match(FRONTMATTER);
+  if (!m) return null;
+  const s = m[1].match(/^schema:\s*["']?([^"'\s]+)/m);
+  return s ? s[1] : null;
+}
+function parsePlan(text) {
+  const m = text.match(FRONTMATTER);
+  if (!m) fail2("缺少 YAML frontmatter");
+  let meta;
+  try {
+    meta = parseYaml(m[1]);
+  } catch (e) {
+    fail2(`frontmatter 不是合法的 YAML：${e.message}`);
+  }
+  if (!isObject2(meta)) fail2("frontmatter 必须是映射");
+  assertPortable(meta, "frontmatter");
+  if (meta.schema === SCHEMA_V1) fail2("这是 gateflow-plan/v1 文件；v2 命令不直接修改 v1，请先由规划重新生成 v2 计划", "v1");
+  if (meta.schema !== SCHEMA) fail2(`schema 必须是 "${SCHEMA}"`);
+  const plan = {
+    schema: SCHEMA,
+    taskId: key(meta.taskId, "frontmatter.taskId"),
+    title: str(meta.title, "frontmatter.title"),
+    revision: posInt(meta.revision, "frontmatter.revision"),
+    progressSeq: posInt(meta.progressSeq ?? 0, "frontmatter.progressSeq", 0),
+    updatedAt: str(meta.updatedAt, "frontmatter.updatedAt"),
+    lanes: {},
+    goal: "",
+    notes: {},
+    tasks: {},
+    history: []
+  };
+  if (meta.flow !== void 0 && meta.flow !== null) plan.flow = str(meta.flow, "frontmatter.flow");
+  if (!isObject2(meta.lanes) || Object.keys(meta.lanes).length === 0) fail2("frontmatter.lanes 至少需要一条链路");
+  for (const [id, raw] of Object.entries(meta.lanes)) plan.lanes[id] = parseLane(raw, id);
+  const body = text.slice(m[0].length);
+  const headings = [...body.matchAll(HEADING)];
+  const seenLanes = /* @__PURE__ */ new Set();
+  headings.forEach((h, i) => {
+    const name = h[1].trim();
+    const start = h.index + h[0].length;
+    const end = i + 1 < headings.length ? headings[i + 1].index : body.length;
+    const chunk = body.slice(start, end);
+    const blocks = [...chunk.matchAll(BLOCK)];
+    const prose = chunk.replace(BLOCK, "").trim();
+    if (name.startsWith("目标")) {
+      plan.goal = prose;
+      return;
+    }
+    if (name.startsWith("看板")) return;
+    if (name.startsWith("进度")) {
+      const p = blocks.find((b) => b[1] === "gateflow-progress");
+      if (!p) return;
+      let value;
+      try {
+        value = JSON.parse(p[2]);
+      } catch (e) {
+        fail2(`进度块不是合法的 JSON：${e.message}`);
+      }
+      assertPortable(value, "进度");
+      if (value.history !== void 0 && !Array.isArray(value.history)) fail2("进度.history 必须是数组");
+      plan.history = value.history ?? [];
+      return;
+    }
+    if (!Object.hasOwn(plan.lanes, name)) fail2(`未知的二级标题 "## ${name}"；链路标题必须是 lanes 里定义的 id`);
+    if (seenLanes.has(name)) fail2(`链路标题 "## ${name}" 出现了不止一次`);
+    seenLanes.add(name);
+    if (blocks.some((b) => b[1] !== "gateflow-task")) fail2(`链路 ${name} 下只能放 gateflow-task 块`);
+    plan.tasks[name] = blocks.map((b, j) => {
+      let value;
+      try {
+        value = JSON.parse(b[2]);
+      } catch (e) {
+        fail2(`链路 ${name} 第 ${j + 1} 个任务不是合法的 JSON：${e.message}`);
+      }
+      return parseTask(value, `链路 ${name} 任务 ${j + 1}`);
+    });
+    const note = prose.replace(/^disabled$/m, "").trim();
+    if (note) plan.notes[name] = note;
+  });
+  for (const id of Object.keys(plan.lanes)) {
+    if (!seenLanes.has(id)) fail2(`缺少链路标题 "## ${id}"`);
+  }
+  return validatePlan(plan);
+}
+
+// builtin-skills/gateflow-plan/scripts/lib/read-only.mjs
+var DEFINITION_CONTRACT = "gateflow-plan/definition@1";
+function freeze(value) {
+  if (value && typeof value === "object") {
+    Object.values(value).forEach(freeze);
+    Object.freeze(value);
+  }
+  return value;
+}
+function canonical(value) {
+  if (typeof value === "number" && !Number.isFinite(value)) throw new PlanError("Definition numbers must be finite");
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  if (value && typeof value === "object") return `{${Object.keys(value).sort().map((key2) => `${JSON.stringify(key2)}:${canonical(value[key2])}`).join(",")}}`;
+  return JSON.stringify(value);
+}
+function projectDefinitions(text, selection) {
+  if (typeof text !== "string") throw new PlanError("Definition projection requires handoff text");
+  if (!selection || !["upstream", "full"].includes(selection.mode)) throw new PlanError("Definition mode must be upstream or full");
+  if (!Array.isArray(selection.roots) || !selection.roots.length || selection.roots.some((root) => typeof root !== "string")) throw new PlanError("Definition roots must be a nonempty array of planKeys");
+  const roots = [...new Set(selection.roots)].sort();
+  const plan = parsePlan(text);
+  const line = Object.entries(plan.tasks).flatMap(([lane, tasks2]) => tasks2.map((task) => ({ lane, task }))).sort((a, b) => a.task.no - b.task.no);
+  const byKey = new Map(line.map((entry) => [entry.task.planKey, entry]));
+  const selected = /* @__PURE__ */ new Set();
+  const visit = (key2) => {
+    if (selected.has(key2)) return;
+    const entry = byKey.get(key2);
+    if (!entry) throw new PlanError(`Definition root/dependency missing: ${key2}`);
+    if (selection.mode === "upstream" && deploymentPurpose(entry.task) === "prod-execution") throw new PlanError(`Upstream definitions cannot include generated release task: ${key2}`);
+    selected.add(key2);
+    entry.task.dependsOn.forEach(visit);
+    const requirement = entry.task.scope?.deployment?.requirementRef;
+    if (requirement) visit(requirement.planKey);
+  };
+  roots.forEach(visit);
+  const entries = line.filter(({ task }) => selected.has(task.planKey));
+  const lanes = Object.fromEntries([...new Set(entries.map((entry) => entry.lane))].map((id) => {
+    const lane = plan.lanes[id];
+    return [id, { state: lane.state, ...lane.skill !== void 0 ? { skill: lane.skill } : {}, steps: (lane.steps ?? []).map((step) => step.id) }];
+  }));
+  const tasks = entries.map(({ lane, task }) => ({
+    lane,
+    planKey: task.planKey,
+    rev: task.rev,
+    ...Object.fromEntries(CONTRACT_FIELDS.filter((field) => Object.hasOwn(task, field)).map((field) => [field, task[field]]))
+  }));
+  const snapshot = freeze({
+    contract: DEFINITION_CONTRACT,
+    schema: plan.schema,
+    taskId: plan.taskId,
+    ...plan.flow !== void 0 ? { flow: plan.flow } : {},
+    roots,
+    lanes,
+    tasks
+  });
+  return Object.freeze({ snapshot, bytes: canonical(snapshot) });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFINITION_CONTRACT,
+  FAILURE_CATEGORIES,
+  PlanError,
+  SAFE_KEY,
+  SCHEMA,
+  SCHEMA_V1,
+  SKILL_NAME,
+  TASK_STATUSES,
+  deploymentPurpose,
+  deploymentRequirementIssue,
+  detectSchema,
+  parsePlan,
+  productionActionAllowed,
+  projectDefinitions,
+  skillNames,
+  toolRefs,
+  validateEvmContracts
+});