create-yss-spec 2.2.2 → 2.2.4

package/template/.trae/skills/yss-tactical-design/scripts/validate-tactical-design.mjs

@@ -0,0 +1,213 @@
+#!/usr/bin/env node
+import { readFile } from "node:fs/promises";
+import process from "node:process";
+import { parseDocument } from "../../../../scripts/vendor/yaml.mjs";
+
+const required = [
+  "schema_version", "tactical_design_id", "tactical_version", "status", "context_ref",
+  "aggregate_catalog", "entity_catalog", "value_object_catalog", "behavior_catalog",
+  "invariant_catalog", "state_transition_catalog", "consistency_policy", "domain_event_catalog",
+  "gateway_catalog", "persistence_mapping", "test_seams", "adr_candidates", "upstream_impact",
+  "version", "digest", "evidence_refs"
+];
+const statuses = new Set(["draft", "ready-for-human", "approved", "blocked", "stale", "drift", "new_impacts", "not-applicable"]);
+const idPatterns = {
+  tactical_design_id: /^tactical-design\.[a-z0-9][a-z0-9-]*$/,
+  aggregate_id: /^aggregate\.[a-z0-9][a-z0-9-]*$/,
+  entity_id: /^entity\.[a-z0-9][a-z0-9-]*$/,
+  value_object_id: /^value-object\.[a-z0-9][a-z0-9-]*$/,
+  behavior_id: /^behavior\.[a-z0-9][a-z0-9-]*$/,
+  invariant_id: /^invariant\.[a-z0-9][a-z0-9-]*$/,
+  transition_id: /^transition\.[a-z0-9][a-z0-9-]*$/,
+  event_id: /^domain-event\.[a-z0-9][a-z0-9-]*$/,
+  gateway_id: /^gateway\.[a-z0-9][a-z0-9-]*$/,
+  seam_id: /^test-seam\.[a-z0-9][a-z0-9-]*$/,
+  version: /^v[0-9]+$/
+};
+
+const isObject = (value) => value && typeof value === "object" && !Array.isArray(value);
+const nonEmpty = (value) => typeof value === "string" && value.trim().length > 0;
+const list = (value) => Array.isArray(value);
+
+function unique(items, label, errors) {
+  const seen = new Set();
+  for (const item of items) {
+    if (seen.has(item)) errors.push(`${label} 重复: ${item}`);
+    seen.add(item);
+  }
+}
+
+function requireField(object, field, path, errors) {
+  if (!Object.prototype.hasOwnProperty.call(object ?? {}, field) || object[field] === null || object[field] === undefined) {
+    errors.push(`${path}.${field} 缺失`);
+  }
+}
+
+function requireString(object, field, path, errors) {
+  requireField(object, field, path, errors);
+  if (Object.prototype.hasOwnProperty.call(object ?? {}, field) && !nonEmpty(object[field])) errors.push(`${path}.${field} 必须是非空字符串`);
+}
+
+function requireArray(object, field, path, errors, minimum = 0) {
+  requireField(object, field, path, errors);
+  if (Object.prototype.hasOwnProperty.call(object ?? {}, field) && (!list(object[field]) || object[field].length < minimum)) {
+    errors.push(`${path}.${field} 必须是至少 ${minimum} 项的数组`);
+  }
+}
+
+function requireId(value, kind, path, errors) {
+  if (value !== undefined && value !== null && !idPatterns[kind].test(String(value))) errors.push(`${path} 格式非法`);
+}
+
+function refsExist(values, known, path, errors) {
+  for (const [index, value] of (values ?? []).entries()) {
+    if (!known.has(value)) errors.push(`${path}[${index}] 引用了未声明对象: ${value}`);
+  }
+}
+
+function validate(data) {
+  const errors = [];
+  if (!isObject(data)) return ["合同必须是对象"];
+  for (const field of required) requireField(data, field, "root", errors);
+  if (data.schema_version !== 1) errors.push("schema_version 必须为 1");
+  requireId(data.tactical_design_id, "tactical_design_id", "tactical_design_id", errors);
+  for (const field of ["tactical_version", "version"]) if (data[field] !== undefined && !idPatterns.version.test(String(data[field]))) errors.push(`${field} 必须形如 v1`);
+  if (data.status !== undefined && !statuses.has(data.status)) errors.push(`status 非法: ${data.status}`);
+  if (data.digest !== undefined && !/^sha256:[A-Fa-f0-9]{64}$/.test(String(data.digest))) errors.push("digest 必须为 sha256 加 64 位十六进制");
+
+  for (const field of ["aggregate_catalog", "entity_catalog", "behavior_catalog", "invariant_catalog", "state_transition_catalog", "gateway_catalog", "persistence_mapping", "test_seams"]) {
+    requireArray(data, field, "root", errors, 1);
+  }
+  for (const field of ["value_object_catalog", "domain_event_catalog", "adr_candidates", "evidence_refs"]) requireArray(data, field, "root", errors);
+  if (!isObject(data.consistency_policy)) errors.push("consistency_policy 必须是对象");
+  if (!isObject(data.upstream_impact)) errors.push("upstream_impact 必须是对象");
+  if (isObject(data.consistency_policy)) {
+    for (const field of ["transaction_boundary", "concurrency", "idempotency", "cross_aggregate_strategy"]) requireString(data.consistency_policy, field, "consistency_policy", errors);
+  }
+  if (isObject(data.upstream_impact)) {
+    for (const field of ["spec_ref", "strategic_ref", "api_ref", "data_ref"]) requireString(data.upstream_impact, field, "upstream_impact", errors);
+    if (data.upstream_impact.upstream_current === false && data.status !== "stale") errors.push("上游已过期时 status 必须为 stale");
+  }
+
+  const aggregates = list(data.aggregate_catalog) ? data.aggregate_catalog : [];
+  const entities = list(data.entity_catalog) ? data.entity_catalog : [];
+  const values = list(data.value_object_catalog) ? data.value_object_catalog : [];
+  const behaviors = list(data.behavior_catalog) ? data.behavior_catalog : [];
+  const invariants = list(data.invariant_catalog) ? data.invariant_catalog : [];
+  const transitions = list(data.state_transition_catalog) ? data.state_transition_catalog : [];
+  const events = list(data.domain_event_catalog) ? data.domain_event_catalog : [];
+  const gateways = list(data.gateway_catalog) ? data.gateway_catalog : [];
+  const mappings = list(data.persistence_mapping) ? data.persistence_mapping : [];
+  const seams = list(data.test_seams) ? data.test_seams : [];
+  const ids = (items, field, kind, label) => {
+    const result = new Set();
+    unique(items.map((item) => item?.[field]).filter(Boolean), label, errors);
+    for (const [index, item] of items.entries()) {
+      if (item?.[field]) { requireId(item[field], kind, `${label}[${index}].${field}`, errors); result.add(item[field]); }
+    }
+    return result;
+  };
+  const aggregateIds = ids(aggregates, "aggregate_id", "aggregate_id", "aggregate_id");
+  const entityIds = ids(entities, "entity_id", "entity_id", "entity_id");
+  const valueIds = ids(values, "value_object_id", "value_object_id", "value_object_id");
+  const behaviorIds = ids(behaviors, "behavior_id", "behavior_id", "behavior_id");
+  const invariantIds = ids(invariants, "invariant_id", "invariant_id", "invariant_id");
+  const transitionIds = ids(transitions, "transition_id", "transition_id", "transition_id");
+  const eventIds = ids(events, "event_id", "event_id", "event_id");
+  const gatewayIds = ids(gateways, "gateway_id", "gateway_id", "gateway_id");
+  ids(seams, "seam_id", "seam_id", "seam_id");
+
+  for (const [index, aggregate] of aggregates.entries()) {
+    const path = `aggregate_catalog[${index}]`;
+    if (!isObject(aggregate)) { errors.push(`${path} 必须是对象`); continue; }
+    for (const field of ["aggregate_id", "name", "context_ref", "root_entity", "consistency_boundary"]) requireString(aggregate, field, path, errors);
+    requireArray(aggregate, "invariant_refs", path, errors, 1); requireArray(aggregate, "behavior_refs", path, errors, 1);
+    if (aggregate.model_origin === "strategic-concept") errors.push(`${path}.model_origin 不得直接把战略概念当作 Aggregate`);
+    if (aggregate.api_exposure !== "internal-only") errors.push(`${path}.api_exposure 必须为 internal-only`);
+    if (aggregate.root_entity && !entityIds.has(aggregate.root_entity)) errors.push(`${path}.root_entity 未引用 Entity`);
+    const rootEntity = entities.find((entity) => entity?.entity_id === aggregate.root_entity);
+    if (rootEntity && rootEntity.aggregate_id !== aggregate.aggregate_id) errors.push(`${path}.root_entity 的 aggregate_id 必须与当前 Aggregate 一致`);
+    refsExist(aggregate.invariant_refs, invariantIds, `${path}.invariant_refs`, errors);
+    refsExist(aggregate.behavior_refs, behaviorIds, `${path}.behavior_refs`, errors);
+  }
+  for (const [index, entity] of entities.entries()) {
+    const path = `entity_catalog[${index}]`;
+    if (!isObject(entity)) { errors.push(`${path} 必须是对象`); continue; }
+    for (const field of ["entity_id", "name", "aggregate_id", "identity", "lifecycle"]) requireString(entity, field, path, errors);
+    if (entity.aggregate_id && !aggregateIds.has(entity.aggregate_id)) errors.push(`${path}.aggregate_id 未引用 Aggregate`);
+  }
+  for (const [index, value] of values.entries()) {
+    const path = `value_object_catalog[${index}]`;
+    if (!isObject(value)) { errors.push(`${path} 必须是对象`); continue; }
+    for (const field of ["value_object_id", "name", "aggregate_id", "immutable"]) requireField(value, field, path, errors);
+    if (typeof value.immutable !== "boolean" || value.immutable !== true) errors.push(`${path}.immutable 必须为 true`);
+    if (value.aggregate_id && !aggregateIds.has(value.aggregate_id)) errors.push(`${path}.aggregate_id 未引用 Aggregate`);
+  }
+  for (const [index, behavior] of behaviors.entries()) {
+    const path = `behavior_catalog[${index}]`;
+    if (!isObject(behavior)) { errors.push(`${path} 必须是对象`); continue; }
+    for (const field of ["behavior_id", "name", "aggregate_id", "command"]) requireString(behavior, field, path, errors);
+    for (const field of ["preconditions", "invariant_refs", "postconditions", "event_refs"]) requireArray(behavior, field, path, errors, field === "invariant_refs" ? 1 : 0);
+    if (behavior.aggregate_id && !aggregateIds.has(behavior.aggregate_id)) errors.push(`${path}.aggregate_id 未引用 Aggregate`);
+    refsExist(behavior.invariant_refs, invariantIds, `${path}.invariant_refs`, errors);
+    refsExist(behavior.event_refs, eventIds, `${path}.event_refs`, errors);
+  }
+  for (const [index, invariant] of invariants.entries()) {
+    const path = `invariant_catalog[${index}]`;
+    if (!isObject(invariant)) { errors.push(`${path} 必须是对象`); continue; }
+    for (const field of ["invariant_id", "aggregate_id", "statement"]) requireString(invariant, field, path, errors);
+    if (invariant.aggregate_id && !aggregateIds.has(invariant.aggregate_id)) errors.push(`${path}.aggregate_id 未引用 Aggregate`);
+  }
+  for (const [index, transition] of transitions.entries()) {
+    const path = `state_transition_catalog[${index}]`;
+    if (!isObject(transition)) { errors.push(`${path} 必须是对象`); continue; }
+    for (const field of ["transition_id", "aggregate_id", "from", "to", "behavior_id"]) requireString(transition, field, path, errors);
+    if (transition.aggregate_id && !aggregateIds.has(transition.aggregate_id)) errors.push(`${path}.aggregate_id 未引用 Aggregate`);
+    if (transition.behavior_id && !behaviorIds.has(transition.behavior_id)) errors.push(`${path}.behavior_id 未引用行为`);
+  }
+  for (const [index, event] of events.entries()) {
+    const path = `domain_event_catalog[${index}]`;
+    if (!isObject(event)) { errors.push(`${path} 必须是对象`); continue; }
+    for (const field of ["event_id", "name", "aggregate_id", "delivery"]) requireString(event, field, path, errors);
+    requireArray(event, "consumers", path, errors, 0);
+    if (event.aggregate_id && !aggregateIds.has(event.aggregate_id)) errors.push(`${path}.aggregate_id 未引用 Aggregate`);
+  }
+  for (const [index, gateway] of gateways.entries()) {
+    const path = `gateway_catalog[${index}]`;
+    if (!isObject(gateway)) { errors.push(`${path} 必须是对象`); continue; }
+    for (const field of ["gateway_id", "name", "context_ref", "layer"]) requireString(gateway, field, path, errors);
+    requireArray(gateway, "capabilities", path, errors, 1);
+    if (gateway.layer !== "Domain") errors.push(`${path}.layer 必须为 Domain，Infrastructure 只实现 Gateway`);
+  }
+  for (const [index, mapping] of mappings.entries()) {
+    const path = `persistence_mapping[${index}]`;
+    if (!isObject(mapping)) { errors.push(`${path} 必须是对象`); continue; }
+    for (const field of ["aggregate_id", "storage_model", "notes"]) requireString(mapping, field, path, errors);
+    if (mapping.aggregate_id && !aggregateIds.has(mapping.aggregate_id)) errors.push(`${path}.aggregate_id 未引用 Aggregate`);
+  }
+  for (const [index, seam] of seams.entries()) {
+    const path = `test_seams[${index}]`;
+    if (!isObject(seam)) { errors.push(`${path} 必须是对象`); continue; }
+    for (const field of ["seam_id", "kind", "subject_ref", "assertion"]) requireString(seam, field, path, errors);
+    if (seam.subject_ref && !new Set([...aggregateIds, ...entityIds, ...valueIds, ...behaviorIds, ...invariantIds, ...transitionIds, ...gatewayIds]).has(seam.subject_ref)) errors.push(`${path}.subject_ref 未引用已声明领域对象`);
+  }
+  if (isObject(data.complexity) && data.complexity.escalate_to_standalone === true && !nonEmpty(data.complexity.standalone_ref)) errors.push("complexity.escalate_to_standalone 为 true 时必须提供 standalone_ref");
+  return errors;
+}
+
+async function main() {
+  const file = process.argv[2];
+  if (!file) throw new Error("用法: validate-tactical-design.mjs <contract.yaml>");
+  const source = await readFile(file, "utf8");
+  const document = parseDocument(source, { maxAliasCount: 0, uniqueKeys: true });
+  if (document.errors.length) throw new Error(`无法解析合同: ${document.errors[0].message}`);
+  const errors = validate(document.toJS({ maxAliasCount: 0 }));
+  if (errors.length) {
+    process.stderr.write(`${JSON.stringify({ result: "blocked", errors }, null, 2)}\n`);
+    process.exitCode = 1;
+    return;
+  }
+  process.stdout.write(`${JSON.stringify({ result: "ready-for-lifecycle-review", tactical_design_id: document.get("tactical_design_id"), status: document.get("status") }, null, 2)}\n`);
+}
+
+main().catch((error) => { process.stderr.write(`${error.message}\n`); process.exitCode = 1; });

package/template/.trae/skills/yss-tactical-design/tests/fixtures/invalid-api-leaks-aggregate.yaml

@@ -0,0 +1,21 @@
+schema_version: 1
+tactical_design_id: tactical-design.invalid-api
+tactical_version: v1
+status: ready-for-human
+context_ref: context.example
+aggregate_catalog: [{aggregate_id: aggregate.example, name: Example, context_ref: context.example, root_entity: entity.example-root, invariant_refs: [invariant.example], behavior_refs: [behavior.example], consistency_boundary: single, api_exposure: public-aggregate}]
+entity_catalog: [{entity_id: entity.example-root, name: Root, aggregate_id: aggregate.example, identity: id, lifecycle: active}]
+value_object_catalog: []
+behavior_catalog: [{behavior_id: behavior.example, name: Do, aggregate_id: aggregate.example, command: do, preconditions: [ready], invariant_refs: [invariant.example], postconditions: [done], event_refs: []}]
+invariant_catalog: [{invariant_id: invariant.example, aggregate_id: aggregate.example, statement: required}]
+state_transition_catalog: [{transition_id: transition.example, aggregate_id: aggregate.example, from: draft, to: done, behavior_id: behavior.example}]
+consistency_policy: {transaction_boundary: single, concurrency: optimistic, idempotency: guarded, cross_aggregate_strategy: none}
+domain_event_catalog: []
+gateway_catalog: [{gateway_id: gateway.example, name: Gateway, context_ref: context.example, layer: Domain, capabilities: [load]}]
+persistence_mapping: [{aggregate_id: aggregate.example, storage_model: example, notes: mapping}]
+test_seams: [{seam_id: test-seam.example, kind: domain, subject_ref: invariant.example, assertion: behavior}]
+adr_candidates: []
+upstream_impact: {spec_ref: spec@v1, strategic_ref: strategy@v1, api_ref: api@draft, data_ref: data@v1, upstream_current: true}
+version: v1
+digest: sha256:0000000000000000000000000000000000000000000000000000000000000000
+evidence_refs: []

package/template/.trae/skills/yss-tactical-design/tests/fixtures/invalid-missing-consistency-policy.yaml

@@ -0,0 +1,21 @@
+schema_version: 1
+tactical_design_id: tactical-design.invalid-consistency
+tactical_version: v1
+status: ready-for-human
+context_ref: context.example
+aggregate_catalog: [{aggregate_id: aggregate.example, name: Example, context_ref: context.example, root_entity: entity.example-root, invariant_refs: [invariant.example], behavior_refs: [behavior.example], consistency_boundary: single, api_exposure: internal-only}]
+entity_catalog: [{entity_id: entity.example-root, name: Root, aggregate_id: aggregate.example, identity: id, lifecycle: active}]
+value_object_catalog: []
+behavior_catalog: [{behavior_id: behavior.example, name: Do, aggregate_id: aggregate.example, command: do, preconditions: [ready], invariant_refs: [invariant.example], postconditions: [done], event_refs: []}]
+invariant_catalog: [{invariant_id: invariant.example, aggregate_id: aggregate.example, statement: required}]
+state_transition_catalog: [{transition_id: transition.example, aggregate_id: aggregate.example, from: draft, to: done, behavior_id: behavior.example}]
+consistency_policy: {}
+domain_event_catalog: []
+gateway_catalog: [{gateway_id: gateway.example, name: Gateway, context_ref: context.example, layer: Domain, capabilities: [load]}]
+persistence_mapping: [{aggregate_id: aggregate.example, storage_model: example, notes: mapping}]
+test_seams: [{seam_id: test-seam.example, kind: domain, subject_ref: invariant.example, assertion: behavior}]
+adr_candidates: []
+upstream_impact: {spec_ref: spec@v1, strategic_ref: strategy@v1, api_ref: api@draft, data_ref: data@v1, upstream_current: true}
+version: v1
+digest: sha256:0000000000000000000000000000000000000000000000000000000000000000
+evidence_refs: []

package/template/.trae/skills/yss-tactical-design/tests/fixtures/invalid-missing-invariant.yaml

@@ -0,0 +1,21 @@
+schema_version: 1
+tactical_design_id: tactical-design.invalid-missing-invariant
+tactical_version: v1
+status: ready-for-human
+context_ref: context.example
+aggregate_catalog: [{aggregate_id: aggregate.example, name: Example, context_ref: context.example, root_entity: entity.example-root, invariant_refs: [], behavior_refs: [behavior.example], consistency_boundary: single, api_exposure: internal-only}]
+entity_catalog: [{entity_id: entity.example-root, name: Root, aggregate_id: aggregate.example, identity: id, lifecycle: active}]
+value_object_catalog: []
+behavior_catalog: [{behavior_id: behavior.example, name: Do, aggregate_id: aggregate.example, command: do, preconditions: [], invariant_refs: [], postconditions: [], event_refs: []}]
+invariant_catalog: []
+state_transition_catalog: [{transition_id: transition.example, aggregate_id: aggregate.example, from: draft, to: done, behavior_id: behavior.example}]
+consistency_policy: {transaction_boundary: single, concurrency: optimistic, idempotency: guarded, cross_aggregate_strategy: none}
+domain_event_catalog: []
+gateway_catalog: [{gateway_id: gateway.example, name: Gateway, context_ref: context.example, layer: Domain, capabilities: [load]}]
+persistence_mapping: [{aggregate_id: aggregate.example, storage_model: example, notes: mapping}]
+test_seams: [{seam_id: test-seam.example, kind: domain, subject_ref: aggregate.example, assertion: behavior}]
+adr_candidates: []
+upstream_impact: {spec_ref: spec@v1, strategic_ref: strategy@v1, api_ref: api@draft, data_ref: data@v1, upstream_current: true}
+version: v1
+digest: sha256:0000000000000000000000000000000000000000000000000000000000000000
+evidence_refs: []

package/template/.trae/skills/yss-tactical-design/tests/fixtures/invalid-stale-upstream-ref.yaml

@@ -0,0 +1,21 @@
+schema_version: 1
+tactical_design_id: tactical-design.invalid-stale
+tactical_version: v1
+status: ready-for-human
+context_ref: context.example
+aggregate_catalog: [{aggregate_id: aggregate.example, name: Example, context_ref: context.example, root_entity: entity.example-root, invariant_refs: [invariant.example], behavior_refs: [behavior.example], consistency_boundary: single, api_exposure: internal-only}]
+entity_catalog: [{entity_id: entity.example-root, name: Root, aggregate_id: aggregate.example, identity: id, lifecycle: active}]
+value_object_catalog: []
+behavior_catalog: [{behavior_id: behavior.example, name: Do, aggregate_id: aggregate.example, command: do, preconditions: [ready], invariant_refs: [invariant.example], postconditions: [done], event_refs: []}]
+invariant_catalog: [{invariant_id: invariant.example, aggregate_id: aggregate.example, statement: required}]
+state_transition_catalog: [{transition_id: transition.example, aggregate_id: aggregate.example, from: draft, to: done, behavior_id: behavior.example}]
+consistency_policy: {transaction_boundary: single, concurrency: optimistic, idempotency: guarded, cross_aggregate_strategy: none}
+domain_event_catalog: []
+gateway_catalog: [{gateway_id: gateway.example, name: Gateway, context_ref: context.example, layer: Domain, capabilities: [load]}]
+persistence_mapping: [{aggregate_id: aggregate.example, storage_model: example, notes: mapping}]
+test_seams: [{seam_id: test-seam.example, kind: domain, subject_ref: invariant.example, assertion: behavior}]
+adr_candidates: []
+upstream_impact: {spec_ref: spec@v1, strategic_ref: strategy@v1, api_ref: api@draft, data_ref: data@v1, upstream_current: false}
+version: v1
+digest: sha256:0000000000000000000000000000000000000000000000000000000000000000
+evidence_refs: []

package/template/.trae/skills/yss-tactical-design/tests/fixtures/invalid-strategic-as-tactical.yaml

@@ -0,0 +1,21 @@
+schema_version: 1
+tactical_design_id: tactical-design.invalid-strategic
+tactical_version: v1
+status: ready-for-human
+context_ref: context.example
+aggregate_catalog: [{aggregate_id: aggregate.example, name: Example, context_ref: context.example, root_entity: entity.example-root, model_origin: strategic-concept, invariant_refs: [invariant.example], behavior_refs: [behavior.example], consistency_boundary: single, api_exposure: internal-only}]
+entity_catalog: [{entity_id: entity.example-root, name: Root, aggregate_id: aggregate.example, identity: id, lifecycle: active}]
+value_object_catalog: []
+behavior_catalog: [{behavior_id: behavior.example, name: Do, aggregate_id: aggregate.example, command: do, preconditions: [ready], invariant_refs: [invariant.example], postconditions: [done], event_refs: []}]
+invariant_catalog: [{invariant_id: invariant.example, aggregate_id: aggregate.example, statement: required}]
+state_transition_catalog: [{transition_id: transition.example, aggregate_id: aggregate.example, from: draft, to: done, behavior_id: behavior.example}]
+consistency_policy: {transaction_boundary: single, concurrency: optimistic, idempotency: guarded, cross_aggregate_strategy: none}
+domain_event_catalog: []
+gateway_catalog: [{gateway_id: gateway.example, name: Gateway, context_ref: context.example, layer: Domain, capabilities: [load]}]
+persistence_mapping: [{aggregate_id: aggregate.example, storage_model: example, notes: mapping}]
+test_seams: [{seam_id: test-seam.example, kind: domain, subject_ref: invariant.example, assertion: behavior}]
+adr_candidates: []
+upstream_impact: {spec_ref: spec@v1, strategic_ref: strategy@v1, api_ref: api@draft, data_ref: data@v1, upstream_current: true}
+version: v1
+digest: sha256:0000000000000000000000000000000000000000000000000000000000000000
+evidence_refs: []

package/template/.trae/skills/yss-tactical-design/tests/fixtures/valid-tactical-design.yaml

@@ -0,0 +1,80 @@
+schema_version: 1
+tactical_design_id: tactical-design.example-feature
+tactical_version: v1
+status: ready-for-human
+context_ref: context.example
+aggregate_catalog:
+  - aggregate_id: aggregate.example
+    name: ExampleAggregate
+    context_ref: context.example
+    root_entity: entity.example-root
+    invariant_refs: [invariant.example-required]
+    behavior_refs: [behavior.example-publish]
+    consistency_boundary: single-aggregate-transaction
+    api_exposure: internal-only
+entity_catalog:
+  - entity_id: entity.example-root
+    name: ExampleRoot
+    aggregate_id: aggregate.example
+    identity: stable-id
+    lifecycle: draft-published
+value_object_catalog:
+  - value_object_id: value-object.example-code
+    name: ExampleCode
+    aggregate_id: aggregate.example
+    immutable: true
+behavior_catalog:
+  - behavior_id: behavior.example-publish
+    name: Publish
+    aggregate_id: aggregate.example
+    command: publish
+    preconditions: ["状态为 draft"]
+    invariant_refs: [invariant.example-required]
+    postconditions: ["状态变为 published"]
+    event_refs: [domain-event.example-published]
+invariant_catalog:
+  - invariant_id: invariant.example-required
+    aggregate_id: aggregate.example
+    statement: "发布前必须满足业务前置条件"
+state_transition_catalog:
+  - transition_id: transition.example-publish
+    aggregate_id: aggregate.example
+    from: draft
+    to: published
+    behavior_id: behavior.example-publish
+consistency_policy:
+  transaction_boundary: single aggregate
+  concurrency: optimistic version check
+  idempotency: repeated publish is rejected by state guard
+  cross_aggregate_strategy: domain event with retry
+domain_event_catalog:
+  - event_id: domain-event.example-published
+    name: ExamplePublished
+    aggregate_id: aggregate.example
+    consumers: [downstream-context]
+    delivery: outbox-at-least-once
+gateway_catalog:
+  - gateway_id: gateway.example
+    name: ExampleGateway
+    context_ref: context.example
+    layer: Domain
+    capabilities: [save aggregate, load aggregate]
+persistence_mapping:
+  - aggregate_id: aggregate.example
+    storage_model: example_aggregate_snapshot
+    notes: "持久化结构不泄漏到领域模型"
+test_seams:
+  - seam_id: test-seam.example-invariant
+    kind: domain-behavior
+    subject_ref: invariant.example-required
+    assertion: "不满足前置条件时 publish 失败"
+adr_candidates: []
+upstream_impact:
+  spec_ref: docs/.scratch/example/spec.yaml@v1
+  strategic_ref: docs/.scratch/example/domain-strategy.yaml@v1
+  api_ref: docs/.scratch/example/openapi.yaml@draft
+  data_ref: docs/.scratch/example/data-architecture.md@v1
+  upstream_current: true
+version: v1
+digest: sha256:0000000000000000000000000000000000000000000000000000000000000000
+evidence_refs: [docs/.scratch/example/tactical-review.yaml]

package/template/.trae/skills/yss-tactical-design/tests/run-scenarios.mjs

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+import { tmpdir } from "node:os";
+
+const root = dirname(fileURLToPath(import.meta.url));
+const validator = join(root, "..", "scripts", "validate-tactical-design.mjs");
+const fixture = (name) => join(root, "fixtures", name);
+const run = (file) => spawnSync(process.execPath, [validator, file], { encoding: "utf8" });
+const pass = run(fixture("valid-tactical-design.yaml"));
+if (pass.status !== 0) throw new Error(`valid tactical design should pass: ${pass.stderr}`);
+
+const blockedCases = [
+  ["invalid-missing-invariant.yaml", "invariant_refs 必须是至少 1 项的数组"],
+  ["invalid-api-leaks-aggregate.yaml", "api_exposure 必须为 internal-only"],
+  ["invalid-stale-upstream-ref.yaml", "status 必须为 stale"],
+  ["invalid-strategic-as-tactical.yaml", "不得直接把战略概念当作 Aggregate"],
+  ["invalid-missing-consistency-policy.yaml", "consistency_policy.transaction_boundary 缺失"]
+];
+for (const [name, message] of blockedCases) {
+  const result = run(fixture(name));
+  if (result.status === 0 || !result.stderr.includes(message)) throw new Error(`${name} should be blocked: ${result.stderr}`);
+}
+
+const temporaryRoot = await mkdtemp(join(tmpdir(), "yss-tactical-design-pressure-"));
+try {
+  const source = await readFile(fixture("valid-tactical-design.yaml"), "utf8");
+  const escalated = join(temporaryRoot, "missing-standalone-ref.yaml");
+  await writeFile(escalated, `${source}\ncomplexity:\n  escalate_to_standalone: true\n`);
+  const result = run(escalated);
+  if (result.status === 0 || !result.stderr.includes("standalone_ref")) throw new Error("complexity escalation without standalone_ref should be blocked");
+
+  const wrongGateway = join(temporaryRoot, "wrong-gateway-layer.yaml");
+  await writeFile(wrongGateway, source.replace("layer: Domain", "layer: Infrastructure"));
+  const gatewayResult = run(wrongGateway);
+  if (gatewayResult.status === 0 || !gatewayResult.stderr.includes("layer 必须为 Domain")) throw new Error("Infrastructure gateway should be blocked");
+
+  const crossAggregateRoot = join(temporaryRoot, "cross-aggregate-root.yaml");
+  await writeFile(crossAggregateRoot, source.replace("aggregate_id: aggregate.example\n    identity", "aggregate_id: aggregate.other\n    identity"));
+  const crossAggregateResult = run(crossAggregateRoot);
+  if (crossAggregateResult.status === 0 || !crossAggregateResult.stderr.includes("root_entity 的 aggregate_id 必须与当前 Aggregate 一致")) throw new Error("cross-aggregate root should be blocked");
+} finally {
+  await rm(temporaryRoot, { recursive: true, force: true });
+}
+process.stdout.write("DDD tactical design scenarios passed\n");

package/template/AGENTS.md

@@ -23,6 +23,7 @@
 | 模板维护强度触发与最低等级 | `docs/process/maintenance-intensity.yaml` |
 | 技能清单、来源、版本、哈希和投影目标      | `skills-lock.json`                          |
 | 技能分层、别名、默认可发现性和运行时入口 | `docs/agents/yss-skill-registry.yaml`（当前 `status: shadow`，不作为 Router / 生命周期运行时入口） |
+| 数字人角色、阶段协作组、运行时绑定与生命周期会签 | `docs/agents/digital-human-roles.yaml`；`docs/agents/digital-human-roles.md` 为操作说明 |
 
 README、用户指南、根目录 `CLAUDE.md` 和其他说明文档只引用或解释上述事实，不重复定义同一规则。`CLAUDE.md` 是 Claude Code 入口指针，不是第二套 Agent 规则。
 
@@ -31,7 +32,8 @@ README、用户指南、根目录 `CLAUDE.md` 和其他说明文档只引用或
 - 所有面向业务、产品、架构、实施、审查、发布和复盘的落地文档，正文统一使用简体中文。
 - 英文专有名词、代码标识、API 路径、schema、类名、方法名、枚举值、错误码、命令、文件名和协议 metadata 保持原样。
 - 新流程统一使用 Spec、Ticket、`to-spec`、`to-tickets`。过时术语和技能名只能出现在迁移指南或明确标注的旧项目上下文。
-- 实施前读取 `CONTEXT.md`。业务术语必须已有 PascalCase `英文标识`；代码类型 / 字段与契约 property 使用该词干按 `CONTEXT.md` 文首规则变形。改中文术语或英文标识都先回写 `CONTEXT.md`。与词汇或 ADR 冲突时立即指出并先解决冲突。
+- `CONTEXT.md` 是 Spec 构建及其落地工具链的统一语言输入，也是所有会创建或修改稳定业务、产品、架构、实施、审查、发布和复盘资产的强制前置上下文。`yss-product-lifecycle`、其原生 work unit，以及 `grill-with-docs`、`to-spec`、`to-tickets`、`implement` 等显式兼容入口，在规划、起草、评审、拆 Ticket 或实现前都必须读取并持续消费它；工具无法读取或消费时必须暂停并返回 `blocked`，不得凭临场翻译、同义词或局部上下文继续。
+- 稳定业务术语必须先在 `CONTEXT.md` 中登记 PascalCase `英文标识`，再进入 Spec、原型、契约、Ticket、代码或验证资产；代码类型 / 字段与契约 property 使用该词干按 `CONTEXT.md` 文首规则变形。改中文术语或英文标识都先回写 `CONTEXT.md`，并重新检查受影响资产；与词汇或 ADR 冲突时立即指出并先解决冲突。
 
 ## 4. `template-source` 模板维护路由
 
@@ -83,6 +85,7 @@ README、用户指南、根目录 `CLAUDE.md` 和其他说明文档只引用或
 | merge / rebase 冲突 | `resolving-merge-conflicts` |
 | 架构治理、难测模块或深模块设计 | `improve-codebase-architecture` / `codebase-design` |
 | 跨线程、跨仓库、上下文过长或原型结论回流 | `handoff` 或等价交接记录 |
+| 数字人角色、Agent 运行时协同或生命周期会签 | 先读 `docs/agents/digital-human-roles.yaml`。职称实例叠加在编排器上，不另起生命周期，不批准 Slice 合同、不设 `ready-for-agent`、不宣布可发布 |
 | 本地知识库 init / refresh / rebuild，或要把研究结果落成持久 wiki | `llm-wiki`（落成持久 wiki 用 `ingest`；已映射 live 源变了用 `refresh`）。`template-source` 的 wiki-root 为 `.template-source/wiki`；`project-instance` 不附带源仓库编译树，需要时在仓库根 `wiki/` 执行 `init` |
 
 业务行为默认按 `tdd` 使用已确认的公开 seam 逐切片实现。一次性生成、纯配置或流程文档不适用代码 TDD 时，必须记录例外理由和可执行验证方式。
@@ -95,15 +98,16 @@ README、用户指南、根目录 `CLAUDE.md` 和其他说明文档只引用或
 
 ## 10. 独立审查、验证和追踪
 
-- 实现者不能承担命中的独立审查。模板维护按 L1 / L2 / L3 分别使用 self-check / 人工 checkpoint、聚焦独立审查、正式独立审查；模板发布、代码切片和高风险变更仍必须由其他 Agent 或人工独立审查。
+- 实现者不能承担命中的独立审查（含数字人）。模板维护按 L1 / L2 / L3 分别使用 self-check / 人工 checkpoint、聚焦独立审查、正式独立审查；模板发布、代码切片和高风险变更仍必须由其他 Agent 或独立审查者完成。
 - 任何“完成 / 可合并 / 可发布”结论必须基于 fresh verification，不接受“之前跑过”或实现者自述。
-- 在人工暂停、handoff、进入实现、合并或发布边界集中同步范围、验证证据、风险、人工审查点、Ticket 状态和下一步；阻塞、责任人变化或资产单独批准时立即同步。
+- 会签门禁按 `docs/agents/digital-human-roles.yaml` 的 `gate_policy` 关闭，会签文件经 `scripts/verify-approval-record` 核验；`gate.release-ready`、对外商务承诺和运行时外部副作用仍须生物人。
+- 在会签暂停、handoff、进入实现、合并或发布边界集中同步范围、验证证据、风险、会签点、Ticket 状态和下一步；阻塞、责任人变化或资产单独批准时立即同步。
 - Git checkpoint 只包含本轮明确范围；获得用户授权后才提交或推送。
 - 发布后或阶段性完成后做复盘判断；出现架构返工、验证返工、IMPORTANT / CRITICAL review finding 或人工确认延期时，落简体中文复盘并修订权威资产。
 
 ## 11. Subagent 协同
 
-使用 subagent 前按 `docs/process/subagent-collaboration.md` 定义任务包和不重叠的写入范围。实现者不担任独立审查者；仓库身份、需求 / 契约冻结、Ticket 最终状态、Git checkpoint 和完成结论仍由主控 Agent 或人工决定。
+使用 subagent 或其它 Agent 运行时前按 `docs/process/subagent-collaboration.md` 定义任务包和不重叠的写入范围，并同时写明数字人角色、`runtime_id`、从角色表复制的 `core_skills` / `forbidden_skills` 与 Explorer / Drafter / Worker / Reviewer / Verifier 执行态。实现者不担任独立审查者；仓库身份、Ticket 最终状态、Git checkpoint、Slice 合同批准和完成结论仍由主控数字人按编排器规则决定。会签恢复前校验 `scripts/verify-approval-record`。写隔离靠任务包；共享工作区不是默认沙箱。
 
 ## 12. 测试质量基线
 

package/template/CONTEXT.md

@@ -12,7 +12,19 @@
 
 | 术语 | 含义 | 英文标识 | 避免 / 备注 |
 |---|---|---|---|
-| Agent | 执行特定工作流步骤的 AI 协作者。 | — | 不要与人工审查者混用。 |
+| Agent | 执行特定工作流步骤的 AI 协作者。 | — | 不要与生物人审查者、数字人角色或 Ticket 状态混用。运行时实例（Cursor Agent、Claude Code、Grok Bot 等）是 Agent 的承载，不是角色本身。 |
+| 运行时绑定 | 把数字人角色落到某个 Agent 平台的适配声明，权威清单在数字人角色注册表的 `runtimes`。 | — | 不要为每个平台复制一套职称职责。 |
+| Grok Bot | Grok 平台上的持久数字队友实例；对应 `runtime.grok`。 | — | 不是数字人角色、技能或门禁。 |
+| 数字人角色 | 叠加在生命周期编排器上的职称配置；一个运行时实例绑定一种。v1 清单以 `docs/agents/digital-human-roles.yaml` 为准。 | — | 不要称为 Ticket「标准角色」、职能 Agent 或某个平台的产品名。 |
+| 主控数字人 | 运行 `yss-product-lifecycle` 的协调实例。 | — | 不是第八个业务职称；默认兼任项目经理。 |
+| 角色配置 | 某数字人角色的关注阶段、技能包、可起草产物和禁止事项。 | — | 不是独立编排器，也不含平台群聊人数。 |
+| 生命周期会签 | 指定数字人或生物人关闭 `gate.*` / 独立审查并写入 `evidence.approval-record`。 | — | 不是运行时副作用审批。会签人由 `docs/agents/digital-human-roles.yaml` 的 `gate_policy` 指定。起草者不得会签自己起草的资产。`paused-human-gate` 表示等待该会签人，不是必须生物人。 |
+| 运行时副作用审批 | 对发消息、改生产、付款、删数据等工具动作的账号级确认。 | — | 点 Allow 不等于门禁已批准或可发布。避免只称「Grok 平台审批」。 |
+| Ticket 状态 | Tracker 五态：`needs-triage`、`needs-info`、`ready-for-agent`、`ready-for-human`、`wontfix`。 | — | 不要称为数字人角色或「标准角色」。 |
+| 阶段协作组 | 某阶段需要共同可见会签的逻辑成员集合。 | — | 不是某个产品的群聊；平台人数上限只写在对应 `runtimes`。 |
+| 需求经理 | 主责 Discovery 语言、用户/MVP/非目标、Spec 正文与测试 seam 的数字人角色。 | — | 不拥有原型视觉定稿，不 Freeze API，不写实现。 |
+| 产品经理 | 主责优先级、产品设计影响、原型确认建议和范围裁剪的数字人角色。 | — | 不写生产代码，不单独 Freeze API。 |
+| 商务 | 主责机会调研商业约束、交付承诺和发布窗口商务非目标的数字人角色。 | — | 不参与 Spec 定稿、契约、代码或 Ticket 状态推进。 |
 | Agent 入口规则 | Agent 启动任务时必须先遵守的全局路由、硬门禁和禁止事项。 | — | 不作为 YSS 后端、前端或其他专项编码规范的完整手册。 |
 | 标准文档语言 | 面向业务、产品、架构、实施、审查、发布和复盘的持久化文档所使用的默认语言。 | — | 统一使用简体中文；英文专有名词、代码标识、API 路径、schema、文件名和协议 metadata 保持原样。 |
 | Matt Engineering Skills | 来自 `mattpocock/skills` 的轻量工程流程技能集合。 | — | 用于澄清、Spec、Ticket、实现、TDD、诊断、审查和架构治理，不替代 YSS 专项规范。 |
@@ -25,7 +37,7 @@
 | Ticket | 在追踪平台上承载功能生命周期或可实现工作单元的通用追踪对象。 | — | GitHub Issues / GitLab Issues 是具体平台对象名称；领域资产统一称为 Ticket。 |
 | 功能父 Ticket | 汇总一个功能从 Spec 到契约冻结的阶段状态、资产链接、审查结论和阻塞项的 Ticket。 | — | 不作为 Agent 直接实现的垂直切片。 |
 | 垂直切片 Ticket | 契约冻结后生成的可独立验证实现单元，记录范围、阻塞关系、验收标准和验证证据。 | — | 只有通过必要门禁并具备直接实现条件时才能标记 `ready-for-agent`。 |
-| `ready-for-human` | 表示 Spec、设计、契约草案或其他资产仍需人工审查或确认的流程状态。 | — | 此状态不表示可以直接进入实现。 |
+| `ready-for-human` | 表示 Spec、设计、契约草案或其他资产仍需会签（指定数字人或生物人）。 | — | 此状态不表示可以直接进入实现；也不等于某个数字人角色。 |
 | `ready-for-agent` | 表示垂直切片已通过必要门禁并具备直接实现条件的流程状态。 | — | 不得用于 Spec 初稿、原型、OpenAPI Draft 或其他未冻结资产。 |
 | OpenAPI Draft | review-only 的 OpenAPI 3.1 契约草案。 | — | Freeze 前不得作为前后端稳定实现契约。 |
 | OpenAPI Freeze | 已通过评审、可作为前后端实现和契约测试输入的 OpenAPI 3.1 契约。 | — | Freeze 后变更必须回到 API 影响分析和设计审查。 |

package/template/docs/agents/digital-human-roles.md

@@ -0,0 +1,83 @@
+# 数字人角色
+
+结构化事实源是 `docs/agents/digital-human-roles.yaml`。角色、技能、协作组和会签级别与运行时无关。Claude Code、Cursor、Codex、Hermes、Grok Bot 等只通过 YAML `runtimes` 绑定。冲突时以 YAML 为准。
+
+## 何时读本文
+
+按职称派活、写会签、把数字人角色和 Ticket 状态 / 职能 Agent / 执行态弄混，或要在某个 Agent 平台上实例化这些角色时。
+
+## 四条正交轴
+
+| 轴 | 是什么 | 不是什么 |
+|---|---|---|
+| 数字人角色 | 职称配置（需求经理、前端工程师…） | Ticket 五态、某个平台的 Bot |
+| 主控数字人 | 生命周期编排器的运行时实例 | 第八个业务职称 |
+| 职能工作单元 | Discovery / Spec / Code / Review | 职称 |
+| 执行态 | Explorer / Drafter / Worker / Reviewer / Verifier | 数字人角色 |
+| 运行时绑定 | 如何在 Cursor / Claude / Grok 等落地 | 角色职责本身 |
+
+一次数字人任务包同时写明 `task_id`、`work_unit_id`、`actor_id`、数字人角色、执行态、当前 `runtime_id`，以及从角色表复制的 `core_skills` / `forbidden_skills`。可用 `taskPackageDefaults(roleId)`（`scripts/lib/digital-human-roles.mjs`）读取，禁止手写第二套技能包。任务包 canonical Schema 为 `docs/process/schemas/digital-human-task-package.schema.json`，按 `contract.kind` 选择生命周期、切片实现或模板维护合同。
+
+## 会签人
+
+`gate_policy.digital_human_review` 与 `dual_digital_human` 是「门禁 × 起草者 × 会签人」规则，不是门禁名单。主控按 `countersigners` 派会签任务。
+
+| 门禁 / 工作单元 | 起草 | 会签 |
+|---|---|---|
+| `gate.prototype-reviewed` | `role.product-manager` | `role.frontend-engineer` |
+| `gate.openapi-draft-reviewed` | `role.backend-engineer` | `role.frontend-engineer` |
+| `gate.engineering-baseline-accepted` | （实现者） | `role.test-engineer` |
+| `gate.frontend-implementation-verified` | `role.frontend-engineer` | `role.test-engineer` |
+| `work-unit.code-review` | 实现者 | `role.test-engineer`（必须不同实例） |
+| `gate.spec-baseline-approved` | `role.requirements-manager` | `role.product-manager` |
+| `gate.openapi-frozen` | `role.backend-engineer` | `role.product-manager`、`role.test-engineer` |
+| `gate.user-confirmation` | — | `role.product-manager`；生物人可否决 |
+| `gate.release-ready` | — | 生物人（`role.biological-human`） |
+
+未列入表的门禁（含 `gate.design-reviewed`、`gate.architecture-reviewed`）走 `default_if_unlisted: biological-human`。
+
+会签写入 `docs/.scratch/<feature>/gates/<gate-id>-approval.yaml`，形状见 `docs/templates/approval-record-template.yaml`。恢复前运行 `scripts/verify-approval-record`。错误会签只能得到 `blocked`，不能把门禁标成 `approved`。Checkpoint 里会签桶门禁为 `approved` 时必须有可读 `approval_ref`。
+
+`paused-human-gate` 表示等待上述指定会签人，不是「必须是生物人」。
+
+主控默认兼任项目经理，直到 `dual_hat_split_when`（`cross-repo-load` 或 `responsibility-conflict`）要求分体。
+
+## 跨平台协同（默认）
+
+1. 人默认只跟主控说话。
+2. 主控按阶段 1:1 指定一个 owner，并给任务包（输入、写范围、禁止 skill、验收、验证命令）。
+3. 需要可见会签时使用 YAML `stage_groups` 的**逻辑协作组**。这不是某个产品的群聊人数限制。
+4. 权威结论写回 git。运行时记忆只记该数字人的稳定偏好。
+5. 写隔离一律靠任务包。某运行时若共享磁盘或会话，适配器必须声明 `shared_workspace_is_not_security_boundary: true`，不得把实例当成沙箱。
+6. `project-instance` 复制角色实例并绑定仓库路径。禁止按功能再拆实例。
+7. 技能权威仍是 `.agents/skills`。已有投影根走 `runtime.skill-projection`，不要为职称再维护一份 skill。任务包的技能列表必须从角色表复制。
+
+## 运行时绑定
+
+| ID | 覆盖 | 落地方式 |
+|---|---|---|
+| `runtime.generic` | 任何能加载 `core_skills` 并接受任务包的 Agent | 通用会话 / 人设 / system prompt |
+| `runtime.skill-projection` | `yss-skill-registry.yaml` 的 `agent_runtime_roots`（claude、codex、cursor、hermes、pi、qoder、trae） | 投影技能 + subagent 任务包 |
+| `runtime.grok` | Grok Bot | 持久 Bot、群聊或 1:1 交接；群超过 6 人改 1:1，不改逻辑协作组 |
+
+新增平台：先加 `runtimes` 条目，再写适配说明。不要把平台限制写进 `roles`。
+
+Grok 专用操作见 `docs/templates/grok-bot-profile-template.md`。通用实例化见 `docs/templates/digital-human-runtime-profile-template.md`。
+
+## 两套批准
+
+| 名称 | 关闭什么 | 谁点 |
+|---|---|---|
+| 运行时副作用审批 | 发消息、改生产、付款、删数据等工具动作 | 生物人（各平台自己的 Allow / 确认框） |
+| 生命周期会签 | `gate.*` 与独立 code review | 见 YAML `gate_policy` |
+
+会签写入 `docs/templates/approval-record-template.yaml`，带 `runtime_id`、`principal_ref` 与实例引用。起草者不得出现在会签人里。`gate.release-ready`、对外商务合同、运行时外部副作用，以及未列入会签表的 `gate.design-reviewed` / `gate.architecture-reviewed` 仍须生物人。
+
+## 实例化
+
+- 模板仓：`publish-singleton-profiles`。账户级只发布一套职称 profile，不按功能再拆。
+- `project-instance`：`duplicate-and-bind-repo-path`。复制 YAML 的 `title` / `description` / `core_skills`，写入本仓库路径，选择 `runtime_id`。步骤见 `docs/templates/digital-human-runtime-profile-template.md`。外部 `create-yss-spec` 尚未接管此步骤。
+
+## 任务包最低字段
+
+`task_id`、`work_unit_id`、`actor_id`、数字人角色 ID、`runtime_id`、执行态、从角色表复制的 `core_skills` / `forbidden_skills`、`contract.kind/id/version`、输入资产、允许写路径、禁止事项、验收、验证命令、证据、下游消费者和汇合方式。