cli-blueprint 7.0.33 → 7.0.34

package/blueprint-bridge.mjs

@@ -0,0 +1,137 @@
+import { createHash } from "node:crypto";
+import { BLUEPRINT_OPERATION_INPUTS, blueprintSchemaFindings } from "./blueprint-schema.mjs";
+import { buildBlueprintMachineTasks } from "./blueprint-task-graph.mjs";
+
+const BP_RESPONSE_SCHEMA = "blueprint.skill.response/1.0";
+const BP_REQUEST_SCHEMA = "blueprint.skill.request/1.0";
+const BP_MANIFEST = "ARTIFACT-MANIFEST.json";
+const BP_IR_ARTIFACT = "PROJECT-BLUEPRINT.json";
+const BP_REPORT_MODE = "caller-supplied-test-evidence";
+const blueprintDigest = (value) => createHash("sha256").update(value).digest("hex");
+const blueprintSummary = (findings) => ({
+  p0: findings.filter((item) => item.severity === "P0").length,
+  p1: findings.filter((item) => item.severity === "P1").length,
+  p2: findings.filter((item) => item.severity === "P2").length,
+  p3: findings.filter((item) => item.severity === "P3").length, total: findings.length,
+});
+function bridgeFinding(ruleId, entityRef, message, evidence = {}) {
+  return { ruleId, severity: "P0", entityRef, message, evidence,
+    recommendedAction: "Provide the current compiled Blueprint hash and actual evidence for every criterion." };
+}
+function blueprintBlocked(request, findings) {
+  return { schemaVersion: BP_RESPONSE_SCHEMA, requestId: request.requestId, status: "blocked",
+    brainMode: null, requestedBrainMode: "ide", brainUsed: false, revision: null,
+    validation: { valid: false, guarantee: "blocked", findings, summary: blueprintSummary(findings) },
+    artifacts: [], questions: [], findingSummary: blueprintSummary(findings) };
+}
+function blueprintJsonArtifact(role, name, value) {
+  const content = `${JSON.stringify(value, null, 2)}\n`;
+  return { role, name, mediaType: "application/json", sha256: `sha256:${blueprintDigest(content)}`, content };
+}
+function compiledBlueprint(result) {
+  const artifacts = result.artifacts.filter((artifact) => artifact.name === BP_IR_ARTIFACT);
+  if (artifacts.length !== 1) throw new Error("Blueprint compiler must return exactly one IR artifact.");
+  const artifact = artifacts[0];
+  if (artifact.sha256 !== `sha256:${blueprintDigest(artifact.content)}`) throw new Error("Compiled Blueprint artifact digest mismatch.");
+  return { blueprint: JSON.parse(artifact.content), blueprintSha256: artifact.sha256 };
+}
+function addBlueprintMachineArtifact(result) {
+  const { blueprint, blueprintSha256 } = compiledBlueprint(result);
+  const machineTasks = buildBlueprintMachineTasks(blueprint, blueprintSha256, blueprintDigest);
+  const taskArtifact = blueprintJsonArtifact("implementation-tasks-json", "IMPLEMENTATION-TASKS.json", machineTasks);
+  const manifests = result.artifacts.filter((artifact) => artifact.name === BP_MANIFEST);
+  if (manifests.length !== 1) throw new Error("Blueprint compiler must return exactly one artifact manifest.");
+  const manifest = JSON.parse(manifests[0].content);
+  const { content, ...entry } = taskArtifact;
+  manifest.artifacts.push(entry);
+  const manifestArtifact = blueprintJsonArtifact(manifests[0].role, BP_MANIFEST, manifest);
+  return { ...result, machineTasks, artifacts: [...result.artifacts.filter((artifact) => artifact.name !== BP_MANIFEST),
+    taskArtifact, manifestArtifact] };
+}
+function criterionEvidenceFindings(results, expectedIds) {
+  const findings = [], seen = new Set();
+  results.forEach((result, index) => {
+    const entityRef = `input.results[${index}]`;
+    if (!expectedIds.has(result.criterionId)) findings.push(bridgeFinding("ACCEPTANCE_UNKNOWN_CRITERION", entityRef, "Unknown criterionId.", { criterionId: result.criterionId }));
+    if (seen.has(result.criterionId)) findings.push(bridgeFinding("ACCEPTANCE_DUPLICATE_CRITERION", entityRef, "A criterion must have exactly one result.", { criterionId: result.criterionId }));
+    seen.add(result.criterionId);
+    const evidenceIds = new Set();
+    result.evidence.forEach((evidence) => {
+      if (evidenceIds.has(evidence.evidenceId)) findings.push(bridgeFinding("ACCEPTANCE_DUPLICATE_EVIDENCE", entityRef, "Duplicate evidenceId within a criterion.", { evidenceId: evidence.evidenceId }));
+      evidenceIds.add(evidence.evidenceId);
+    });
+  });
+  return findings;
+}
+function reconcileBlueprintAcceptance(request, compiled) {
+  const { blueprint, blueprintSha256 } = compiledBlueprint(compiled);
+  const input = request.input, expectedIds = new Set(blueprint.acceptanceCriteria.map((criterion) => criterion.id));
+  const findings = criterionEvidenceFindings(input.results, expectedIds);
+  if (input.blueprintSha256 !== blueprintSha256) findings.push(bridgeFinding("ACCEPTANCE_BLUEPRINT_HASH", "input.blueprintSha256",
+    "The report does not reference this exact compiled Blueprint.", { expected: blueprintSha256, received: input.blueprintSha256 }));
+  const criteria = blueprint.acceptanceCriteria.map((criterion) => {
+    const matches = input.results.filter((result) => result.criterionId === criterion.id);
+    const evidence = matches.length === 1 ? matches[0].evidence : [];
+    const status = matches.length === 0 || evidence.length === 0 ? "missing"
+      : matches.length !== 1 || evidence.some((item) => item.exitCode !== 0) ? "failed" : "passed";
+    if (status !== "passed") findings.push(bridgeFinding("ACCEPTANCE_EVIDENCE_REQUIRED", `criteria.${criterion.id}`,
+      "Each criterion requires a unique result with nonempty, successful TestEvidence.", { criterionId: criterion.id, status }));
+    return { criterionId: criterion.id, statement: criterion.statement, nodeRefs: criterion.nodeRefs, status, evidence };
+  });
+  const passed = findings.length === 0;
+  const acceptanceReport = { schemaVersion: "blueprint.acceptance-report/1.0", blueprintId: blueprint.blueprintId,
+    revision: blueprint.revision, blueprintSha256, passed, verificationMode: BP_REPORT_MODE, executionVerified: false,
+    criteria, summary: { total: criteria.length, passed: criteria.filter((item) => item.status === "passed").length,
+      failed: criteria.filter((item) => item.status === "failed").length, missing: criteria.filter((item) => item.status === "missing").length },
+    findings };
+  return { ...compiled, status: passed ? "succeeded" : "blocked", acceptanceReport,
+    validation: { valid: passed, guarantee: passed ? "reported-evidence-structurally-verified" : "blocked", findings, summary: blueprintSummary(findings) },
+    artifacts: [blueprintJsonArtifact("acceptance-report", "ACCEPTANCE-REPORT.json", acceptanceReport)],
+    findingSummary: blueprintSummary(findings) };
+}
+function blueprintOperationCatalog(result) {
+  const known = new Map(result.operationSchemas.map((schema) => [schema.operation, schema]));
+  const operationSchemas = Object.entries(BLUEPRINT_OPERATION_INPUTS).map(([operation, inputSchema]) => {
+    if (operation === "acceptance-report") return { operation,
+      summary: "Recompile the referenced IR and reconcile every criterion with caller-supplied TestEvidence.",
+      input: inputSchema, inputSchema };
+    const original = known.get(operation);
+    if (!original) throw new Error(`Hermes capability is missing: ${operation}`);
+    return { ...original, input: inputSchema, inputSchema };
+  });
+  return { ...result, operationSchemas, capabilities: { ...result.capabilities,
+    operations: Object.keys(BLUEPRINT_OPERATION_INPUTS), machineTaskSchema: "swarm.project/1.0",
+    acceptanceReportSchema: "blueprint.acceptance-report/1.0", acceptanceEvidenceMode: BP_REPORT_MODE,
+    localRunnerOperations: [] } };
+}
+function blueprintEnvelopeFindings(request) {
+  if (!request || typeof request !== "object" || Array.isArray(request)) return [bridgeFinding("BLUEPRINT_REQUEST", "request", "Request must be an object.")];
+  const findings = [];
+  if (request.schemaVersion !== BP_REQUEST_SCHEMA) findings.push(bridgeFinding("BLUEPRINT_REQUEST_SCHEMA", "schemaVersion", "Unsupported request schema."));
+  if (typeof request.requestId !== "string" || !request.requestId.trim()) findings.push(bridgeFinding("BLUEPRINT_REQUEST_ID", "requestId", "requestId must be a nonempty string."));
+  if (typeof request.operation !== "string" || !Object.hasOwn(BLUEPRINT_OPERATION_INPUTS, request.operation)) findings.push(bridgeFinding("BLUEPRINT_OPERATION_UNSUPPORTED", "operation", "Unsupported public operation."));
+  return findings;
+}
+export function createBlueprintRuntime(coreRun) {
+  return async function runBlueprint(request, runtimeOptions) {
+    const envelopeFindings = blueprintEnvelopeFindings(request);
+    if (envelopeFindings.length) return blueprintBlocked(
+      { requestId: typeof request?.requestId === "string" ? request.requestId : null }, envelopeFindings);
+    const inputFindings = blueprintSchemaFindings(request.input, BLUEPRINT_OPERATION_INPUTS[request.operation]);
+    if (inputFindings.length) return blueprintBlocked(request, inputFindings);
+    if (request.operation === "acceptance-report") {
+      const compiled = await coreRun({ ...request, operation: "compile-inline", input: { blueprint: request.input.blueprint } }, runtimeOptions);
+      if (compiled.status !== "succeeded" || compiled.validation?.valid !== true) return compiled;
+      return reconcileBlueprintAcceptance(request, compiled);
+    }
+    const result = await coreRun(request, runtimeOptions);
+    if (result.status !== "succeeded") return result;
+    if (request.operation === "capabilities") return blueprintOperationCatalog(result);
+    if (request.operation === "help") {
+      const catalog = blueprintOperationCatalog({ ...result, operationSchemas: result.help.operations, capabilities: {} });
+      return { ...result, operationSchemas: catalog.operationSchemas, help: { ...result.help, operations: catalog.operationSchemas } };
+    }
+    if (request.operation === "compile-inline" && result.validation?.valid === true) return addBlueprintMachineArtifact(result);
+    return result;
+  };
+}

package/blueprint-schema.mjs

@@ -0,0 +1,81 @@
+// Public operation schemas supplement, and never replace, Hermes IR semantic validation.
+const bpString = { type: "string", minLength: 1, pattern: "\\S" };
+const bpArray = (items, minItems = 0) => ({ type: "array", items, minItems });
+const bpObject = (properties, required = Object.keys(properties), additionalProperties = false) =>
+  ({ type: "object", properties, required, additionalProperties });
+const bpRefs = bpArray(bpString);
+const bpPort = bpObject({ name: bpString, exposed: { type: "boolean" } }, ["name"], true);
+const bpNode = bpObject({
+  id: bpString, title: bpString, moduleId: bpString, entry: { type: "boolean" },
+  inputs: bpArray(bpPort), outputs: bpArray(bpPort), requirementRefs: bpRefs,
+}, ["id", "title", "moduleId", "inputs", "outputs"], true);
+const bpEdge = bpObject({
+  id: bpString, fromNodeId: bpString, toNodeId: bpString,
+  type: { enum: ["data", "control", "success", "error", "trace", "event", "approval", "recovery", "audit", "optional", "compensation"] },
+  fromOutput: bpString, toInput: bpString, allowCycle: { type: "boolean" }, loopGuard: bpString,
+  loopLimit: bpObject({ maxIterations: { type: "integer", minimum: 1 } }, ["maxIterations"], true),
+}, ["id", "fromNodeId", "toNodeId", "type"], true);
+export const BLUEPRINT_IR_INPUT_SCHEMA = bpObject({
+  schemaVersion: { const: "blueprint.ir/1.0" }, blueprintId: bpString, title: bpString,
+  revision: { type: "integer", minimum: 0 }, entryNodeId: bpString,
+  baseline: bpObject({ summary: bpString, facts: bpArray(bpObject({
+    id: bpString, statement: bpString,
+    status: { enum: ["confirmed", "inferred", "defaulted", "unknown", "conflicted", "rejected"] },
+  }, ["id", "statement", "status"], true)) }, ["summary", "facts"], true),
+  domains: bpArray(bpObject({ id: bpString, name: bpString, summary: bpString }, ["id", "name"], true)),
+  modules: bpArray(bpObject({ id: bpString, domainId: bpString, name: bpString }, ["id", "domainId", "name"], true)),
+  nodes: bpArray(bpNode, 1), edges: bpArray(bpEdge),
+  acceptanceCriteria: bpArray(bpObject({ id: bpString, statement: bpString, nodeRefs: bpRefs }, ["id", "statement", "nodeRefs"], true), 1),
+}, undefined, true);
+export const BLUEPRINT_EVIDENCE_SCHEMA = bpObject({
+  schemaVersion: { const: "cli.tax.test-evidence/1.0" }, evidenceId: bpString,
+  kind: { enum: ["test", "build", "lint", "security", "benchmark"] },
+  runner: { enum: ["local", "trusted-runner"] }, command: bpString, exitCode: { type: "integer" },
+  durationMs: { type: "number", minimum: 0 }, summary: bpString,
+  artifactSha256: { type: "string", pattern: "^[0-9a-f]{64}$" },
+}, ["schemaVersion", "evidenceId", "kind", "runner", "command", "exitCode", "durationMs", "summary"], true);
+const bpEmptyInput = bpObject({});
+const bpCompileInput = bpObject({ blueprint: BLUEPRINT_IR_INPUT_SCHEMA });
+export const BLUEPRINT_OPERATION_INPUTS = Object.freeze({
+  capabilities: bpEmptyInput, help: bpEmptyInput, intake: bpEmptyInput,
+  validate: bpCompileInput, "compile-inline": bpCompileInput,
+  "acceptance-report": bpObject({
+    blueprint: BLUEPRINT_IR_INPUT_SCHEMA,
+    blueprintSha256: { type: "string", pattern: "^sha256:[0-9a-f]{64}$" },
+    results: bpArray(bpObject({ criterionId: bpString, evidence: bpArray(BLUEPRINT_EVIDENCE_SCHEMA) })),
+  }),
+});
+export function blueprintSchemaFindings(value, schema, path = "input") {
+  const findings = [];
+  const reject = (message) => findings.push({
+    severity: "P0", ruleId: "BLUEPRINT_INPUT_SCHEMA", entityRef: path, message,
+    evidence: {}, recommendedAction: "Follow this operation's published inputSchema.",
+  });
+  const object = value !== null && typeof value === "object" && !Array.isArray(value);
+  const matches = !schema.type || (schema.type === "object" ? object
+    : schema.type === "array" ? Array.isArray(value)
+      : schema.type === "integer" ? Number.isInteger(value)
+        : typeof value === schema.type && (schema.type !== "number" || Number.isFinite(value)));
+  if (!matches) { reject(`Expected ${schema.type}.`); return findings; }
+  if (Object.hasOwn(schema, "const") && value !== schema.const) reject(`Expected ${schema.const}.`);
+  if (schema.enum && !schema.enum.includes(value)) reject("Value is not in the supported enum.");
+  if (typeof value === "string") {
+    if (schema.minLength !== undefined && value.length < schema.minLength) reject("String is too short.");
+    if (schema.pattern && !new RegExp(schema.pattern).test(value)) reject("String does not match the required pattern.");
+  }
+  if (typeof value === "number" && schema.minimum !== undefined && value < schema.minimum) reject("Number is below the minimum.");
+  if (Array.isArray(value)) {
+    if (schema.minItems !== undefined && value.length < schema.minItems) reject("Array has too few items.");
+    if (schema.items) value.forEach((item, index) => findings.push(...blueprintSchemaFindings(item, schema.items, `${path}[${index}]`)));
+  }
+  if (object) {
+    if (schema.required) for (const key of schema.required) {
+      if (!Object.hasOwn(value, key)) findings.push(...blueprintSchemaFindings(undefined, schema.properties[key], `${path}.${key}`));
+    }
+    for (const [key, item] of Object.entries(value)) {
+      if (schema.properties && Object.hasOwn(schema.properties, key)) findings.push(...blueprintSchemaFindings(item, schema.properties[key], `${path}.${key}`));
+      else if (schema.additionalProperties === false) reject(`Unsupported property: ${key}.`);
+    }
+  }
+  return findings;
+}

package/blueprint-task-graph.mjs

@@ -0,0 +1,68 @@
+// Condense all IR edge types into an acyclic implementation dependency graph.
+function blueprintComponents(nodes, edges) {
+  const ids = nodes.map((node) => node.id).sort();
+  const forward = new Map(ids.map((id) => [id, []]));
+  const reverse = new Map(ids.map((id) => [id, []]));
+  for (const edge of edges) {
+    forward.get(edge.fromNodeId).push(edge.toNodeId);
+    reverse.get(edge.toNodeId).push(edge.fromNodeId);
+  }
+  const seen = new Set(), finish = [];
+  for (const id of ids) {
+    if (seen.has(id)) continue;
+    const stack = [{ id, expanded: false }];
+    while (stack.length) {
+      const current = stack.pop();
+      if (current.expanded) { finish.push(current.id); continue; }
+      if (seen.has(current.id)) continue;
+      seen.add(current.id);
+      stack.push({ id: current.id, expanded: true });
+      for (const next of forward.get(current.id)) if (!seen.has(next)) stack.push({ id: next, expanded: false });
+    }
+  }
+  const assigned = new Set(), components = [];
+  for (const id of finish.reverse()) {
+    if (assigned.has(id)) continue;
+    const component = [], stack = [id];
+    while (stack.length) {
+      const current = stack.pop();
+      if (assigned.has(current)) continue;
+      assigned.add(current); component.push(current);
+      for (const next of reverse.get(current)) if (!assigned.has(next)) stack.push(next);
+    }
+    components.push(component.sort());
+  }
+  return components.sort((left, right) => left[0] < right[0] ? -1 : left[0] > right[0] ? 1 : 0);
+}
+export function buildBlueprintMachineTasks(blueprint, blueprintSha256, digest) {
+  const components = blueprintComponents(blueprint.nodes, blueprint.edges);
+  const nodeById = new Map(blueprint.nodes.map((node) => [node.id, node]));
+  const nodeTaskIds = new Map(), taskIds = new Set();
+  const tasks = components.map((nodeRefs) => {
+    const taskId = `bp-${digest(JSON.stringify(nodeRefs)).slice(0, 40)}`;
+    if (taskIds.has(taskId)) throw new Error("Blueprint task identifier collision.");
+    taskIds.add(taskId);
+    nodeRefs.forEach((nodeId) => nodeTaskIds.set(nodeId, taskId));
+    return { taskId, title: nodeRefs.map((id) => nodeById.get(id).title).join(" / "),
+      status: "backlog", owner: null, dependsOn: [], nodeRefs,
+      acceptanceRefs: blueprint.acceptanceCriteria.filter((criterion) =>
+        criterion.nodeRefs.some((id) => nodeRefs.includes(id))).map((criterion) => criterion.id).sort(),
+      internalEdgeRefs: blueprint.edges.filter((edge) => nodeRefs.includes(edge.fromNodeId)
+        && nodeRefs.includes(edge.toNodeId)).map((edge) => edge.id).sort() };
+  });
+  const byId = new Map(tasks.map((task) => [task.taskId, task]));
+  for (const edge of blueprint.edges) {
+    const from = nodeTaskIds.get(edge.fromNodeId), to = nodeTaskIds.get(edge.toNodeId);
+    if (from !== to) byId.get(to).dependsOn.push(from);
+  }
+  for (const task of tasks) task.dependsOn = [...new Set(task.dependsOn)].sort();
+  return {
+    schemaVersion: "swarm.project/1.0", blueprintId: blueprint.blueprintId, revision: blueprint.revision,
+    blueprintSha256, entryTaskId: nodeTaskIds.get(blueprint.entryNodeId),
+    dependencyModel: "all-ir-edges-condensed", tasks,
+    acceptanceCriteria: blueprint.acceptanceCriteria.map((criterion) => ({
+      criterionId: criterion.id, statement: criterion.statement, nodeRefs: [...criterion.nodeRefs].sort(),
+      taskRefs: [...new Set(criterion.nodeRefs.map((id) => nodeTaskIds.get(id)))].sort(),
+    })).sort((left, right) => left.criterionId < right.criterionId ? -1 : left.criterionId > right.criterionId ? 1 : 0),
+  };
+}

package/package.json

@@ -9,7 +9,10 @@
     "broker.mjs",
     "README.md",
     "skill/SKILL.md",
-    "skill/skill.json"
+    "skill/skill.json",
+    "blueprint-schema.mjs",
+    "blueprint-task-graph.mjs",
+    "blueprint-bridge.mjs"
   ],
   "license": "UNLICENSED",
   "name": "cli-blueprint",
@@ -18,5 +21,5 @@
     "url": "https://github.com/88208555/blueprint-clitax.git"
   },
   "type": "module",
-  "version": "7.0.33"
+  "version": "7.0.34"
 }

package/skill/SKILL.md

@@ -5,7 +5,7 @@ description: '把一个目标编译为可执行、可验证、可追溯的工程
 
 # Blueprint Skill
 
-Package version: v7.0.33
+Package version: v7.0.34
 
 远端 Hermes 编译器版本：0.4.0（独立于 npm 包版本）
 
@@ -34,7 +34,8 @@ POST JSON to the endpoint with an `input` wrapper:
 - `help`: return the usage guide, operation catalog, and request examples.
 - `intake`: return the questions the IDE must ask the user before building the Blueprint.
 - `validate`: deterministically validate a Blueprint object conforming to `blueprint.ir/1.0`.
-- `compile-inline`: validate and compile a Blueprint, returning the generated artifacts inline.
+- `compile-inline`: validate and compile a Blueprint, returning artifacts and a deterministic Swarm machine task package inline.
+- `acceptance-report`: recompile the referenced Blueprint and reconcile every acceptance criterion with supplied TestEvidence.
 
 ## Required flow
 
@@ -44,6 +45,8 @@ POST JSON to the endpoint with an `input` wrapper:
 3. Do not compile a Blueprint until all required questions are answered.
 4. Build a Blueprint conforming to `blueprint.ir/1.0`, then call `validate`.
 5. Fix every validation finding until the report is green, then call `compile-inline` and save the artifacts.
+6. Bind `response.machineTasks` to Swarm `validate-json.input.project`; bind `response.machineTasks.tasks` to the first `dispatch.input.tasks`. Pass each real Swarm response's complete tasks array to the next mutation. There is no separate Swarm import operation.
+7. After actual execution, call `acceptance-report` with the same Blueprint, its original `machineTasks.blueprintSha256`, and one evidence result for every criterion. A reported pass checks structure and coverage; execution provenance remains the caller's responsibility.
 
 ## Official catalog hops
 
@@ -248,9 +251,51 @@ After `capabilities`, read `officialCatalog`. Default allowlist is official skil
 | B1 | 结构校验与可修复 Finding | 已实现 | `evidence` 与 `recommendedAction` 已由远端 Hermes 0.4.0 返回。 |
 | B2 | 增量规划/修订 | 部分实现 | IR 支持调用方维护 `revision`；服务端不保存蓝图，也没有增量更新操作。 |
 | B3 | 业务模板库与粗粒度模式 | 规划中 | 当前没有模板操作，`template` 与 `coarseMode` 均不是受支持输入。 |
-| B4 | 验收回传、开放问题闭环、Validator 桥接 | 规划中 | 当前没有 `acceptance-report`、`answer-questions` 或 Validator 桥接操作。 |
+| B4 | 验收回传、开放问题闭环、Validator 桥接 | 部分实现 | `acceptance-report` 已逐项核对共享 TestEvidence；`answer-questions` 与自动调用 Validator 仍未实现。 |
 
-只调用 `capabilities` 返回的五个操作。不要根据规划中条目构造请求，也不要把 npm 包版本 `v7.0.33` 与远端 Hermes 编译器版本 `0.4.0` 混为一谈。
+只调用 `capabilities` 返回的六个操作。不要根据规划中条目构造请求，也不要把 npm 包版本 `v7.0.34` 与远端 Hermes 编译器版本 `0.4.0` 混为一谈。
+
+
+## 机器任务与验收回传
+
+`capabilities.operationSchemas[].inputSchema` 与 `help.operationSchemas[].inputSchema` 是可执行的 JSON Schema；公开操作拒绝未知输入字段。IR 内的扩展字段交给 Hermes 的既有语义校验，结构 Schema 不替代节点、边、追溯与环规则。
+
+成功的 `compile-inline` 同时返回 `machineTasks` 和同内容的 `IMPLEMENTATION-TASKS.json`。后者也登记于 `ARTIFACT-MANIFEST.json`。机器包格式为 `swarm.project/1.0`，含 `blueprintId`、`revision`、`blueprintSha256`、`entryTaskId`、`tasks` 与 `acceptanceCriteria`。
+
+- `blueprintSha256` 是原 `PROJECT-BLUEPRINT.json` 工件的 `sha256:<64hex>`，调用方必须原样传递。
+- `tasks` 包含 `taskId/title/status/owner/dependsOn/nodeRefs/acceptanceRefs/internalEdgeRefs`；初始状态为 `backlog`，`owner` 为 `null`。
+- 任务依赖采用所有 IR 连线的保守顺序。显式有界循环的强连通节点合并为一个实现任务，组内边保存在 `internalEdgeRefs` 并可追溯原 IR；跨组边成为 `dependsOn`，不会生成 Swarm 依赖环。
+- 任务 ID 为 `bp-` 加排序后的 `nodeRefs` JSON 的 SHA-256 前 40 位，节点顺序改变不会重编号。验收项 `criterionId` 原样保留 IR 的 `acceptanceCriteria.id`；`taskRefs` 指向对应机器任务。
+- 该包表达实现计划，不证明代码已执行。具体执行步骤由调用方显式定义，不根据文案 `nextStep` 猜测执行。
+
+`acceptance-report.input`：
+
+```json
+{
+  "blueprint": "<原 blueprint.ir/1.0 对象>",
+  "blueprintSha256": "<原 PROJECT-BLUEPRINT.json 的 sha256:...>",
+  "results": [
+    {
+      "criterionId": "<原验收项 id>",
+      "evidence": [
+        {
+          "schemaVersion": "cli.tax.test-evidence/1.0",
+          "evidenceId": "<实际执行证据 id>",
+          "kind": "test",
+          "runner": "local",
+          "command": "<实际执行命令>",
+          "exitCode": 0,
+          "durationMs": 12,
+          "summary": "<实际执行摘要>",
+          "artifactSha256": "<可选，小写 64 位裸 SHA>"
+        }
+      ]
+    }
+  ]
+}
+```
+
+以上占位文字仅为字段说明，不能作为执行证据提交。每个验收项必须恰好一条结果，证据数组非空且全部退出码为 0。未知或重复验收项、缺失或重复证据、错误格式、非零退出码以及蓝图哈希不一致，均返回 `blocked`。返回 `ACCEPTANCE-REPORT.json` 与逐项 `acceptanceReport.criteria`，并明确 `verificationMode=caller-supplied-test-evidence`、`executionVerified=false`；本地 CLI、受信执行器的日志与产物才是实际执行来源。
 
 ## 受限调用与自动评价闭环
 

package/skill/skill.json

@@ -6,5 +6,5 @@
   "name": "blueprint",
   "schemaVersion": "blueprint.skill.request/1.0",
   "type": "Skill",
-  "version": "v7.0.33"
+  "version": "v7.0.34"
 }