create-yss-spec 3.3.1 → 3.3.3

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

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

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

@@ -1,80 +0,0 @@
-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/.claude/skills/yss-tactical-design/tests/run-scenarios.mjs

@@ -1,47 +0,0 @@
-#!/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/.claude/skills/yss-technical-design/SKILL.md

@@ -1,31 +0,0 @@
----
-name: yss-technical-design
-description: 在 YSS 技术分析中统一承接需求与战略输入，按已确认的 DDD 或传统 MVC 架构组织设计合同。
----
-
-# YSS 技术设计
-
-由 `yss-product-lifecycle` 调度，负责 `work-unit.technical-analysis` 的技术设计，不另起生命周期、不生成生产代码。生命周期维护批准和状态；`yss-implementation-contract-compiler` 消费批准且当前的设计，起草实现合同。
-
-## 输入与架构选择
-
-先读根 `CONTEXT.md`、已批准且当前的 Spec、业务规则、关键场景、适用的 API 契约、ADR 和工程约束。没有 API 或其他专项影响时记录有依据的不适用，不生成占位设计。
-
-按项目绑定架构选择的来源及摘要。新工程复用 `scaffold-architecture-decisions.yaml` 的用户确认决定，先确认再进入分支，后续脚手架消费同一决定；既有工程沿用已登记架构，架构转换另行立项。只有 `domain-driven` 和 `layered-mvc` 两种架构族，不能从目录推断或默认 DDD。具体 Profile 及模块边界消费技能注册表与 `docs/agents/backend-architecture-profiles.md`。
-
-- `domain-driven`：调用 `yss-tactical-design`，补齐适用的战略领域输入。
-- `layered-mvc`：调用 `yss-mvc-design`，不要求战略 DDD、聚合、值对象、Domain Event 或 DDD Gateway。
-
-已有 Strategic Design Handoff 时，两种分支都必须先完成导入和目标词汇对账，再逐条承接规则与关键场景。没有战略交接包的项目直接消费批准需求，不能为 MVC 补造战略 DDD。
-
-## 合同与验证
-
-新产物使用 schema v2 Technical Design Contract：共同头记录架构来源、输入版本与摘要、规则/场景承接、评审证据和状态，`design` 保存架构专属内容。合同格式与兼容规则见 `references/technical-design-contract.md`，Schema 见 `references/technical-design.schema.json`。
-
-运行 `node .agents/skills/yss-technical-design/scripts/validate-technical-design.mjs <合同> --root <项目根>`。整体存在延期或冲突即阻断整体；相关切片可带 `--slice <切片ID>` 按依赖核验，仍须合同已批准。校验成功只返回审查输入，不批准、不设置 `ready-for-agent`。
-
-schema v1 战术合同只按 DDD 显式兼容读取；使用 `--legacy-ddd`，不能解释为 MVC。迁移不自动批准，输入或架构变化必须重新校验并按现有门禁审查。新合同使用 `artifact.technical-design` / `evidence.technical-design-review`；旧 DDD 稳定 ID 保留原含义。
-
-## 交接
-
-按现有架构审查门禁进行独立评审。批准且版本当前后交回生命周期，再交编译器；DDD 实现使用 `yss-domain`，MVC 实现按已登记 Profile 的能力与 Recipe 路由。发现 `stale`、`drift`、`new_impacts` 或路径越界时回交重路由。需要图示时按用户或合同要求调用 `archify`，图只作派生证据。

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

@@ -1,4 +0,0 @@
-interface:
-  display_name: "YSS 技术设计"
-  short_description: "按已确认 DDD 或 MVC 架构组织技术设计合同"
-  default_prompt: "基于当前批准输入和已确认架构，按已确认 DDD 或 MVC 架构组织技术设计合同，返回待生命周期审查的结果。"

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

@@ -1,290 +0,0 @@
-{
-  "type": "object",
-  "properties": {
-    "schema_version": {
-      "const": 2
-    },
-    "technical_design_id": {
-      "type": "string",
-      "pattern": "^technical-design\\.[a-z0-9][a-z0-9-]*$"
-    },
-    "version": {
-      "type": "string",
-      "pattern": "^v[1-9][0-9]*$"
-    },
-    "status": {
-      "enum": [
-        "draft",
-        "ready-for-human",
-        "approved",
-        "blocked",
-        "stale",
-        "drift",
-        "new_impacts"
-      ]
-    },
-    "context_ref": {
-      "const": "CONTEXT.md"
-    },
-    "architecture": {
-      "type": "object",
-      "properties": {
-        "family": {
-          "enum": [
-            "domain-driven",
-            "layered-mvc"
-          ]
-        },
-        "project_id": {
-          "type": "string",
-          "minLength": 1
-        },
-        "source_kind": {
-          "enum": [
-            "scaffold-decision",
-            "existing-registration"
-          ]
-        },
-        "decision_ref": {
-          "type": "string",
-          "minLength": 1
-        },
-        "decision_digest": {
-          "type": "string",
-          "pattern": "^sha256:[a-f0-9]{64}$"
-        }
-      },
-      "required": [
-        "family",
-        "project_id",
-        "source_kind",
-        "decision_ref",
-        "decision_digest"
-      ],
-      "additionalProperties": false
-    },
-    "inputs": {
-      "type": "array",
-      "minItems": 2,
-      "items": {
-        "type": "object",
-        "properties": {
-          "ref": {
-            "type": "string",
-            "minLength": 1
-          },
-          "version": {
-            "type": "string",
-            "minLength": 1
-          },
-          "digest": {
-            "type": "string",
-            "pattern": "^sha256:[a-f0-9]{64}$"
-          },
-          "kind": {
-            "enum": [
-              "context",
-              "spec",
-              "rules",
-              "scenarios",
-              "api",
-              "adr",
-              "engineering",
-              "strategic"
-            ]
-          }
-        },
-        "required": [
-          "ref",
-          "version",
-          "digest",
-          "kind"
-        ],
-        "additionalProperties": false
-      }
-    },
-    "source_items": {
-      "type": "array",
-      "minItems": 0,
-      "items": {
-        "type": "object",
-        "properties": {
-          "source_id": {
-            "type": "string",
-            "minLength": 1
-          },
-          "kind": {
-            "enum": [
-              "rule",
-              "scenario"
-            ]
-          },
-          "critical": {
-            "type": "boolean"
-          },
-          "source_ref": {
-            "type": "string",
-            "minLength": 1
-          }
-        },
-        "required": [
-          "source_id",
-          "kind",
-          "critical",
-          "source_ref"
-        ],
-        "additionalProperties": false
-      }
-    },
-    "traceability": {
-      "type": "array",
-      "items": {
-        "type": "object",
-        "properties": {
-          "source_id": {
-            "type": "string",
-            "minLength": 1
-          },
-          "disposition": {
-            "enum": [
-              "implemented",
-              "deferred",
-              "not-applicable",
-              "pending",
-              "conflict"
-            ]
-          },
-          "tactical_refs": {
-            "type": "array",
-            "items": {
-              "type": "string",
-              "minLength": 1
-            },
-            "uniqueItems": true
-          },
-          "test_seam_refs": {
-            "type": "array",
-            "items": {
-              "type": "string",
-              "minLength": 1
-            },
-            "uniqueItems": true
-          },
-          "evidence_refs": {
-            "type": "array",
-            "items": {
-              "type": "string",
-              "minLength": 1
-            },
-            "uniqueItems": true
-          },
-          "dependency_status": {
-            "enum": [
-              "known",
-              "unknown"
-            ]
-          },
-          "dependent_slice_refs": {
-            "type": "array",
-            "items": {
-              "type": "string",
-              "minLength": 1
-            },
-            "uniqueItems": true
-          },
-          "scenario_tests": {
-            "type": "array",
-            "items": {
-              "type": "object",
-              "properties": {
-                "outcome": {
-                  "enum": [
-                    "success",
-                    "failure"
-                  ]
-                },
-                "seam_ref": {
-                  "type": "string",
-                  "minLength": 1
-                }
-              },
-              "required": [
-                "outcome",
-                "seam_ref"
-              ],
-              "additionalProperties": false
-            }
-          },
-          "reason": {
-            "type": "string",
-            "minLength": 1
-          },
-          "risk": {
-            "type": "string",
-            "minLength": 1
-          },
-          "owner": {
-            "type": "string",
-            "minLength": 1
-          },
-          "followup_ticket_ref": {
-            "type": "string",
-            "minLength": 1
-          },
-          "verification_plan": {
-            "type": "string",
-            "minLength": 1
-          },
-          "target_version": {
-            "type": "string",
-            "minLength": 1
-          }
-        },
-        "required": [
-          "source_id",
-          "disposition",
-          "dependency_status",
-          "dependent_slice_refs"
-        ],
-        "additionalProperties": true
-      }
-    },
-    "strategic_handoff": {
-      "type": "object"
-    },
-    "design": {
-      "type": "object"
-    },
-    "evidence_refs": {
-      "type": "array",
-      "items": {
-        "type": "string",
-        "minLength": 1
-      },
-      "uniqueItems": true
-    },
-    "digest": {
-      "type": "string",
-      "pattern": "^sha256:[a-f0-9]{64}$"
-    }
-  },
-  "required": [
-    "schema_version",
-    "technical_design_id",
-    "version",
-    "status",
-    "context_ref",
-    "architecture",
-    "inputs",
-    "source_items",
-    "traceability",
-    "design",
-    "evidence_refs",
-    "digest"
-  ],
-  "additionalProperties": false,
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://yss.dev/schemas/technical-design-v2.json",
-  "title": "YSS Technical Design Contract v2",
-  "$comment": "共同合同权威；完整分支 Schema 由 scripts/generate-schema.mjs 派生。"
-}

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

@@ -1,31 +0,0 @@
-# Technical Design Contract v2
-
-共同合同字段由 `technical-design-common.schema.json` 定义，完整 `technical-design.schema.json` 通过 `scripts/generate-schema.mjs` 合并专项 Schema 派生，使用 `--check` 检查同步，`design` 按 `architecture.family` 校验：`domain-driven` 沿用 DDD v1 内容结构，`layered-mvc` 使用 `yss-mvc-design/references/mvc-design.schema.json`。DDD 内层的 schema/version/status 是分支内容版本，status 必须与共同头一致；战略交接绑定只写共同头，避免双重维护。
-
-## 共同头
-
-- `schema_version: 2`、`technical_design_id: technical-design.<name>`、`version: vN`、`status`、`context_ref: CONTEXT.md`。
-- `architecture`：`family`、`project_id`、`source_kind: scaffold-decision | existing-registration`、`decision_ref`、`decision_digest`。新项目引用正式且 current 的脚手架决定，所选项目必须已由用户确认；既有登记引用当前 `project_id` 和 `architecture_identity.architecture_family`，也可从登记的 `repositories` 数组按项目解析。架构来源变化须重新绑定和审查，不能改合同字段冒充用户改选。
-- `inputs`：每行 `{kind, ref, version, digest}`，kind 为 context/spec/rules/scenarios/api/adr/engineering/strategic；至少包含根 CONTEXT.md 与 Spec。适用的工程/API 约束同样绑定。无 API 影响理由记录在需求或工程输入中。DDD 另须 strategic 输入，MVC 不要求。
-- `source_items`：无战略包时从批准需求提取稳定规则和场景 `{source_id, kind: rule | scenario, critical, source_ref}`。source_ref 必须对应 inputs，不复制源正文成为第二事实源。
-- `traceability`：逐项对应 source_items。沿用 `tactical_refs` 字段名以兼容承接协议，其值在新合同中可指向 MVC 用例、规则或 DDD 对象；其他字段与战略承接 rows 相同。implemented 仅表示设计承接已落实，不表示代码已实现。
-- 有战略包时追加 `strategic_handoff`，按 `docs/process/strategic-handoff-package.md` 绑定导入收据、摘要、正式对账及 rows；本地补充规则仍可写 source_items / traceability，但不能重复维护包内来源。
-- `evidence_refs`：现有审查证据的可读取路径。approved 状态必须有评审证据，真正批准仍由生命周期核验适用批准记录；本校验器不产生批准。
-- `digest`：删除根 digest 后按键排序、数组保持顺序的 canonical JSON SHA-256，前缀 `sha256:`。来源文件的 digest 使用原始字节 SHA-256；这两种摘要不可混用。
-
-所有仓内引用相对 `--root` 解析；不接受越界或符号链接。输入摘要不匹配、未知架构、悬空落点、缺少关键场景成功/失败测试均阻断。延期与冲突按已声明的切片依赖阻断，依赖未知时整体阻断。
-
-## 设计与实现交接
-
-```bash
-node .agents/skills/yss-technical-design/scripts/validate-technical-design.mjs docs/design/technical-design.yaml --root <项目根>
-node .agents/skills/yss-technical-design/scripts/validate-technical-design.mjs docs/design/technical-design.yaml --root <项目根> --slice <切片ID>
-```
-
-编译器输入与 resolution 使用 `technical_design: {ref, version, digest}`，digest 是已持久化整个合同的原始字节摘要，并绑定 `slice_id`。命中 `backend-technical-design-impact` 或已有领域/状态/一致性影响条件时必须提供；编译与 freshness 检查重新执行验证，并核对架构族。没有相关设计影响的编译继续消费原有最小合同。
-
-schema v1 仅配合 `--legacy-ddd`（编译器绑定 `legacy_ddd: true`）读取为 DDD。旧 DDD 校验入口保留，不改变旧批准或历史文件。新写合同一律 v2；格式迁移不代表批准，架构、输入或设计变化走现有门禁重审。
-
-## MVC 示例
-
-可执行示例见 `../tests/fixtures.mjs` 的 `mvcFixture`：在临时项目绑定需求与现有登记，定义 server → service → repository、提交用例、规则、事务、存储映射和成功/失败 seam。它只用于模板验证，不生成产品实例 Spec。