@godv61/dsh-task-engine 0.24.0 → 0.25.0

package/.p0-test.mjs

@@ -6,12 +6,29 @@ import { readFileSync } from 'node:fs'
 import { registerDevTask } from './lib/dev-task.js'
 import { assertAdvance, checkFileScope, newTask, taskIdFromMessage, validateWorkflow } from './lib/engine.js'
 import {
+
+
   FLOW_PRESETS,
   HIGH_RISK_REQUIRED_CAPABILITIES,
   flowSatisfies,
   resolveFlow,
+  adoptRecommendation,
 } from './lib/workflows.js'
 
+/**
+ * The preset as a project would actually run it: the skeleton plus the shipped
+ * recommendation, adopted exactly the way a user adopts it. A test that asserts
+ * on bindings, commit rules or artifacts wants this, because those no longer come
+ * from the preset itself.
+ * @param {string} id - preset id.
+ * @returns {import('./lib/engine.js').WorkflowConfig} the adopted config.
+ */
+function adoptedFlow(id, extra) {
+  const base = adoptRecommendation(id)
+  if (base === undefined) throw new Error('unknown preset: ' + id)
+  return resolveFlow(id, { ...base, ...extra }).config
+}
+
 let passed = 0
 function assert(cond, msg) {
   if (!cond) {
@@ -101,34 +118,64 @@ function sessionExec(cwd) {
 assert(flowSatisfies('standard', HIGH_RISK_REQUIRED_CAPABILITIES), 'standard satisfies high-risk capabilities')
 assert(!flowSatisfies('agile', HIGH_RISK_REQUIRED_CAPABILITIES), 'agile lacks a high-risk capability')
 assert(!flowSatisfies('minimal', HIGH_RISK_REQUIRED_CAPABILITIES), 'minimal lacks a high-risk capability')
-assert(FLOW_PRESETS.standard.version === 2, 'standard preset carries the review-before-commit version')
+// Version 3 is the skeleton/recommendation split: the preset now carries only
+// state control, and its former bindings, commit text and artifacts are a
+// separate recommendation a user adopts. The version number is what makes an
+// already-created task keep its frozen config instead of silently changing.
+assert(FLOW_PRESETS.standard.version === 3, 'standard preset carries the skeleton/recommendation version')
+// Versions are per-preset because they record per-preset changes: agile moved
+// again when 审查 gained a completion guard, and a task created before that
+// keeps its frozen version and behaves exactly as it did.
+assert(FLOW_PRESETS.standard.version === 3, 'standard carries the skeleton/recommendation version')
+assert(FLOW_PRESETS.minimal.version === 3, 'minimal carries the skeleton/recommendation version')
+assert(FLOW_PRESETS.agile.version === 4, 'agile moved again for the completion guard')
 
 // ── 2. unknown flow fails closed ───────────────────────────────────────────
+// `resolveFlow` is called directly here: this test is about the fail-closed
+// result, and the adoption helper throws instead of returning one.
 const unknown = resolveFlow('nope')
 assert(unknown.ok === false && unknown.code === 'UNKNOWN_FLOW', 'unknown flow returns UNKNOWN_FLOW')
 assert(unknown.knownFlows.includes('standard'), 'known flow list is surfaced')
 
-// ── 3. core skill bindings cannot be cancelled by an override ──────────────
-// Rules moved onto the skill, so the invariant is about the SKILL surviving an
-// override and that skill's own rule list staying intact. A stage has no rule
-// list left to empty.
-const merged = resolveFlow('standard', { stage_bindings: { '开发': {} } })
-assert(merged.ok
-  && merged.config.stage_bindings['开发'].skills.some(entry => entry.skill.name === 'code-implement'),
-  'an empty stage override keeps the core skill binding')
-const implementBinding = merged.config.stage_bindings['开发'].skills.find(entry => entry.skill.name === 'code-implement')
-assert(implementBinding.rules.map(rule => rule.name).includes('coding-conventions'),
-  'a skill keeps its own rules; there is no stage-level rule list for an override to empty')
+// ── 3. the user's bindings are taken as given, not merged with a preset's ────
+// The old invariant here was "a preset's core skill survives any override", which
+// meant a project could never drop a shipped skill and a project's own rule list
+// for that skill was discarded because the skill reference already existed. The
+// contract is now the opposite: what the user configured IS the configuration,
+// and the preset offers its setup only through explicit adoption.
+const bare = resolveFlow('standard', { flow: 'standard' })
+assert(bare.ok && Object.keys(bare.config.stage_bindings ?? {}).length === 0,
+  'the preset skeleton carries no bindings of its own')
+
+const emptied = resolveFlow('standard', { flow: 'standard', stage_bindings: { '开发': { skills: [] } } })
+assert(emptied.ok && (emptied.config.stage_bindings['开发'].skills ?? []).length === 0,
+  'a project that binds nothing to a stage keeps it empty; nothing is merged back in')
+
+const adopted = adoptedFlow('standard')
+assert(adopted.stage_bindings['开发'].skills.some(entry => entry.skill.name === 'code-implement'),
+  'adopting the recommendation is what supplies the shipped skills')
+
+// And a user who gives a shipped skill their own rule list gets that list — the
+// defect this replaces was that the entry was skipped as a duplicate reference.
+const ownRules = resolveFlow('standard', {
+  flow: 'standard',
+  stage_bindings: {
+    '开发': { skills: [{ skill: { source: 'bundled', name: 'code-implement' }, rules: [{ source: 'project', name: 'only-mine' }] }] },
+  },
+}).config
+const implementBinding = ownRules.stage_bindings['开发'].skills.find(entry => entry.skill.name === 'code-implement')
+assert(implementBinding.rules.length === 1 && implementBinding.rules[0].name === 'only-mine',
+  'a project rule list for a shipped skill is used as given, not discarded as a duplicate')
 
 // ── 4. newTask freezes the snapshot ────────────────────────────────────────
-const snapshot = { flow: 'standard', version: 1, config: FLOW_PRESETS.standard.config }
+const snapshot = { flow: 'standard', version: 1, config: adoptedFlow('standard') }
 const state = newTask({ id: 'T1', title: 'x', branch: 'main', work_size: 'standard', risk_level: 'standard', flow: snapshot })
 assert(state.flow?.flow === 'standard' && state.flow.version === 1, 'newTask stores the frozen snapshot')
 assert(state.stage === '需求评审', 'newTask starts at the frozen start stage')
 
 // ── 5. high_risk create on minimal is rejected ─────────────────────────────
 await assertThrows(
-  () => registered(makeFs({ '.dsh/eng.json': JSON.stringify({ flow: 'minimal' }) }))
+  () => registered(makeFs({ '.dsh/eng.json': JSON.stringify(adoptRecommendation('minimal')) }))
     .then(exe => exe({ operation: 'create', task_id: 'T2', title: 'x', branch: 'main', risk_level: 'high_risk' }, EXEC)),
   'high_risk',
   'high_risk on minimal is rejected',
@@ -136,13 +183,13 @@ await assertThrows(
 
 // ── 6. a task keeps its frozen snapshot after eng.json changes ─────────────
 {
-  const fs = makeFs({ '.dsh/eng.json': JSON.stringify({ flow: 'standard' }) })
+  const fs = makeFs({ '.dsh/eng.json': JSON.stringify(adoptRecommendation('standard')) })
   const exe = await registered(fs)
   const created = await exe({ operation: 'create', task_id: 'T3', title: 'x', branch: 'main' }, EXEC)
   assert(created.includes('需求评审'), 'standard create starts at 需求评审')
-  fs._files.set('.dsh/eng.json', JSON.stringify({ flow: 'minimal' }))
+  fs._files.set('.dsh/eng.json', JSON.stringify(adoptRecommendation('minimal')))
   const status = JSON.parse(await exe({ operation: 'status', task_id: 'T3' }, EXEC))
-  assert(status.flow?.flow === 'standard' && status.flow.version === 2, 'status re-reads the frozen snapshot')
+  assert(status.flow?.flow === 'standard' && status.flow.version === 3, 'status re-reads the frozen snapshot')
   assert(Array.isArray(status.legal_next) && status.legal_next.includes('设计'),
     'gates come from the frozen standard flow, not the live minimal flow')
 }
@@ -213,22 +260,59 @@ await assertThrows(
   )
 }
 
-// ── 11. a project cannot shadow a bundled core rule ────────────────────────
-{
-  const bundled = readFileSync('./rules/security-redlines.md', 'utf8')
-  assert(bundled.includes('服务端'), 'bundled security-redlines exists as expected')
-  const fs = makeFs({
-    '.dsh/eng.json': JSON.stringify({ flow: 'standard' }),
-    '.dsh/rules/security-redlines.md': '# 弱化的安全红线，前端校验即可',
-  })
-  const exe = await registered(fs)
-  await exe({ operation: 'create', task_id: 'T9', title: 'x', branch: 'main' }, EXEC)
-  const status = JSON.parse(await exe({ operation: 'status', task_id: 'T9' }, EXEC))
-  const sec = status.bindings.rules.find(r => r.name === 'security-redlines')
-  assert(sec !== undefined, 'security-redlines is disclosed at the start stage')
-  assert(!sec.content.includes('前端校验即可'), 'a project shadow of a core rule is ignored')
-  assert(sec.content.includes('服务端'), 'the bundled core rule body wins over a shadow')
-}
+// ── 11. a bound rule resolves from the layer the reference names ────────────
+// Rules used to be looked up by bare name through a precedence chain, so a
+// project file named like a bundled one silently replaced the shipped body.
+// A reference now names its layer (`bundled:` / `project:` / `user:`), so there
+// is no chain to walk and no shadowing to defend against: the same name in two
+// layers is two distinct resources, and the binding says which one it means.
+{
+  const bundled = readFileSync('./rules/security-redlines.md', 'utf8')
+  assert(bundled.includes('服务端'), 'bundled security-redlines exists as expected')
+  const fs = makeFs({
+    // A project file with the same NAME but a different body. Under the old
+    // bare-name lookup this would have replaced the bundled rule silently.
+    '.dsh/eng.json': JSON.stringify({
+      flow: 'standard',
+      stage_bindings: {
+        '需求评审': { skills: [{
+          skill: { source: 'bundled', name: 'requirement-analysis' },
+          rules: [{ source: 'project', name: 'security-redlines' }],
+        }] },
+      },
+    }),
+    '.dsh/rules/security-redlines.md': '# 弱化的安全红线，前端校验即可',
+  })
+  const exe = await registered(fs)
+  await exe({ operation: 'create', task_id: 'T9', title: 'x', branch: 'main' }, EXEC)
+  const status = JSON.parse(await exe({ operation: 'status', task_id: 'T9' }, EXEC))
+  const sec = status.bindings.rules.find(r => r.name === 'security-redlines')
+  assert(sec !== undefined, 'the bound project rule is disclosed at the start stage')
+  assert(sec.source === 'project', 'the disclosed rule reports the layer it was resolved from')
+  assert(sec.content.includes('前端校验即可'), 'the PROJECT body is what gets disclosed, because the reference names the project layer')
+}
+
+// ── 11b. a bundled reference keeps resolving the bundled body ───────────────
+{
+  const fs = makeFs({
+    '.dsh/eng.json': JSON.stringify({
+      flow: 'standard',
+      stage_bindings: {
+        '需求评审': { skills: [{
+          skill: { source: 'bundled', name: 'requirement-analysis' },
+          rules: [{ source: 'bundled', name: 'security-redlines' }],
+        }] },
+      },
+    }),
+    '.dsh/rules/security-redlines.md': '# 弱化的安全红线，前端校验即可',
+  })
+  const exe = await registered(fs)
+  await exe({ operation: 'create', task_id: 'T10', title: 'x', branch: 'main' }, EXEC)
+  const status = JSON.parse(await exe({ operation: 'status', task_id: 'T10' }, EXEC))
+  const sec = status.bindings.rules.find(r => r.name === 'security-redlines')
+  assert(sec !== undefined && sec.source === 'bundled', 'a bundled reference resolves to the bundled layer')
+  assert(sec.content.includes('服务端'), 'the bundled body is used, untouched by the same-named project file')
+}
 
 // ── 12. session cwd drives every relative path (init regression) ──────────
 {
@@ -246,7 +330,7 @@ await assertThrows(
 // ── 13. create writes the task record into the session workspace ──────────
 {
   const cwd = 'C:/users/ggbond/.dsh-verify/e2e-project'
-  const fs = makeFs({ [`${cwd}/.dsh/eng.json`]: JSON.stringify({ flow: 'standard' }) })
+  const fs = makeFs({ [`${cwd}/.dsh/eng.json`]: JSON.stringify(adoptRecommendation('standard')) })
   const exe = await registered(fs)
   await exe({ operation: 'create', task_id: 'T12', title: 'x', branch: 'main' }, sessionExec(cwd))
   assert(fs._files.get(`${cwd}/.dsh/task-T12.json`) !== undefined, 'task record lands in the session workspace')
@@ -255,7 +339,7 @@ await assertThrows(
 
 // ── 14. K: artifact ids must be unique across ALL stages ────────────────────
 {
-  const withDup = { ...FLOW_PRESETS.standard.config, artifacts: [
+  const withDup = { ...adoptedFlow('standard'), artifacts: [
     { stage: '需求评审', id: 'doc', name: '需求', fields: ['scope'] },
     { stage: '设计', id: 'doc', name: '设计', fields: ['approach'] },
   ] }
@@ -266,7 +350,7 @@ await assertThrows(
 
 // ── 15. K: record rejects an artifact owned by another stage ─────────────────
 {
-  const fs = makeFs({ '.dsh/eng.json': JSON.stringify({ flow: 'standard' }) })
+  const fs = makeFs({ '.dsh/eng.json': JSON.stringify(adoptRecommendation('standard')) })
   const exe = await registered(fs)
   await exe({ operation: 'create', task_id: 'K1', title: 'x', branch: 'main' }, EXEC)
   await assertThrows(
@@ -278,7 +362,7 @@ await assertThrows(
 
 // ── 16. L/4.2: high-risk verification requires a REAL command receipt ────────
 {
-  const cfg = FLOW_PRESETS.standard.config
+  const cfg = adoptedFlow('standard')
   const receipt = overrides => ({
     command: 'npm test', exit_code: 0, timed_out: false, aborted: false,
     started_at: '2026-01-01T00:00:00Z', finished_at: '2026-01-01T00:00:01Z',
@@ -303,20 +387,20 @@ await assertThrows(
 
 // ── 17. J: task id extracted from the summary (the hook uses it, not a guess) ─
 {
-  const cfg = FLOW_PRESETS.standard.config
+  const cfg = adoptedFlow('standard')
   assert(taskIdFromMessage('【GREET-001】【TASK】实现登录', cfg) === 'GREET-001', 'standard summary yields its task id')
   assert(taskIdFromMessage('【GREET-001】【T1】实现登录', cfg) === 'GREET-001', 'item-label summary yields its task id')
   assert(taskIdFromMessage('实现登录', cfg) === undefined, 'non-matching summary yields no task id')
-  assert(taskIdFromMessage('随意', FLOW_PRESETS.minimal.config) === undefined, 'pattern-less flow yields no task id')
+  assert(taskIdFromMessage('随意', adoptedFlow('minimal')) === undefined, 'pattern-less flow yields no task id')
 }
 
 // ── 18. N: engine bookkeeping files are exempt from file scope ───────────────
 {
   const s = newTask({ id: 'N1', title: 'x', branch: 'main', work_size: 'standard', risk_level: 'standard', flow: snapshot })
   s.files = ['src/a.ts']
-  assert(checkFileScope(s, ['src/a.ts', '.dsh/task-N1.json', '.dsh/eng.json'], FLOW_PRESETS.standard.config).ok,
+  assert(checkFileScope(s, ['src/a.ts', '.dsh/task-N1.json', '.dsh/eng.json'], adoptedFlow('standard')).ok,
     'task record and eng.json do not violate file scope')
-  assert(!checkFileScope(s, ['src/b.ts'], FLOW_PRESETS.standard.config).ok,
+  assert(!checkFileScope(s, ['src/b.ts'], adoptedFlow('standard')).ok,
     'an out-of-scope code file is still flagged')
 }
 
@@ -447,7 +531,7 @@ function memProbe(files) {
 // ── 23. 0.22-A: snapshot hash integrity ────────────────────────────────────
 {
   const { hashConfig } = await import('./lib/snapshot.js')
-  const config = FLOW_PRESETS.standard.config
+  const config = adoptedFlow('standard')
   const h1 = hashConfig(config)
   const h2 = hashConfig(JSON.parse(JSON.stringify(config)))
   assert(h1 === h2 && /^[0-9a-f]{64}$/.test(h1), 'hashConfig is a deterministic sha256')
@@ -456,7 +540,7 @@ function memProbe(files) {
   assert(hashConfig(tampered) !== h1, 'editing the frozen config changes the hash')
 }
 {
-  const fs = makeFs({ '.dsh/eng.json': JSON.stringify({ flow: 'standard' }) })
+  const fs = makeFs({ '.dsh/eng.json': JSON.stringify(adoptRecommendation('standard')) })
   const exe = await registered(fs)
   await exe({ operation: 'create', task_id: 'HASH-1', title: 'x', branch: 'main' }, EXEC)
   const record = JSON.parse(fs._files.get('.dsh/task-HASH-1.json'))
@@ -491,7 +575,7 @@ function memProbe(files) {
 
 // ── 25. 0.22-B: risk downgrade approval + bindings fingerprint ─────────────
 {
-  const fs = makeFs({ '.dsh/eng.json': JSON.stringify({ flow: 'standard' }) })
+  const fs = makeFs({ '.dsh/eng.json': JSON.stringify(adoptRecommendation('standard')) })
   const exe = await registered(fs)
   await exe({ operation: 'create', task_id: 'RISK-1', title: 'x', branch: 'main', risk_level: 'high_risk' }, EXEC)
   await assertThrows(
@@ -504,7 +588,7 @@ function memProbe(files) {
 }
 {
   const approval = { async request() { return 'allowed-once' } }
-  const fs = makeFs({ '.dsh/eng.json': JSON.stringify({ flow: 'standard' }) })
+  const fs = makeFs({ '.dsh/eng.json': JSON.stringify(adoptRecommendation('standard')) })
   const exe = await registered(fs, approval)
   await exe({ operation: 'create', task_id: 'RISK-2', title: 'x', branch: 'main', risk_level: 'high_risk' }, EXEC)
   assert((await exe({ operation: 'set_risk', task_id: 'RISK-2', risk_level: 'standard' }, EXEC)).includes('risk_level set to standard'),
@@ -514,7 +598,7 @@ function memProbe(files) {
     'downgrade is recorded in the audit trail')
 }
 {
-  const fs = makeFs({ '.dsh/eng.json': JSON.stringify({ flow: 'standard' }) })
+  const fs = makeFs({ '.dsh/eng.json': JSON.stringify(adoptRecommendation('standard')) })
   const exe = await registered(fs)
   await exe({ operation: 'create', task_id: 'FP-1', title: 'x', branch: 'main' }, EXEC)
   const status = JSON.parse(await exe({ operation: 'status', task_id: 'FP-1' }, EXEC))
@@ -536,7 +620,7 @@ function memProbe(files) {
   )
 }
 {
-  const fs = makeFs({ '.dsh/eng.json': JSON.stringify({ flow: 'standard' }), 'package.json': '{}' })
+  const fs = makeFs({ '.dsh/eng.json': JSON.stringify(adoptRecommendation('standard')), 'package.json': '{}' })
   const exe = await registered(fs)
   await exe({ operation: 'create', task_id: 'V-2', title: 'x', branch: 'main' }, EXEC)
   await assertThrows(
@@ -546,7 +630,7 @@ function memProbe(files) {
   )
 }
 {
-  const fs = makeFs({ '.dsh/eng.json': JSON.stringify({ flow: 'standard' }) })
+  const fs = makeFs({ '.dsh/eng.json': JSON.stringify(adoptRecommendation('standard')) })
   const exe = await registered(fs)
   await exe({ operation: 'create', task_id: 'V-3', title: 'x', branch: 'main' }, EXEC)
   await assertThrows(() => exe({ operation: 'verify', task_id: 'V-3', passed: true }, EXEC),
@@ -558,7 +642,7 @@ function memProbe(files) {
     'legacy tasks retain their verification contract')
 }
 {
-  const fs = makeFs({ '.dsh/eng.json': JSON.stringify({ flow: 'standard' }) })
+  const fs = makeFs({ '.dsh/eng.json': JSON.stringify(adoptRecommendation('standard')) })
   const exe = await registered(fs)
   await exe({ operation: 'create', task_id: 'A-1', title: 'x', branch: 'main' }, EXEC)
   await exe({ operation: 'create', task_id: 'B-2', title: 'y', branch: 'main' }, EXEC)
@@ -594,7 +678,7 @@ function memProbe(files) {
 
 // ── 29. dev_task writes carry the per-call sandbox policy ───────────────────
 {
-  const fs = makeFs({ '.dsh/eng.json': JSON.stringify({ flow: 'standard' }) })
+  const fs = makeFs({ '.dsh/eng.json': JSON.stringify(adoptRecommendation('standard')) })
   let seenPolicy
   const origWrite = fs.writeText
   fs.writeText = async (target, content, expected, signal, sandboxPolicy) => {
@@ -616,7 +700,7 @@ function memProbe(files) {
 
 // ── 30. 0.22.x: sandbox escalation requires a human one-shot approval ───────
 {
-  const fs = makeFs({ '.dsh/eng.json': JSON.stringify({ flow: 'standard' }) })
+  const fs = makeFs({ '.dsh/eng.json': JSON.stringify(adoptRecommendation('standard')) })
   let seenPolicy
   const origWrite = fs.writeText
   fs.writeText = async (target, content, expected, signal, sandboxPolicy) => {
@@ -634,7 +718,7 @@ function memProbe(files) {
 }
 
 {
-  const fs = makeFs({ '.dsh/eng.json': JSON.stringify({ flow: 'standard' }) })
+  const fs = makeFs({ '.dsh/eng.json': JSON.stringify(adoptRecommendation('standard')) })
   const exe = await registered(fs) // no approval service
   await assertThrows(
     () => exe({
@@ -648,7 +732,7 @@ function memProbe(files) {
 
 // ── 31. 0.22.x: set_risk cannot raise risk past the flow's capabilities ─────
 {
-  const fs = makeFs({ '.dsh/eng.json': JSON.stringify({ flow: 'minimal' }) })
+  const fs = makeFs({ '.dsh/eng.json': JSON.stringify(adoptRecommendation('minimal')) })
   const exe = await registered(fs)
   await exe({ operation: 'create', task_id: 'SR-1', title: 'x', branch: 'main' }, EXEC)
   await assertThrows(
@@ -658,7 +742,7 @@ function memProbe(files) {
   )
 }
 {
-  const fs = makeFs({ '.dsh/eng.json': JSON.stringify({ flow: 'standard' }) })
+  const fs = makeFs({ '.dsh/eng.json': JSON.stringify(adoptRecommendation('standard')) })
   const exe = await registered(fs)
   await exe({ operation: 'create', task_id: 'SR-2', title: 'x', branch: 'main' }, EXEC)
   assert((await exe({ operation: 'set_risk', task_id: 'SR-2', risk_level: 'high_risk' }, EXEC)).includes('high_risk'),
@@ -674,7 +758,7 @@ function memProbe(files) {
 
 // ── 33. 0.23: verify runs in the task's recorded project root ──────────────
 {
-  const fs = makeFs({ '.dsh/eng.json': JSON.stringify({ flow: 'standard' }), 'package.json': '{}' })
+  const fs = makeFs({ '.dsh/eng.json': JSON.stringify(adoptRecommendation('standard')), 'package.json': '{}' })
   const seenWorkdirs = []
   const shell = {
     resolve(request) { return { command: request.command, workdir: request.workdir ?? '', timeoutMs: request.timeoutMs } },
@@ -694,7 +778,7 @@ function memProbe(files) {
 
 // ── 34. 0.23: revision increments on every write (CAS foundation) ───────────
 {
-  const fs = makeFs({ '.dsh/eng.json': JSON.stringify({ flow: 'standard' }) })
+  const fs = makeFs({ '.dsh/eng.json': JSON.stringify(adoptRecommendation('standard')) })
   const exe = await registered(fs)
   await exe({ operation: 'create', task_id: 'CAS-1', title: 'x', branch: 'main' }, EXEC)
   const r1 = JSON.parse(fs._files.get('.dsh/task-CAS-1.json')).revision
@@ -724,7 +808,7 @@ function memProbe(files) {
 
 // A second writer between content read and write must not be silently overwritten.
 {
-  const fs = makeFs({ '.dsh/eng.json': JSON.stringify({ flow: 'standard' }) })
+  const fs = makeFs({ '.dsh/eng.json': JSON.stringify(adoptRecommendation('standard')) })
   const exe = await registered(fs)
   await exe({ operation: 'create', task_id: 'CAS-RACE', title: 'race', branch: 'main' }, EXEC)
   const originalRead = fs.readText.bind(fs)

package/.revision-test.mjs

@@ -11,7 +11,22 @@
 import test from 'node:test'
 import assert from 'node:assert/strict'
 import { applyRevision, invalidatedBy, completionBlockers } from './lib/engine.js'
-import { resolveFlow } from './lib/workflows.js'
+import { adoptRecommendation, resolveFlow } from './lib/workflows.js'
+
+/**
+ * The preset as a project would actually run it: the skeleton plus the shipped
+ * recommendation, adopted exactly the way a user adopts it. A test that asserts
+ * on bindings, commit rules or artifacts wants this, because those no longer come
+ * from the preset itself.
+ * @param {string} id - preset id.
+ * @returns {import('./lib/engine.js').WorkflowConfig} the adopted config.
+ */
+function adoptedFlow(id, extra) {
+  const base = adoptRecommendation(id)
+  if (base === undefined) throw new Error('unknown preset: ' + id)
+  return resolveFlow(id, { ...base, ...extra }).config
+}
+
 
 /** A task carrying every conclusion, so a rework has something to invalidate. */
 function loadedTask() {
@@ -83,7 +98,7 @@ test('rework: clearing evidence returns an item to unfinished, not to done-witho
   const state = loadedTask()
   applyRevision(state, rework('defect', '开发'))
   assert.equal(state.items[0].status, 'doing')
-  const config = resolveFlow('standard', {}).config
+  const config = adoptedFlow('standard')
   assert.ok(completionBlockers({ ...state, stage: '完成' }, config).length > 0,
     'a task with an unproven item must not be completable')
 })

package/.roundtrip-test.mjs

@@ -0,0 +1,63 @@
+/**
+ * Config round-trip: what the panel shows is what the file holds.
+ *
+ * The write path and the panel both carried only `flow` + `stage_bindings`, so a
+ * commit rule, artifact declarations or a review depth were resolved for the preview
+ * and then dropped on save. A user could set them, see them applied, and lose them.
+ */
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { resolveFlow, adoptRecommendation } from './lib/workflows.js'
+
+/** The fields a project config can carry, so a round-trip is checked on all of them. */
+const FIELDS = ['flow', 'stage_bindings', 'commit', 'artifacts', 'review_depth', 'commit_required']
+
+test('round-trip: every configurable field survives being written and read back', () => {
+  // The save path serialises the payload and the read path parses it back through
+  // resolveFlow, so this asserts exactly those two steps.
+  const adopted = adoptRecommendation('standard')
+  const written = {
+    flow: 'standard',
+    stage_bindings: adopted.stage_bindings,
+    commit: adopted.commit,
+    artifacts: adopted.artifacts,
+    review_depth: 'single',
+    commit_required: false,
+  }
+  const serialised = JSON.stringify(written, null, 2)
+  const readBack = JSON.parse(serialised)
+  for (const field of FIELDS) {
+    assert.ok(field in readBack, `${field} must survive serialisation`)
+  }
+
+  const resolved = resolveFlow(readBack.flow, readBack)
+  assert.equal(resolved.ok, true)
+  assert.deepEqual(resolved.config.stage_bindings, written.stage_bindings, 'bindings round-trip')
+  assert.equal(resolved.config.commit.message_pattern, written.commit.message_pattern, 'the commit text convention round-trips')
+  assert.equal(resolved.config.commit.policy, 'task', 'the flow-control half of the commit rule is preserved')
+  assert.deepEqual(resolved.config.artifacts, written.artifacts, 'artifacts round-trip')
+  assert.equal(resolved.config.review_depth, 'single', 'review depth round-trips')
+  assert.equal(resolved.config.commit_required, false, 'commit_required round-trips')
+})
+
+test('round-trip: the payload the panel sends contains every edited field', () => {
+  // Mirrors the panel's save payload, so a field added to the config but not to the
+  // payload is caught here rather than by a user losing their settings.
+  const adopted = adoptRecommendation('standard')
+  const commitRule = adopted.commit
+  const artifacts = adopted.artifacts
+  const reviewDepth = 'single'
+  const payload = {
+    flow: 'standard',
+    stage_bindings: adopted.stage_bindings,
+    ...(commitRule !== undefined ? { commit: commitRule } : {}),
+    ...(artifacts !== undefined ? { artifacts } : {}),
+    ...(reviewDepth !== undefined ? { review_depth: reviewDepth } : {}),
+  }
+  for (const field of ['flow', 'stage_bindings', 'commit', 'artifacts', 'review_depth']) {
+    assert.ok(field in payload, `the panel must send ${field}`)
+  }
+  // And the whole payload must be accepted by the resolver the write path uses.
+  const resolved = resolveFlow(payload.flow, payload)
+  assert.equal(resolved.ok, true, 'the payload the panel sends must resolve without problems')
+})

package/.workflow-test.mjs

@@ -5,14 +5,41 @@ import { tmpdir } from 'node:os'
 import { join, resolve, sep } from 'node:path'
 import { registerDevTask } from './lib/dev-task.js'
 import { newTask } from './lib/engine.js'
-import { resolveFlow } from './lib/workflows.js'
+import { adoptRecommendation, resolveFlow } from './lib/workflows.js'
 import Controller from './lib/controller.js'
 import { registerShippedSkills } from './lib/shipped-skills.js'
 
+/**
+ * The preset as a project would actually run it: the skeleton plus the shipped
+ * recommendation, adopted exactly the way a user adopts it. A test that asserts
+ * on bindings, commit rules or artifacts wants this, because those no longer come
+ * from the preset itself.
+ * @param {string} id - preset id.
+ * @returns {import('./lib/engine.js').WorkflowConfig} the adopted config.
+ */
+function adoptedFlow(id, extra) {
+  const base = adoptRecommendation(id)
+  if (base === undefined) throw new Error('unknown preset: ' + id)
+  return resolveFlow(id, { ...base, ...extra }).config
+}
+
+
 function fixture(stage = '开发', extra = {}, services = {}) {
   const cwd = resolve('test-project')
-  const config = resolveFlow('standard', { stage_bindings: { 完成: { skills: [{ skill: { source: 'bundled', name: 'software-testing' }, rules: [] }] } } }).config
-  const state = newTask({ id: 'LIVE-1', title: 'EAM regression', branch: 'test', work_size: 'standard', risk_level: 'standard', flow: { flow: 'standard', version: 2, config }, root: cwd })
+  // A project running the standard flow: the skeleton plus the adopted
+  // recommendation, with one extra skill mounted on 完成 for the tests that need
+  // a binding beyond the shipped set. The bindings are MERGED, not replaced —
+  // replacing them would drop the recommended skills and artifacts the tests
+  // assert on, since the preset skeleton itself carries none.
+  const adopted = adoptRecommendation('standard')
+  const config = resolveFlow('standard', {
+    ...adopted,
+    stage_bindings: {
+      ...adopted.stage_bindings,
+      完成: { skills: [{ skill: { source: 'bundled', name: 'software-testing' }, rules: [] }] },
+    },
+  }).config
+  const state = newTask({ id: 'LIVE-1', title: 'EAM regression', branch: 'test', work_size: 'standard', risk_level: 'standard', flow: { flow: 'standard', version: 3, config }, root: cwd })
   Object.assign(state, { stage, execution_version: 1, files: ['app.js'], requirement_confirmed: true, solution_confirmed: true, ...extra })
   const records = new Map([[join(cwd, '.dsh/task-LIVE-1.json'), JSON.stringify(state)], [join(cwd, 'app.js'), 'source']])
   const events = [], runs = []
@@ -168,7 +195,7 @@ test('status 披露当前阶段记录字段和缺项，字段误用不写入且
 })
 
 test('记录字段来自冻结流程，精简流程不硬编码标准字段，无记录阶段返回空列表', async () => {
-  const config = resolveFlow('agile').config
+  const config = adoptedFlow('agile')
   const f = fixture('需求', { flow: { flow: 'agile', version: 1, config } })
   assert.deepEqual(JSON.parse(await f.call({ operation: 'status' })).artifact_requirements, [{ id: 'requirement', name: '需求说明', fields: ['scope'], missing_fields: ['scope'] }])
   await f.call({ operation: 'record', artifact: 'requirement', fields: { scope: '目标、验收与疑问' } })

package/README.md

@@ -27,7 +27,7 @@
 让 AI 修改代码时，你可以先明确需求，再检查方案、推进实施、验证结果，最后审核提交。DSH Task Engine 把这些步骤组织成可检查、可追踪的任务流程，适合在本机使用 DeepSeek Harness 开发个人项目。
 
 - **知道下一步做什么**：按所选流程推进，当前阶段需要的条件和产物清楚可查。
-- **复用自己的工作方法**：把技能和规则安装到项目或个人目录，再挂到对应阶段。
+- **复用自己的工作方法**：把技能和规则安装到项目或个人目录，再挂到节点上；规则跟着技能走，所以同一技能在任何节点都是同一套约束。
 - **找得到过程记录**：任务台账集中查看阶段、实施项、验证与审核状态。
 
 ## 快速开始
@@ -51,13 +51,15 @@ dsh plugin --profile web add @godv61/dsh-task-engine
 | 页面 | 你可以做什么 |
 | :--- | :--- |
 | **项目初始化** | 查看或编辑 `AGENTS.md`，让 AI 生成项目说明，预览后保存。 |
-| **流程配置** | 选择内置流程，为各阶段追加技能和规则。 |
+| **流程配置** | 选择流程骨架，给节点挂技能，并在技能上配置它遵循的规则。需要现成起点时可「采用推荐配置」。 |
 | **任务台账** | 查看实施、验证和审核记录，按关键词、阶段或风险筛选。 |
 | **技能** | 选择技能文件夹，预览内容与目标目录后安装；支持查看、编辑和删除。 |
 | **规则** | 选择 Markdown 文件安装规则，维护项目或个人开发约定。 |
 
 内置技能和规则只读；项目与个人资源可编辑。安装、删除都会明确展示目标位置。
 
+**流程与工作方法是两回事。** 流程只决定工作怎么流转（阶段顺序与门禁），预设不自带任何技能或提交格式。要用什么技能、遵守哪些规则、提交信息写什么，都由你配置——「采用推荐配置」只是把一份现成的起点**写入**你的配置，之后完全归你：删掉的不再补回，升级也不覆盖。规则挂在技能下，所以打开一个技能看到的就是它完整的规则列表，挂到任何节点都一样。
+
 ## 选择适合这次任务的流程
 
 | 预设 | 阶段顺序 | 适用场景 |

package/docs/CHANGELOG.md

@@ -4,6 +4,43 @@
 
 按版本查阅功能变化。当前使用方式以[项目首页](../README.md)和使用指南为准；历史条目中的实现方式、限制与测试数量可能已被后续版本替代。
 
+## 0.25.0
+
+针对 2026-09-24 复评的改造。**这是一个破坏性版本**：预设不再自带任何技能、产物或提交格式，`SkillBinding` 新增 `evidence` 字段，敏捷流程的门禁语义与版本号都变了。核心是落实产品原则：**流程只控制状态，业务方法由用户配置，Rule 真正归属 Skill。**
+
+已有项目不会因此失效，但**行为会变**：预设不再提供内置技能，所以一个从未采用推荐配置的项目，其节点将没有绑定。升级后打开工作台点一次「采用推荐配置」即可获得与升级前等价的起点，此后完全由你控制——删除的不再补回，升级也不覆盖。已有任务按各自的冻结快照执行，不受影响。
+
+### 流程骨架与可选推荐配置（破坏性）
+
+预设此前把技能、提交规则和产物字段烘焙进解析结果，`mergeBindings` 又只做**追加**——于是内置技能无法移除，而用户给内置技能配自己的规则时，条目会因引用已存在被整个跳过，静默保留预设规则。工作台里选择流程也会一并写入这些内容，等于选择流程即接受内置工作方法。
+
+现在分成两层：
+
+- **骨架**只含阶段图、每条边的守卫，以及提交规则中属于**流程控制**的那一半：何时需要提交、哪个节点是检查点、是否强制文件范围。最后一项留在骨架上是有意的——高风险检查读它作为安全底线，不能因为用户没采用推荐配置就消失。
+- **推荐配置**（`FlowRecommendation`）单独存放技能绑定、提交**文本**约定、产物字段与审查深度。
+- `adoptRecommendation()` 只在用户显式请求时写入。这是一次性动作：此后这些值就是用户的普通配置，用户删除的值不会回来，升级也不覆盖。
+- `resolveFlow` 逐字采用项目配置。用户没配的节点就是没有绑定，这是合法状态，不是待补齐的空缺。
+- 工作台新增「采用推荐配置」按钮；**选择流程不再写入任何绑定**。
+
+### 冻结真正接入执行链
+
+此前 `flow.resources` 只**存档**正文，`status` 与阶段披露仍走 `readRuleAt` 读实时文件——改一条规则会无声改变进行中任务所遵循的内容，正是快照本该阻止的不稳定。现在解析优先使用冻结正文，并把漂移**报告**出来：源被改动记为 `stale_source_rules`（source edited），源被删除也记为漂移而非缺失——任务手里已有内容，说它缺失是错的。没有快照的旧任务继续读实时文件并把删除报为缺失，两条路径可区分，不会互相悄悄退化。
+
+### 缺失资源、节点结果与完成条件改为真正阻塞
+
+- **规则无法解析则不可推进**。`missing_rules` 以前只披露不阻塞，删掉绑定规则仍能推进——阶段在缺少既定约束的情况下走完，而记录看起来正常。判定实现为引擎里的纯函数，工具与 hook 从同样输入得到同样结论。
+- **完成检查流程声明的节点结果**。此前只查「是否站在终态、实施项是否完成、有无提交」，于是一个在进入终态的路上声明了 `review_passed` 的流程，只要**到达**就满足——审核被 blocked 仍能完成。要求由 `terminalRequirements` 从流程推导，没声明验证门禁的流程不会被强加。
+- 敏捷流程的审查要求需要另一种机制：`审查` 是终态且**就是**审查本身，没有出边可承载守卫。把 `review_passed` 挂到 `交付 → 审查` 会要求「在产生结论的阶段之前就有结论」，还会挡住 `交付` 的提交（提交要求其出边守卫全部满足）。改用 `completion_guards` 显式声明，这正是 `complete` 作为独立操作存在的原因。敏捷版本号升至 4。
+
+### 技能声明自己需要哪类证据
+
+每种非内置技能都必须记录「真实验收命令」，于是需求或设计类技能——产出是一份文档——被迫运行一条无关命令来满足门禁。证据本来就有，只是形态不同。技能绑定现在可声明 `evidence`：`command` / `artifact` / `review` / `manual` / `none`，引擎按各自形态检查对应记录。未声明时保持历史行为（命令回执），因此既有配置与冻结快照不受影响。
+
+### 保存完整配置 + 列表可用性
+
+- **保存不再只写 `flow` 与 `stage_bindings`**。提交规则、产物声明、审查深度与 `commit_required` 以前只用于预览，保存时被静默丢弃——面板显示一套配置、文件里是另一套。写入载荷与面板状态现在都覆盖全部字段。
+- **技能与规则列表在规模增长后可用**：加搜索（匹配名称、说明与来源层）、「仅看已选」筛选，展开的规则列表改为**有界滚动区**。一条规则贯穿全部筛选：**已绑定或预设自带的条目任何查询下都保持可见**——面板展示的是配置本身，筛选藏起正在生效的资源会让面板与它显示的配置不一致，那比列表长更糟。
+
 ## 0.24.0
 
 针对 2026-09-23 外部深度评测的改造。**这是一个破坏性版本**：配置里的 `stage_bindings[*].rules` 不再作为节点级规则读取，`skills` 的格式也从字符串数组改为带来源的对象。已有配置会继续工作——旧的节点级规则以 `legacy_rules` 保留并**仍然生效**——但它们的归属需要你确认一次，见下面「规则改为只挂在技能下」。