@godv61/dsh-task-engine 0.23.9 → 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,27 +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 bindings cannot be cancelled by an override ────────────────────
-const merged = resolveFlow('standard', { stage_bindings: { '开发': { rules: [] } } })
-assert(merged.ok && merged.config.stage_bindings['开发'].rules.includes('coding-conventions'),
-  'emptying a stage override keeps the core rule')
+// ── 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',
@@ -129,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')
 }
@@ -206,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) ──────────
 {
@@ -239,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')
@@ -248,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'] },
   ] }
@@ -259,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(
@@ -271,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',
@@ -296,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')
 }
 
@@ -440,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')
@@ -449,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'))
@@ -484,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(
@@ -497,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'),
@@ -507,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))
@@ -529,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(
@@ -539,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),
@@ -551,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)
@@ -587,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) => {
@@ -609,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) => {
@@ -627,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({
@@ -641,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(
@@ -651,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'),
@@ -667,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 } },
@@ -687,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
@@ -717,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

@@ -0,0 +1,114 @@
+/**
+ * Rework semantics: going backwards must invalidate exactly the superseded
+ * conclusions, no more and no less.
+ *
+ * The graph has only forward edges while the work does not, and before this the
+ * only way back was hand-editing the record — which left a confirmation,
+ * verification receipt or review verdict describing a superseded tree still
+ * reading as passing. The two halves of that are both tested: what must fall, and
+ * what must survive so work is not redone for no reason.
+ */
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { applyRevision, invalidatedBy, completionBlockers } from './lib/engine.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() {
+  return {
+    schema: 1,
+    id: 'R-1',
+    title: 'rework',
+    branch: 'main',
+    work_size: 'standard',
+    risk_level: 'standard',
+    stage: '代码审核',
+    executed: undefined,
+    requirement_confirmed: true,
+    solution_confirmed: true,
+    items: [{ id: 'A', title: 'a', status: 'done', review: { spec: { outcome: 'pass' }, quality: { outcome: 'pass' } } }],
+    verification: { passed: true, evidence: ['checks'], receipt: { exit_code: 0, timed_out: false, aborted: false } },
+    review: { outcome: 'pass' },
+    artifacts: {},
+    files: ['a.js'],
+    commits: [{ label: 'TASK', hash: 'abc1234' }],
+    execution_version: 1,
+  }
+}
+
+const rework = (kind, to) => ({ kind, reason: 'why', to, from: '代码审核', at: '2026-09-23T00:00:00.000Z', invalidated: invalidatedBy(kind) })
+
+test('rework: the three kinds declare distinct scopes rather than one blanket rule', () => {
+  const requirement = invalidatedBy('requirement')
+  const solution = invalidatedBy('solution')
+  const defect = invalidatedBy('defect')
+  assert.ok(requirement.includes('requirement_confirmation'),
+    'a changed requirement must invalidate its own confirmation')
+  assert.ok(!solution.includes('requirement_confirmation'),
+    'a changed approach leaves the agreed requirement standing')
+  assert.ok(!defect.includes('requirement_confirmation') && !defect.includes('solution_confirmation'),
+    'a defect in the work does not un-agree what was agreed')
+  assert.ok(defect.includes('verification') && defect.includes('review'),
+    'a defect invalidates the evidence that the old implementation was correct')
+})
+
+test('rework: a changed requirement clears confirmations and downstream evidence', () => {
+  const state = loadedTask()
+  const outcome = applyRevision(state, rework('requirement', '需求评审'))
+  assert.equal(state.stage, '需求评审')
+  assert.equal(state.requirement_confirmed, false)
+  assert.equal(state.solution_confirmed, false)
+  assert.equal(state.verification.passed, false)
+  assert.equal(state.review.outcome, 'pending')
+  assert.equal(state.items[0].review, undefined)
+  assert.deepEqual(state.commits, [])
+  assert.equal(state.completed, undefined)
+  assert.ok(outcome.invalidated.includes('requirement_confirmation'))
+})
+
+test('rework: fixing a defect keeps the agreed requirement and solution', () => {
+  // The point of distinguishing kinds: a defect must not force the requirement to
+  // be re-agreed, which would make the lightest flows unusable for ordinary fixes.
+  const state = loadedTask()
+  applyRevision(state, rework('defect', '开发'))
+  assert.equal(state.requirement_confirmed, true, 'a defect does not un-agree the requirement')
+  assert.equal(state.solution_confirmed, true, 'nor the approach')
+  assert.equal(state.verification.passed, false, 'the evidence about the old implementation falls')
+  assert.deepEqual(state.commits, [], 'the commit described a superseded tree')
+})
+
+test('rework: clearing evidence returns an item to unfinished, not to done-without-audit', () => {
+  // A cleared review means the item is no longer proven done. Leaving it `done`
+  // would let todos_done pass on work whose audit had just been discarded.
+  const state = loadedTask()
+  applyRevision(state, rework('defect', '开发'))
+  assert.equal(state.items[0].status, 'doing')
+  const config = adoptedFlow('standard')
+  assert.ok(completionBlockers({ ...state, stage: '完成' }, config).length > 0,
+    'a task with an unproven item must not be completable')
+})
+
+test('rework: history records what was invalidated, for audit', () => {
+  const state = loadedTask()
+  applyRevision(state, rework('solution', '设计'))
+  assert.equal(state.revisions.length, 1)
+  assert.equal(state.revisions[0].kind, 'solution')
+  assert.equal(state.revisions[0].from, '代码审核')
+  assert.equal(state.revisions[0].to, '设计')
+  assert.deepEqual(state.revisions[0].invalidated, invalidatedBy('solution'))
+})

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')
+})