create-yss-spec 3.2.0 → 3.3.1

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

@@ -1,5 +1,6 @@
 import { existsSync, readFileSync, mkdtempSync, rmSync } from "node:fs";
 import path from "node:path";
+import { buildPlanFixture } from "../fixtures/user-decision/plan-fixture.mjs";
 import os from "node:os";
 import { buildDecisionFixture, buildImplementationFixture } from "../fixtures/user-decision/build-fixture.mjs";
 import { fileURLToPath } from "node:url";
@@ -58,8 +59,8 @@ function validateInvocationBoundary(data) {
   ensure(native?.default_entry === "yss-product-lifecycle" && native?.formal_artifact_owner === "yss-product-lifecycle", "生命周期原生入口未持有默认正式资产所有权");
   ensure(native?.user_confirmation_policy_ref === "docs/agents/digital-human-roles.yaml#user_decision_policy", "生命周期人工门禁集合已漂移");
   const routes = data.work_unit_routes;
-  ensure(routes?.["work-unit.discovery-requirements"]?.skills?.includes("grilling") && routes?.["work-unit.discovery-requirements"]?.skills?.includes("domain-modeling"), "需求分析工作单元缺少 grilling/domain-modeling");
-  ensure(routes?.["work-unit.discovery-opportunity"]?.route_by?.market_or_competitor_fact === "competitive-intelligence" && routes["work-unit.discovery-opportunity"].route_by.technical_or_standard_fact === "yss-research:technical-evidence" && routes["work-unit.discovery-opportunity"].route_by.strategy_fact === "yss-research:strategy-evidence", "机会调研事实路由不准确");
+  ensure(routes?.["work-unit.plan-requirements"]?.skills?.includes("grilling") && routes?.["work-unit.plan-requirements"]?.skills?.includes("domain-modeling"), "需求分析工作单元缺少 grilling/domain-modeling");
+  ensure(routes?.["work-unit.plan-opportunity"]?.route_by?.market_or_competitor_fact === "competitive-intelligence" && routes["work-unit.plan-opportunity"].route_by.technical_or_standard_fact === "yss-research:technical-evidence" && routes["work-unit.plan-opportunity"].route_by.strategy_fact === "yss-research:strategy-evidence", "机会调研事实路由不准确");
   const strategyResearch = routes?.["work-unit.domain-strategy-design"]?.research_contract;
   ensure(strategyResearch?.profile === "strategy-evidence" && strategyResearch.mode_before_gate === "evidence-audited" && strategyResearch.artifact_owner === "yss-research" && strategyResearch.downstream_owner === "yss-stage-decision", "领域战略研究合同缺少 profile、门禁前审计或资产所有权边界");
   const stageDecisionResearch = routes?.["work-unit.stage-decision"]?.research_contract;
@@ -76,7 +77,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 未要求实现者修复后全轴复审");
@@ -92,7 +95,7 @@ function validateInvocationBoundary(data) {
   }
 }
 
-function validateWorkflowExecutionResult(payload, contract, workUnitRoutes) {
+function validateWorkflowExecutionResult(payload, contract, workUnitRoutes, options = {}) {
   for (const field of contract.required) ensure(Object.hasOwn(payload, field), `Workflow Execution Result 缺少 ${field}`);
   ensure(contract.result_values.includes(payload.result), "Workflow Execution Result result 无效");
   if (Object.hasOwn(payload, "unavailable_skill")) {
@@ -105,7 +108,7 @@ function validateWorkflowExecutionResult(payload, contract, workUnitRoutes) {
   const workUnit = workUnitRoutes?.[payload.work_unit];
   ensure(workUnit, `未知 Workflow Execution Result work_unit: ${payload.work_unit}`);
   if (payload.result === "completed") {
-    const routeResult = validateNextRoute(payload.work_unit, payload.next_route, payload);
+    const routeResult = validateNextRoute(payload.work_unit, payload.next_route, payload, options);
     ensure(routeResult.result === "allowed", `Workflow Execution Result next_route 非法: ${routeResult.blocking_signals.join(", ")}`);
     ensure(payload.context_reconciliation?.status === "reconciled", "project-instance 完成态必须具有 reconciled context_reconciliation");
     ensure(hasText(payload.context_reconciliation?.ref) && payload.evidence_refs.includes(payload.context_reconciliation.ref) && exists(payload.context_reconciliation.ref), "context_reconciliation.ref 必须可读并包含在 evidence_refs 中");
@@ -125,6 +128,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 +169,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 +194,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 +250,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" });
@@ -264,7 +269,9 @@ export function runScenario(name) {
     process.on("exit", () => rmSync(decisionTemp, { recursive: true, force: true }));
     const specDecision = buildDecisionFixture(path.join(decisionTemp, "spec"));
     const implementationDecision = buildImplementationFixture(path.join(decisionTemp, "implementation"), "docs/.scratch/demo/issues/01-valid-slice.md");
+    const planFixture = buildPlanFixture(path.join(decisionTemp, 'plan'));
     const validResult = {
+      ...planFixture.state,
       user_decisions: [specDecision.requirement],
       result_schema: "workflow-execution-result-v1",
       work_unit: "work-unit.spec-synthesis",
@@ -275,10 +282,10 @@ 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);
+    validateWorkflowExecutionResult(validResult, data.workflow_execution_result, data.work_unit_routes, { root: planFixture.root });
     const validTicketResult = {
       ...validResult,
       work_unit: "work-unit.ticket-decomposition",
@@ -286,7 +293,7 @@ export function runScenario(name) {
       ticket_decomposition_result_ref: "docs/.scratch/demo/evidence/ticket-decomposition-result.yaml",
       vertical_slice_ticket_ref: "docs/.scratch/demo/issues/01-valid-slice.md",
     };
-    validateWorkflowExecutionResult(validTicketResult, data.workflow_execution_result, data.work_unit_routes);
+    validateWorkflowExecutionResult(validTicketResult, data.workflow_execution_result, data.work_unit_routes, { root: planFixture.root });
     const validImplementationResult = {
       ...validResult,
       ...implementationDecision.state,
@@ -304,8 +311,16 @@ 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);
+    validateWorkflowExecutionResult(validImplementationResult, data.workflow_execution_result, data.work_unit_routes, { root: planFixture.root });
     for (const mutate of [
       (item) => { item.vertical_slice_ticket_role = "ready-for-human"; },
       (item) => { item.vertical_slice_ticket_kind = "parent-ticket"; },
@@ -317,22 +332,22 @@ export function runScenario(name) {
     ]) {
       const invalid = structuredClone(validImplementationResult); mutate(invalid);
       let rejected = false;
-      try { validateWorkflowExecutionResult(invalid, data.workflow_execution_result, data.work_unit_routes); } catch { rejected = true; }
+      try { validateWorkflowExecutionResult(invalid, data.workflow_execution_result, data.work_unit_routes, { root: planFixture.root }); } catch { rejected = true; }
       ensure(rejected, "实现 Workflow Execution Result 的 Ticket 语义变异未被拒绝");
     }
     const unavailableResult = structuredClone(validResult);
     unavailableResult.result = "blocked";
     unavailableResult.unavailable_skill = { skill: "yss-ui", provider: "codex", fallback: "manual-review", resolution: "needs-human" };
     unavailableResult.blocking_signals = ["missing_evidence"];
-    validateWorkflowExecutionResult(unavailableResult, data.workflow_execution_result, data.work_unit_routes);
+    validateWorkflowExecutionResult(unavailableResult, data.workflow_execution_result, data.work_unit_routes, { root: planFixture.root });
     const malformedUnavailable = structuredClone(unavailableResult);
     delete malformedUnavailable.unavailable_skill.fallback;
     let unavailableRejected = false;
-    try { validateWorkflowExecutionResult(malformedUnavailable, data.workflow_execution_result, data.work_unit_routes); } catch { unavailableRejected = true; }
+    try { validateWorkflowExecutionResult(malformedUnavailable, data.workflow_execution_result, data.work_unit_routes, { root: planFixture.root }); } catch { unavailableRejected = true; }
     ensure(unavailableRejected, "技能不可用结果缺少 fallback 时未被拒绝");
     const compatibleResult = structuredClone(validResult);
     compatibleResult.workflow_reference = { source: "mattpocock/skills", skill: "to-spec", invocation_mode: "reference" };
-    validateWorkflowExecutionResult(compatibleResult, data.workflow_execution_result, data.work_unit_routes);
+    validateWorkflowExecutionResult(compatibleResult, data.workflow_execution_result, data.work_unit_routes, { root: planFixture.root });
     for (const mutate of [
       (item) => { delete item.workflow_reference; },
       (item) => { delete item.context_reconciliation; },
@@ -348,7 +363,7 @@ export function runScenario(name) {
     ]) {
       const invalid = structuredClone(validResult); mutate(invalid);
       let rejected = false;
-      try { validateWorkflowExecutionResult(invalid, data.workflow_execution_result, data.work_unit_routes); } catch { rejected = true; }
+      try { validateWorkflowExecutionResult(invalid, data.workflow_execution_result, data.work_unit_routes, { root: planFixture.root }); } catch { rejected = true; }
       ensure(rejected, "Workflow Execution Result 完成态变异未被拒绝");
     }
     let metadataRejected = false;
@@ -377,16 +392,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/skill-supply-chain.mjs

@@ -117,7 +117,16 @@ function loadStrategicDesignSkillManifest() {
   return validateStrategicDesignSkillManifest(JSON.parse(readFileSync(STRATEGIC_DESIGN_MANIFEST_PATH, "utf8")));
 }
 function git(args) { return spawnSync("git", args, { cwd: ROOT, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }); }
-function tracked(relativePath) { return git(["ls-files", "-z", "--", relativePath]).stdout.length > 0; }
+function trackedPaths() {
+  const result = git(["ls-files", "-z"]);
+  if (result.status !== 0) throw new TypeError("无法读取 Git 受跟踪路径");
+  const paths = new Set();
+  for (const file of result.stdout.split("\0").filter(Boolean)) {
+    let ref = file;
+    while (ref !== ".") { paths.add(ref); ref = path.posix.dirname(ref); }
+  }
+  return paths;
+}
 function parseLock() { return existsSync(LOCK_PATH) ? JSON.parse(readFileSync(LOCK_PATH, "utf8")) : null; }
 function sharedFromLock(lock) {
   const shared = lock?.version === 3 && lock.skills?.shared;
@@ -137,6 +146,13 @@ export function unlockedCanonicalEntries(names, allowedNames, hasSkillMd = () =>
   return names.filter((name) => !allowed.has(name) && !OBSOLETE.has(name) && hasSkillMd(name)).sort();
 }
 export function syncSkills({ check = false } = {}) {
+  let trackedSet;
+  const tracked = ref => (trackedSet ??= trackedPaths()).has(ref);
+  const sourceHashes = new Map();
+  const sourceHash = source => {
+    if (!sourceHashes.has(source)) sourceHashes.set(source, treeHash(source));
+    return sourceHashes.get(source);
+  };
   const lock = parseLock();
   const shared = sharedFromLock(lock);
   const absent = shared.filter((name) => !lstatSafe(path.join(SOURCE_ROOT, name))?.isDirectory());
@@ -162,7 +178,7 @@ export function syncSkills({ check = false } = {}) {
         if (info?.isSymbolicLink()) {
           if (!existsSync(target) || realpathSync(target) !== realpathSync(source)) drift.push(`projection target mismatch: ${relative(target)}`);
         } else if (!info?.isDirectory()) drift.push(`missing projection: ${relative(target)}`);
-        else if (treeHash(source) !== treeHash(target)) drift.push(`projection drift: ${relative(target)}`);
+        else if (sourceHash(source) !== treeHash(target)) drift.push(`projection drift: ${relative(target)}`);
       } else if (info?.isSymbolicLink() && existsSync(target) && realpathSync(target) === realpathSync(source)) {
         continue;
       } else {

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

@@ -3,6 +3,7 @@ import { existsSync, lstatSync, readdirSync, readFileSync, mkdirSync, writeFileS
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
+import { validateJsonSchemas } from './json-schema.mjs';
 import { parseDocument } from '../vendor/yaml.mjs';
 export const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
 export const ensure = (condition, message) => { if (!condition) throw new TypeError(message); };
@@ -50,11 +51,11 @@ export function project(root) {
   ensure(value.schema_version === 1 && value.repository_mode === 'project-instance', '只允许 project-instance 导出或导入业务包');
   return realpathSync(root);
 }
-export function schema(value, ref) {
-  const program = 'import json,sys; from jsonschema import Draft202012Validator; s=json.load(open(sys.argv[1])); v=json.load(sys.stdin); errors=list(Draft202012Validator(s).iter_errors(v)); print("\\n".join(str(e) for e in errors)); sys.exit(bool(errors))';
-  const out = spawnSync('python3', ['-c', program, safe(ROOT, ref)], { input: JSON.stringify(value), encoding: 'utf8', maxBuffer: 4 * 1024 * 1024 });
-  ensure(out.status === 0, `schema 校验失败: ${out.error?.message || out.stdout || out.stderr}`);
+export function schemaBatch(items) {
+  const results = validateJsonSchemas(items.map(([value, ref]) => ({ value, schemaPath: safe(ROOT, ref), formatChecker: false, errorStyle: 'verbose' })));
+  for (const result of results) ensure(result.valid, `schema 校验失败: ${result.error}\n`);
 }
+export function schema(value, ref) { schemaBatch([[value, ref]]); }
 export function archive(command, source, destination) {
   const out = spawnSync('python3', [path.join(ROOT, 'scripts/lib/strategic-handoff-zip.py'), command, source, destination], { encoding: 'utf8' });
   ensure(out.status === 0, `ZIP 操作失败: ${out.error?.message || out.stderr}`);

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

@@ -1,7 +1,7 @@
 import { existsSync, lstatSync, readFileSync, mkdirSync, mkdtempSync, renameSync, rmSync, cpSync } from 'node:fs';
 import path from 'node:path';
 import { tmpdir } from 'node:os';
-import { ensure, canonical, digest, hash, json, parse, read, safe, relative, files, write, project, schema, archive, ROOT, sourceApprovalPolicy } from './strategic-handoff-io.mjs';
+import { ensure, canonical, digest, hash, json, parse, read, safe, relative, files, write, project, schema, schemaBatch, archive, ROOT, sourceApprovalPolicy } from './strategic-handoff-io.mjs';
 import { parseContextSource, parseContextContract, resolveContextTermRefs } from './context-contract.mjs';
 import { countersignRuleForGate } from './digital-human-roles.mjs';
 import { validateApprovalRecord } from './approval-record.mjs';
@@ -91,8 +91,7 @@ export async function inspectSource(root, handoffRef) {
   snapshot(handoff.source_context_snapshot,source); checkDelta(handoff,source);
   const strategy=read(safe(root,handoff.source.domain_strategy_ref.persisted_ref));
   const stage=read(safe(root,handoff.source.stage_decision_package_ref.persisted_ref));
-  schema(strategy,'docs/process/schemas/strategic-handoff-domain-strategy.schema.json');
-  schema(stage,'docs/process/schemas/strategic-handoff-stage-decision-package.schema.json');
+  schemaBatch([[strategy,'docs/process/schemas/strategic-handoff-domain-strategy.schema.json'],[stage,'docs/process/schemas/strategic-handoff-stage-decision-package.schema.json']]);
   snapshot(strategy.context_snapshot,source); snapshot(stage.context_snapshot,source);
   ensure(strategy.status==='approved' && stage.status==='approved', '战略合同/方案决策包尚未批准');
   ensure(strategy.domain_strategy_id===handoff.source.domain_strategy_ref.id && strategy.domain_version===handoff.source.domain_strategy_ref.version, '战略身份/版本不一致');
@@ -141,21 +140,22 @@ function collect(root, handoffRef, handoff, config) {
     if(Array.isArray(value)) { if(key==='evidence_refs') value.forEach(enqueue); else value.forEach(v=>refs(v,key)); }
     else if(value && typeof value==='object') for(const [k,v]of Object.entries(value)) { if(['approval_ref','persisted_ref','user_decision_ref'].includes(k)&&typeof v==='string')enqueue(v); else if(k==='ref'&&typeof v==='string'&&!/^[a-z]+:\/\//i.test(v))enqueue(v); else refs(v,k); }
   }
+  let totalBytes = 0;
   while(queue.length) {
     const ref=symbolic[queue[0]]||queue[0]; queue.shift(); if(/^https?:\/\//i.test(ref))continue; relative(ref);
     if(collected.has(ref))continue;
     const full=safe(root,ref),stat=lstatSync(full);
     if(stat.isDirectory()) { queue.push(...files(root,ref)); continue; }
     ensure(stat.isFile() && stat.size<=MAX_BYTES,`源文件类型/大小无效: ${ref}`);
-    const bytes=readFileSync(full); collected.set(ref,bytes);
-    ensure(collected.size<=20000 && [...collected.values()].reduce((n,b)=>n+b.length,0)<=MAX_BYTES,'交接包大小超限');
+    const bytes=readFileSync(full); collected.set(ref,bytes); totalBytes += bytes.length;
+    ensure(collected.size<=20000 && totalBytes<=MAX_BYTES,'交接包大小超限');
     if(/\.(yaml|yml|json)$/.test(ref))refs(parse(bytes));
     queue.push(...documentLinks(ref,bytes));
   }
   return collected;
 }
-function materialize(bundleRoot, manifest, destination) {
-  for(const file of manifest.files.filter(x=>x.original_ref))write(destination,file.original_ref,readFileSync(safe(bundleRoot,file.path)));
+function materialize(captured, manifest, destination) {
+  for(const file of manifest.files.filter(x=>x.original_ref))write(destination,file.original_ref,captured.get(file.path));
 }
 export async function openBundle(input, action) {
   const temp=mkdtempSync(path.join(tmpdir(),'yss-handoff-'));
@@ -170,10 +170,11 @@ export async function openBundle(input, action) {
     ensure(new Set(paths.map(x=>x.toLowerCase())).size===paths.length,'包文件路径重复');
     ensure(own([...paths,'manifest.json'].sort(),files(root).sort()),'包文件缺失或存在未登记文件');
     ensure(manifest.files.length<=20000 && manifest.files.reduce((n,f)=>n+f.size_bytes,0)<=MAX_BYTES,'包大小超限');
-    for(const file of manifest.files){const bytes=readFileSync(safe(root,file.path));ensure(bytes.length===file.size_bytes && hash(bytes)===file.sha256,`文件摘要不一致: ${file.path}`);if(file.original_ref)relative(file.original_ref);}
+    const captured = new Map();
+    for(const file of manifest.files){const bytes=readFileSync(safe(root,file.path));ensure(bytes.length===file.size_bytes && hash(bytes)===file.sha256,`文件摘要不一致: ${file.path}`);if(file.original_ref)relative(file.original_ref);captured.set(file.path,bytes);}
     const originals=manifest.files.filter(x=>x.original_ref).map(x=>x.original_ref);
     ensure(new Set(originals.map(x=>x.toLowerCase())).size===originals.length,'源路径重复');
-    const source=path.join(temp,'source');mkdirSync(source);materialize(root,manifest,source);
+    const source=path.join(temp,'source');mkdirSync(source);materialize(captured,manifest,source);
     const inspected=await inspectSource(source,manifest.handoff_ref);
     ensure(manifest.bundle_id===inspected.handoff.handoff_id && manifest.version===inspected.handoff.handoff_version,'包身份与源交接不一致');
     ensure(own(read(safe(root,'indexes/rules.json')),inspected.indexes.rules) && own(read(safe(root,'indexes/scenarios.json')),inspected.indexes.scenarios),'规则/场景索引与源资产不一致');

package/template/scripts/lib/task-package.mjs

@@ -6,6 +6,7 @@ import { loadRegistry, ROOT } from "./lifecycle-registry.mjs";
 import { loadMaintenanceCheckpoint, validateMaintenanceCheckpoint } from "./maintenance-intensity.mjs";
 import { assertImplementationDecision } from "./user-decision.mjs";
 import { validateNextRoute } from "./lifecycle-transition.mjs";
+import { assertPlanSpecEntry } from "./plan-spec-entry.mjs";
 import { enforceHarnessTaskScope } from "./harness-execution-scope.mjs";
 import { enforceFrontendDelivery } from "./frontend-delivery-boundary.mjs";
 import { LEGACY_TASK_PACKAGE_SCHEMA, TASK_PACKAGE_SCHEMA, validateTaskPackageSchema } from "./task-package-schema.mjs";
@@ -59,6 +60,7 @@ function validateSkillSource(value, registry) {
 }
 
 function validateCommon(value, registry, lifecycle) {
+  if (value.work_unit_id === 'work-unit.spec-synthesis') assertPlanSpecEntry(value);
   const workUnit = lifecycle.work_units.find((item) => item.id === value.work_unit_id);
   if (!workUnit && value.contract.kind !== "slice-implementation") fail(`未知 work_unit_id: ${value.work_unit_id}`);
   const roleDefaults = taskPackageDefaults(value.role_id, registry);

package/template/scripts/lib/template-commit-cache.mjs

@@ -1,3 +1,4 @@
+import { runCommandSync } from "./command-runner.mjs";
 import { spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
@@ -7,13 +8,14 @@ import { ROOT } from "./template-verification.mjs";
 
 function fail(message) { throw new TypeError(message); }
 function ensure(condition, message) { if (!condition) fail(message); }
-function git(args, cwd) {
-  const result = spawnSync("git", args, { cwd, encoding: "utf8" });
-  if (result.status !== 0) fail(result.stderr.trim() || `git ${args.join(" ")} 执行失败`);
+function git(args, cwd, timeoutMs = 0, cleanupPathsOnFailure = []) {
+  const result = args.includes("fetch") ? runCommandSync("git", args, { cwd, timeoutMs, progress: true, cleanupPathsOnFailure }) : spawnSync("git", args, { cwd, encoding: "utf8" });
+  if (result.status !== 0) fail(result.termination || result.error?.message || result.stderr.trim() || `git ${args.join(" ")} 执行失败`);
   return result.stdout.trim();
 }
 
-export function acquireTemplateCommit({ repository, commit, cacheRoot = path.join(ROOT, ".template-source/cache/remote-templates"), allowLocal = false }) {
+export function acquireTemplateCommit({ repository, commit, cacheRoot = path.join(ROOT, ".template-source/cache/remote-templates"), allowLocal = false, timeoutMs = 0 }) {
+  ensure(Number.isFinite(timeoutMs) && timeoutMs >= 0, "timeoutMs 必须是非负毫秒数");
   ensure(typeof repository === "string" && repository.trim(), "repository 不能为空");
   ensure(/^[a-f0-9]{40}$/.test(commit), "模板 ref 必须是 40 位 commit");
   if (!allowLocal) ensure(/^(?:https?:\/\/|ssh:\/\/|git@)/.test(repository), "正式模板缓存只接受远程 repository URL");
@@ -35,7 +37,7 @@ export function acquireTemplateCommit({ repository, commit, cacheRoot = path.joi
   try {
     const temporaryRepository = path.join(temporary, "repository.git");
     git(["init", "--bare", "-q", temporaryRepository], ROOT);
-    git(["--git-dir", temporaryRepository, "fetch", "--depth=1", "--no-tags", repository, commit], ROOT);
+    git(["--git-dir", temporaryRepository, "fetch", "--depth=1", "--no-tags", repository, commit], ROOT, timeoutMs, [temporary]);
     const actual = git(["--git-dir", temporaryRepository, "rev-parse", "FETCH_HEAD^{commit}"], ROOT);
     ensure(actual === commit, `远程返回 commit 与请求不一致: ${actual}`);
     writeFileSync(path.join(temporary, "metadata.json"), `${JSON.stringify({ schema_version: 1, key, repository, commit })}\n`);

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/run-template-verification

@@ -23,12 +23,18 @@ function collectChangedFiles(base) {
 function runCommand(command) {
   return new Promise((resolve) => {
     const started = Date.now();
+    process.stderr.write(`[开始] ${command}\n`);
     const child = spawn(command, { cwd: ROOT, shell: true, env: process.env, stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
     child.stdout.on("data", (chunk) => { stdout += chunk; });
     child.stderr.on("data", (chunk) => { stderr += chunk; });
-    child.on("close", (code) => resolve({ command, code: code ?? 1, duration_ms: Date.now() - started, stdout, stderr }));
+    child.on("error", error => { stderr += `${error.message}\n`; });
+    child.on("close", (code) => {
+      const duration_ms = Date.now() - started;
+      process.stderr.write(`[${code === 0 ? "完成" : "失败"}] ${command} (${duration_ms}ms, exit=${code ?? 1})\n`);
+      resolve({ command, code: code ?? 1, duration_ms, stdout, stderr });
+    });
   });
 }
 
@@ -106,8 +112,8 @@ try {
   const concurrency = Number(values.concurrency || plan.max_concurrency);
   if (!Number.isInteger(concurrency) || concurrency < 1 || concurrency > 4) throw new TypeError("concurrency 必须为 1..4");
 
-  process.stdout.write(`模板核验 profile: ${plan.requested_profile} -> ${plan.effective_profile}\n`);
-  if (plan.escalation_reason) process.stdout.write(`自动升级原因: ${plan.escalation_reason}\n`);
+  process.stderr.write(`模板核验 profile: ${plan.requested_profile} -> ${plan.effective_profile}\n`);
+  if (plan.escalation_reason) process.stderr.write(`自动升级原因: ${plan.escalation_reason}\n`);
   const groups = await runGroups(plan, modeResult.stdout.trim(), concurrency);
   printResults(groups);
   const failed = groups.flatMap((group) => group.results).find((result) => result.code !== 0);

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

@@ -7,10 +7,19 @@ 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/lib/command-runner.mjs','scripts/lib/json-schema.mjs','scripts/lib/context-reconciliation.mjs','scripts/verify-context-reconciliation');
 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=[];
 // 专职执行范围由各模板持有；后端只消费 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);}
+// CLI core owns the portable external-command runner; all runtime copies are generated here.
+sync(path.join(root,'.template-source/cli-core/command-runner.mjs'),path.join(root,'scripts/lib/command-runner.mjs'));
+for(const name of ['create-yss-spec','create-yss-strategic-design','create-yss-harness-dev']) {
+ const target=`submodules/${name}`;
+ if(!existsSync(path.join(root,target,'.git')))continue;
+ if(!check){const state=inspectWorkingTreeScope(root,{project_root:target,repository_scope:'git-submodule',checkout_state:'attached-branch'});if(!state.writable)throw new Error(`${target}: ${state.violation}`);}
+ sync(path.join(root,'.template-source/cli-core/command-runner.mjs'),path.join(root,target,'src/command-runner.mjs'));
+}
 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-context-reconciliation

@@ -1,56 +1,10 @@
 #!/usr/bin/env node
-import { existsSync, readFileSync } from "node:fs";
-import path from "node:path";
-import { spawnSync } from "node:child_process";
 import { parseArgs } from "node:util";
-import { fileURLToPath } from "node:url";
-import { parseDocument } from "./vendor/yaml.mjs";
-import { resolveContextTermRefs, verifyContextSnapshot } from "./lib/context-contract.mjs";
-
-const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-const schemaPath = path.join(repoRoot, "docs/process/schemas/context-reconciliation.schema.json");
-const pythonValidator = String.raw`
-import json, sys
-from jsonschema import Draft202012Validator
-schema = json.load(open(sys.argv[1], encoding="utf-8"))
-value = json.load(sys.stdin)
-errors = sorted(Draft202012Validator(schema).iter_errors(value), key=lambda error: list(error.absolute_path))
-for error in errors:
-    where = ".".join(str(part) for part in error.absolute_path) or "<root>"
-    print(f"{where}: {error.message}", file=sys.stderr)
-sys.exit(1 if errors else 0)
-`;
-
-function parseFile(file) {
-  const document = parseDocument(readFileSync(file, "utf8"), { maxAliasCount: 0, uniqueKeys: true });
-  if (document.errors.length) throw new TypeError(document.errors[0].message);
-  return document.toJS({ maxAliasCount: 0 });
-}
-
+import { verifyContextReconciliation } from "./lib/context-reconciliation.mjs";
 try {
   const { values, positionals } = parseArgs({ options: { root: { type: "string", default: process.cwd() } }, allowPositionals: true, strict: true });
   if (positionals.length !== 1) throw new TypeError("用法: scripts/verify-context-reconciliation [--root <repo>] <record.yaml|json>");
-  const root = path.resolve(values.root);
-  const file = path.resolve(positionals[0]);
-  const value = parseFile(file);
-  const schemaResult = spawnSync("python3", ["-c", pythonValidator, schemaPath], { encoding: "utf8", input: JSON.stringify(value) });
-  if (schemaResult.status !== 0) throw new TypeError(`${schemaResult.stdout}${schemaResult.stderr}`.trim());
-  const manifest = parseFile(path.join(root, "yss-project.yaml"));
-  if (value.repository_mode !== manifest.repository_mode) throw new TypeError("repository_mode 必须与根目录 yss-project.yaml 一致");
-  const contract = verifyContextSnapshot(value.context_snapshot, { root });
-  const changedRefs = [...value.changes.added, ...value.changes.updated, ...value.changes.deprecated];
-  resolveContextTermRefs(contract, changedRefs);
-  if (new Set(changedRefs).size !== changedRefs.length) throw new TypeError("changes 中的术语引用不得跨分类重复");
-  if (value.repository_mode === "project-instance" && value.status !== "reconciled") throw new TypeError("project-instance 工作单元只有 status=reconciled 才允许批准或进入下一步");
-  if (value.status === "reconciled" && value.unresolved_terms.length) throw new TypeError("reconciled 不得包含 unresolved_terms");
-  if (value.status === "blocked" && value.unresolved_terms.length === 0) throw new TypeError("blocked 必须说明 unresolved_terms");
-  if (value.status === "not-applicable" && (value.repository_mode !== "template-source" || !value.reason)) throw new TypeError("not-applicable 只适用于 template-source 且必须说明 reason");
-  for (const ref of value.evidence_refs) {
-    if (/^https?:\/\//.test(ref)) continue;
-    const resolved = path.resolve(root, ref);
-    if (!resolved.startsWith(`${root}${path.sep}`) && resolved !== root) throw new TypeError(`evidence_ref 越出仓库: ${ref}`);
-    if (!existsSync(resolved)) throw new TypeError(`evidence_ref 不可读: ${ref}`);
-  }
+  verifyContextReconciliation(positionals[0], { root: values.root });
   process.stdout.write("Context reconciliation 验证通过\n");
 } catch (error) {
   process.stderr.write(`Context reconciliation 验证失败: ${error.message}\n`);

package/template/scripts/verify-context-reconciliation-scenarios

@@ -40,7 +40,7 @@ function record(overrides = {}) {
   return {
     schema_version: 1,
     repository_mode: "project-instance",
-    stage: "stage.discovery",
+    stage: "stage.plan",
     work_unit: "work-unit.domain-strategy-design",
     status: "reconciled",
     context_snapshot: snapshot,

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";

package/template/scripts/verify-lifecycle-checkpoint

@@ -6,6 +6,7 @@ import { parseArgs } from "node:util";
 import { fileURLToPath } from "node:url";
 import { parseDocument } from "./vendor/yaml.mjs";
 import { assertCheckpointApprovals, assertCheckpointUserDecisions } from "./lib/approval-record.mjs";
+import { assertPlanCheckpoint } from "./lib/plan-spec-entry.mjs";
 
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const schemaPath = path.join(root, "docs/process/schemas/lifecycle-checkpoint.schema.json");
@@ -32,6 +33,7 @@ try {
   const result = spawnSync("python3", ["-c", validator, schemaPath], { cwd: root, encoding: "utf8", input: JSON.stringify(value) });
   if (result.status !== 0) throw new TypeError(`${result.stdout}${result.stderr}`.trim());
   assertCheckpointApprovals(value, sourcePath);
+  assertPlanCheckpoint(value);
   assertCheckpointUserDecisions(value);
   if (value.repository_mode === "project-instance" && ["paused-human-gate", "completed"].includes(value.status)) {
     if (value.context_reconciliation?.status !== "reconciled" || !value.context_reconciliation?.ref) throw new TypeError("project-instance 在会签或完成前必须具有 reconciled context_reconciliation");