create-yss-spec 3.1.3 → 3.3.0

package/template/scripts/lib/lifecycle-context-query.mjs

@@ -0,0 +1,137 @@
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { parseDocument } from "../vendor/yaml.mjs";
+import { ROOT, loadRegistry, semanticDigest, validateRegistry } from "./lifecycle-registry.mjs";
+import { loadSkillRegistry } from "./skill-registry.mjs";
+
+const LIFECYCLE_REGISTRY_REF = "docs/process/lifecycle-registry.yaml";
+const ORCHESTRATION_CONTRACT_REF = ".agents/skills/yss-product-lifecycle/references/orchestration-contract.yaml";
+const SKILL_REGISTRY_REF = "docs/agents/yss-skill-registry.yaml";
+
+function read(relativePath) {
+  return readFileSync(path.join(ROOT, relativePath), "utf8");
+}
+
+function sha256(source) {
+  return createHash("sha256").update(source).digest("hex");
+}
+
+function loadYaml(relativePath, label) {
+  const document = parseDocument(read(relativePath), { maxAliasCount: 0, uniqueKeys: true });
+  if (document.errors.length) throw new TypeError(`无法解析${label}: ${document.errors[0].message}`);
+  const value = document.toJS({ maxAliasCount: 0 });
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new TypeError(`${label}必须是对象`);
+  return value;
+}
+
+function canonicalize(value) {
+  if (Array.isArray(value)) return value.map(canonicalize);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.keys(value).sort().map((key) => [key, canonicalize(value[key])]));
+  }
+  return value;
+}
+
+function selectById(records, id, label) {
+  if (!id) return null;
+  const selected = records.find((record) => record.id === id);
+  if (!selected) throw new TypeError(`未知${label}: ${id}`);
+  return selected;
+}
+
+function collectPathReferences(value, references = new Set()) {
+  if (Array.isArray(value)) {
+    for (const item of value) collectPathReferences(item, references);
+  } else if (value && typeof value === "object") {
+    for (const item of Object.values(value)) collectPathReferences(item, references);
+  } else if (typeof value === "string" && /(?:^|\/)[^\s]+\.(?:md|ya?ml|json|mjs)(?:#.*)?$/.test(value)) {
+    references.add(value);
+  }
+  return references;
+}
+
+function selectedSkills(route, skillRegistry) {
+  if (!route) return [];
+  const ids = new Set([
+    route.primary_skill,
+    route.native?.skill,
+    ...(route.supporting_skills ?? []),
+    ...(route.skills ?? []),
+  ].filter(Boolean));
+  return skillRegistry.skills.filter((skill) => ids.has(skill.id));
+}
+
+export function queryLifecycleContext({ mode, stageId, workUnitId, include = [] } = {}) {
+  if (!mode && !stageId && !workUnitId && include.length === 0) {
+    throw new TypeError("至少提供 --mode、--stage、--work-unit 或 --include 之一");
+  }
+
+  const lifecycle = validateRegistry(loadRegistry());
+  const orchestration = loadYaml(ORCHESTRATION_CONTRACT_REF, "生命周期编排合同");
+  const skillRegistry = loadSkillRegistry();
+  const stage = selectById(lifecycle.stages, stageId, "阶段");
+  const workUnit = selectById(lifecycle.work_units, workUnitId, "工作单元");
+
+  if (mode && !(mode in orchestration.modes)) throw new TypeError(`未知模式: ${mode}`);
+  const normalizedIncludes = [...new Set(include.flatMap((value) => value.split(",")).map((value) => value.trim()).filter(Boolean))].sort();
+  for (const key of normalizedIncludes) {
+    if (!(key in orchestration)) throw new TypeError(`未知编排合同子树: ${key}`);
+  }
+
+  const route = workUnitId ? orchestration.work_unit_routes?.[workUnitId] ?? null : null;
+  const gates = stageId ? lifecycle.gates.filter((gate) => gate.stage === stageId) : [];
+  const artifacts = stageId ? lifecycle.artifacts.filter((artifact) => artifact.stage === stageId) : [];
+  const evidenceIds = new Set(gates.flatMap((gate) => gate.evidence ?? []));
+  const selected = Object.fromEntries(normalizedIncludes.map((key) => [key, orchestration[key]]));
+  const transition = workUnitId ? {
+    next: orchestration.transition_graph?.routes?.[workUnitId] ?? [],
+    forbidden_shortcuts: (orchestration.transition_graph?.forbidden_shortcuts ?? [])
+      .filter((edge) => edge.from === workUnitId || edge.to === workUnitId),
+  } : null;
+
+  const result = {
+    schema_version: 1,
+    query: {
+      include: normalizedIncludes,
+      mode: mode ?? null,
+      stage: stageId ?? null,
+      work_unit: workUnitId ?? null,
+    },
+    sources: {
+      lifecycle_registry: {
+        ref: LIFECYCLE_REGISTRY_REF,
+        semantic_sha256: semanticDigest(lifecycle),
+        status: lifecycle.status,
+      },
+      orchestration_contract: {
+        ref: ORCHESTRATION_CONTRACT_REF,
+        sha256: sha256(read(ORCHESTRATION_CONTRACT_REF)),
+      },
+      skill_registry: {
+        ref: SKILL_REGISTRY_REF,
+        sha256: sha256(read(SKILL_REGISTRY_REF)),
+        status: skillRegistry.status,
+      },
+    },
+    lifecycle: {
+      artifacts,
+      evidence: lifecycle.evidence.filter((item) => evidenceIds.has(item.id)),
+      gates,
+      stage,
+      work_unit: workUnit,
+    },
+    execution: {
+      mode: mode ? orchestration.modes[mode] : null,
+      selected,
+      transition,
+      work_unit_route: route,
+    },
+    skills: selectedSkills(route, skillRegistry),
+  };
+  result.references = [...collectPathReferences(result), LIFECYCLE_REGISTRY_REF, ORCHESTRATION_CONTRACT_REF, SKILL_REGISTRY_REF]
+    .filter((value, index, all) => all.indexOf(value) === index)
+    .sort();
+  return canonicalize(result);
+}
+

package/template/scripts/lib/lifecycle-transition.mjs

@@ -5,6 +5,7 @@ import { enforceFrontendDelivery } from "./frontend-delivery-boundary.mjs";
 
 const IMPLEMENTATION_WORK_UNIT = "work-unit.slice-implementation";
 const TICKET_DECOMPOSITION_WORK_UNIT = "work-unit.ticket-decomposition";
+const REPOSITORY_PREPARATION_WORK_UNIT = "work-unit.implementation-repository-preparation";
 
 function deepFreeze(value) {
   if (!value || typeof value !== "object" || Object.isFrozen(value)) return value;
@@ -26,9 +27,10 @@ const NEXT_ROUTES = deepFreeze({
   "work-unit.discovery-requirements": ["work-unit.domain-strategy-design", "work-unit.stage-decision", "work-unit.spec-synthesis"],
   "work-unit.domain-strategy-design": ["work-unit.stage-decision", "work-unit.spec-synthesis"],
   "work-unit.stage-decision": ["work-unit.spec-synthesis"],
-  "work-unit.spec-synthesis": ["work-unit.prototype-design", "work-unit.technical-analysis", TICKET_DECOMPOSITION_WORK_UNIT],
-  "work-unit.prototype-design": ["work-unit.technical-analysis", TICKET_DECOMPOSITION_WORK_UNIT],
-  "work-unit.technical-analysis": [TICKET_DECOMPOSITION_WORK_UNIT],
+  "work-unit.spec-synthesis": ["work-unit.prototype-design", "work-unit.technical-analysis", REPOSITORY_PREPARATION_WORK_UNIT],
+  "work-unit.prototype-design": ["work-unit.technical-analysis", REPOSITORY_PREPARATION_WORK_UNIT],
+  "work-unit.technical-analysis": [REPOSITORY_PREPARATION_WORK_UNIT],
+  [REPOSITORY_PREPARATION_WORK_UNIT]: [TICKET_DECOMPOSITION_WORK_UNIT],
   [TICKET_DECOMPOSITION_WORK_UNIT]: [IMPLEMENTATION_WORK_UNIT],
   [IMPLEMENTATION_WORK_UNIT]: ["work-unit.frontend-implementation-verification", "work-unit.code-review"],
   "work-unit.frontend-implementation-verification": ["work-unit.code-review"],
@@ -56,6 +58,15 @@ const BLOCKING_SIGNALS = Object.freeze({
   contractNotCurrent: "slice-contract-not-current",
   missingEvidence: "ticket-formalization-evidence-missing",
   stale: "ticket-formalization-stale",
+  repositoryDecisionRequired: "implementation-repository-decision-required",
+  repositoryLocationRequired: "implementation-repository-location-required",
+  repositoryOnboardingIncomplete: "implementation-repository-onboarding-incomplete",
+  scaffoldChoiceRequired: "scaffold-choice-required",
+  scaffoldContractUnapproved: "scaffold-contract-unapproved",
+  scaffoldGenerationIncomplete: "scaffold-generation-incomplete",
+  scaffoldVerificationFailed: "scaffold-verification-failed",
+  frontendTemplateUnavailable: "frontend-template-unavailable",
+  implementationRepositoriesStale: "implementation-repositories-stale",
 });
 
 const allowedResult = (evidenceRefs = []) => ({
@@ -130,9 +141,101 @@ export function validateNextRoute(currentWorkUnit, nextRoute, decisionState, opt
     }
     return blockedResult(signals, ["allowed_next_route"]);
   }
+  if (nextRoute === TICKET_DECOMPOSITION_WORK_UNIT) {
+    const readiness = validateImplementationRepositoriesReady(decisionState, options);
+    if (readiness.result === "blocked") return readiness;
+  }
   return decisionState ? validateDecisionBoundary(currentWorkUnit, decisionState, options) : allowedResult();
 }
 
+/**
+ * Validate the aggregate stage-5 repository-preparation result. Every affected
+ * delivery role must resolve to an onboarded existing repository or a freshly
+ * generated and verified scaffold. Unaffected roles need an explicit reason.
+ */
+export function validateImplementationRepositoriesReady(state, { exists = existsSync } = {}) {
+  const preparation = state?.implementation_repository_preparation;
+  const impacts = state?.delivery_impacts;
+  const signals = [];
+  const missing = [];
+  const evidenceRefs = Array.isArray(preparation?.evidence_refs) ? preparation.evidence_refs : [];
+
+  if (!preparation || preparation.result !== "completed" || !Array.isArray(preparation.projects)) {
+    return blockedResult([BLOCKING_SIGNALS.repositoryDecisionRequired], ["completed implementation_repository_preparation with projects"]);
+  }
+  if (preparation.current_version !== true || state?.implementation_repositories_stale === true) {
+    signals.push(BLOCKING_SIGNALS.implementationRepositoriesStale);
+    missing.push("implementation repository preparation is current");
+  }
+  if (evidenceRefs.length === 0 || evidenceRefs.some((ref) => !isReadable(ref, exists))) {
+    signals.push(BLOCKING_SIGNALS.repositoryOnboardingIncomplete);
+    missing.push("readable implementation_repository_preparation.evidence_refs");
+  }
+
+  for (const role of ["backend", "frontend"]) {
+    const affected = impacts?.[role] === true;
+    const projects = preparation.projects.filter((project) => project?.delivery_role === role);
+    if (affected && projects.length === 0) {
+      signals.push(BLOCKING_SIGNALS.repositoryDecisionRequired);
+      missing.push(`${role} repository decision`);
+    }
+    if (!affected && projects.length === 0) {
+      signals.push(BLOCKING_SIGNALS.repositoryDecisionRequired);
+      missing.push(`${role} not-applicable decision with reason`);
+    }
+    for (const project of projects) {
+      if (!hasText(project.project_id) || !hasText(project.status)) {
+        signals.push(BLOCKING_SIGNALS.repositoryDecisionRequired);
+        missing.push(`${role} project_id and status`);
+        continue;
+      }
+      if (project.status === "not-applicable") {
+        if (affected || !hasText(project.reason)) {
+          signals.push(BLOCKING_SIGNALS.repositoryDecisionRequired);
+          missing.push(`${project.project_id} not-applicable reason for an unaffected role`);
+        }
+        continue;
+      }
+      if (!hasText(project.repository_ref) || !hasText(project.project_root) || !hasText(project.repository_scope)) {
+        signals.push(BLOCKING_SIGNALS.repositoryLocationRequired);
+        missing.push(`${project.project_id} repository_ref, project_root and repository_scope`);
+      }
+      if (project.status === "existing-and-onboarded") {
+        if (project.onboarding_result?.status !== "completed" || !isReadable(project.onboarding_result?.ref, exists)) {
+          signals.push(BLOCKING_SIGNALS.repositoryOnboardingIncomplete);
+          missing.push(`${project.project_id} readable completed onboarding result`);
+        }
+      } else if (project.status === "initialized-and-verified") {
+        if (role === "backend" && !hasText(project.architecture_family)) {
+          signals.push(BLOCKING_SIGNALS.scaffoldChoiceRequired);
+          missing.push(`${project.project_id} confirmed backend architecture_family`);
+        }
+        const contract = project.scaffold_contract;
+        if (![3, 4].includes(contract?.schema_version) || contract?.status !== "approved" || contract?.persisted !== true || contract?.current_version !== true || (role === "frontend" && contract?.schema_version !== 4)) {
+          signals.push(BLOCKING_SIGNALS.scaffoldContractUnapproved);
+          missing.push(`${project.project_id} approved persisted current scaffold contract`);
+        }
+        if (!isReadable(project.scaffold_manifest_ref, exists)) {
+          signals.push(BLOCKING_SIGNALS.scaffoldGenerationIncomplete);
+          missing.push(`${project.project_id} readable scaffold manifest`);
+        }
+        if (project.scaffold_verification?.status !== "passed" || !isReadable(project.scaffold_verification?.ref, exists)) {
+          signals.push(BLOCKING_SIGNALS.scaffoldVerificationFailed);
+          missing.push(`${project.project_id} readable passed scaffold verification`);
+        }
+        if (role === "frontend" && project.template_available !== true) {
+          signals.push(BLOCKING_SIGNALS.frontendTemplateUnavailable);
+          missing.push(`${project.project_id} verified frontend template source`);
+        }
+      } else {
+        signals.push(BLOCKING_SIGNALS.repositoryDecisionRequired);
+        missing.push(`${project.project_id} supported repository preparation status`);
+      }
+    }
+  }
+  return signals.length === 0 ? allowedResult(evidenceRefs) : blockedResult(signals, missing, evidenceRefs);
+}
+
 function validateDecisionBoundary(workUnit, state, options) {
   try { assertWorkUnitUserDecision(workUnit, state, options); return allowedResult(); }
   catch (error) { return blockedResult([error.code || "user-decision-invalid"], [error.message]); }
@@ -145,6 +248,8 @@ function validateDecisionBoundary(workUnit, state, options) {
 export function validateTicketFormalization(state, { exists = existsSync, read = (ref) => readFileSync(ref, "utf8"), ...decisionOptions } = {}) {
   try { enforceFrontendDelivery(state, { root: decisionOptions.root, phase: "implementation" }); }
   catch (error) { return blockedResult(["frontend-delivery-blocked"], [error.message]); }
+  const repositoryResult = validateImplementationRepositoriesReady(state, { exists });
+  if (repositoryResult.result === "blocked") return repositoryResult;
   const decomposition = state?.ticket_decomposition_result;
   const ticket = state?.vertical_slice_ticket;
   const contract = state?.slice_contract;
@@ -276,6 +381,7 @@ export function validateImplementationEntry(state, options = {}) {
 export const lifecycleTransitionContract = Object.freeze({
   implementation_work_unit: IMPLEMENTATION_WORK_UNIT,
   ticket_decomposition_work_unit: TICKET_DECOMPOSITION_WORK_UNIT,
+  repository_preparation_work_unit: REPOSITORY_PREPARATION_WORK_UNIT,
   next_routes: NEXT_ROUTES,
   blocking_signals: BLOCKING_SIGNALS,
 });

package/template/scripts/lib/scenario-checks.mjs

@@ -76,7 +76,9 @@ function validateInvocationBoundary(data) {
   ensure(routes?.["work-unit.frontend-implementation-verification"]?.skills?.includes("code-review") && routes?.["work-unit.frontend-implementation-verification"]?.applies_when === "ui_impact", "前端还原验证未绑定 UI fidelity 审查轴");
   const reviewRoute = routes?.["work-unit.code-review"];
   ensure(reviewRoute?.primary_skill === "code-review" && reviewRoute?.review_standards_route?.unique_default_skill === "code-review" && reviewRoute?.review_standards_route?.second_generic_review_skill === "forbidden", "code-review 不是唯一默认审查入口或允许第二套通用审查 skill");
-  ensure(includesAll(reviewRoute?.supporting_skills, ["alibaba-java-code-style", "yss-ui", "yss-domain"]) && includesAll(reviewRoute?.skills, ["code-review", "alibaba-java-code-style", "yss-ui"]), "审查工作单元缺少 YSS / Alibaba 专项检查输入");
+  ensure(includesAll(reviewRoute?.supporting_skills, ["alibaba-java-code-style", "yss-ui", "yss-domain", "yss-repository", "yss-mybatis"]) && includesAll(reviewRoute?.skills, ["code-review", "alibaba-java-code-style", "yss-ui", "yss-repository", "yss-mybatis"]), "审查工作单元缺少 YSS / Alibaba / Repository / MyBatis 专项检查输入");
+  const reviewScope = reviewRoute?.review_standards_route?.project_scope;
+  ensure(includesAll(reviewScope?.sources, ["candidate-project-root", "implementation-repository-registry", "slice-project-roots", "allowed-write-paths"]) && includesAll(reviewScope?.include, ["project-itself", "registered-backend-development-projects"]) && includesAll(reviewScope?.exclude, ["frontend-projects", "unrelated-submodules", "vendor", "unregistered-directories"]) && reviewScope?.fixed_apps_backend_assumption === "forbidden", "后端审查范围未绑定本体项目与已登记后端研发项目，或仍固定为 apps/backend");
   const disposition = reviewRoute?.review_standards_route?.finding_disposition;
   ensure(includesAll(disposition?.same_loop_for, ["product-slice", "template-maintenance"]) && disposition?.reviewer_write_implementation === "forbidden", "审查 finding 闭环未同时覆盖产品切片与模板维护，或允许审查者写实现");
   ensure(includesAll(disposition?.repair_then_full_rereview?.kinds, ["violation", "machine_check_failure", "blank_applicable_row", "missing_evidence"]) && disposition?.repair_then_full_rereview?.actor === "implementer" && disposition?.repair_then_full_rereview?.then === "recapture_candidate_and_rerun_all_axes", "violation 类 finding 未要求实现者修复后全轴复审");
@@ -125,6 +127,8 @@ function validateWorkflowExecutionResult(payload, contract, workUnitRoutes) {
     const implementationState = {
       user_decisions: payload.user_decisions,
       slice_contract_ref: payload.slice_contract_ref,
+      delivery_impacts: payload.delivery_impacts,
+      implementation_repository_preparation: payload.implementation_repository_preparation,
       tracker_kind: payload.tracker_kind,
       predecessor_work_unit: payload.predecessor_work_unit,
       ready_for_agent: payload.ready_for_agent,
@@ -164,18 +168,15 @@ function validateInvocationMetadata(boundary, skillContents) {
   for (const skill of boundary.model_invoked_skills) ensure(!skillContents(skill).includes("disable-model-invocation: true"), `${skill} 不应出现在 model-invoked 白名单`);
 }
 
-function validateMattProse(skill, adapter) {
-  ensure(skill.includes("不得写生命周期资产或改变门禁/Ticket 状态") && skill.includes("任何写入前回交本编排器"), "主技能缺少 direct Matt 只导航并回交的说明");
-  ensure(adapter.includes("仅发现旧路径资产") && adapter.includes("不得调用 `setup-matt-pocock-skills`"), "适配器缺少 setup 旧资产迁移或显式用户入口条件");
-  ensure(adapter.includes("frontier 为空") && adapter.includes("双方共同理解已确认"), "适配器缺少 grill_exit 的 frontier 或共同理解条件");
-  ensure(skill.includes("自然语言意向不构成上述结构化 Git 授权") && adapter.includes("本身不是结构化授权"), "主技能或适配器缺少自然语言 Git 意向不是授权的说明");
-  ensure(adapter.includes("禁止 detached HEAD 提交") && adapter.includes("先推子仓再更新父仓 gitlink"), "适配器缺少 git-submodule 嵌套 Git 授权说明");
-}
-
-function validateInvocationProse(skill, adapter, orchestration) {
-  ensure(skill.includes("不得自动调用它们或代替其创建正式资产") && skill.includes("Workflow Execution Result"), "主技能未限制 user-invoked 调用或未采用新结果协议");
-  ensure(adapter.includes("workflow reference 不表示调用") && adapter.includes("正式 Spec、Ticket 或实现资产仍只能由对应显式用户入口创建"), "适配器未限制 workflow reference 的正式资产所有权");
-  ensure(orchestration.includes("只实际调用允许的 model-invoked skill") && orchestration.includes("用户显式启动"), "编排协议未区分 model-invoked 原语和显式用户入口");
+function validateLifecycleEntrySkill(skill) {
+  ensure(/^---\nname: yss-product-lifecycle\n/m.test(skill), "生命周期入口缺少有效 frontmatter");
+  ensure(Buffer.byteLength(skill) <= 8192, "生命周期入口超过 8KB 上下文预算");
+  for (const reference of ["docs/process/lifecycle-registry.yaml", "references/orchestration-contract.yaml", "docs/agents/yss-skill-registry.yaml", "scripts/query-lifecycle-context"]) {
+    ensure(skill.includes(reference), `生命周期入口缺少权威引用: ${reference}`);
+  }
+  for (const heading of ["### 仓库身份", "### 流转与实现", "### 用户决定", "### 外部副作用与 Git"]) {
+    ensure(skill.includes(heading), `生命周期入口缺少边界分组: ${heading}`);
+  }
 }
 
 const profiles = {
@@ -192,7 +193,7 @@ const profiles = {
   prototype: {
     message: "原型到后端脚手架及后续 YSS 代码生成压力场景验证通过",
     files: [".agents/skills/yss-ddd-scaffold-generator/scripts/generate_scaffold.mjs", ".agents/skills/yss-implementation-contract-compiler/references/compiler-contract.yaml"],
-    markers: [[".agents/skills/yss-product-lifecycle/SKILL.md", "controlled-generation"]]
+    markers: [[".agents/skills/yss-implementation-contract-compiler/references/compiler-contract.yaml", "controlled-generation"]]
   },
   implementationContractCompiler: {
     message: "YSS implementation contract compiler stage 7 scenarios passed",
@@ -248,7 +249,10 @@ export function runScenario(name) {
       { from: "work-unit.spec-synthesis", to: "work-unit.slice-implementation" },
       { from: "work-unit.prototype-design", to: "work-unit.slice-implementation" },
       { from: "work-unit.technical-analysis", to: "work-unit.slice-implementation" },
-    ]), "生命周期转换图缺少 Spec/原型/技术分析到实现的越级阻断");
+      { from: "work-unit.technical-analysis", to: "work-unit.ticket-decomposition" },
+    ]), "生命周期转换图缺少工程准备、Ticket 正式化与实现越级阻断");
+    ensure(contract.transition_graph?.routes?.["work-unit.implementation-repository-preparation"]?.includes("work-unit.ticket-decomposition"), "实现仓库准备未成为 Ticket 正式化前置");
+    ensure(contract.implementation_repository_preparation?.gate === "gate.implementation-repositories-ready", "实现仓库准备聚合门禁缺失");
     ensure(lifecycleTransitionContract.next_routes["work-unit.ticket-decomposition"]?.includes("work-unit.slice-implementation"), "转换校验器未允许 Ticket 正式化后进入实现");
     ensure(contract.release_readiness?.conditional?.ui_impact?.includes("gate.frontend-implementation-verified") && contract.frontend_implementation_plan?.acceptance?.includes("no_template_placeholders"), "发布公式或前端计划实质校验不完整");
     const templateRejected = spawnSync("scripts/verify-frontend-implementation-evidence", ["docs/process/templates/frontend-implementation-plan-template.yaml"], { cwd: root, encoding: "utf8" });
@@ -275,7 +279,7 @@ export function runScenario(name) {
       changed_artifacts: [],
       new_impacts: [],
       stale_candidates: [],
-      next_route: "work-unit.ticket-decomposition",
+      next_route: "work-unit.implementation-repository-preparation",
       blocking_signals: []
     };
     validateWorkflowExecutionResult(validResult, data.workflow_execution_result, data.work_unit_routes);
@@ -304,6 +308,14 @@ export function runScenario(name) {
       slice_contract_status: "approved",
       slice_contract_persisted: true,
       slice_contract_current_version: true,
+      delivery_impacts: { backend: true, frontend: false },
+      implementation_repository_preparation: {
+        result: "completed", current_version: true, evidence_refs: ["docs/process/lifecycle-registry.yaml"],
+        projects: [
+          { project_id: "backend", delivery_role: "backend", status: "existing-and-onboarded", repository_ref: "git://backend", project_root: "/workspace/backend", repository_scope: "external-repository", onboarding_result: { status: "completed", ref: "docs/process/lifecycle-registry.yaml" } },
+          { project_id: "frontend-na", delivery_role: "frontend", status: "not-applicable", reason: "no frontend impact" },
+        ],
+      },
     };
     validateWorkflowExecutionResult(validImplementationResult, data.workflow_execution_result, data.work_unit_routes);
     for (const mutate of [
@@ -377,16 +389,7 @@ export function runScenario(name) {
       ensure(rejected, "Matt/YSS 契约变异未被 baseline oracle 拒绝");
     }
     const skill = read(".agents/skills/yss-product-lifecycle/SKILL.md");
-    const adapter = read(".agents/skills/yss-product-lifecycle/references/matt-yss-adapter.md");
-    const orchestration = read(".agents/skills/yss-product-lifecycle/references/orchestration.md");
-    validateMattProse(skill, adapter);
-    validateInvocationProse(skill, adapter, orchestration);
-    let proseRejected = false;
-    try { validateMattProse(skill.replace("任何写入前回交本编排器", "允许直接写入"), adapter); } catch { proseRejected = true; }
-    ensure(proseRejected, "Matt/YSS prose 变异未被 baseline oracle 拒绝");
-    let invocationProseRejected = false;
-    try { validateInvocationProse(skill.replace("不得自动调用它们或代替其创建正式资产", "可以自动调用并创建正式资产"), adapter, orchestration); } catch { invocationProseRejected = true; }
-    ensure(invocationProseRejected, "调用边界 prose 变异未被 baseline oracle 拒绝");
+    validateLifecycleEntrySkill(skill);
     for (const relative of ["SKILL.md", "references/matt-yss-adapter.md", "references/orchestration-contract.yaml"]) {
       ensure(read(`.agents/skills/yss-product-lifecycle/${relative}`) === read(`.codex/skills/yss-product-lifecycle/${relative}`), `YSS 生命周期投影未同步: ${relative}`);
     }

package/template/scripts/lib/skill-registry.mjs

@@ -166,6 +166,10 @@ function validateReviewInputFinding(reviewInput) {
   if (reviewInput.completed_requires_no_open_mandatory_violations !== true) fail("未关闭的 mandatory violation 不得 completed");
   if (reviewInput.completed_requires_no_blank_applicable_rows !== true) fail("适用报告行空白不得 completed");
   if (reviewInput.reviewer_write_implementation !== "forbidden") fail("review_input 禁止审查者写实现");
+  requireObject(reviewInput.scope_resolution, "review_input.scope_resolution");
+  requireStringSet(reviewInput.scope_resolution.sources, ["candidate-project-root", "implementation-repository-registry", "slice-project-roots", "allowed-write-paths"], "review_input.scope_resolution.sources");
+  requireStringSet(reviewInput.scope_resolution.backend_includes, ["project-itself", "registered-backend-development-projects"], "review_input.scope_resolution.backend_includes");
+  requireStringSet(reviewInput.scope_resolution.excludes, ["frontend-projects", "unrelated-submodules", "vendor", "unregistered-directories"], "review_input.scope_resolution.excludes");
 }
 
 function validateCodeReviewRoute(route, resolve) {
@@ -180,6 +184,11 @@ function validateCodeReviewRoute(route, resolve) {
   if (standards.contract_required_skills !== "required") fail("Standards 必须消费 Slice 合同 required_skills");
   requireString(standards.report_template, "review_standards_route.report_template");
   if (!existsSync(path.join(ROOT, standards.report_template))) fail(`审查报告模板不存在: ${standards.report_template}`);
+  requireObject(standards.project_scope, "review_standards_route.project_scope");
+  requireStringSet(standards.project_scope.sources, ["candidate-project-root", "implementation-repository-registry", "slice-project-roots", "allowed-write-paths"], "review_standards_route.project_scope.sources");
+  requireStringSet(standards.project_scope.include, ["project-itself", "registered-backend-development-projects"], "review_standards_route.project_scope.include");
+  requireStringSet(standards.project_scope.exclude, ["frontend-projects", "unrelated-submodules", "vendor", "unregistered-directories"], "review_standards_route.project_scope.exclude");
+  if (standards.project_scope.fixed_apps_backend_assumption !== "forbidden") fail("code-review 不得把后端审查范围固定为 apps/backend");
   const conditional = standards.conditional_skills;
   if (!conditional || typeof conditional !== "object" || Array.isArray(conditional)) {
     fail("review_standards_route.conditional_skills 必须是对象");

package/template/scripts/lib/strategic-handoff-consumption.mjs

@@ -3,6 +3,7 @@ import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { openBundle } from './strategic-handoff.mjs';
 import { read, safe, ensure, ROOT, digest, project } from './strategic-handoff-io.mjs';
+import { designTargets } from './strategic-handoff-design-targets.mjs';
 import { parseContextContract } from './context-contract.mjs';
 const present=x=>typeof x==='string'&&x.trim();
 const list=x=>Array.isArray(x)&&x.length&&x.every(present);
@@ -14,6 +15,7 @@ const strategyBasis=value=>({
 export async function verifyConsumption(data,{root=process.cwd(),sliceRef,consumer='tactical'}={}) {
   project(root);
   ensure(['tactical','frontend'].includes(consumer),'未知战略消费者');
+  if (data.schema_version === 2 && consumer === 'tactical') ensure(['domain-driven','layered-mvc'].includes(data.architecture?.family), '未知技术设计架构');
   if (sliceRef) ensure(data.status === (consumer==='frontend'?'accepted':'approved'), consumer==='frontend'?'前端接收记录尚未 accepted':'切片只能消费 approved 战术合同');
   const binding=data.strategic_handoff;
   ensure(binding && present(binding.import_receipt_ref) && present(binding.context_reconciliation_ref),'缺少战略交接导入收据与目标对账引用');
@@ -42,9 +44,7 @@ export async function verifyConsumption(data,{root=process.cwd(),sliceRef,consum
       const rows=new Map();for(const row of binding.rows){ensure(!rows.has(row.source_id),`重复承接: ${row.source_id}`);rows.set(row.source_id,row);}
       const issues=[], blocked=new Set();let all=false;
       const mark=(id,reason,row)=>{issues.push({source_id:id,reason});if(row?.dependency_status!=='known'||!list(row.dependent_slice_refs))all=true;else row.dependent_slice_refs.forEach(x=>blocked.add(x));};
-      const catalogs=['aggregate_catalog','entity_catalog','value_object_catalog','behavior_catalog','invariant_catalog','state_transition_catalog','domain_event_catalog','gateway_catalog'];
-      const ids=new Set(catalogs.flatMap(k=>(data[k]||[]).flatMap(x=>Object.entries(x).filter(([k])=>k.endsWith('_id')).map(([,v])=>v))));
-      const seams=new Map((data.test_seams||[]).map(x=>[x.seam_id,x]));
+      const { ids, seams } = designTargets(data);
       const cases=new Map((data.frontend_cases||[]).map(x=>[x.case_id,x]));
       for(const[id,source]of known){
         const row=rows.get(id);
@@ -77,7 +77,7 @@ export async function verifyConsumption(data,{root=process.cwd(),sliceRef,consum
         all=true;issues.push({source_id:'strategic-design-basis',reason:'upstream-design-stale'});
       }
       const blockedHere=all||(sliceRef?blocked.has(sliceRef):issues.length>0);
-      return {result:blockedHere?'blocked':'verified',bundle_digest:current.manifest.bundle_digest,consumed_bundle_digest:receipt.bundle_digest,...(consumer==='frontend'?{frontend_acceptance_digest:digest(data)}:{tactical_digest:digest(data)}),scope:sliceRef||`whole-${consumer}-design`,coverage_complete:[...known.keys()].every(id=>rows.has(id)),block_all:all,blocked_slice_refs:[...blocked].sort(),issues};
+      return {result:blockedHere?'blocked':'verified',bundle_digest:current.manifest.bundle_digest,consumed_bundle_digest:receipt.bundle_digest,...(consumer==='frontend'?{frontend_acceptance_digest:digest(data)}:{tactical_digest:digest(data), ...(data.schema_version === 2 ? {technical_design_digest:digest(data)} : {})}),scope:sliceRef||`whole-${consumer}-design`,coverage_complete:[...known.keys()].every(id=>rows.has(id)),block_all:all,blocked_slice_refs:[...blocked].sort(),issues};
     });
   });
 }

package/template/scripts/lib/strategic-handoff-design-targets.mjs

@@ -0,0 +1,15 @@
+import { ensure } from './strategic-handoff-io.mjs';
+
+export function designTargets(data) {
+  const design = data.schema_version === 2 ? data.design : data;
+  const catalogs = data.schema_version === 2 && data.architecture?.family === 'layered-mvc'
+    ? ['module_catalog', 'use_case_catalog', 'rule_catalog', 'state_transition_catalog', 'persistence_mapping', 'integration_catalog']
+    : ['aggregate_catalog', 'entity_catalog', 'value_object_catalog', 'behavior_catalog', 'invariant_catalog', 'state_transition_catalog', 'domain_event_catalog', 'gateway_catalog'];
+  const primaryKeys = { module_catalog: 'module_id', use_case_catalog: 'use_case_id', rule_catalog: 'rule_id', state_transition_catalog: 'transition_id', persistence_mapping: 'mapping_id', integration_catalog: 'integration_id', aggregate_catalog: 'aggregate_id', entity_catalog: 'entity_id', value_object_catalog: 'value_object_id', behavior_catalog: 'behavior_id', invariant_catalog: 'invariant_id', domain_event_catalog: 'event_id', gateway_catalog: 'gateway_id' };
+  const ids = catalogs.flatMap(key => (design?.[key] || []).map(item => item[primaryKeys[key]]).filter(Boolean));
+  ensure(new Set(ids).size === ids.length, '设计对象 ID 重复');
+  const seams = design?.test_seams || [];
+  ensure(new Set(seams.map(item => item.seam_id)).size === seams.length, '测试 seam ID 重复');
+  return { ids: new Set(ids), seams: new Map(seams.map(item => [item.seam_id, item])) };
+}
+

package/template/scripts/lib/technical-design-boundary.mjs

@@ -0,0 +1,23 @@
+import path from 'node:path';
+import { readFileSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { ROOT, read, safe, ensure, hash } from './strategic-handoff-io.mjs';
+
+// The compiler's synchronous boundary reruns the design verifier against current files.
+export function enforceTechnicalDesign(state = {}, { root = ROOT } = {}) {
+  const binding = state.technical_design;
+  const affected = (state.conditions || []).some(value => ['backend-technical-design-impact','tactical-domain','tactical-domain-impact','aggregate-impact','state-machine-impact','invariant-impact','consistency-impact','domain-event-impact','gateway-boundary-impact','persistence-mapping-impact'].includes(value));
+  if (!binding && !affected) return;
+  ensure(binding?.ref && binding?.digest && binding?.version, '缺少已批准技术设计绑定');
+  ensure(state.slice_id, '技术设计消费必须绑定切片 ID');
+  const file = safe(root, binding.ref);
+  ensure(hash(readFileSync(file)) === binding.digest, '技术设计绑定摘要漂移');
+  const data = read(file);
+  ensure(data.status === 'approved' && data.version === binding.version, '技术设计必须为批准且绑定版本');
+  const family = data.schema_version === 1 && binding.legacy_ddd === true ? 'domain-driven' : data.architecture?.family;
+  ensure(family && family === state.architecture_identity?.architecture_family, '技术设计与实现架构不匹配');
+  const args = [path.join(ROOT, '.agents/skills/yss-technical-design/scripts/validate-technical-design.mjs'), file, '--root', root, '--slice', state.slice_id];
+  if (binding.legacy_ddd === true) args.push('--legacy-ddd');
+  const verified = spawnSync(process.execPath, args, { cwd: root, encoding: 'utf8', timeout: 60000, maxBuffer: 2 * 1024 * 1024 });
+  ensure(verified.status === 0, `技术设计不可消费: ${verified.error?.message || verified.stderr}`);
+}

package/template/scripts/query-lifecycle-context

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import { parseArgs } from "node:util";
+import { queryLifecycleContext } from "./lib/lifecycle-context-query.mjs";
+
+try {
+  const { values } = parseArgs({
+    options: {
+      mode: { type: "string" },
+      stage: { type: "string" },
+      "work-unit": { type: "string" },
+      include: { type: "string", multiple: true },
+    },
+    strict: true,
+  });
+  const result = queryLifecycleContext({
+    mode: values.mode,
+    stageId: values.stage,
+    workUnitId: values["work-unit"],
+    include: values.include ?? [],
+  });
+  process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+} catch (error) {
+  process.stderr.write(`${error.message}\n`);
+  process.exitCode = 1;
+}

package/template/scripts/sync-strategic-handoff-tools

@@ -7,9 +7,10 @@ const root=path.resolve(import.meta.dirname,'..');
 const check=process.argv.includes('--check');
 const targets=['submodules/yss-harness-design-agent','submodules/yss-harness-dev-agent','submodules/yss-harness-backend-agent','submodules/yss-harness-frontend-agent'];
 const shared=['scripts/strategic-handoff','scripts/verify-strategic-handoff-consumption','scripts/verify-strategic-handoff-package-scenarios','scripts/verify-strategic-context-import','scripts/verify-strategic-context-import-scenarios','scripts/lib/context-contract.mjs','docs/process/strategic-handoff-package.md','docs/process/schemas/strategic-design-handoff.schema.json',...readdirSync(path.join(root,'scripts/lib')).filter(x=>x.startsWith('strategic-handoff-')||x==='strategic-handoff.mjs').map(x=>`scripts/lib/${x}`),...readdirSync(path.join(root,'docs/process/schemas')).filter(x=>x.startsWith('strategic-handoff-')).map(x=>`docs/process/schemas/${x}`),...readdirSync(path.join(root,'scripts/fixtures/strategic-handoff')).map(x=>`scripts/fixtures/strategic-handoff/${x}`)];
-shared.push('scripts/instantiate-harness','scripts/lib/harness-execution-scope.mjs','scripts/backend-delivery','scripts/verify-frontend-delivery','scripts/lib/backend-delivery.mjs','scripts/lib/frontend-delivery.mjs','scripts/lib/frontend-delivery-boundary.mjs','docs/process/frontend-backend-delivery.md','docs/process/schemas/backend-delivery.schema.json','docs/process/schemas/backend-delivery-verification.schema.json','docs/process/schemas/frontend-delivery-acceptance.schema.json');
+shared.push('scripts/instantiate-harness','scripts/backend-delivery','scripts/verify-frontend-delivery','scripts/lib/backend-delivery.mjs','scripts/lib/frontend-delivery.mjs','scripts/lib/frontend-delivery-boundary.mjs','docs/process/frontend-backend-delivery.md','docs/process/schemas/backend-delivery.schema.json','docs/process/schemas/backend-delivery-verification.schema.json','docs/process/schemas/frontend-delivery-acceptance.schema.json');
 let differences=[];
-function sync(source,dest){const bytes=readFileSync(source);if(!existsSync(dest)||!bytes.equals(readFileSync(dest))){differences.push(path.relative(root,dest));if(!check){mkdirSync(path.dirname(dest),{recursive:true});writeFileSync(dest,bytes);}}if(!check&&path.basename(path.dirname(dest))==='scripts'&&!path.extname(dest))chmodSync(dest,0o755);}
+// 专职执行范围由各模板持有；后端只消费 wire 校验器，不恢复原型构建技能。
+function sync(source,dest){let bytes=readFileSync(source);if(dest.includes('/yss-harness-backend-agent/')){let content=bytes.toString();if(dest.endsWith('/scripts/lib/strategic-handoff.mjs'))content=content.replace('../../.agents/skills/yss-prototype-stage/scripts/visual-baseline-contract.mjs','./visual-baseline-contract.mjs');if(dest.endsWith('/scripts/fixtures/strategic-handoff/fixture.mjs'))content=content.replace('../../../.agents/skills/yss-prototype-stage/scripts/visual-baseline-contract.mjs','../../lib/visual-baseline-contract.mjs');bytes=Buffer.from(content);}if(!existsSync(dest)||!bytes.equals(readFileSync(dest))){differences.push(path.relative(root,dest));if(!check){mkdirSync(path.dirname(dest),{recursive:true});writeFileSync(dest,bytes);}}if(!check&&path.basename(path.dirname(dest))==='scripts'&&!path.extname(dest))chmodSync(dest,0o755);}
 for(const kind of ['domain-strategy','stage-decision-package'])sync(path.join(root,`.agents/skills/yss-stage-decision/references/${kind}.schema.json`),path.join(root,`docs/process/schemas/strategic-handoff-${kind}.schema.json`));
 for(const target of targets){
  if(!existsSync(path.join(root,target,'.git')))continue;

package/template/scripts/verify-business-language-scenarios

@@ -25,13 +25,6 @@ for (const relativePath of PUBLIC_FILES) {
   }
 }
 
-const lifecycle = read(".agents/skills/yss-product-lifecycle/SKILL.md");
-for (const phrase of [
-  "机会与目标 → 业务故事 → 责任与交接 → 规则、例子与疑问 → 可验收需求 → 页面验证 → 业务任务 → 交接研发",
-  "业务方案总览",
-  "不成为新的事实源",
-]) assert.match(lifecycle, new RegExp(phrase));
-
 const registry = read("docs/process/lifecycle-registry.yaml");
 for (const stableId of ["work-unit.domain-strategy-design", "artifact.domain-strategy", "gate.domain-strategy-approved"]) {
   assert.match(registry, new RegExp(`id: ${stableId.replaceAll(".", "\\.")}`));

package/template/scripts/verify-frontend-scaffold-generator-scenarios

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../.agents/skills/yss-frontend-scaffold-generator/scripts/scaffold-generator.test.mjs";