create-yss-spec 3.3.0 → 3.3.1

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

package/template/scripts/verify-lifecycle-context-query-scenarios

@@ -10,24 +10,44 @@ const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 
 const query = {
   mode: "route",
-  stageId: "stage.discovery",
-  workUnitId: "work-unit.discovery-requirements",
+  stageId: "stage.plan",
+  workUnitId: "work-unit.plan-requirements",
   include: ["grill_exit"],
 };
 const first = queryLifecycleContext(query);
 const second = queryLifecycleContext(query);
 
 assert.deepEqual(first, second, "同一查询必须产生确定性结果");
+// 合并调用须保留原来三次查询的路由、阶段和技能信息。
+const modeOnly = queryLifecycleContext({ mode: query.mode });
+const stageOnly = queryLifecycleContext({ stageId: query.stageId });
+const unitOnly = queryLifecycleContext({ workUnitId: query.workUnitId });
+assert.deepEqual(first.execution.mode, modeOnly.execution.mode);
+for (const key of ["stage", "gates", "artifacts", "evidence"]) {
+  assert.deepEqual(first.lifecycle[key], stageOnly.lifecycle[key]);
+}
+assert.deepEqual(first.lifecycle.work_unit, unitOnly.lifecycle.work_unit);
+assert.deepEqual(first.execution.work_unit_route, unitOnly.execution.work_unit_route);
+assert.deepEqual(first.execution.transition, unitOnly.execution.transition);
+assert.deepEqual(first.skills, unitOnly.skills);
+const efficient = queryLifecycleContext({ ...query, include: ["grill_exit", "execution_efficiency"] });
+assert.deepEqual(efficient.lifecycle, first.lifecycle, "执行成本策略不得改变阶段门禁");
+assert.deepEqual(efficient.skills, first.skills);
+assert.deepEqual(efficient.execution.transition, first.execution.transition);
+assert.equal(efficient.execution.selected.execution_efficiency.verification.skip_triggered_gates, "forbidden");
+assert.equal("execution_efficiency" in first.execution.selected, false, "成本策略仍按需加载");
 assert.equal(first.query.mode, "route");
-assert.equal(first.lifecycle.stage.id, "stage.discovery");
-assert.ok(first.lifecycle.gates.every((gate) => gate.stage === "stage.discovery"));
-assert.ok(first.lifecycle.artifacts.every((artifact) => artifact.stage === "stage.discovery"));
-assert.equal(first.lifecycle.work_unit.id, "work-unit.discovery-requirements");
+assert.equal(first.lifecycle.stage.id, "stage.plan");
+assert.ok(first.lifecycle.gates.every((gate) => gate.stage === "stage.plan"));
+assert.ok(first.lifecycle.artifacts.every((artifact) => artifact.stage === "stage.plan"));
+assert.equal(first.lifecycle.work_unit.id, "work-unit.plan-requirements");
 assert.equal(first.execution.mode, "read_only");
 assert.equal(first.execution.work_unit_route.primary_skill, "yss-product-lifecycle");
 assert.ok(first.execution.selected.grill_exit.required.includes("frontier_empty"));
 assert.equal("review_input" in first.execution.selected, false, "不得返回未请求的合同子树");
 assert.ok(first.skills.some((skill) => skill.id === "grilling"));
+assert.throws(() => queryLifecycleContext({ stageId: "stage.discovery" }), /未知阶段/);
+assert.throws(() => queryLifecycleContext({ workUnitId: "work-unit.discovery-requirements" }), /未知工作单元/);
 assert.match(first.sources.lifecycle_registry.semantic_sha256, /^[0-9a-f]{64}$/);
 assert.match(first.sources.orchestration_contract.sha256, /^[0-9a-f]{64}$/);
 
@@ -43,8 +63,8 @@ for (const invalid of [
 const cli = spawnSync("node", [
   "scripts/query-lifecycle-context",
   "--mode", "route",
-  "--stage", "stage.discovery",
-  "--work-unit", "work-unit.discovery-requirements",
+  "--stage", "stage.plan",
+  "--work-unit", "work-unit.plan-requirements",
   "--include", "grill_exit",
 ], { cwd: ROOT, encoding: "utf8" });
 assert.equal(cli.status, 0, cli.stderr);

package/template/scripts/verify-plan-spec-entry

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import { decisionIO } from './lib/user-decision.mjs';
+import { assertPlanSpecEntry } from './lib/plan-spec-entry.mjs';
+try {
+  if (process.argv.length !== 3) throw new TypeError('用法: node scripts/verify-plan-spec-entry <state.yaml|json>');
+  assertPlanSpecEntry(decisionIO().document(process.argv[2]));
+  process.stdout.write('Plan → Spec 入口检查通过（不授权实现）\n');
+} catch (error) {
+  process.stderr.write(`${error.message}\n`);
+  process.exitCode = 1;
+}

package/template/scripts/verify-plan-spec-entry-scenarios

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+import assert from 'node:assert/strict';
+import { validateNextRoute } from './lib/lifecycle-transition.mjs';
+import { queryLifecycleContext } from './lib/lifecycle-context-query.mjs';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { buildPlanFixture } from './fixtures/user-decision/plan-fixture.mjs';
+import { assertPlanSpecEntry, assertPlanCheckpoint } from './lib/plan-spec-entry.mjs';
+import { readFileSync } from 'node:fs';
+import { decisionDigest } from './lib/user-decision.mjs';
+import { buildDecisionFixture } from './fixtures/user-decision/build-fixture.mjs';
+import { loadDigitalHumanRoles, countersignRuleForGate } from './lib/digital-human-roles.mjs';
+
+for (const unit of ['plan-opportunity', 'plan-requirements', 'domain-strategy-design', 'stage-decision']) {
+  for (const state of [undefined, {}, { gates: {}, user_decisions: [] }]) {
+    assert.equal(validateNextRoute(`work-unit.${unit}`, 'work-unit.spec-synthesis', state).result, 'blocked', `${unit}: missing Plan review must block`);
+  }
+}
+const query = queryLifecycleContext({ workUnitId: 'work-unit.plan-requirements' });
+assert.ok(query.execution.selected.planning);
+assert.ok(query.execution.selected.grill_exit);
+assert.ok(query.lifecycle.gates.length);
+assert.ok(query.execution.plan_checks.every(check => check.status === 'pending'));
+const specQuery = queryLifecycleContext({ stageId: 'stage.spec-architecture' });
+assert.ok(specQuery.execution.selected.planning);
+assert.ok(specQuery.execution.plan_checks.every(check => check.status === 'pending'));
+assert.ok(specQuery.lifecycle.gates.some(gate => gate.stage === 'stage.plan'));
+const temp = mkdtempSync(path.join(tmpdir(), 'yss-plan-entry-'));
+try {
+  const mutations = [
+    ['缺检查项', f => delete f.review.checks.goals],
+    ['默认 pending', f => f.review.checks.goals.status = 'pending'],
+    ['检查项不能 N/A', f => f.review.checks.goals.status = 'not-applicable'],
+    ['缺证据', f => f.review.checks.goals.evidence_refs = []],
+    ['缺影响面', f => delete f.review.impacts.domain_strategy],
+    ['缺门禁', f => delete f.review.gates['gate.domain-strategy-approved']],
+    ['命中门禁不能 N/A', f => f.review.impacts.domain_strategy = true],
+    ['N/A 无原因', f => delete f.review.gates['gate.domain-strategy-approved'].reason],
+    ['关键问题延期', f => f.review.open_items.push({ id: 'q1', critical: true, runnable_blocker: false, status: 'deferred' })],
+    ['可执行阻塞延期', f => f.review.open_items.push({ id: 'q1', critical: false, runnable_blocker: true, status: 'deferred' })],
+    ['延期未交接', f => f.review.open_items.push({ id: 'q1', critical: false, runnable_blocker: false, status: 'deferred' })],
+    ['无回复', f => { f.approval.record.responses = []; f.approval.save(); }],
+    ['过期依据', f => f.write('plan.md', '变更后的范围')],
+    ['错误范围', f => f.state.feature_id = 'feature.other'],
+    ['调和未通过', f => f.review.context_reconciliation_ref = 'plan.md'],
+  ];
+  const valid = buildPlanFixture(path.join(temp, 'valid'));
+  assert.equal(assertPlanSpecEntry(valid.state, { root: valid.root }).result, 'allowed');
+  assert.equal(validateNextRoute('work-unit.plan-opportunity', 'work-unit.spec-synthesis', valid.state, { root: valid.root }).result, 'allowed');
+  valid.review.open_items = [{ id: 'q-detail', critical: false, runnable_blocker: false, status: 'deferred', noncritical_reason: '不影响范围或关键规则', owner: '测试负责人', resolution_point: 'Spec 评审前', downstream_recipient: '测试需求负责人', evidence_refs: ['plan.md'] }];
+  valid.reapprove();
+  assert.equal(assertPlanSpecEntry(valid.state, { root: valid.root }).result, 'allowed', '用户确认后的非关键延期可通过');
+  for (const [gateId, impact] of Object.entries({ 'gate.domain-strategy-approved': 'domain_strategy', 'gate.stage-decision-package-approved': 'stage_decision' })) {
+    const subjectRef = path.join(valid.root, 'plan.md');
+    const reply = buildDecisionFixture(path.join(valid.root, impact), { boundary: gateId, subjectRef });
+    const rule = countersignRuleForGate(loadDigitalHumanRoles().gate_policy, gateId);
+    const approvalRef = path.join(valid.root, `${impact}.json`);
+    valid.write(approvalRef, { schema_version: 1, gate_id: gateId, decision: 'approved', actor_kind: 'digital-human', role_id: rule.countersigners[0], runtime_id: 'runtime.skill-projection', principal_ref: 'test-only.reviewer', subject_ref: subjectRef, approval_scope: ['feature.demo'], user_decision_ref: reply.ref });
+    valid.review.impacts[impact] = true;
+    valid.review.gates[gateId] = { status: 'approved', approval_ref: approvalRef, subject_ref: subjectRef, approval_scope: ['feature.demo'], evidence_refs: [approvalRef, subjectRef] };
+    for (const ref of [approvalRef, subjectRef]) if (!valid.review.basis.some(asset => asset.ref === ref)) valid.review.basis.push({ ref, digest: decisionDigest(readFileSync(ref)) });
+  }
+  valid.reapprove();
+  assert.equal(assertPlanSpecEntry(valid.state, { root: valid.root }).result, 'allowed', '命中门禁、真实回复来源与当前资产绑定均通过');
+  valid.review.gates['gate.domain-strategy-approved'].approval_scope = ['feature.other']; valid.reapprove();
+  assert.throws(() => assertPlanSpecEntry(valid.state, { root: valid.root }), /会签资产或范围不匹配/);
+  for (const [name, mutate] of mutations) {
+    const f = buildPlanFixture(path.join(temp, name)); mutate(f); f.save();
+    assert.throws(() => assertPlanSpecEntry(f.state, { root: f.root }), undefined, name);
+  }
+  for (const checkpoint of [{ next_work_unit: 'work-unit.spec-synthesis' }, { stage: 'stage.spec-architecture' }, { stage_trace: { completed_work_unit: 'work-unit.spec-synthesis' } }]) {
+    assert.throws(() => assertPlanCheckpoint({ repository_mode: 'project-instance', ...checkpoint }), /plan-spec-entry-blocked/);
+  }
+  const stale = buildPlanFixture(path.join(temp, 'stale-review'));
+  stale.review.gates['gate.domain-strategy-approved'].reason += ' changed'; stale.save();
+  assert.throws(() => assertPlanSpecEntry(stale.state, { root: stale.root }), /user-decision-stale/);
+} finally { rmSync(temp, { recursive: true, force: true }); }
+process.stdout.write('Plan → Spec 无状态绕过与默认加载检查通过\n');

package/template/scripts/verify-script-performance-scenarios

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+import assert from 'node:assert/strict';
+import * as fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn, spawnSync } from 'node:child_process';
+import { once } from 'node:events';
+import { pathToFileURL } from 'node:url';
+import { validateJsonSchemas, validateJsonSchema } from './lib/json-schema.mjs';
+import { runCommand, runCommandSync } from './lib/command-runner.mjs';
+const temp=fs.mkdtempSync(path.join(os.tmpdir(),'yss-performance-scenarios-'));
+try {
+  const schema=path.join(temp,'schema.json');
+  fs.writeFileSync(schema,JSON.stringify({$defs:{name:{type:'string',minLength:2}},type:'object',required:['name'],properties:{name:{$ref:'#/$defs/name'},email:{type:'string',format:'email'},items:{type:'array',items:{type:'integer'}}},additionalProperties:false}));
+  const values=[{name:'okay'},{name:'x'},{name:'okay',email:'wrong'},null,{name:'okay',items:['bad']},{name:'okay',unknown:1}];
+  for(const formatChecker of [true,false])for(const errorStyle of ['compact','verbose']) {
+    const jobs=values.map(value=>({value,schemaPath:schema,formatChecker,errorStyle}));
+    const results=validateJsonSchemas(jobs);
+    // Independent original Python behavior, not the new single-item wrapper.
+    const legacy=spawnSync('python3',['-c',`import json,sys\nfrom jsonschema import Draft202012Validator,FormatChecker\ns=json.load(open(sys.argv[1])); rows=[]\nfor v in json.load(sys.stdin):\n e=list(Draft202012Validator(s,format_checker=${formatChecker?'FormatChecker()':'None'}).iter_errors(v))\n ${errorStyle==='compact'?"e.sort(key=lambda x:list(x.absolute_path))":"pass"}\n message=${errorStyle==='compact'?`'\\n'.join(f"{'.'.join(str(p) for p in x.absolute_path) or '<root>'}: {x.message}" for x in e)`:`'\\n'.join(str(x) for x in e)`}\n rows.append({'valid':not e,'error':message})\njson.dump(rows,sys.stdout)`,schema],{input:JSON.stringify(values),encoding:'utf8'});
+    assert.equal(legacy.status,0,legacy.stderr);
+    assert.deepEqual(results,JSON.parse(legacy.stdout));
+  }
+  assert.deepEqual(validateJsonSchemas([]),[]);
+  assert.throws(()=>validateJsonSchema({},path.join(temp,'missing.json')),/缺少/);
+  fs.writeFileSync(schema,JSON.stringify({type:'number'}));
+  assert.throws(()=>validateJsonSchema({name:'okay'},schema),/not of type/,'schema 改变后必须重新读取');
+  const log=path.join(temp,'stdout.log');
+  const split=await runCommand(process.execPath,['-e',"process.stdout.write('ab');setTimeout(()=>process.stdout.write('aba!'),20)"],{stdoutFile:log,secrets:['ababa']});
+  assert.equal(split.stdout,'[REDACTED]!');assert.equal(fs.readFileSync(log,'utf8'),'[REDACTED]!');
+  const timed=await runCommand(process.execPath,['-e',"setInterval(()=>{},1000)"],{timeoutMs:100});
+  assert.equal(timed.status,124);assert.equal(timed.termination,'timeout');
+  const controller=new AbortController();
+  const cancelled=runCommand(process.execPath,['-e',"setInterval(()=>{},1000)"],{signal:controller.signal});
+  setTimeout(()=>controller.abort(),50);assert.equal((await cancelled).termination,'cancelled');
+  const missing=await runCommand(path.join(temp,'missing'),[]);assert.notEqual(missing.status,0);
+  assert.equal(runCommandSync(process.execPath,['-e',"process.stdout.write('sync')"]).stdout,'sync');
+  const pidFile=path.join(temp,'pid');
+  const tree=await runCommand(process.execPath,['-e',`const {spawn}=require('node:child_process');const fs=require('node:fs');const c=spawn(process.execPath,['-e','setInterval(()=>{},1000)'],{stdio:'ignore'});fs.writeFileSync(${JSON.stringify(pidFile)},String(c.pid));setInterval(()=>{},1000)`],{timeoutMs:250});
+  assert.equal(tree.termination,'timeout');
+  const pid=Number(fs.readFileSync(pidFile,'utf8'));
+  // A reparented zombie may briefly exist; it must never remain a running child.
+  const state=spawnSync('ps',['-o','stat=','-p',String(pid)],{encoding:'utf8'});
+  assert.ok(state.status!==0 || !state.stdout.trim() || state.stdout.trim().startsWith('Z'),state.stdout);
+  const orphanPid=path.join(temp,'orphan-pid'), scratch=path.join(temp,'owned-fetch');fs.mkdirSync(scratch);
+  const parent=spawn(process.execPath,['--input-type=module','-e',`import {runCommandSync} from ${JSON.stringify(pathToFileURL(path.join(import.meta.dirname,'lib/command-runner.mjs')).href)};runCommandSync(process.execPath,['-e',${JSON.stringify(`require('node:fs').writeFileSync(${JSON.stringify(orphanPid)},String(process.pid));setInterval(()=>{},1000)`)}],{cleanupPathsOnFailure:[${JSON.stringify(scratch)}]});`],{stdio:'ignore'});
+  const exited=once(parent,'exit');
+  for(let n=0;n<150&&!fs.existsSync(orphanPid);n++)await new Promise(resolve=>setTimeout(resolve,20));
+  assert.ok(fs.existsSync(orphanPid),'worker 子进程应启动');
+  parent.kill('SIGTERM');await exited;
+  for(let n=0;n<150&&fs.existsSync(scratch);n++)await new Promise(resolve=>setTimeout(resolve,20));
+  assert.equal(fs.existsSync(scratch),false,'同步调用者退出后 worker 应清理其临时资源');
+  const orphanState=spawnSync('ps',['-o','stat=','-p',fs.readFileSync(orphanPid,'utf8')],{encoding:'utf8'});
+  assert.ok(orphanState.status!==0 || !orphanState.stdout.trim() || orphanState.stdout.trim().startsWith('Z'),orphanState.stdout);
+  console.log('schema 批量差分、重新读取、日志脱敏、超时、取消与进程树清理通过');
+} finally { fs.rmSync(temp,{recursive:true,force:true}); }

package/template/scripts/verify-subagent-task-package-scenarios

@@ -83,7 +83,7 @@ function packageBase(roleId, taskId, workUnitId, kind, contractFields, stageId)
 }
 
 function lifecyclePackage() {
-  return packageBase("role.requirements-manager", "task-discovery", "work-unit.discovery-opportunity", "lifecycle-work-unit", { lifecycle_ref: "docs/process/lifecycle-registry.yaml", artifact_refs: ["artifact.discovery-record"] , gate_refs: [] , contract_id: "lifecycle-discovery", contract_version: 1 }, "stage.discovery");
+  return packageBase("role.requirements-manager", "task-discovery", "work-unit.plan-opportunity", "lifecycle-work-unit", { lifecycle_ref: "docs/process/lifecycle-registry.yaml", artifact_refs: ["artifact.plan-record"] , gate_refs: [] , contract_id: "lifecycle-discovery", contract_version: 1 }, "stage.plan");
 }
 
 function lifecycleStagePackage(roleId, taskId, workUnitId, stageId) {
@@ -134,7 +134,7 @@ function completedResult(pkg, overrides = {}) {
     violation: [],
     new_impacts: [],
     stale_candidates: [],
-    next_route: "work-unit.spec-synthesis",
+    next_route: "work-unit.plan-requirements",
     blocking_signals: [],
     ...overrides
   };
@@ -160,18 +160,19 @@ try {
   maintenance.review_context = { implementation_actor_id: "role.lifecycle-orchestrator.instance-1" };
   const frontend = slicePackage("role.frontend-engineer", "task-frontend", "work-unit.slice-frontend", "apps/frontend/todo/");
   const backend = slicePackage("role.backend-engineer", "task-backend", "work-unit.slice-backend", "apps/backend/todo/");
-  [discovery, spec, prototype, technical, tickets, review].forEach((pkg) => validateTaskPackage(pkg));
+  [discovery, prototype, technical, tickets, review].forEach((pkg) => validateTaskPackage(pkg));
+  assert.throws(() => validateTaskPackage(spec), /plan-spec-entry-blocked/, "直接派发 Spec 缺 Plan 审阅须阻断");
   validateTaskPackage(maintenance);
   validateTaskPackage(frontend);
   assert.throws(() => validateTaskPackage({ ...frontend, user_decisions: [] }), /user-decision-scope-mismatch/, "Worker 派发前必须有当前实施范围批准");
   validateTaskPackage(backend);
   validateTaskPackageSet([frontend, backend]);
 
-  const completedDiscovery = lifecyclePackage();
-  completedDiscovery.workflow_status = "resolved";
-  completedDiscovery.verification_results = [{ command: "scripts/verify-template", exit_code: 0, executed_at: "now", evidence_ref: evidenceRef }];
-  completedDiscovery.result = completedResult(completedDiscovery);
-  validateTaskPackage(completedDiscovery);
+  const completedPlan = lifecyclePackage();
+  completedPlan.workflow_status = "resolved";
+  completedPlan.verification_results = [{ command: "scripts/verify-template", exit_code: 0, executed_at: "now", evidence_ref: evidenceRef }];
+  completedPlan.result = completedResult(completedPlan);
+  validateTaskPackage(completedPlan);
 
   const validFile = path.join(ROOT, ".template-source/evidence/.task-package-valid.json");
   writeFileSync(validFile, JSON.stringify(discovery));

package/template/scripts/verify-template-cache-scenarios

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import assert from "node:assert/strict";
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { chmodSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { spawnSync } from "node:child_process";
@@ -40,6 +40,16 @@ try {
   assert.throws(() => acquireTemplateCommit({ repository: remote, commit, cacheRoot, allowLocal: true }), /缓存不完整/);
   assert.throws(() => acquireTemplateCommit({ repository: path.join(root, "offline"), commit, cacheRoot: path.join(root, "offline-cache"), allowLocal: true }), /执行失败|does not appear to be a git repository/);
   assert.throws(() => acquireTemplateCommit({ repository: remote, commit: "main", cacheRoot, allowLocal: true }), /40 位 commit/);
+  const realGit = spawnSync("which", ["git"], { encoding: "utf8" }).stdout.trim();
+  const bin = path.join(root, "bin"), timeoutCache = path.join(root, "timeout-cache"), previousPath = process.env.PATH;
+  mkdirSync(bin);
+  writeFileSync(path.join(bin, "git"), `#!/usr/bin/env node\nconst {spawnSync}=require('node:child_process');const args=process.argv.slice(2);if(args.includes('fetch'))setTimeout(()=>{},10000);else process.exit(spawnSync(${JSON.stringify(realGit)},args,{stdio:'inherit'}).status ?? 1);\n`);
+  chmodSync(path.join(bin, "git"), 0o755);
+  try {
+    process.env.PATH = bin + path.delimiter + previousPath;
+    assert.throws(() => acquireTemplateCommit({ repository: remote, commit, cacheRoot: timeoutCache, allowLocal: true, timeoutMs: 100 }), /timeout/);
+    assert.deepEqual(readdirSync(timeoutCache), [], "超时 fetch 不遗留临时缓存或伪成功条目");
+  } finally { process.env.PATH = previousPath; }
 } finally {
   rmSync(root, { recursive: true, force: true });
 }

package/template/scripts/verify-user-decision-scenarios

@@ -88,10 +88,10 @@ check("历史数字人记录可读但不能关闭关键门禁", () => {
   const f = fixture("approval"); Object.assign(record, { subject_ref: f.requirement.subject_ref, approval_scope: f.requirement.scope, user_decision_ref: f.ref }); validateApprovalRecord(record, { requireApproved: true });
 });
 check("等待期间可保存状态但不能流转依赖工作", () => {
-  const f = fixture("workflow", { boundary: "discovery-conclusion" }); const state = { user_decisions: [f.requirement] };
-  assert.equal(validateNextRoute("work-unit.discovery-requirements", "work-unit.spec-synthesis", state).result, "allowed");
-  f.record.responses = []; f.save(); assert.equal(validateNextRoute("work-unit.discovery-requirements", "work-unit.spec-synthesis", state).result, "blocked");
-  assert.equal(validateNextRoute("work-unit.discovery-opportunity", "work-unit.discovery-requirements", state).result, "allowed");
+  const f = fixture("workflow", { boundary: "plan-conclusion" }); const state = { user_decisions: [f.requirement] };
+  assert.equal(validateNextRoute("work-unit.plan-requirements", "work-unit.spec-synthesis", state).result, "blocked", "仅用户确认不能代替完整 Plan 入口审阅");
+  f.record.responses = []; f.save(); assert.equal(validateNextRoute("work-unit.plan-requirements", "work-unit.spec-synthesis", state).result, "blocked");
+  assert.equal(validateNextRoute("work-unit.plan-opportunity", "work-unit.plan-requirements", state).result, "allowed");
   assertCheckpointUserDecisions({ repository_mode: "project-instance", status: "paused-human-gate", human_review: { required_decisions: [f.requirement] } });
   assert.throws(() => assertCheckpointUserDecisions({ repository_mode: "project-instance", status: "running", human_review: { required_decisions: [f.requirement] } }), /user-decision-response-required/);
 });

package/template/skills-lock.json

@@ -21,7 +21,7 @@
       "revision": "c4d958f18cc947cb91cbe1bd48783fa4601cc18f"
     },
     "iloveZzz/yss-harness-design-agent": {
-      "revision": "8a67e0f5a56aa5085d18c2b42bb540c8f36c2fab"
+      "revision": "3a358684c5684ada433dca4fd97ee187050ca6d8"
     }
   },
   "skills": {
@@ -99,7 +99,7 @@
         "source": "competitive-intelligence",
         "sourceType": "local",
         "skillPath": "sales/skills/competitive-intelligence/SKILL.md",
-        "effectiveHash": "d4b83600889b6045182232f0c11a9d6a563030b5f60faa4385a7886843ef0109",
+        "effectiveHash": "df1473dfd96b1a3ba63ef929917973b613988edf62193b5b82d734de2e8418cd",
         "targets": [
           ".agents/skills",
           ".claude/skills",
@@ -164,7 +164,7 @@
         "source": "mattpocock/skills",
         "sourceType": "github",
         "skillPath": "skills/engineering/domain-modeling/SKILL.md",
-        "effectiveHash": "02989ac6fd21562ba87af7a88b5d34f11661f86a3a42014e366613ecdb81bd81",
+        "effectiveHash": "7e691aeef60ee61c423f224acd3c4481a8764d3d336c8c49585b36d1a9bca9be",
         "sourceRevision": "0ab1b63a410a03d3627979a109c8695de27af954",
         "upstreamHash": "2bc3bb0a64ea9c6f5c3bcf78fc17f0fcdc7c062edc547ef006441de0b576d248",
         "adaptationRef": "docs/process/MATT-POCOCK-ENGINEERING-SKILLS.md",
@@ -304,7 +304,7 @@
         "source": "mattpocock/skills",
         "sourceType": "github",
         "skillPath": "skills/engineering/grill-with-docs/SKILL.md",
-        "effectiveHash": "c0f724b8cb4be22d10d8e8de3dfd49eb024cf131a3bcf5e7b89e109ad3d80b32",
+        "effectiveHash": "2006f65f386e79ff37c2c3294efe146e2e546845cf52e1571340dcb2a81a0df3",
         "sourceRevision": "0ab1b63a410a03d3627979a109c8695de27af954",
         "upstreamHash": "6b1292031c4f38a11309b9dad9be1141c1921c6edf86d1ae6da8b048fa71a349",
         "adaptationRef": "docs/process/MATT-POCOCK-ENGINEERING-SKILLS.md",
@@ -559,7 +559,7 @@
         "sourceType": "git-submodule",
         "skillPath": ".agents/skills/prototype-review/SKILL.md",
         "effectiveHash": "51021f119697dbff644d70c3d6ba3314147c47f412c6f56e4b5540ea3bf554a1",
-        "sourceRevision": "8a67e0f5a56aa5085d18c2b42bb540c8f36c2fab",
+        "sourceRevision": "3a358684c5684ada433dca4fd97ee187050ca6d8",
         "upstreamHash": "2e77b3093a758bb692fb3bda453c5c020d0523f875975e17e2731365f67432e1",
         "adaptationRef": "docs/agents/strategic-design-skills-integration.md",
         "targets": [
@@ -594,7 +594,7 @@
         "source": "mattpocock/skills",
         "sourceType": "github",
         "skillPath": "skills/engineering/setup-matt-pocock-skills/SKILL.md",
-        "effectiveHash": "c1463ecc928789308855e9995e9787cf311128a8567f8ed671b83d696a9b4cc9",
+        "effectiveHash": "1f63e63e8036a08ac6d0626b4dbbd16d8fbe1ae171cae31b36e82c606552396e",
         "sourceRevision": "0ab1b63a410a03d3627979a109c8695de27af954",
         "upstreamHash": "80cd6b5be4f67913f1b10f5acd97fccaeb6401682ae7ff3a971460cb73d86cbe",
         "adaptationRef": "docs/process/MATT-POCOCK-ENGINEERING-SKILLS.md",
@@ -824,7 +824,7 @@
         "sourceType": "git-submodule",
         "skillPath": ".agents/skills/yss-antd-design/SKILL.md",
         "effectiveHash": "917099caa9b76ca3cfd1d0f81f61b28111c1c54ed93e92891f81012dcd0662e2",
-        "sourceRevision": "8a67e0f5a56aa5085d18c2b42bb540c8f36c2fab",
+        "sourceRevision": "3a358684c5684ada433dca4fd97ee187050ca6d8",
         "upstreamHash": "08ce99d45586d5ea19e25fdd9e9a6ede16e66f18992b70b87e0cd23f92343b16",
         "adaptationRef": "docs/agents/strategic-design-skills-integration.md",
         "targets": [
@@ -842,7 +842,7 @@
         "sourceType": "git-submodule",
         "skillPath": ".agents/skills/yss-antdv-next-design/SKILL.md",
         "effectiveHash": "8c55e3a815ace34fbf591e931a58970b3d58cb657e00432ca6c72938d307563b",
-        "sourceRevision": "8a67e0f5a56aa5085d18c2b42bb540c8f36c2fab",
+        "sourceRevision": "3a358684c5684ada433dca4fd97ee187050ca6d8",
         "upstreamHash": "2942ed52dd58a38e51f09eb11254809334aeaed08f21cd081f09f35e6647a68c",
         "adaptationRef": "docs/agents/strategic-design-skills-integration.md",
         "targets": [
@@ -937,7 +937,7 @@
         "source": "project",
         "sourceType": "local",
         "skillPath": ".agents/skills/yss-ddd-scaffold-generator/SKILL.md",
-        "effectiveHash": "96e1c82c538a96af293273906db5ddefcf9943e8b76bb47b05d08772f16258cb",
+        "effectiveHash": "ab1bd70b73a148d57a8e3f88e9a94be57b81f59bbfb81849e6e1dba16bfc7e16",
         "targets": [
           ".agents/skills",
           ".claude/skills",
@@ -953,7 +953,7 @@
         "sourceType": "git-submodule",
         "skillPath": ".agents/skills/yss-design-system/SKILL.md",
         "effectiveHash": "e69597b8b6a5ce4de5bd40f67630443b8176202f6b028b2ce146a2a1d062816f",
-        "sourceRevision": "8a67e0f5a56aa5085d18c2b42bb540c8f36c2fab",
+        "sourceRevision": "3a358684c5684ada433dca4fd97ee187050ca6d8",
         "upstreamHash": "90aaf06b2514353152464a4d032076fa9d5ef56272d8ad526f5544f3c22a2b00",
         "adaptationRef": "docs/agents/strategic-design-skills-integration.md",
         "targets": [
@@ -1078,7 +1078,7 @@
         "source": "project",
         "sourceType": "local",
         "skillPath": ".agents/skills/yss-frontend-scaffold-generator/SKILL.md",
-        "effectiveHash": "968c213c90a30d719e51050a6122ef729bc03ae97d2841a5d47824d68a5d27ff",
+        "effectiveHash": "2f829e4e2a9cb42e123e8de37fe812bc65eef1308758e077b52f0698de9b68ab",
         "targets": [
           ".agents/skills",
           ".claude/skills",
@@ -1228,7 +1228,7 @@
         "source": "project",
         "sourceType": "local",
         "skillPath": ".agents/skills/yss-product-lifecycle/SKILL.md",
-        "effectiveHash": "d317bd2799da0442745c8126e62f7919a0b3de03f2c3cc2e1a7ca0433dc69645",
+        "effectiveHash": "a54a583c92621aede69e2f7db99f7373e0724b3187acd44c6d20c0144ca9943b",
         "targets": [
           ".agents/skills",
           ".claude/skills",
@@ -1244,7 +1244,7 @@
         "sourceType": "git-submodule",
         "skillPath": ".agents/skills/yss-prototype-stage/SKILL.md",
         "effectiveHash": "0ecf3125a73d15e4c9b6b665f92535180df82ccb2255fa863ec59f3ff5d460aa",
-        "sourceRevision": "8a67e0f5a56aa5085d18c2b42bb540c8f36c2fab",
+        "sourceRevision": "3a358684c5684ada433dca4fd97ee187050ca6d8",
         "upstreamHash": "e8f2f3a507da6bf7be0582e4a4dd9659381da8e291755070698a1f51a4e33808",
         "adaptationRef": "docs/agents/strategic-design-skills-integration.md",
         "targets": [
@@ -1276,7 +1276,7 @@
         "source": "mattpocock/skills",
         "sourceType": "github",
         "skillPath": "skills/engineering/research/SKILL.md",
-        "effectiveHash": "a0c69c6cff59bdb6d36b03d24cceb29698e76cd6aae88919bf864284737c3aaa",
+        "effectiveHash": "0d8f94e6379ad56897a7821b4803a3ba72910e617aab730e47db719e6eb02807",
         "sourceRevision": "0ab1b63a410a03d3627979a109c8695de27af954",
         "upstreamHash": "75b7f9bbd7ccff6755a006f8b25d319a46ecbf6bd4b4c3323965ed9cb65e78ff",
         "adaptationRef": "docs/process/MATT-POCOCK-ENGINEERING-SKILLS.md",
@@ -1339,9 +1339,9 @@
         "source": "iloveZzz/yss-harness-design-agent",
         "sourceType": "git-submodule",
         "skillPath": ".agents/skills/yss-stage-decision/SKILL.md",
-        "effectiveHash": "63e222ec2bc572c8d66fc52143ba3862650d243f57e1e9c71214b533eba37c23",
-        "sourceRevision": "8a67e0f5a56aa5085d18c2b42bb540c8f36c2fab",
-        "upstreamHash": "1eadf230f0e17bf6d209c1df1249acef3520ab29c26a80c476a2a557a224c10a",
+        "effectiveHash": "ad5180d162c6f9484aac556ed114e1447f93715d2d7e3c4bc1a53430adae65f1",
+        "sourceRevision": "3a358684c5684ada433dca4fd97ee187050ca6d8",
+        "upstreamHash": "2ec63f66aaf799d693cec0f0b5d71b8c4917e4e2822e0ddd519bc9b711fa3c95",
         "adaptationRef": "docs/agents/strategic-design-skills-integration.md",
         "targets": [
           ".agents/skills",

package/template.manifest.json

@@ -56,6 +56,7 @@
     ".pi/settings.json",
     ".cursor/environment.json",
     "docs/.scratch",
+    "docs/discovery",
     "docs/reviews",
     "docs/adr"
   ],
@@ -65,7 +66,7 @@
     "yss-project.yaml"
   ],
   "exampleDocPaths": [
-    "docs/discovery/IDEATION.md"
+    "docs/plan/IDEATION.md"
   ],
   "initExcludeRootEntries": [],
   "initExcludeRootFiles": [

package/template.snapshot.json

@@ -3,15 +3,15 @@
   "templateName": "yss-spec-project-template",
   "templateSource": "github:iloveZzz/yss-spec-project-template",
   "templateRepository": "https://github.com/iloveZzz/yss-spec-project-template.git",
-  "requestedRef": "6f5c5d80adcdb743fb06199f70a7ab0b0a640ce5",
-  "templateCommit": "6f5c5d80adcdb743fb06199f70a7ab0b0a640ce5",
-  "manifestHash": "f7520dfdfa388b19ea47cb893c2daab8936019783aa84589f13921e459702280",
+  "requestedRef": "ae2a3bdeca25249aed96d0a4d289b356d38417f9",
+  "templateCommit": "ae2a3bdeca25249aed96d0a4d289b356d38417f9",
+  "manifestHash": "e1e9f7d3e00c43b3e6cc889d961c94d684d08b852d8635c0a2f6b463b24432e6",
   "encodedPaths": {
     ".codex/skills/data-analytics/.gitignore": ".codex/skills/data-analytics/__yss_dotfile__.gitignore",
     ".codex/skills/product-design/.npmignore": ".codex/skills/product-design/__yss_dotfile__.npmignore",
     ".codex/skills/product-design/templates/prototype/.npmrc": ".codex/skills/product-design/templates/prototype/__yss_dotfile__.npmrc",
     ".gitignore": "__yss_dotfile__.gitignore"
   },
-  "snapshotHash": "2a676bf4ed0d3151bab51ad900181cbb8fdd628385572e11dd398bcbaceab61b",
-  "generatedAt": "2026-09-09T02:16:12.516Z"
+  "snapshotHash": "b15d75307273b8d82f7e08b1b81a7d47ff88aa76cb7e05638ff5489620fe1888",
+  "generatedAt": "2026-09-10T02:41:41.548Z"
 }