@godv61/dsh-task-engine 0.27.1 → 0.29.0

package/.freeze-test.mjs

@@ -13,23 +13,23 @@ 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 stage = { standard: '需求评审', agile: '需求', minimal: '开发' }[flow]
-  const shared = { source: 'project', name: 'shared-rule' }
-  const adopted = adoptRecommendation(flow)
-  const project = { ...adopted, stage_bindings: { [stage]: { skills: [
-    { skill: { source: 'project', name: 'first-skill' }, rules: [shared], evidence: 'none' },
-    { skill: { source: 'project', name: 'second-skill' }, rules: [shared], evidence: 'none' },
-  ] } } }
-  const records = new Map([
+async function created(flow) {
+  const cwd = resolve('freeze-project')
+  const stage = { standard: '需求评审', agile: '需求', minimal: '开发' }[flow]
+  const shared = { source: 'project', name: 'shared-rule' }
+  const adopted = adoptRecommendation(flow)
+  const project = { ...adopted, stage_bindings: { [stage]: { skills: [
+    { skill: { source: 'project', name: 'first-skill' }, rules: [shared], evidence: 'none' },
+    { skill: { source: 'project', name: 'second-skill' }, rules: [shared], evidence: 'none' },
+  ] } } }
+  const records = new Map([
     // A project that adopted the shipped recommendation, which is what gives it
     // skills and rules to freeze. `{flow}` alone adopts nothing and therefore has
     // nothing to freeze — a legitimate state, but not the one under test.
-    [join(cwd, '.dsh/eng.json'), JSON.stringify(project)],
-    [join(cwd, '.dsh/skills/first-skill/SKILL.md'), '# First skill'],
-    [join(cwd, '.dsh/skills/second-skill/SKILL.md'), '# Second skill'],
-    [join(cwd, '.dsh/rules/shared-rule.md'), '# Shared rule'],
+    [join(cwd, '.dsh/eng.json'), JSON.stringify(project)],
+    [join(cwd, '.dsh/skills/first-skill/SKILL.md'), '# First skill'],
+    [join(cwd, '.dsh/skills/second-skill/SKILL.md'), '# Second skill'],
+    [join(cwd, '.dsh/rules/shared-rule.md'), '# Shared rule'],
     [join(cwd, 'a.js'), 'source'],
   ])
   const events = []
@@ -85,13 +85,13 @@ test('freeze: a frozen body carries its content and a hash of that content', asy
 })
 
 test('freeze: shared resources are stored once, not duplicated per reference', async () => {
-  // One project rule is referenced by two skills; the body is stored once.
+  // One project rule is referenced by two skills; the body is stored once.
   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 === 'shared-rule'),
+  assert.ok(resources.some(r => r.ref.name === 'shared-rule'),
     'the shared rule must be present')
 })
 
@@ -113,13 +113,13 @@ test('freeze: every preset freezes a complete, non-empty set', async () => {
 async function atDevelopmentWithProjectRule() {
   const cwd = resolve('freeze-live')
   const adopted = adoptRecommendation('standard')
-  const skills = [{ skill: { source: 'project', name: 'my-implementation' },
-    rules: [{ source: 'project', name: 'mine' }], evidence: 'none' }]
+  const skills = [{ skill: { source: 'project', name: 'my-implementation' },
+    rules: [{ source: 'project', name: 'mine' }], evidence: 'none' }]
   const project = { ...adopted, stage_bindings: { ...adopted.stage_bindings, '开发': { skills } } }
   const records = new Map([
     [join(cwd, '.dsh/eng.json'), JSON.stringify(project)],
-    [join(cwd, '.dsh/rules/mine.md'), 'ORIGINAL RULE'],
-    [join(cwd, '.dsh/skills/my-implementation/SKILL.md'), '# Implementation skill'],
+    [join(cwd, '.dsh/rules/mine.md'), 'ORIGINAL RULE'],
+    [join(cwd, '.dsh/skills/my-implementation/SKILL.md'), '# Implementation skill'],
     [join(cwd, 'a.js'), 'source'],
   ])
   let execute
@@ -159,29 +159,29 @@ async function atDevelopmentWithProjectRule() {
   }
 }
 
-test('live: a running task reads the latest rule body at the same reference', async () => {
-  const f = await atDevelopmentWithProjectRule()
-  const before = await f.disclosed()
-  assert.equal(before.mine?.content, 'ORIGINAL RULE')
-
-  f.records.set(f.rule(), 'CHANGED RULE')
-  const after = await f.disclosed()
-  assert.equal(after.mine?.content, 'CHANGED RULE',
-    'the next interaction must disclose the edited body')
-  assert.ok((after.status.stale_source_rules ?? []).some(r => r.includes('edited')),
-    'the difference from the creation-time audit copy must be visible')
-  assert.match(after.status.resource_update_notice, /current source body is in force/u)
-})
-
-test('live: deleting a source rule makes the binding unresolved', async () => {
-  const f = await atDevelopmentWithProjectRule()
-  f.records.delete(f.rule())
-  const { status, mine } = await f.disclosed()
-  assert.equal(mine, undefined)
-  assert.ok(status.missing_rules.includes('project:mine'))
-  assert.ok((status.stale_source_rules ?? []).some(r => r.includes('deleted')),
-    'the deletion is also reported against the creation-time audit copy')
-})
+test('live: a running task reads the latest rule body at the same reference', async () => {
+  const f = await atDevelopmentWithProjectRule()
+  const before = await f.disclosed()
+  assert.equal(before.mine?.content, 'ORIGINAL RULE')
+
+  f.records.set(f.rule(), 'CHANGED RULE')
+  const after = await f.disclosed()
+  assert.equal(after.mine?.content, 'CHANGED RULE',
+    'the next interaction must disclose the edited body')
+  assert.ok((after.status.stale_source_rules ?? []).some(r => r.includes('edited')),
+    'the difference from the creation-time audit copy must be visible')
+  assert.match(after.status.resource_update_notice, /current source body is in force/u)
+})
+
+test('live: deleting a source rule makes the binding unresolved', async () => {
+  const f = await atDevelopmentWithProjectRule()
+  f.records.delete(f.rule())
+  const { status, mine } = await f.disclosed()
+  assert.equal(mine, undefined)
+  assert.ok(status.missing_rules.includes('project:mine'))
+  assert.ok((status.stale_source_rules ?? []).some(r => r.includes('deleted')),
+    'the deletion is also reported against the creation-time audit copy')
+})
 
 test('freeze: an unfrozen task falls back to live resolution and reports a missing file', async () => {
   // Tasks created before freezing have no snapshot. They must keep working, and a
@@ -200,4 +200,4 @@ test('freeze: an unfrozen task falls back to live resolution and reports a missi
   assert.equal(mine, undefined, 'with no snapshot and no file, the rule cannot resolve')
   assert.ok((status.missing_rules ?? []).includes('project:mine'),
     'it is reported as missing so the gate can block on it')
-})
+})

package/.hook-test.mjs

@@ -113,7 +113,7 @@ async function standardConfig() {
   return resolved.config
 }
 
-test('a task at its checkpoint with the right message commits', async () => {
+test('a task at its checkpoint with the right message commits', async () => {
   const config = await standardConfig()
   const root = repo('allow', approvedTask({ flow: { flow: 'standard', version: 2, config } }))
   try {
@@ -193,4 +193,21 @@ test('touching a sensitive path without a high-risk receipt is refused', async (
   } finally {
     rmSync(root, { recursive: true, force: true })
   }
-})
+})
+
+test('adaptive task can make its first CI commit before Sonar review', async () => {
+  const { adaptiveWorkflow } = await import('./lib/adaptive.js')
+  const config = adaptiveWorkflow('medium')
+  const root = repo('adaptive-sonar', approvedTask({
+    stage: '测试',
+    review: { outcome: 'pending' },
+    sonar_policy: { enabled: true, host_url: 'https://sonar.example.test', project_key: 'example', mode: 'branch', token_env: 'SONAR_TOKEN' },
+    flow: { flow: 'adaptive-medium', version: 1, config },
+  }))
+  try {
+    const result = tryCommit(root, 'first CI scan')
+    assert.equal(result.allowed, true, `the commit must precede its Sonar analysis: ${result.stderr}`)
+  } finally {
+    rmSync(root, { recursive: true, force: true })
+  }
+})

package/.p0-test.mjs

@@ -151,21 +151,21 @@ const emptied = resolveFlow('standard', { flow: 'standard', stage_bindings: { '
 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(Object.keys(adopted.stage_bindings ?? {}).length === 0,
-  'adopting the recommendation does not supply skills')
+const adopted = adoptedFlow('standard')
+assert(Object.keys(adopted.stage_bindings ?? {}).length === 0,
+  'adopting the recommendation does not supply skills')
 
-// And a user who gives a project skill their own rule list gets that list — the
+// And a user who gives a project 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: 'project', name: 'my-implementation' }, rules: [{ source: 'project', name: 'only-mine' }] }] },
+    '开发': { skills: [{ skill: { source: 'project', name: 'my-implementation' }, rules: [{ source: 'project', name: 'only-mine' }] }] },
   },
 }).config
-const implementBinding = ownRules.stage_bindings['开发'].skills.find(entry => entry.skill.name === 'my-implementation')
+const implementBinding = ownRules.stage_bindings['开发'].skills.find(entry => entry.skill.name === 'my-implementation')
 assert(implementBinding.rules.length === 1 && implementBinding.rules[0].name === 'only-mine',
-  'a project rule list for a project skill is used as given, not discarded as a duplicate')
+  'a project rule list for a project skill is used as given, not discarded as a duplicate')
 
 // ── 4. newTask freezes the snapshot ────────────────────────────────────────
 const snapshot = { flow: 'standard', version: 1, config: adoptedFlow('standard') }
@@ -267,20 +267,20 @@ await assertThrows(
 // 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 fs = makeFs({
+  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: 'project', name: 'requirement-analysis' },
+          skill: { source: 'project', name: 'requirement-analysis' },
           rules: [{ source: 'project', name: 'security-redlines' }],
         }] },
       },
     }),
-    '.dsh/rules/security-redlines.md': '# 弱化的安全红线，前端校验即可',
-    '.dsh/skills/requirement-analysis/SKILL.md': '# Project requirement analysis',
+    '.dsh/rules/security-redlines.md': '# 弱化的安全红线，前端校验即可',
+    '.dsh/skills/requirement-analysis/SKILL.md': '# Project requirement analysis',
   })
   const exe = await registered(fs)
   await exe({ operation: 'create', task_id: 'T9', title: 'x', branch: 'main' }, EXEC)
@@ -291,24 +291,24 @@ await assertThrows(
   assert(sec.content.includes('前端校验即可'), 'the PROJECT body is what gets disclosed, because the reference names the project layer')
 }
 
-// ── 11b. a deleted bundled rule is reported as missing ───────────────────────
+// ── 11b. a deleted bundled rule is reported as missing ───────────────────────
 {
   const fs = makeFs({
     '.dsh/eng.json': JSON.stringify({
       flow: 'standard',
       stage_bindings: {
         '需求评审': { skills: [{
-          skill: { source: 'project', name: 'requirement-analysis' },
+          skill: { source: 'project', name: 'requirement-analysis' },
           rules: [{ source: 'bundled', name: 'security-redlines' }],
         }] },
       },
     }),
-    '.dsh/rules/security-redlines.md': '# 弱化的安全红线，前端校验即可',
-    '.dsh/skills/requirement-analysis/SKILL.md': '# Project requirement analysis',
+    '.dsh/rules/security-redlines.md': '# 弱化的安全红线，前端校验即可',
+    '.dsh/skills/requirement-analysis/SKILL.md': '# Project requirement analysis',
   })
   const exe = await registered(fs)
-  await assertThrows(() => exe({ operation: 'create', task_id: 'T10', title: 'x', branch: 'main' }, EXEC),
-    'unreadable', 'a reference to a removed bundled rule fails closed')
+  await assertThrows(() => exe({ operation: 'create', task_id: 'T10', title: 'x', branch: 'main' }, EXEC),
+    'unreadable', 'a reference to a removed bundled rule fails closed')
 }
 
 // ── 12. session cwd drives every relative path (init regression) ──────────
@@ -599,10 +599,10 @@ function memProbe(files) {
   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))
-  assert(status.bindings_drift === undefined, 'fresh task has no bundled-rule drift marker')
-  const record = JSON.parse(fs._files.get('.dsh/task-FP-1.json'))
-  assert(record.bindings_fingerprint === undefined,
-    'create does not record a fingerprint for removed bundled rules')
+  assert(status.bindings_drift === undefined, 'fresh task has no bundled-rule drift marker')
+  const record = JSON.parse(fs._files.get('.dsh/task-FP-1.json'))
+  assert(record.bindings_fingerprint === undefined,
+    'create does not record a fingerprint for removed bundled rules')
 }
 
 // ── 26. 0.22-C: multi-language verify command chain + parallel tasks ────────

package/.preset-test.mjs

@@ -158,4 +158,14 @@ test('the rewritten persona row keeps valid indentation for both shapes', () =>
   const legacy = applyPersona(PERSONA_FIXTURE_LEGACY, 'ENGINEER').text
   assert.match(legacy, /- id: persona\n {2}name: '@deepseek-ai\/dsh-persona'\n {2}config:\n {4}text: [|>]-\n {6}ENGINEER\n/u,
     'the legacy row is indented correctly')
-})
+})
+
+test('DSH 0.2 bundle declares the engineering preset', () => {
+  const patch = readFileSync(resolve('cordis.patch.yml'), 'utf8')
+  assert.match(patch, /id: preset-eng/u)
+  assert.match(patch, /name: '@deepseek-ai\/dsh-agent-preset'/u)
+  assert.match(patch, /id: eng/u)
+  assert.match(patch, /engineering-delivery coding agent/u)
+  assert.match(patch, /id: task-engine-agent/u)
+  assert.match(patch, /name: '@godv61\/dsh-task-engine\/agent'/u)
+})

package/.revision-test.mjs

@@ -92,7 +92,7 @@ test('rework: fixing a defect keeps the agreed requirement and solution', () =>
   assert.deepEqual(state.commits, [], 'the commit described a superseded tree')
 })
 
-test('rework: clearing evidence returns an item to unfinished, not to done-without-audit', () => {
+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()
@@ -111,18 +111,18 @@ test('rework: history records what was invalidated, for audit', () => {
   assert.equal(state.revisions[0].from, '代码审核')
   assert.equal(state.revisions[0].to, '设计')
   assert.deepEqual(state.revisions[0].invalidated, invalidatedBy('solution'))
-})
-
-test('rework: skill results from revised stages are invalidated', () => {
-  const state = loadedTask()
-  state.flow = { flow: 'standard', version: 3, config: adoptedFlow('standard') }
-  state.skill_results = {
-    '需求评审': { analysis: { evidence: ['still agreed'] } },
-    '开发': { implementation: { evidence: ['old implementation'] } },
-    '代码审核': { audit: { evidence: ['old audit'] } },
-  }
-  applyRevision(state, rework('defect', '开发'))
-  assert.ok(state.skill_results['需求评审'])
-  assert.equal(state.skill_results['开发'], undefined)
-  assert.equal(state.skill_results['代码审核'], undefined)
-})
+})
+
+test('rework: skill results from revised stages are invalidated', () => {
+  const state = loadedTask()
+  state.flow = { flow: 'standard', version: 3, config: adoptedFlow('standard') }
+  state.skill_results = {
+    '需求评审': { analysis: { evidence: ['still agreed'] } },
+    '开发': { implementation: { evidence: ['old implementation'] } },
+    '代码审核': { audit: { evidence: ['old audit'] } },
+  }
+  applyRevision(state, rework('defect', '开发'))
+  assert.ok(state.skill_results['需求评审'])
+  assert.equal(state.skill_results['开发'], undefined)
+  assert.equal(state.skill_results['代码审核'], undefined)
+})