create-yss-spec 3.3.1 → 3.3.3

package/template/.claude/skills/yss-stage-decision/tests/run-scenarios.mjs

@@ -1,146 +0,0 @@
-#!/usr/bin/env node
-import { buildDecisionFixture } from "../../../../scripts/fixtures/user-decision/build-fixture.mjs";
-import { createHash } from "node:crypto";
-import { spawnSync } from "node:child_process";
-import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { tmpdir } from "node:os";
-import { parseDocument } from "../../../../scripts/vendor/yaml.mjs";
-
-const testsRoot = dirname(fileURLToPath(import.meta.url));
-const projectRoot = resolve(testsRoot, "../../../..");
-const validator = join(testsRoot, "..", "scripts", "validate-domain-strategy.mjs");
-const packageValidator = join(testsRoot, "..", "scripts", "validate-stage-decision-package.mjs");
-const contextValidator = join(projectRoot, "scripts", "verify-context-contract");
-const migrationTool = join(testsRoot, "..", "scripts", "migrate-context-references.mjs");
-const validTemplate = join(testsRoot, "fixtures", "valid-supplier-domain.yaml");
-const validPackageTemplate = join(testsRoot, "fixtures", "valid-stage-decision-package.yaml");
-
-function canonical(value) {
-  if (Array.isArray(value)) return value.map(canonical);
-  if (value && typeof value === "object") return Object.fromEntries(Object.keys(value).sort().map((key) => [key, canonical(value[key])]));
-  return value;
-}
-
-function digestYaml(source) {
-  const document = parseDocument(source, { maxAliasCount: 0, uniqueKeys: true });
-  if (document.errors.length) throw new Error(document.errors[0].message);
-  return `sha256:${createHash("sha256").update(JSON.stringify(canonical(document.toJS({ maxAliasCount: 0 })))).digest("hex")}`;
-}
-
-function run(command, file, contextRoot) {
-  return spawnSync(process.execPath, [command, file, "--root", contextRoot], { cwd: projectRoot, encoding: "utf8" });
-}
-
-function expectBlocked(result, pattern, label) {
-  if (result.status === 0 || !pattern.test(`${result.stdout}\n${result.stderr}`)) throw new Error(`${label} should be blocked: ${result.stderr}`);
-}
-
-const contextSource = `---
-context_schema_version: 1
----
-# 领域上下文
-
-## 流程术语
-
-| 术语 | 含义 | 英文标识 | 避免 / 备注 |
-|---|---|---|---|
-| Spec | 产品研发规格。 | — |  |
-
-## 业务术语
-
-| 术语 | 含义 | 英文标识 | 适用业务责任区 | 避免 / 备注 |
-|---|---|---|---|---|
-| 供应商 | 提供商品或服务的业务主体。 | Supplier | Global | 避免：\`厂商\` |
-| 准入决定 | 合规审查形成的准入结论。 | AdmissionDecision | ComplianceReview | 避免：\`审批结果\` |
-`;
-
-const temporaryRoot = await mkdtemp(join(tmpdir(), "yss-stage-decision-v2-"));
-try {
-  await writeFile(join(temporaryRoot, "CONTEXT.md"), contextSource);
-  const contextResult = spawnSync(process.execPath, [contextValidator, "--root", temporaryRoot, "--allowed-context", "SupplierManagement", "--allowed-context", "ComplianceReview", "--allowed-context", "ProcurementExecution", "--term-ref", "Global/Supplier", "--term-ref", "ComplianceReview/AdmissionDecision", "--json"], { cwd: projectRoot, encoding: "utf8" });
-  if (contextResult.status !== 0) throw new Error(`context fixture should pass: ${contextResult.stderr}`);
-  const context = JSON.parse(contextResult.stdout);
-
-  const domainApprovalRef = join(temporaryRoot, "domain-approval.json");
-  const domainSource = (await readFile(validTemplate, "utf8"))
-    .replace(".agents/skills/yss-stage-decision/tests/fixtures/domain-strategy-approval.yaml", domainApprovalRef)
-    .replace("<document-digest>", context.document_digest)
-    .replace("<referenced-terms-digest>", context.referenced_terms_digest);
-  const domainFile = join(temporaryRoot, "domain-strategy.yaml");
-  await writeFile(domainFile, domainSource);
-  const domainDecision = buildDecisionFixture(join(temporaryRoot, "domain-decision"), { boundary: "gate.domain-strategy-approved", subjectRef: domainFile });
-  const domainApproval = parseDocument(await readFile(join(testsRoot, "fixtures/domain-strategy-approval.yaml"), "utf8")).toJS();
-  await writeFile(domainApprovalRef, JSON.stringify({ ...domainApproval, subject_ref: domainFile, approval_scope: domainDecision.requirement.scope, user_decision_ref: domainDecision.ref }));
-  const pass = run(validator, domainFile, temporaryRoot);
-  if (pass.status !== 0) throw new Error(`valid v2 fixture should pass: ${pass.stderr}`);
-
-  const legacyFile = join(temporaryRoot, "legacy-domain.yaml");
-  await writeFile(legacyFile, domainSource.replace("schema_version: 2", "schema_version: 1"));
-  expectBlocked(run(validator, legacyFile, temporaryRoot), /migration-required/, "legacy domain contract");
-
-  const migratableLegacy = join(temporaryRoot, "migratable-legacy-domain.yaml");
-  const migratableLegacySource = domainSource
-    .replace("schema_version: 2", "schema_version: 1")
-    .replace(/context_snapshot:\n[\s\S]*?\ndownstream_mapping:/, "terminology_refs: [CONTEXT.md#Supplier, contexts/ComplianceReview/CONTEXT.md#AdmissionDecision]\ndownstream_mapping:");
-  await writeFile(migratableLegacy, migratableLegacySource);
-  const migrated = spawnSync(process.execPath, [migrationTool, migratableLegacy, "--root", temporaryRoot], { cwd: projectRoot, encoding: "utf8" });
-  if (migrated.status !== 0) throw new Error(`migratable v1 contract should migrate: ${migrated.stderr}`);
-  const migratedValue = JSON.parse(migrated.stdout);
-  if (migratedValue.schema_version !== 2 || migratedValue.terminology_refs !== undefined || migratedValue.context_snapshot.context_ref !== "CONTEXT.md" || migratedValue.context_snapshot.term_refs.join(",") !== "ComplianceReview/AdmissionDecision,Global/Supplier") throw new Error("migrated context snapshot is incomplete");
-
-  const ambiguousLegacy = join(temporaryRoot, "ambiguous-legacy-domain.yaml");
-  await writeFile(ambiguousLegacy, migratableLegacySource.replace("CONTEXT.md#Supplier, contexts/ComplianceReview/CONTEXT.md#AdmissionDecision", "contexts/ComplianceReview/CONTEXT.md"));
-  const ambiguousMigration = spawnSync(process.execPath, [migrationTool, ambiguousLegacy, "--root", temporaryRoot], { cwd: projectRoot, encoding: "utf8" });
-  expectBlocked(ambiguousMigration, /migration-required.*无法唯一定位|无法唯一定位.*migration-required/, "ambiguous legacy reference");
-
-  const wrongPath = join(temporaryRoot, "wrong-context-path.yaml");
-  await writeFile(wrongPath, domainSource.replace("context_ref: CONTEXT.md", "context_ref: contexts/ComplianceReview/CONTEXT.md"));
-  expectBlocked(run(validator, wrongPath, temporaryRoot), /context_ref.*CONTEXT\.md/, "nested context path");
-
-  const staleContext = join(temporaryRoot, "stale-context.yaml");
-  await writeFile(staleContext, domainSource.replace(context.document_digest, "sha256:stale"));
-  expectBlocked(run(validator, staleContext, temporaryRoot), /document_digest/, "stale context digest");
-
-  const invalidDirection = join(temporaryRoot, "invalid-direction.yaml");
-  await writeFile(invalidDirection, domainSource.replace("direction_explanation: 申请资料由", "direction_explanation: \n    ignored: 申请资料由"));
-  expectBlocked(run(validator, invalidDirection, temporaryRoot), /direction_explanation/, "missing direction explanation");
-
-  const sharedKernel = join(temporaryRoot, "shared-kernel.yaml");
-  await writeFile(sharedKernel, domainSource.replace("relationship_pattern: Customer/Supplier", "relationship_pattern: Shared Kernel"));
-  expectBlocked(run(validator, sharedKernel, temporaryRoot), /shared_kernel_approval_ref/, "unapproved Shared Kernel");
-
-  const unknownContext = join(temporaryRoot, "unknown-context.yaml");
-  await writeFile(unknownContext, domainSource.replace("to_context: ComplianceReview", "to_context: UnknownContext"));
-  expectBlocked(run(validator, unknownContext, temporaryRoot), /未引用已声明上下文|未在领域战略中登记/, "unknown context");
-
-  const packageApprovalRef = join(temporaryRoot, "package-approval.json");
-  const packageSource = (await readFile(validPackageTemplate, "utf8"))
-    .replace(".agents/skills/yss-stage-decision/tests/fixtures/stage-decision-approval.yaml", packageApprovalRef)
-    .replace("<document-digest>", context.document_digest)
-    .replace("<referenced-terms-digest>", context.referenced_terms_digest)
-    .replace("<domain-strategy-digest>", digestYaml(domainSource));
-  const packageFile = join(temporaryRoot, "stage-decision.yaml");
-  await writeFile(packageFile, packageSource);
-  const packageDecision = buildDecisionFixture(join(temporaryRoot, "package-decision"), { boundary: "gate.stage-decision-package-approved", subjectRef: packageFile });
-  const packageApproval = parseDocument(await readFile(join(testsRoot, "fixtures/stage-decision-approval.yaml"), "utf8")).toJS();
-  await writeFile(packageApprovalRef, JSON.stringify({ ...packageApproval, subject_ref: packageFile, approval_scope: packageDecision.requirement.scope, user_decision_ref: packageDecision.ref }));
-  const packagePass = run(packageValidator, packageFile, temporaryRoot);
-  if (packagePass.status !== 0) throw new Error(`valid v2 stage decision package should pass: ${packagePass.stderr}`);
-
-  const packageLegacy = join(temporaryRoot, "legacy-stage-decision.yaml");
-  await writeFile(packageLegacy, packageSource.replace("schema_version: 2", "schema_version: 1"));
-  expectBlocked(run(packageValidator, packageLegacy, temporaryRoot), /migration-required/, "legacy stage decision contract");
-
-  const packageBlocker = join(temporaryRoot, "stage-decision-blocker.yaml");
-  await writeFile(packageBlocker, packageSource.replace("type: deferred", "type: blocker"));
-  expectBlocked(run(packageValidator, packageBlocker, temporaryRoot), /blocker/, "blocker package");
-
-  const packageWrongArray = join(temporaryRoot, "stage-decision-wrong-array.yaml");
-  await writeFile(packageWrongArray, packageSource.replace("target_users: [采购专员、合规专员]", "target_users: [42]"));
-  expectBlocked(run(packageValidator, packageWrongArray, temporaryRoot), /target_users\[0\]/, "package non-string array item");
-} finally {
-  await rm(temporaryRoot, { recursive: true, force: true });
-}
-process.stdout.write("业务边界与规则设计 v2 场景验证通过\n");

package/template/.claude/skills/yss-tactical-design/SKILL.md

@@ -1,41 +0,0 @@
----
-name: yss-tactical-design
-description: 在 YSS 技术分析阶段将批准的战略领域输入细化为可审查的聚合、行为、一致性和 Gateway 设计；不生成生产代码。
----
-
-# yss-tactical-design
-
-本 skill 负责 DDD 战术设计，不新增生命周期主阶段，也不替代 `yss-stage-decision` 或 `yss-domain`。
-
-## 适用边界
-
-- 由 `yss-technical-design` 在已确认 `domain-driven` 的技术设计分支中调用；传统 MVC 使用 `yss-mvc-design`，不得按状态或一致性影响单独推断为 DDD。
-- 输入必须是版本当前的 Spec、功能架构、战略 DDD、状态矩阵、OpenAPI Draft / Freeze、ADR 和工程约束。若输入来自 Strategic Design Handoff，必须先用 `scripts/verify-strategic-context-import` 验证 schema v3 `source_context_snapshot` / `context_delta` 已对账到目标仓根 `CONTEXT.md`，Visual Baseline Bundle 可读取且 digest 当前，并且目标侧 `context_reconciliation` 有效；未完成时不得开始战术建模。
-- 默认将结果写入系统概要设计 / 数据架构中的 Tactical DDD Check；聚合、状态机、一致性或持久化映射复杂到无法清楚表达时，才升级为独立战术设计文档。
-- 没有聚合、状态、不变量、一致性或领域边界影响时返回 `not-applicable` 及原因，不生成空设计。
-
-## 设计内容
-
-必须明确 Aggregate Root、Entity、Value Object、领域行为、状态转换、不变量、一致性 / 事务、幂等 / 并发、Domain Event、Gateway、持久化映射和 Domain / Application 测试 seam。
-
-数据库表、HTTP 调用链或菜单结构不能单独决定聚合边界；OpenAPI 不得暴露内部聚合、Repository 或持久化表结构。
-
-## 输出与状态
-
-新产物输出 Technical Design Contract schema v2 的 DDD `design` 分支（沿用 v1 DDD 内容结构）；旧独立 tactical-design contract schema v1 仅显式兼容读取，不自动迁移或批准。输出验证结果、评审引用和影响标记；来自 Strategic Design Handoff 时保留 `strategic_context_import_ref` 与 `context_reconciliation_ref`。状态使用 `draft`、`ready-for-human`、`approved`、`blocked`、`stale`、`drift`、`new_impacts`。
-
-当用户或当前技术分析 / 架构评审合同明确要求聚合关系、状态转换、调用链、数据流或 Before/After 图示时，追加使用 `archify`。图必须从当前 Spec、ADR、OpenAPI、Tactical Design Contract 和代码证据派生，保存成 `*.archify.json`、`*.html` 与 `*.receipt.json` 配对资产；它是审查证据，不是新的事实源或批准门禁。没有明确图示要求时，不把 `archify` 加入 `required_skills`。
-
-本 skill 不能自行批准资产、设置 `ready-for-agent`、创建 Ticket 或修改生命周期状态。批准由 `yss-product-lifecycle` 维护；独立架构评审使用 `evidence.tactical-design-review`。
-
-## 与实现交接
-
-批准且版本当前的战术设计合同由 `Slice Implementation Contract` 引用，再由 `yss-domain` 使用 `behavior-tdd` 实现。`yss-domain` 不得静默重新定义聚合或不变量；发现新的 API、状态、数据或架构影响时必须返回 `new_impacts` / `drift` 并重新路由。
-
-合同、Schema、校验规则和示例见 `references/`；使用 `scripts/validate-tactical-design.mjs` 做只读验证。该 skill 不生成 Java、Repository、Controller、DTO、OpenAPI Freeze、实现 Ticket 或生产代码。
-
-## 战略交接快照包
-
-跨仓交接使用 `scripts/strategic-handoff export / verify / import`。正式导出前补齐源战略的稳定规则 ID、关键场景和当前批准绑定；源资产原字节冻结、包内路径通过清单解析。目标导入只产生快照和对账/承接草案，正式 reconciliation 通过后才能进入战术设计。流程与字段见 `docs/process/strategic-handoff-package.md`。
-
-战术合同必须绑定 `strategic_handoff` 导入收据、包摘要、正式目标对账及逐条承接 rows。来自导入包时禁止仅填 `upstream_current: true`。批准前执行 `scripts/verify-strategic-handoff-consumption --root <target> <tactical>`；存在受控延期时按切片执行 `--slice <slice-id>`，实际核验通过且合同批准后才可继续相关切片。最新源规则、关键场景或资产变化使依赖项 stale；未知依赖扩大阻断，业务冲突回交战略方。结果绑定当前包与战术摘要，不能复用旧输出宣布 ready-for-agent。

package/template/.claude/skills/yss-tactical-design/agents/openai.yaml

@@ -1,4 +0,0 @@
-interface:
-  display_name: "YSS Tactical DDD Design"
-  short_description: "聚合、不变量、状态机、一致性与 Gateway 的战术设计"
-  default_prompt: "基于批准且版本当前的上游资产，完成可审查的 YSS DDD 战术设计并返回结构化验证结果。"

package/template/.claude/skills/yss-tactical-design/references/output-template.md

@@ -1,33 +0,0 @@
-pipeline: <feature-id>
-stage: system-data-engineering
-status: draft
-owner: ai
-
-# <功能名称> Tactical DDD Design
-
-仅用于已确认 domain-driven 分支的阅读视图；引用 Technical Design Contract v2 的 design，不复制共同输入与审批状态。MVC 使用 yss-mvc-design。
-
-## 上游引用
-
-| 资产 | ref | version / digest | 状态 |
-|---|---|---|---|
-| Spec |  |  |  |
-| Strategic DDD |  |  |  |
-| Strategic Design Handoff v3 |  |  |  |
-| Visual Baseline Bundle v1 |  |  |  |
-| Strategic Context Import / Context Reconciliation |  |  |  |
-| 状态矩阵 |  |  |  |
-| OpenAPI / 无 API 影响记录 |  |  |  |
-
-## Tactical DDD Check
-
-| 限界上下文 | 聚合根 | Entity / Value Object | 行为与不变量 | 一致性边界 | Gateway | 测试 seam |
-|---|---|---|---|---|---|---|
-|  |  |  |  |  |  |  |
-
-## 结论
-
-- 复杂度升级：是 / 否
-- API / 数据 / 状态新增影响：是 / 否
-- 评审结论：Approved / Blocked
-- 下一步：

package/template/.claude/skills/yss-tactical-design/references/tactical-design-contract.md

@@ -1,45 +0,0 @@
-# Tactical DDD Design Contract
-
-## 输入
-
-必须引用批准且版本当前的 Spec、功能架构、战略 DDD、原型状态矩阵、OpenAPI Draft / Freeze（或无 API 影响记录）、ADR 和工程约束。来自 Strategic Design Handoff 时，额外要求 v3 交接包、`strategic_context_import_ref` 和目标仓 `context_reconciliation_ref`；目标根 `CONTEXT.md` 未完成增量对账前返回 `blocked`。所有引用都必须带版本或 digest；不可读或过期引用返回 `blocked` / `stale`。
-
-## 输出
-
-以下 v1 结构作为新 Technical Design Contract v2 的 DDD `design` 内容使用。旧独立 v1 文件保持显式只读兼容；新合同共同头与战略交接绑定由 `yss-technical-design` 持有，分支不重复保存。
-
-```yaml
-schema_version: 1
-tactical_design_id: tactical-design.<feature>
-tactical_version: v1
-status: draft | ready-for-human | approved | blocked | stale | drift | new_impacts | not-applicable
-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: v1
-digest: sha256:<digest>
-evidence_refs: []
-```
-
-## 设计规则
-
-1. 聚合边界由业务行为和不变量决定，不由数据库表或外键自动推导。
-2. 每个聚合根必须列出行为、不变量和一致性边界。
-3. 状态转换必须绑定领域行为，禁止只有状态字段而没有行为语义。
-4. Gateway 接口属于 Domain，Repository / Mapper / GatewayImpl 属于 Infrastructure。
-5. OpenAPI schema 使用上下文公开语言，不泄漏内部聚合或持久化结构。
-6. 复杂跨聚合一致性、并发、幂等、事件补偿或持久化错位必须写明策略，必要时升级独立文档。
-7. 实现发现新影响时必须阻断并回到生命周期重新路由。
-
-跨仓快照消费在 v2 共同头（旧独立 v1 则为根对象）绑定 `strategic_handoff`；字段与实际命令以 `docs/process/strategic-handoff-package.md` 为准。

package/template/.claude/skills/yss-tactical-design/references/tactical-design.schema.json

@@ -1,31 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://yss.dev/schemas/tactical-design.schema.json",
-  "title": "YSS Tactical DDD Design Contract",
-  "type": "object",
-  "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"],
-  "properties": {
-    "schema_version": {"const": 1},
-    "tactical_design_id": {"type": "string", "pattern": "^tactical-design\\.[a-z0-9][a-z0-9-]*$"},
-    "tactical_version": {"type": "string", "pattern": "^v[0-9]+$"},
-    "status": {"enum": ["draft", "ready-for-human", "approved", "blocked", "stale", "drift", "new_impacts", "not-applicable"]},
-    "context_ref": {"type": "string", "minLength": 1},
-    "aggregate_catalog": {"type": "array", "minItems": 1},
-    "entity_catalog": {"type": "array", "minItems": 1},
-    "value_object_catalog": {"type": "array"},
-    "behavior_catalog": {"type": "array", "minItems": 1},
-    "invariant_catalog": {"type": "array", "minItems": 1},
-    "state_transition_catalog": {"type": "array", "minItems": 1},
-    "consistency_policy": {"type": "object", "minProperties": 1},
-    "domain_event_catalog": {"type": "array"},
-    "gateway_catalog": {"type": "array", "minItems": 1},
-    "persistence_mapping": {"type": "array", "minItems": 1},
-    "test_seams": {"type": "array", "minItems": 1},
-    "adr_candidates": {"type": "array"},
-    "upstream_impact": {"type": "object", "minProperties": 1},
-    "version": {"type": "string", "pattern": "^v[0-9]+$"},
-    "digest": {"type": "string", "pattern": "^sha256:[A-Fa-f0-9]{64}$"},
-    "evidence_refs": {"type": "array", "items": {"type": "string"}}
-  },
-  "additionalProperties": true
-}

package/template/.claude/skills/yss-tactical-design/references/validation-rules.md

@@ -1,13 +0,0 @@
-# Tactical DDD Validation Rules
-
-- 根对象必须包含合同要求的字段，状态只能使用生命周期状态集合。
-- `aggregate_catalog`、`behavior_catalog`、`invariant_catalog`、`state_transition_catalog`、`consistency_policy` 和 `test_seams` 不能为空。
-- 聚合、Entity、Value Object、行为、不变量、状态转换、事件和 Gateway ID 必须唯一且引用已声明对象。
-- 聚合根必须是 Entity；Entity 和 Value Object 不得跨聚合隐式共享身份。
-- 每个行为至少引用一个聚合和一个不变量；每个状态转换必须引用已声明行为。
-- `api_exposure: internal-only` 是内部聚合的唯一允许值；其他值需要回到 API 影响分析。
-- Gateway 的 `layer` 必须为 `Domain`，持久化实现不得出现在 Domain 目录。
-- `consistency_policy` 必须说明事务边界、并发、幂等和跨聚合策略。
-- 上游引用发生版本变化时，设计标记为 `stale`，不得进入 `approved` 或 `ready-for-agent`。
-- 若合同标记 `model_origin: strategic-concept`，必须阻断并要求完成战术细化。
-- 当 `complexity.escalate_to_standalone` 为真时，必须提供独立文档引用；否则仅允许作为嵌入式 Tactical DDD Check 消费。

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

@@ -1,222 +0,0 @@
-#!/usr/bin/env node
-import { readFile } from "node:fs/promises";
-import process from "node:process";
-import { pathToFileURL } from "node:url";
-import { parseDocument } from "../../../../scripts/vendor/yaml.mjs";
-
-import { parseArgs } from "node:util";
-import { verifyConsumption } from "../../../../scripts/lib/strategic-handoff-consumption.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}`);
-  }
-}
-
-export 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 { values, positionals } = parseArgs({ allowPositionals: true, options: { root: { type: "string", default: process.cwd() }, slice: { type: "string" } } });
-  const file = positionals[0];
-  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 data = document.toJS({ maxAliasCount: 0 });
-  const errors = validate(data);
-  if (data.strategic_handoff || data.strategic_context_import_ref || data.upstream_impact?.source_kind === "strategic-handoff") {
-    try { const result = await verifyConsumption(data, { root: values.root, sliceRef: values.slice }); if (result.result !== "verified") errors.push(JSON.stringify(result)); } catch (error) { errors.push(error.message); }
-  }
-  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`);
-}
-
-if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) main().catch((error) => { process.stderr.write(`${error.message}\n`); process.exitCode = 1; });

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

@@ -1,21 +0,0 @@
-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/.claude/skills/yss-tactical-design/tests/fixtures/invalid-missing-consistency-policy.yaml

@@ -1,21 +0,0 @@
-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/.claude/skills/yss-tactical-design/tests/fixtures/invalid-missing-invariant.yaml

@@ -1,21 +0,0 @@
-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: []