@godv61/dsh-task-engine 0.23.8 → 0.24.0

package/.e2e-presets.mjs

@@ -0,0 +1,195 @@
+/**
+ * End-to-end tool-chain regression over the three presets.
+ *
+ * Drives the REAL built `dev_task` tool — create, skill loading, artifact
+ * recording, item review, verification, review, commit, completion — through an
+ * in-memory fs, so it exercises the same code path the model does rather than
+ * asserting on source text or calling engine helpers directly.
+ *
+ * Two things the assessment asks for and this does NOT provide: a real Harness
+ * Web session, and a real `git commit`. Those are reported separately as
+ * outstanding; nothing here claims to replace them.
+ */
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { join, resolve } from 'node:path'
+import { registerDevTask } from './lib/dev-task.js'
+import { newTask } from './lib/engine.js'
+import { resolveFlow, FLOW_PRESETS } from './lib/workflows.js'
+
+const HASH = 'abcdef1234567890'
+
+/**
+ * One preset driven from creation to completion.
+ * @param preset - the preset id to run.
+ * @returns the step log plus the final state, so the test can assert on both.
+ */
+async function runPreset(preset) {
+  const cwd = resolve('e2e-project')
+  const config = resolveFlow(preset, {}).config
+  const state = newTask({
+    id: 'E2E-1', title: 'pipeline', branch: 'main', work_size: 'standard',
+    risk_level: 'standard', flow: { flow: preset, version: FLOW_PRESETS[preset].version, config }, root: cwd,
+  })
+  const records = new Map([
+    [join(cwd, '.dsh/task-E2E-1.json'), JSON.stringify(state)],
+    // `create` reads the project's flow from here, so the preset under test must
+    // be the project's declared flow rather than one passed to the tool.
+    [join(cwd, '.dsh/eng.json'), JSON.stringify({ flow: preset })],
+    [join(cwd, 'src/a.js'), 'source'],
+  ])
+  const events = []
+  const session = { id: 'e2e', header: { cwd }, snapshotEvents: () => events }
+  const abort = new AbortController()
+  let execute
+  let lastMessage = ''
+  const key = (p, options) => join(options?.cwd ?? cwd, p)
+  const fs = {
+    resolve: async (p, options) => ({ targetKey: key(p, options) }),
+    readText: async target => records.get(target.targetKey),
+    listDir: async () => [...records.keys()].filter(p => /task-.+\.json$/.test(p)).map(p => ({ name: p.split(/[\\/]/).at(-1) })),
+    lstat: async (p, options) => records.has(key(p, options)) ? { version: 'v' } : undefined,
+    writeText: async (target, content) => { records.set(target.targetKey, content) },
+  }
+  const approvals = []
+  const ctx = {
+    fs,
+    tools: { register(tool) { execute = tool.execute; return () => {} } },
+    get(name) {
+      if (name === 'sandboxPolicy') return { resolve: () => ({ mode: 'workspace-write', workspaceRoot: cwd, sessionId: 'e2e' }) }
+      // The confirmation guards require a human decision; a stub stands in for the
+      // human here and records what it was asked, so the test can show the guard
+      // actually consulted it rather than being bypassed. The verdict is the
+      // protocol's string value, not a boolean.
+      if (name === 'approval') return {
+        async request(request) { approvals.push(request); return 'allowed-once' },
+      }
+      if (name === 'shell') return {
+        resolve: request => request,
+        async run(request) {
+          const isLog = request.command.includes('log -1')
+          return {
+            exitCode: 0, timedOut: false, aborted: false,
+            sandbox: { mode: 'workspace-write', denied: false },
+            stdout: { text: isLog ? `${HASH}\n${lastMessage}\n\nsrc/a.js\n` : 'checks passed' },
+            stderr: { text: '' },
+          }
+        },
+      }
+      return undefined
+    },
+  }
+  registerDevTask(ctx)
+  const exec = { agent: { session }, signal: abort.signal }
+  const call = async args => {
+    if (args.message !== undefined) lastMessage = args.message
+    const text = await execute(JSON.parse(JSON.stringify({ task_id: 'E2E-1', ...args })), exec)
+    return args.operation === 'status' ? JSON.parse(text) : text
+  }
+  const load = name => {
+    const callId = `c${events.length}`
+    events.push({ type: 'tool/call', data: { name: 'skill', callId, arguments: JSON.stringify({ name }) } })
+    events.push({ type: 'tool/result', data: { message: { content: [{ type: 'tool-result', toolCallId: callId, isError: false }] } } })
+  }
+  const current = () => JSON.parse(records.get(join(cwd, '.dsh/task-E2E-1.json')))
+
+  const steps = []
+  await call({ operation: 'create', title: 'pipeline', branch: 'main', files: ['src/a.js'] })
+  steps.push('create')
+
+  for (let hop = 0; hop < 14; hop++) {
+    const snapshot = current()
+    const outgoing = config.transitions.filter(transition => transition.from === snapshot.stage)
+    if (outgoing.length === 0) break
+
+    // Satisfy whatever the stage's outgoing edges need.
+    const needed = new Set(outgoing.flatMap(transition => transition.requires ?? []))
+    if (needed.has('todos_done')) {
+      // Items are reviewed through the dedicated operation; `items` only carries
+      // status, and the review verdicts are recorded against the item by id.
+      await call({ operation: 'items', items: [{ id: 'A', title: 'a', status: 'doing' }] })
+      await call({ operation: 'dispatch', item_id: 'A', description: 'implemented by a worker' })
+      await call({ operation: 'review_item', item_id: 'A', spec_outcome: 'pass', quality_outcome: 'pass' })
+      await call({ operation: 'items', items: [{ id: 'A', status: 'done' }] })
+    }
+    // Confirmation guards are satisfied by a human decision routed through the
+    // approval service; the tool refuses to let the model assert them itself.
+    if (needed.has('requirement_confirmation') && !snapshot.requirement_confirmed) {
+      await call({ operation: 'config', confirmations: ['requirement_confirmation'] })
+    }
+    if (needed.has('solution_confirmation') && !snapshot.solution_confirmed) {
+      await call({ operation: 'config', confirmations: ['solution_confirmation'] })
+    }
+    if (needed.has('verified')) {
+      await call({ operation: 'verify', command: 'npm test', description: 'run the suite' })
+    }
+    if (needed.has('review_passed')) {
+      await call({ operation: 'review', outcome: 'pass' })
+    }
+    for (const artifact of config.artifacts.filter(a => a.stage === snapshot.stage)) {
+      const fields = {}
+      for (const field of artifact.fields) fields[field] = 'recorded'
+      await call({ operation: 'record', artifact: artifact.id, fields })
+    }
+    // Obligations cover the current stage AND the stage being entered, so both
+    // sets are loaded. This mirrors the disclosure the model follows.
+    for (const obligated of new Set([snapshot.stage, ...outgoing.map(t => t.to)])) {
+      for (const binding of config.stage_bindings?.[obligated]?.skills ?? []) load(binding.skill.name)
+    }
+
+    if (config.commit.checkpoints.includes(snapshot.stage)) {
+      const status = await call({ operation: 'status' })
+      await call({
+        operation: 'commit', files: ['src/a.js'], hash: HASH,
+        message: `【E2E-1】【${status.commit?.label ?? 'TASK'}】deliver the stage`,
+      })
+    }
+
+    const target = outgoing[0].to
+    // The target stage's skills must be loaded before the move, because leaving a
+    // stage checks the obligations of the stage being entered. This mirrors what
+    // the disclosure tells the model to do.
+    for (const binding of config.stage_bindings?.[target]?.skills ?? []) load(binding.skill.name)
+    await call({ operation: 'advance', target_stage: target })
+    steps.push(`${snapshot.stage}→${target}`)
+  }
+
+  const terminal = config.stages.filter(stage => !config.transitions.some(t => t.from === stage))
+  if (!terminal.includes(current().stage)) {
+    return { steps, approvals, final: current(), completed: false, blocked: `stopped at ${current().stage}` }
+  }
+  // The terminal stage's own obligations are checked before it can be left, and
+  // completion is the operation that leaves it.
+  for (const binding of config.stage_bindings?.[current().stage]?.skills ?? []) load(binding.skill.name)
+  if (config.commit.checkpoints.includes(current().stage)) {
+    const status = await call({ operation: 'status' })
+    await call({
+      operation: 'commit', files: ['src/a.js'], hash: HASH,
+      message: `【E2E-1】【${status.commit?.label ?? 'TASK'}】deliver the stage`,
+    })
+  }
+  await call({ operation: 'complete' })
+  return { steps, approvals, final: current(), completed: true, blocked: null }
+}
+
+test('e2e: every preset can be driven from creation to completion through the real tool', async () => {
+  for (const preset of ['standard', 'agile', 'minimal']) {
+    const run = await runPreset(preset)
+    assert.equal(
+      run.completed, true,
+      `${preset} must reach completion; ${run.blocked ?? ''} steps=${run.steps.join(' ')}`,
+    )
+    assert.ok(run.final.completed !== undefined, `${preset} must record its completion`)
+    assert.ok(run.steps.length >= 2, `${preset} must traverse at least one edge`)
+  }
+})
+
+test('e2e: a preset that requires a commit cannot complete without one', async () => {
+  // The completion check is the thing that catches minimal, whose final stage is
+  // also its checkpoint and therefore never fires the "commit before leaving"
+  // rule. Driving it through the tool must refuse completion without a commit.
+  const run = await runPreset('minimal')
+  assert.equal(run.completed, true)
+  assert.ok(run.final.commits.length > 0,
+    'reaching completion means the delivery record exists, not merely that the last stage was reached')
+})

package/.freeze-test.mjs

@@ -0,0 +1,90 @@
+/**
+ * Resource freezing: an in-flight task must not change because the library did.
+ *
+ * Names alone cannot keep a task stable. Before this, editing a rule that a
+ * running task used silently changed what that task was doing, and deleting one
+ * made a configured constraint disappear without the task recording anything.
+ */
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { join, resolve } from 'node:path'
+import { registerDevTask } from './lib/dev-task.js'
+import { hashText } from './lib/snapshot.js'
+
+/** Create one task through the real tool and return its frozen snapshot. */
+async function created(flow) {
+  const cwd = resolve('freeze-project')
+  const records = new Map([
+    [join(cwd, '.dsh/eng.json'), JSON.stringify({ flow })],
+    [join(cwd, 'a.js'), 'source'],
+  ])
+  const events = []
+  const session = { id: 'f', header: { cwd }, snapshotEvents: () => events }
+  let execute
+  const key = (p, options) => join(options?.cwd ?? cwd, p)
+  const fs = {
+    resolve: async (p, options) => ({ targetKey: key(p, options) }),
+    readText: async target => records.get(target.targetKey),
+    listDir: async () => [],
+    lstat: async (p, options) => records.has(key(p, options)) ? { version: 'v' } : undefined,
+    writeText: async (target, content) => { records.set(target.targetKey, content) },
+  }
+  const ctx = {
+    fs,
+    tools: { register(tool) { execute = tool.execute; return () => {} } },
+    get: name => name === 'sandboxPolicy'
+      ? { resolve: () => ({ mode: 'workspace-write', workspaceRoot: cwd, sessionId: 'f' }) }
+      : undefined,
+  }
+  registerDevTask(ctx)
+  const exec = { agent: { session }, signal: new AbortController().signal }
+  await execute({ task_id: 'FZ-1', operation: 'create', title: 'freeze', branch: 'main', files: ['a.js'] }, exec)
+  return JSON.parse(records.get(join(cwd, '.dsh/task-FZ-1.json')))
+}
+
+test('freeze: task creation captures every skill and rule body it will use', async () => {
+  const state = await created('standard')
+  const resources = state.flow.resources ?? []
+  assert.ok(resources.length > 0, 'creation must freeze the resolved resources')
+
+  // Every binding in the frozen config must be covered by a frozen body.
+  const frozen = new Set(resources.map(r => `${r.ref.source}:${r.ref.name}`))
+  for (const [stage, binding] of Object.entries(state.flow.config.stage_bindings ?? {})) {
+    for (const entry of binding.skills ?? []) {
+      assert.ok(frozen.has(`${entry.skill.source}:${entry.skill.name}`),
+        `${entry.skill.name} on ${stage} must be frozen`)
+      for (const rule of entry.rules) {
+        assert.ok(frozen.has(`${rule.source}:${rule.name}`),
+          `rule ${rule.name} for ${entry.skill.name} must be frozen`)
+      }
+    }
+  }
+})
+
+test('freeze: a frozen body carries its content and a hash of that content', async () => {
+  const state = await created('standard')
+  for (const resource of state.flow.resources ?? []) {
+    assert.ok(resource.content.length > 0, `${resource.ref.name} must carry its body`)
+    assert.equal(resource.hash, hashText(resource.content),
+      `${resource.ref.name} hash must describe the frozen body, so a later edit is detectable`)
+  }
+})
+
+test('freeze: shared resources are stored once, not duplicated per reference', async () => {
+  // security-redlines is referenced by two skills; the body must not be copied twice.
+  const state = await created('standard')
+  const resources = state.flow.resources ?? []
+  const hashes = resources.map(r => r.hash)
+  assert.equal(new Set(hashes).size, hashes.length,
+    'identical bodies must not be stored more than once')
+  assert.ok(resources.some(r => r.ref.name === 'security-redlines'),
+    'the shared rule must be present')
+})
+
+test('freeze: every preset freezes a complete, non-empty set', async () => {
+  for (const flow of ['standard', 'agile', 'minimal']) {
+    const state = await created(flow)
+    assert.ok((state.flow.resources ?? []).length >= 3,
+      `${flow} must freeze its resources; saw ${(state.flow.resources ?? []).length}`)
+  }
+})

package/.hook-consistency.mjs

@@ -0,0 +1,60 @@
+/**
+ * The commit hook must agree with the tool about the same commit.
+ *
+ * The assessment requires one set of semantics shared by `status`, the tool's own
+ * gates and the Git hook, rather than three implementations that drift. The hook
+ * is built from the same engine source, so this checks the built artefact rather
+ * than the source relationship.
+ */
+import { readFileSync } from 'node:fs'
+import { resolveFlow } from './lib/workflows.js'
+import { validateCommitMessage, commitCheckpoint, verificationBlockers } from './lib/engine.js'
+
+let bad = 0
+const check = (label, ok, detail = '') => {
+  console.log('  ' + (ok ? '✅' : '❌') + ' ' + label + (detail ? ' — ' + detail : ''))
+  if (!ok) bad++
+}
+
+console.log('=== hook 与工具共享判定 ===')
+const hook = readFileSync('hooks/commit-msg', 'utf8')
+for (const fn of ['validateCommitMessage', 'commitCheckpoint', 'verificationHeldStages', 'verificationBlockers']) {
+  check('hook 内置 ' + fn, hook.includes(fn), hook.includes(fn) ? '' : 'hook 与工具语义会漂移')
+}
+
+console.log('')
+console.log('=== 每种标签形状都能通过它自己预设的校验 ===')
+for (const id of ['standard', 'agile', 'minimal']) {
+  const cfg = resolveFlow(id, {}).config
+  const labels = id === 'agile' ? ['TASK', 'T1', 'T2'] : ['TASK']
+  for (const label of labels) {
+    const message = `【T-1】【${label}】did the thing`
+    const r = validateCommitMessage(message, cfg)
+    check(`${id}「${label}」被接受`, r.ok, r.ok ? '' : (r.errors ?? []).join('; '))
+  }
+}
+
+console.log('')
+console.log('=== 提交许可与验证要求一致（三个预设）===')
+for (const id of ['standard', 'agile', 'minimal']) {
+  const cfg = resolveFlow(id, {}).config
+  const terminal = cfg.stages.filter(s => !cfg.transitions.some(t => t.from === s))[0]
+  const failing = {
+    stage: terminal, execution_version: 1,
+    items: [{ id: 'A', status: 'done', review: { spec: { outcome: 'pass' }, quality: { outcome: 'pass' } } }],
+    verification: { passed: false, evidence: [] }, commits: [],
+  }
+  const vb = verificationBlockers(failing, cfg)
+  const cp = commitCheckpoint(failing, cfg)
+  // 需要验证的流程：失败必须同时阻止提交；不需要验证的流程：两者都不应因验证而阻止
+  const requires = cfg.transitions.some(t => (t.requires ?? []).includes('verified'))
+  if (requires) {
+    check(`${id} 验证失败阻止提交`, vb.length > 0 && cp.allowed === false, `blockers=${vb.length} allowed=${cp.allowed}`)
+  } else {
+    check(`${id} 不发明验证要求`, vb.length === 0, JSON.stringify(vb))
+  }
+}
+
+console.log('')
+console.log(bad === 0 ? '✅ hook 与工具语义一致' : `❌ ${bad} 项不一致`)
+process.exit(bad === 0 ? 0 : 1)

package/.p0-test.mjs

@@ -108,10 +108,17 @@ 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. 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')
 
 // ── 4. newTask freezes the snapshot ────────────────────────────────────────
 const snapshot = { flow: 'standard', version: 1, config: FLOW_PRESETS.standard.config }

package/.preset-test.mjs

@@ -26,7 +26,7 @@ import { derivedEngComposition, wasSeeded, applyPersona, personaFieldOf } from '
  * The live derivation resolves `@deepseek-ai/dsh-agent-presets`, a PEER the
  * running harness provides. In a consumer's install it may be absent or a
  * different version, so the assertions that read a real `standard` skip when it
- * is unavailable rather than failing �?the fixture-driven cases below cover the
+ * is unavailable rather than failing —the fixture-driven cases below cover the
  * logic itself and always run.
  */
 const derived = derivedEngComposition()
@@ -48,7 +48,7 @@ test('the engineering persona replaces the shipped one', live, () => {
 
 test('the derived persona row is well formed and never sets complete', live, () => {
   // Which field is correct depends on the running harness, so assert the SHAPE
-  // (a block scalar under `config:`) rather than one field name �?the field
+  // (a block scalar under `config:`) rather than one field name —the field
   // itself is pinned by the two fixtures below.
   assert.match(derived.text, /- id: persona\n {2}name: '@deepseek-ai\/dsh-persona'\n {2}config:\n(?: {4}suffix: .*\n)? {4}(?:text|prefix): [|>]-/u,
     'the persona row must carry a block scalar under config')

package/.revision-test.mjs

@@ -0,0 +1,99 @@
+/**
+ * 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 { resolveFlow } from './lib/workflows.js'
+
+/** 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 = resolveFlow('standard', {}).config
+  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/.workflow-test.mjs

@@ -9,9 +9,9 @@ import { resolveFlow } from './lib/workflows.js'
 import Controller from './lib/controller.js'
 import { registerShippedSkills } from './lib/shipped-skills.js'
 
-function fixture(stage = '开发', extra = {}, services = {}) {
+function fixture(stage = '开发', extra = {}, services = {}) {
   const cwd = resolve('test-project')
-  const config = resolveFlow('standard', { stage_bindings: { 完成: { skills: ['software-testing'] } } }).config
+  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 })
   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']])
@@ -28,8 +28,8 @@ function fixture(stage = '开发', extra = {}, services = {}) {
     lstat: async (path, options) => records.has(key(path, options)) ? { version: 'v' } : undefined,
     writeText: async (target, content) => { records.set(target.targetKey, content) },
   }
-  const ctx = { fs, tools: { register(tool) { execute = tool.execute; return () => {} } }, get(name) {
-    if (Object.hasOwn(services, name)) return services[name]
+  const ctx = { fs, tools: { register(tool) { execute = tool.execute; return () => {} } }, get(name) {
+    if (Object.hasOwn(services, name)) return services[name]
     if (name === 'sandboxPolicy') return { resolve(request) { assert.equal(request.session, session); return policy } }
     if (name === 'shell') return { resolve(request) { runs.push(request); return request }, async run(request) {
       const fail = request.command === 'fail'
@@ -85,66 +85,66 @@ test('派发立即反映进行中，重派不复用旧审核且保持单一进
   assert.equal(f.state().items[0].review, undefined)
 })
 
-test('无任务 id 的 status 发现当前工作区任务并支持分支过滤', async () => {
+test('无任务 id 的 status 发现当前工作区任务并支持分支过滤', async () => {
   const f = fixture()
   assert.equal(JSON.parse(await f.call({ operation: 'status', task_id: undefined })).tasks[0].id, 'LIVE-1')
   assert.equal(JSON.parse(await f.call({ operation: 'status', task_id: undefined, branch: 'other' })).tasks.length, 0)
-})
-
-test('verify 升级审批不可用时不得先执行命令', async () => {
-  const f = fixture('交付')
-  const before = JSON.stringify(f.state())
-  await assert.rejects(f.call({ operation: 'verify', command: 'npm test', sandbox_permissions: 'danger-full-access', justification: 'Retry the denied test command' }), /approval/)
-  assert.equal(f.runs.length, 0, 'approval must precede shell execution')
-  assert.equal(JSON.stringify(f.state()), before)
-})
-
-test('verify 拒绝、取消及无效升级参数均不执行命令或改写台账', async () => {
-  for (const outcome of ['rejected', 'cancelled', 'unavailable']) {
-    const f = fixture('交付', {}, { approval: { request: async () => outcome } })
-    const before = JSON.stringify(f.state())
-    await assert.rejects(f.call({ operation: 'verify', command: 'npm test', sandbox_permissions: 'danger-full-access', justification: 'Retry denied command' }), /not approved/)
-    assert.equal(f.runs.length, 0)
-    assert.equal(JSON.stringify(f.state()), before)
-  }
-  for (const args of [{ sandbox_permissions: 'danger-full-access' }, { justification: 'orphan justification' }]) {
-    const f = fixture('交付')
-    await assert.rejects(f.call({ operation: 'verify', command: 'npm test', ...args }), /invalid escalation/)
-    assert.equal(f.runs.length, 0)
-  }
-})
-
-test('验证命令审批先于执行，只授权本次命令且回执写入不重复审批', async () => {
-  for (const operation of ['verify', 'skill_result']) {
-    const approvals = []
-    const f = fixture('完成', {}, { approval: { request: async request => {
-      assert.equal(f.runs.length, 0)
-      approvals.push(request)
-      return 'allowed-once'
-    } } })
-    f.load('software-testing')
-    await f.call({ operation, command: 'npm test', skill_name: 'software-testing', evidence: ['real checks'], sandbox_permissions: 'danger-full-access', justification: 'Retry denied test command' })
-    assert.equal(approvals.length, 1)
-    assert.match(approvals[0].reason, /npm test/)
-    assert.equal(f.runs[0].sandboxPolicy.mode, 'danger-full-access')
-    assert.equal(f.runs[0].sandboxPolicy.workspaceRoot, f.cwd)
-    assert.equal(f.runs[0].sandboxPolicy.sessionId, f.policy.sessionId)
-    assert.equal(f.runs[0].signal, f.exec.signal)
-    assert.equal(f.policy.mode, 'workspace-write')
-    await f.call({ operation: 'verify', command: 'npm test' })
-    assert.equal(f.runs[1].sandboxPolicy, f.policy)
-    assert.equal(approvals.length, 1)
-  }
-})
-
-test('skill_result 审批拒绝时不执行命令、不写入技能回执', async () => {
-  const f = fixture('完成', {}, { approval: { request: async () => 'rejected' } })
-  f.load('software-testing')
-  const before = JSON.stringify(f.state())
-  await assert.rejects(f.call({ operation: 'skill_result', skill_name: 'software-testing', command: 'npm test', evidence: ['test'], sandbox_permissions: 'danger-full-access', justification: 'Retry denied tests' }), /not approved/)
-  assert.equal(f.runs.length, 0)
-  assert.equal(JSON.stringify(f.state()), before)
-})
+})
+
+test('verify 升级审批不可用时不得先执行命令', async () => {
+  const f = fixture('交付')
+  const before = JSON.stringify(f.state())
+  await assert.rejects(f.call({ operation: 'verify', command: 'npm test', sandbox_permissions: 'danger-full-access', justification: 'Retry the denied test command' }), /approval/)
+  assert.equal(f.runs.length, 0, 'approval must precede shell execution')
+  assert.equal(JSON.stringify(f.state()), before)
+})
+
+test('verify 拒绝、取消及无效升级参数均不执行命令或改写台账', async () => {
+  for (const outcome of ['rejected', 'cancelled', 'unavailable']) {
+    const f = fixture('交付', {}, { approval: { request: async () => outcome } })
+    const before = JSON.stringify(f.state())
+    await assert.rejects(f.call({ operation: 'verify', command: 'npm test', sandbox_permissions: 'danger-full-access', justification: 'Retry denied command' }), /not approved/)
+    assert.equal(f.runs.length, 0)
+    assert.equal(JSON.stringify(f.state()), before)
+  }
+  for (const args of [{ sandbox_permissions: 'danger-full-access' }, { justification: 'orphan justification' }]) {
+    const f = fixture('交付')
+    await assert.rejects(f.call({ operation: 'verify', command: 'npm test', ...args }), /invalid escalation/)
+    assert.equal(f.runs.length, 0)
+  }
+})
+
+test('验证命令审批先于执行，只授权本次命令且回执写入不重复审批', async () => {
+  for (const operation of ['verify', 'skill_result']) {
+    const approvals = []
+    const f = fixture('完成', {}, { approval: { request: async request => {
+      assert.equal(f.runs.length, 0)
+      approvals.push(request)
+      return 'allowed-once'
+    } } })
+    f.load('software-testing')
+    await f.call({ operation, command: 'npm test', skill_name: 'software-testing', evidence: ['real checks'], sandbox_permissions: 'danger-full-access', justification: 'Retry denied test command' })
+    assert.equal(approvals.length, 1)
+    assert.match(approvals[0].reason, /npm test/)
+    assert.equal(f.runs[0].sandboxPolicy.mode, 'danger-full-access')
+    assert.equal(f.runs[0].sandboxPolicy.workspaceRoot, f.cwd)
+    assert.equal(f.runs[0].sandboxPolicy.sessionId, f.policy.sessionId)
+    assert.equal(f.runs[0].signal, f.exec.signal)
+    assert.equal(f.policy.mode, 'workspace-write')
+    await f.call({ operation: 'verify', command: 'npm test' })
+    assert.equal(f.runs[1].sandboxPolicy, f.policy)
+    assert.equal(approvals.length, 1)
+  }
+})
+
+test('skill_result 审批拒绝时不执行命令、不写入技能回执', async () => {
+  const f = fixture('完成', {}, { approval: { request: async () => 'rejected' } })
+  f.load('software-testing')
+  const before = JSON.stringify(f.state())
+  await assert.rejects(f.call({ operation: 'skill_result', skill_name: 'software-testing', command: 'npm test', evidence: ['test'], sandbox_permissions: 'danger-full-access', justification: 'Retry denied tests' }), /not approved/)
+  assert.equal(f.runs.length, 0)
+  assert.equal(JSON.stringify(f.state()), before)
+})
 
 test('状态明确区分内置节点门禁与附加技能命令回执，避免重复验证', async () => {
   const f = fixture('代码审核')
@@ -196,7 +196,9 @@ test('验证使用会话策略与取消信号，并明确返回失败及沙箱
 })
 
 test('只声明已测试、或加载失败，均不能冒充执行绑定技能', async () => {
-  const f = fixture('代码审核')
+  // 代码审核坐在验证门之后，所以该阶段本就要求验证通过；
+  // 不给出验证状态会让验证阻塞先于本用例要测的技能阻塞。
+  const f = fixture('代码审核', { verification: { passed: true, evidence: ['checks passed'] } })
   f.load('code-review'); f.load('code-commit'); f.load('software-testing', false)
   await assert.rejects(f.call({ operation: 'skill_result', target_stage: '完成', skill_name: 'software-testing', command: 'check', evidence: ['tested'] }), /load skill/)
   await assert.rejects(f.call({ operation: 'advance', target_stage: '完成' }), /software-testing/)