@godv61/dsh-task-engine 0.27.1 → 0.29.0

package/.workflow-test.mjs

@@ -4,20 +4,20 @@ import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join, resolve, sep } from 'node:path'
 import { registerDevTask } from './lib/dev-task.js'
-import { newTask, validateWorkflow } from './lib/engine.js'
-import { adoptRecommendation, resolveFlow, retainStageBindings } from './lib/workflows.js'
-import Controller from './lib/controller.js'
-import { registerShippedSkills } from './lib/shipped-skills.js'
-
-test('switching to minimal drops only stages outside its graph', () => {
-  const requirement = { skills: [{ skill: { source: 'project', name: 'requirements' }, rules: [] }] }
-  const development = { skills: [{ skill: { source: 'project', name: 'implement' }, rules: [] }] }
-  const result = retainStageBindings('minimal', { '需求': requirement, '开发': development })
-  assert.deepEqual(result.dropped, ['需求'])
-  assert.deepEqual(result.bindings, { '开发': development })
-  const resolved = resolveFlow('minimal', { flow: 'minimal', stage_bindings: result.bindings })
-  assert.deepEqual(validateWorkflow(resolved.config), [])
-})
+import { newTask, validateWorkflow } from './lib/engine.js'
+import { adoptRecommendation, resolveFlow, retainStageBindings } from './lib/workflows.js'
+import Controller from './lib/controller.js'
+import { registerShippedSkills } from './lib/shipped-skills.js'
+
+test('switching to minimal drops only stages outside its graph', () => {
+  const requirement = { skills: [{ skill: { source: 'project', name: 'requirements' }, rules: [] }] }
+  const development = { skills: [{ skill: { source: 'project', name: 'implement' }, rules: [] }] }
+  const result = retainStageBindings('minimal', { '需求': requirement, '开发': development })
+  assert.deepEqual(result.dropped, ['需求'])
+  assert.deepEqual(result.bindings, { '开发': development })
+  const resolved = resolveFlow('minimal', { flow: 'minimal', stage_bindings: result.bindings })
+  assert.deepEqual(validateWorkflow(resolved.config), [])
+})
 
 /**
  * The preset as a project would actually run it: the skeleton plus the shipped
@@ -34,7 +34,7 @@ function adoptedFlow(id, extra) {
 }
 
 
-function fixture(stage = '开发', extra = {}, services = {}) {
+function fixture(stage = '开发', extra = {}, services = {}) {
   const cwd = resolve('test-project')
   // A project running the standard flow: the skeleton plus the adopted
   // recommendation, with one extra skill mounted on 完成 for the tests that need
@@ -46,15 +46,15 @@ function fixture(stage = '开发', extra = {}, services = {}) {
     ...adopted,
     stage_bindings: {
       ...adopted.stage_bindings,
-      完成: { skills: [{ skill: { source: 'project', name: 'software-testing' }, rules: [] }] },
+      完成: { skills: [{ skill: { source: 'project', 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'],
-    [join(cwd, '.dsh/skills/software-testing/SKILL.md'), 'test instructions'],
-    [join(cwd, '.dsh/skills/human-check/SKILL.md'), 'manual check instructions']])
+  const records = new Map([[join(cwd, '.dsh/task-LIVE-1.json'), JSON.stringify(state)],
+    [join(cwd, 'app.js'), 'source'],
+    [join(cwd, '.dsh/skills/software-testing/SKILL.md'), 'test instructions'],
+    [join(cwd, '.dsh/skills/human-check/SKILL.md'), 'manual check instructions']])
   const events = [], runs = []
   const session = { id: 'test-session', header: { cwd }, snapshotEvents: () => events }
   const policy = { mode: 'workspace-write', workspaceRoot: cwd, sessionId: session.id }
@@ -86,99 +86,99 @@ function fixture(stage = '开发', extra = {}, services = {}) {
   }
   return { call: args => execute(JSON.parse(JSON.stringify({ task_id: 'LIVE-1', ...args })), exec), load, runs, policy, exec, records, cwd,
     state: () => JSON.parse(records.get(join(cwd, '.dsh/task-LIVE-1.json'))) }
-}
-
-test('manual skill evidence is approved by the host without a shell command', async () => {
-  const config = resolveFlow('minimal', { flow: 'minimal', stage_bindings: {
-    '开发': { skills: [{ skill: { source: 'project', name: 'human-check' }, rules: [], evidence: 'manual' }] },
-  } }).config
-  const approvals = []
-  const f = fixture('开发', { flow: { flow: 'minimal', version: 3, config } }, {
-    approval: { request: async request => { approvals.push(request); return 'allowed-once' } },
-  })
-  f.load('human-check')
-  await f.call({ operation: 'skill_result', skill_name: 'human-check', evidence: ['checked by owner'] })
-  assert.equal(f.runs.length, 0)
-  assert.equal(approvals.length, 1)
-  assert.equal(f.state().skill_results['开发']['human-check'].approved, true)
-  assert.deepEqual(JSON.parse(await f.call({ operation: 'status' })).skill_blockers, [])
-  const denied = fixture('开发', { flow: { flow: 'minimal', version: 3, config } }, {
-    approval: { request: async () => 'rejected' },
-  })
-  denied.load('human-check')
-  await assert.rejects(denied.call({ operation: 'skill_result', skill_name: 'human-check', evidence: ['claimed approval'] }), /not approved/)
-  assert.equal(denied.state().skill_results?.['开发']?.['human-check'], undefined)
-})
-
-test('completion rejects unresolved terminal skills and rules', async () => {
-  const config = resolveFlow('minimal', { flow: 'minimal', stage_bindings: {
-    '交付': { skills: [{ skill: { source: 'project', name: 'must-run' }, rules: [{ source: 'project', name: 'missing' }], evidence: 'command' }] },
-  } }).config
-  const f = fixture('交付', {
-    flow: { flow: 'minimal', version: 3, config },
-    items: [{ id: 'A', title: 'small', status: 'done', review: { spec: { outcome: 'pass' }, quality: { outcome: 'pass' } } }],
-    commits: [{ label: 'TASK', hash: 'abcdef1' }],
-  })
-  const status = JSON.parse(await f.call({ operation: 'status' }))
-  assert.ok(status.skill_blockers.length > 0)
-  assert.ok(status.missing_rules.length > 0)
-  await assert.rejects(f.call({ operation: 'complete' }), /cannot complete.*must-run|cannot complete.*missing/)
-  assert.equal(f.state().completed, undefined)
-})
-
-test('same-named skill and rule freeze separately and disclose the rule body', async () => {
-  const f = fixture()
-  f.records.delete(join(f.cwd, '.dsh/task-LIVE-1.json'))
-  f.records.set(join(f.cwd, '.dsh/eng.json'), JSON.stringify({ flow: 'minimal', stage_bindings: {
-    '开发': { skills: [{ skill: { source: 'project', name: 'custom' }, rules: [{ source: 'project', name: 'custom' }], evidence: 'none' }] },
-  } }))
-  f.records.set(join(f.cwd, '.dsh/skills/custom/SKILL.md'), 'SKILL BODY')
-  f.records.set(join(f.cwd, '.dsh/rules/custom.md'), 'RULE BODY')
-  await f.call({ operation: 'create', title: 'collision', branch: 'main', files: ['app.js'] })
-  const resources = f.state().flow.resources.filter(resource => resource.ref.name === 'custom')
-  assert.deepEqual(resources.map(resource => resource.kind).sort(), ['rule', 'skill'])
-  assert.equal(JSON.parse(await f.call({ operation: 'status' })).bindings.rules[0].content, 'RULE BODY')
-  f.records.set(join(f.cwd, '.dsh/skills/custom/SKILL.md'), 'CHANGED SKILL')
-  const status = JSON.parse(await f.call({ operation: 'status' }))
-  assert.equal(status.bindings.skill_contents[0].content, 'CHANGED SKILL')
-  assert.ok(status.changed_source_skills.some(ref => ref.includes('project:custom')))
-  f.records.delete(join(f.cwd, '.dsh/skills/custom/SKILL.md'))
-  const missing = JSON.parse(await f.call({ operation: 'status' }))
-  assert.ok(missing.missing_skills.includes('project:custom'))
-  assert.equal(missing.bindings.skill_contents.length, 0)
-})
-
-test('task creation applies skill_profiles rules even when legacy inline bindings are empty', async () => {
-  const f = fixture()
-  const skill = { source: 'project', name: 'custom' }
-  const rule = { source: 'project', name: 'my-rule' }
-  f.records.delete(join(f.cwd, '.dsh/task-LIVE-1.json'))
-  f.records.set(join(f.cwd, '.dsh/eng.json'), JSON.stringify({ flow: 'minimal',
-    stage_bindings: {
-      '开发': { skills: [{ skill, rules: [], evidence: 'none' }] },
-      '交付': { skills: [{ skill, rules: [], evidence: 'none' }] },
-    },
-    skill_profiles: { 'project:custom': { rules: [rule], evidence: 'none' } },
-  }))
-  f.records.set(join(f.cwd, '.dsh/skills/custom/SKILL.md'), 'SKILL BODY')
-  await assert.rejects(f.call({ operation: 'create', title: 'profile regression', branch: 'main', files: ['app.js'] }), /rule:project:my-rule/)
-  f.records.set(join(f.cwd, '.dsh/rules/my-rule.md'), 'RULE BODY')
-  await f.call({ operation: 'create', title: 'profile regression', branch: 'main', files: ['app.js'] })
-  assert.deepEqual(f.state().flow.config.stage_bindings['开发'].skills[0].rules, [rule])
-  assert.deepEqual(f.state().flow.config.stage_bindings['交付'].skills[0].rules, [rule])
-  assert.equal(f.state().flow.resources.find(resource => resource.kind === 'rule')?.content, 'RULE BODY')
-  assert.equal(JSON.parse(await f.call({ operation: 'status' })).bindings.rules[0].content, 'RULE BODY')
-})
-
-test('task creation rejects an unavailable skill or rule before writing a record', async () => {
-  const f = fixture()
-  f.records.delete(join(f.cwd, '.dsh/task-LIVE-1.json'))
-  f.records.set(join(f.cwd, '.dsh/eng.json'), JSON.stringify({ flow: 'minimal', stage_bindings: {
-    '开发': { skills: [{ skill: { source: 'project', name: 'missing-skill' }, rules: [] }] },
-  } }))
-  await assert.rejects(f.call({ operation: 'create', title: 'missing', branch: 'main' }), /unreadable bound resources/)
-  assert.equal(f.records.has(join(f.cwd, '.dsh/task-LIVE-1.json')), false)
-})
+}
+
+test('manual skill evidence is approved by the host without a shell command', async () => {
+  const config = resolveFlow('minimal', { flow: 'minimal', stage_bindings: {
+    '开发': { skills: [{ skill: { source: 'project', name: 'human-check' }, rules: [], evidence: 'manual' }] },
+  } }).config
+  const approvals = []
+  const f = fixture('开发', { flow: { flow: 'minimal', version: 3, config } }, {
+    approval: { request: async request => { approvals.push(request); return 'allowed-once' } },
+  })
+  f.load('human-check')
+  await f.call({ operation: 'skill_result', skill_name: 'human-check', evidence: ['checked by owner'] })
+  assert.equal(f.runs.length, 0)
+  assert.equal(approvals.length, 1)
+  assert.equal(f.state().skill_results['开发']['human-check'].approved, true)
+  assert.deepEqual(JSON.parse(await f.call({ operation: 'status' })).skill_blockers, [])
+  const denied = fixture('开发', { flow: { flow: 'minimal', version: 3, config } }, {
+    approval: { request: async () => 'rejected' },
+  })
+  denied.load('human-check')
+  await assert.rejects(denied.call({ operation: 'skill_result', skill_name: 'human-check', evidence: ['claimed approval'] }), /not approved/)
+  assert.equal(denied.state().skill_results?.['开发']?.['human-check'], undefined)
+})
+
+test('completion rejects unresolved terminal skills and rules', async () => {
+  const config = resolveFlow('minimal', { flow: 'minimal', stage_bindings: {
+    '交付': { skills: [{ skill: { source: 'project', name: 'must-run' }, rules: [{ source: 'project', name: 'missing' }], evidence: 'command' }] },
+  } }).config
+  const f = fixture('交付', {
+    flow: { flow: 'minimal', version: 3, config },
+    items: [{ id: 'A', title: 'small', status: 'done', review: { spec: { outcome: 'pass' }, quality: { outcome: 'pass' } } }],
+    commits: [{ label: 'TASK', hash: 'abcdef1' }],
+  })
+  const status = JSON.parse(await f.call({ operation: 'status' }))
+  assert.ok(status.skill_blockers.length > 0)
+  assert.ok(status.missing_rules.length > 0)
+  await assert.rejects(f.call({ operation: 'complete' }), /cannot complete.*must-run|cannot complete.*missing/)
+  assert.equal(f.state().completed, undefined)
+})
+
+test('same-named skill and rule freeze separately and disclose the rule body', async () => {
+  const f = fixture()
+  f.records.delete(join(f.cwd, '.dsh/task-LIVE-1.json'))
+  f.records.set(join(f.cwd, '.dsh/eng.json'), JSON.stringify({ flow: 'minimal', stage_bindings: {
+    '开发': { skills: [{ skill: { source: 'project', name: 'custom' }, rules: [{ source: 'project', name: 'custom' }], evidence: 'none' }] },
+  } }))
+  f.records.set(join(f.cwd, '.dsh/skills/custom/SKILL.md'), 'SKILL BODY')
+  f.records.set(join(f.cwd, '.dsh/rules/custom.md'), 'RULE BODY')
+  await f.call({ operation: 'create', title: 'collision', branch: 'main', files: ['app.js'] })
+  const resources = f.state().flow.resources.filter(resource => resource.ref.name === 'custom')
+  assert.deepEqual(resources.map(resource => resource.kind).sort(), ['rule', 'skill'])
+  assert.equal(JSON.parse(await f.call({ operation: 'status' })).bindings.rules[0].content, 'RULE BODY')
+  f.records.set(join(f.cwd, '.dsh/skills/custom/SKILL.md'), 'CHANGED SKILL')
+  const status = JSON.parse(await f.call({ operation: 'status' }))
+  assert.equal(status.bindings.skill_contents[0].content, 'CHANGED SKILL')
+  assert.ok(status.changed_source_skills.some(ref => ref.includes('project:custom')))
+  f.records.delete(join(f.cwd, '.dsh/skills/custom/SKILL.md'))
+  const missing = JSON.parse(await f.call({ operation: 'status' }))
+  assert.ok(missing.missing_skills.includes('project:custom'))
+  assert.equal(missing.bindings.skill_contents.length, 0)
+})
+
+test('task creation applies skill_profiles rules even when legacy inline bindings are empty', async () => {
+  const f = fixture()
+  const skill = { source: 'project', name: 'custom' }
+  const rule = { source: 'project', name: 'my-rule' }
+  f.records.delete(join(f.cwd, '.dsh/task-LIVE-1.json'))
+  f.records.set(join(f.cwd, '.dsh/eng.json'), JSON.stringify({ flow: 'minimal',
+    stage_bindings: {
+      '开发': { skills: [{ skill, rules: [], evidence: 'none' }] },
+      '交付': { skills: [{ skill, rules: [], evidence: 'none' }] },
+    },
+    skill_profiles: { 'project:custom': { rules: [rule], evidence: 'none' } },
+  }))
+  f.records.set(join(f.cwd, '.dsh/skills/custom/SKILL.md'), 'SKILL BODY')
+  await assert.rejects(f.call({ operation: 'create', title: 'profile regression', branch: 'main', files: ['app.js'] }), /rule:project:my-rule/)
+  f.records.set(join(f.cwd, '.dsh/rules/my-rule.md'), 'RULE BODY')
+  await f.call({ operation: 'create', title: 'profile regression', branch: 'main', files: ['app.js'] })
+  assert.deepEqual(f.state().flow.config.stage_bindings['开发'].skills[0].rules, [rule])
+  assert.deepEqual(f.state().flow.config.stage_bindings['交付'].skills[0].rules, [rule])
+  assert.equal(f.state().flow.resources.find(resource => resource.kind === 'rule')?.content, 'RULE BODY')
+  assert.equal(JSON.parse(await f.call({ operation: 'status' })).bindings.rules[0].content, 'RULE BODY')
+})
+
+test('task creation rejects an unavailable skill or rule before writing a record', async () => {
+  const f = fixture()
+  f.records.delete(join(f.cwd, '.dsh/task-LIVE-1.json'))
+  f.records.set(join(f.cwd, '.dsh/eng.json'), JSON.stringify({ flow: 'minimal', stage_bindings: {
+    '开发': { skills: [{ skill: { source: 'project', name: 'missing-skill' }, rules: [] }] },
+  } }))
+  await assert.rejects(f.call({ operation: 'create', title: 'missing', branch: 'main' }), /unreadable bound resources/)
+  assert.equal(f.records.has(join(f.cwd, '.dsh/task-LIVE-1.json')), false)
+})
 
 test('审查通过后更新状态并激活下一项，保留已完成项的审计', async () => {
   const f = fixture()
@@ -309,9 +309,9 @@ test('记录字段来自冻结流程，精简流程不硬编码标准字段，
   assert.deepEqual(JSON.parse(await fixture('设计').call({ operation: 'status' })).artifact_requirements[0].fields, ['approach', 'risks', 'impact'])
 })
 
-test('空绑定流程不会因范围变更产生额外技能门禁', async () => {
-  const f = fixture('需求评审', { artifacts: { requirement: { scope: 'device picker', acceptance_criteria: 'contract and selection' } } })
-  await f.call({ operation: 'scope', files: ['app.js', 'new-vo.java'] })
+test('空绑定流程不会因范围变更产生额外技能门禁', async () => {
+  const f = fixture('需求评审', { artifacts: { requirement: { scope: 'device picker', acceptance_criteria: 'contract and selection' } } })
+  await f.call({ operation: 'scope', files: ['app.js', 'new-vo.java'] })
   await f.call({ operation: 'advance', target_stage: '设计' })
   assert.equal(f.state().stage, '设计')
 })
@@ -411,12 +411,14 @@ test('同名技能与规则在项目和个人目录各自保留管理入口', as
   assert.match(read.content, /Run tests/)
 })
 
-test('安装包只注册会话编排技能，阶段目录不展示它', async () => {
+test('安装包注册会话编排和元技能，阶段目录只隐藏会话编排技能', async () => {
   const registered = []
   registerShippedSkills({ get: name => name === 'skills' ? { register: skill => { registered.push(skill); return () => {} } } : undefined })
-  const expected = ['eng-delivery']
+  const expected = ['architecture-design', 'code-development', 'code-review', 'eng-delivery',
+    'requirements-analysis', 'task-orchestration', 'test-validation']
   assert.deepEqual(registered.map(skill => skill.name).sort(), expected)
   assert.ok(registered.every(skill => skill.content.trim().length > 0))
   const catalog = await Controller.prototype.listSkills.call({ authorizedPath: async path => path }, '')
-  assert.deepEqual(catalog.skills.filter(skill => skill.source === 'bundled').map(skill => skill.name).sort(), [])
-})
+  assert.deepEqual(catalog.skills.filter(skill => skill.source === 'bundled').map(skill => skill.name).sort(),
+    expected.filter(name => name !== 'eng-delivery'))
+})

package/README.md

@@ -2,10 +2,12 @@
   <img src="docs/assets/workflow-banner.svg" alt="DSH Task Engine：DeepSeek Harness 的个人工程流程工作台，标准流程从需求评审走向完成" width="100%" />
 </p>
 
-<h1 align="center">DSH Task Engine</h1>
+<h1 align="center">DSH Task Engine</h1>
+
+> `0.29.0` 新增自适应流程、项目技能初始化与可选 SonarQube CI 审核。SonarQube 集成目前读取提交后的 CI 分析结果，不提供未提交代码的本地 Sonar 审核。
 
-<p align="center">把开发步骤、技能规则和交付记录，放进一个个人工作台。</p>
-<p align="center"><sub>A personal engineering workflow workbench for DeepSeek Harness.</sub></p>
+<p align="center">按每个需求选择工程路径，用项目 Skill 与 Rule 复用团队开发规范。</p>
+<p align="center"><sub>Task-scoped engineering workflows for DeepSeek Harness.</sub></p>
 
 <p align="center">
   <a href="https://www.npmjs.com/package/@godv61/dsh-task-engine"><img src="https://img.shields.io/npm/v/%40godv61%2Fdsh-task-engine?style=flat-square&amp;color=238636" alt="npm version" /></a>
@@ -24,10 +26,10 @@
 
 ## 为什么用它
 
-让 AI 修改代码时，你可以先明确需求，再检查方案、推进实施、验证结果，最后审核提交。DSH Task Engine 把这些步骤组织成可检查、可追踪的任务流程，适合在本机使用 DeepSeek Harness 开发个人项目。
+让 AI 在持续开发的项目中处理不同需求时，按这次需求的复杂度选择低、中、高、超高四档任务流程。元技能规定交接产物，项目 Skill/Rule 承载团队编码规范；同一项目下的多个会话可以各自推进不同任务。
 
-- **知道下一步做什么**：按所选流程推进，当前阶段需要的条件和产物清楚可查。
-- **复用自己的工作方法**：把技能和规则安装到项目或个人目录，将规则配置在技能下，再把技能挂到节点上；同一技能在任何节点都使用同一套约束。
+- **知道下一步做什么**：任务创建时选择复杂度并冻结流程，当前阶段的条件和产物清楚可查。
+- **复用自己的工作方法**：把技能和规则安装到项目或个人目录，将规则配置在技能下，再把技能挂到节点上；同一技能在任何节点都使用同一套约束。
 - **找得到过程记录**：任务台账集中查看阶段、实施项、验证与审核状态。
 
 ## 快速开始
@@ -38,37 +40,40 @@
 dsh plugin --profile web add @godv61/dsh-task-engine
 ```
 
-1. 重启 Harness Web，打开侧边栏的 **工程流程**。
-2. 选择工作区，在 **流程配置** 中选择一套流程。
+1. 重启 Harness Web，打开侧边栏的 **工程任务**。
+2. 选择工作区，在 **自适应流程** 中查看四档路径，按需挂载项目技能。
 3. 新建会话，选择 **工程化开发引擎** 预设，描述要完成的开发任务。
 
-看到“工程流程”入口和“工程化开发引擎”会话预设，就说明工作台与任务工具已接入。使用 Harness 源码启动的安装方式见[安装与启用](docs/getting-started.md)。
+看到“工程任务”入口和“工程化开发引擎”会话预设，就说明工作台与任务工具已接入。使用 Harness 源码启动的安装方式见[安装与启用](docs/getting-started.md)。
 
-> 工作台中的“流程预设”决定任务怎么推进；会话中的“工程化开发引擎”预设负责启用 `dev_task` 工具。两者作用不同。
+> 工程化会话先分析需求复杂度，再以 `dev_task assess` 预览并创建任务；`.dsh/meta.json` 只配置元技能挂载和可选 SonarQube 审核，不强迫项目所有会话走同一条流程。
 
 ## 工作台里有什么
 
 | 页面 | 你可以做什么 |
 | :--- | :--- |
-| **项目初始化** | 查看或编辑 `AGENTS.md`，让 AI 生成项目说明，预览后保存。 |
-| **流程配置** | 选择流程骨架，给节点挂技能，并在技能上配置它遵循的规则。需要现成起点时可「采用推荐配置」。 |
+| **项目初始化** | 维护 `AGENTS.md`；工程会话可用 `dev_task init_project` 扫描仓库、预览并生成项目 Skill/Rule。 |
+| **自适应流程** | 查看四档任务路径、元技能绑定与可选 SonarQube 审核配置。 |
+| **旧版流程** | 维护旧项目的 `.dsh/eng.json`；已有任务继续按冻结快照执行。 |
 | **任务台账** | 查看实施、验证和审核记录，按关键词、阶段或风险筛选。 |
-| **技能** | 安装、编辑技能，并集中维护每个技能唯一的规则列表。 |
+| **技能** | 安装、编辑技能，并集中维护每个技能唯一的规则列表。 |
 | **规则** | 选择 Markdown 文件安装规则，维护项目或个人开发约定。 |
 
-插件只内置负责会话编排的 `eng-delivery`。阶段技能和规则由使用者创建或安装，可放在项目或个人目录；安装、删除都会明确展示目标位置。
+插件内置会话编排 Skill `eng-delivery` 和六个通用元技能 Skill。项目知识、领域编码方法和 Rule 由使用者创建或通过 init 生成，可放在项目或个人目录；同名项目 Skill 在新任务中覆盖用户级 Skill。
+
+新路径的四档顺序、元技能交接契约、`init_project` 和可选 SonarQube 审核见[自适应工程任务](docs/adaptive-workflows.md)。
 
-**流程与工作方法是两回事。** 流程只决定工作怎么流转（阶段顺序与门禁），预设不自带任何技能或提交格式。要用什么技能、遵守哪些规则，都由你配置。「采用推荐配置」只填写可修改的提交文本、产物字段和评审深度，不改变技能与规则绑定。同一条规则可由多个技能共享。用户级技能及其规则配置由所有项目和会话共用。任务的流程与资源引用在创建时确定；Skill/Rule 正文在每次交互读取最新版本，创建时副本仅用于审计。[配置细节](docs/configuration.md)
+**流程与工作方法各有职责。** 四档流程规定阶段与门禁，并在相应阶段加载内置元技能；项目业务技能和规则由使用者配置。旧版三个流程不自带技能或提交格式，「采用推荐配置」只填写可修改的提交文本、产物字段和评审深度。同一条规则可由多个技能共享。任务的流程与资源引用在创建时确定；Skill/Rule 正文在每次交互读取最新版本，创建时副本仅用于审计。[新流程说明](docs/adaptive-workflows.md) · [旧版配置细节](docs/configuration.md)
 
-## 选择适合这次任务的流程
+## 旧版流程兼容
 
 | 预设 | 阶段顺序 | 适用场景 |
 | :--- | :--- | :--- |
-| **完整研发** `standard` | 需求评审 → 设计 → 开发 → 交付 → 代码审核 → 完成 | 需要需求、方案和交付检查的完整开发任务。 |
-| **日常迭代** `agile` | 需求 → 开发 → 交付 → 审查 | 目标明确的日常开发任务。 |
-| **快速修改** `minimal` | 开发 → 交付 | 已明确做法的小改动。 |
+| **完整研发** `standard` | 需求评审 → 设计 → 开发 → 交付 → 代码审核 → 完成 | 需要需求、方案和交付检查的完整开发任务。 |
+| **日常迭代** `agile` | 需求 → 开发 → 交付 → 审查 | 目标明确的日常开发任务。 |
+| **快速修改** `minimal` | 开发 → 交付 | 已明确做法的小改动。 |
 
-阶段顺序和检查条件由预设固定；技能与规则由用户配置。空绑定也能运行流程。需要提交文本和产物字段的起点时可显式采用推荐配置。**可视化自定义流程不在计划内**，详见[功能规划](docs/roadmap.md)。
+旧版阶段顺序和检查条件继续有效；没有传入 `complexity` 的旧调用仍按 `.dsh/eng.json` 执行。新任务通过 `complexity` 使用四档自适应流程；旧任务不迁移或改写。
 
 ## 把自己的技能和规则带进来
 
@@ -78,11 +83,11 @@ dsh plugin --profile web add @godv61/dsh-task-engine
 
 | 安装范围 | 存放位置 | 用途 |
 | :--- | :--- | :--- |
-| 项目 | 工作区 `.dsh/skills`、`.dsh/rules` | 当前项目的工作方法与约定；工作台新建资源默认写在这里。 |
-| 个人 | `$DSH_HOME/skills`、`$DSH_HOME/rules` | 在这台电脑上的多个项目间复用。 |
-
-工作台也会发现同一项目 `.agents/skills/<名称>/SKILL.md` 中的 Codex 项目技能，可将它绑定到流程节点，并在技能下配置 DSH 规则；它的正文仍留在原目录。运行时使用 `dev_task` 的 `load_skill` 操作读取该技能及其规则，下一次读取会取得文件的最新内容。[Codex 项目技能说明](docs/configuration.md#技能与规则)
-
+| 项目 | 工作区 `.dsh/skills`、`.dsh/rules` | 当前项目的工作方法与约定；工作台新建资源默认写在这里。 |
+| 个人 | `$DSH_HOME/skills`、`$DSH_HOME/rules` | 在这台电脑上的多个项目间复用。 |
+
+工作台也会发现同一项目 `.agents/skills/<名称>/SKILL.md` 中的 Codex 项目技能，可将它绑定到流程节点，并在技能下配置 DSH 规则；它的正文仍留在原目录。运行时使用 `dev_task` 的 `load_skill` 操作读取该技能及其规则，下一次读取会取得文件的最新内容。[Codex 项目技能说明](docs/configuration.md#技能与规则)
+
 技能的脚本、模板和附件会一并保留。文件格式、大小限制和故障处理见[技能与规则安装指南](docs/resource-install.md)。
 
 ## 使用文档
@@ -90,7 +95,8 @@ dsh plugin --profile web add @godv61/dsh-task-engine
 | 想了解什么 | 从这里开始 |
 | :--- | :--- |
 | 安装、启用与第一次使用 | [快速上手](docs/getting-started.md) |
-| 项目配置与阶段绑定 | [流程配置](docs/configuration.md) |
+| 任务级流程、元技能与 SonarQube | [自适应工程任务](docs/adaptive-workflows.md) |
+| 旧项目配置与阶段绑定 | [流程配置](docs/configuration.md) |
 | 技能文件夹与 Markdown 规则 | [资源安装](docs/resource-install.md) |
 | 完整操作说明 | [HTML 手册](docs/manual.html)（下载后在浏览器打开） |
 | 当前能力与常见问题 | [常见问题](docs/faq.md) |
@@ -100,7 +106,7 @@ dsh plugin --profile web add @godv61/dsh-task-engine
 
 ## 能力说明
 
-`dev_task` 按配置检查阶段、产物和提交条件。新任务的验证要求真实命令回执；技能可按自身配置要求命令、产物、审核、人工批准或无需额外证据，执行义务可在任务状态中查看。任务保存创建时的流程与资源引用；之后修改流程配置不会改变进行中任务的状态机，编辑所引用资源的正文会从下一次交互生效。
+`dev_task` 按配置检查阶段、产物和提交条件。新任务的验证要求真实命令回执；技能可按自身配置要求命令、产物、审核、人工批准或无需额外证据，执行义务可在任务状态中查看。任务保存创建时的流程与资源引用；之后修改流程配置不会改变进行中任务的状态机，编辑所引用资源的正文会从下一次交互生效。
 
 审核结论、实施项完成情况和测试覆盖面仍需要你判断。本地提交钩子提供即时检查，不能替代人工审核或项目自己的 CI。详细说明见[常见问题](docs/faq.md)。
 

package/cordis.patch.yml

@@ -1,11 +1,160 @@
-# dsh-task-engine bundle: one host-plane row that mounts the `task-engine`
-# Remote namespace (what the browser workbench reads/writes) plus, via
-# `dsh.client`, the workbench UI. This host row registers NO model-facing tool
-# and NO skill — `dev_task` and the shipped skills live on the AGENT plane,
-# behind the `@godv61/dsh-task-engine/agent` entry. A preset's
-# `agent.cordis.yml` names that agent row to activate the flow for its
-# sessions; presets that never name it get neither the tool nor the skills
-# (the workbench stays available so a human can still configure the flow).
+# dsh-task-engine bundle: mount the host controller and contribute an
+# engineering preset using DSH 0.2's declarative preset plugin.
 - insert:
     - id: task-engine
-      name: '@godv61/dsh-task-engine'
+      name: '@godv61/dsh-task-engine'
+
+# Engineering preset derived from DSH 0.2's shipped standard preset.
+# Keep this declaration in sync with the target DSH release.
+# `config.plugins` by id from the profile patch.
+- insert:
+    - id: preset-eng
+      name: '@deepseek-ai/dsh-agent-preset'
+      config:
+        id: eng
+        name: 工程化开发引擎
+        description: 通过 dev_task 持有工程任务阶段、证据和提交门禁。
+        order: 2
+        plugins:
+          - id: persona
+            name: '@deepseek-ai/dsh-persona'
+            config:
+              prefix: |-
+                You are an engineering-delivery coding agent, powered by the {{model}} model, running on DeepSeek Harness. Your working directory is {{cwd}}.
+
+                本仓库使用 `dev_task` 管理工程任务的状态机。项目根 `.dsh/eng.json` 选择流程骨架，并可配置阶段技能、技能规则、产物字段和提交文本；没有配置的业务方法不能自动补齐。任何开发类请求开始前，先加载 `eng-delivery` 并读取当前任务状态。
+
+                阶段流转、确认、验证、评审、任务完成及受控提交通过 `dev_task`；它拒绝时按返回的条件修正，不绕过。具体工作方法以当前任务冻结的用户配置为准，远程操作或发布由用户明确决定。
+          - id: agent-instructions
+            name: '@deepseek-ai/dsh-agent-instructions'
+            config:
+              maxBytes: 65536
+          - id: tool-bash
+            name: '@deepseek-ai/dsh-tool-bash'
+            disabled: !!js process.platform === 'win32'
+          - id: tool-pwsh
+            name: '@deepseek-ai/dsh-tool-pwsh'
+            disabled: !!js process.platform !== 'win32'
+          - id: tool-fs
+            name: '@deepseek-ai/dsh-tool-fs'
+          - id: tool-fs-search
+            name: '@deepseek-ai/dsh-tool-fs-search'
+            config:
+              sampleOverCapGlobResults: false
+          - id: tool-jobs
+            name: '@deepseek-ai/dsh-tool-jobs'
+          - id: skill-filesystem
+            name: '@deepseek-ai/dsh-skill-filesystem'
+          - id: tool-skill
+            name: '@deepseek-ai/dsh-tool-skill'
+          - id: command-goal
+            name: '@deepseek-ai/dsh-command-goal'
+          - id: tool-goal
+            name: '@deepseek-ai/dsh-tool-goal'
+          - id: planning
+            name: cordis:group
+            group: true
+            isolate:
+              planMode: true
+            config:
+              - id: plan-mode
+                name: '@deepseek-ai/dsh-plan-mode'
+                config:
+                  section: |
+                    You are in plan mode. Stay in plan mode until exit_plan_mode succeeds or the user switches the session mode. Imperative language to implement changes means plan the implementation, not execute it. A user's conversational agreement — including an answer confirming something you asked — approves nothing and does not end plan mode; fold the confirmed decision into the plan and submit it through exit_plan_mode.
+
+                    Explore first. Use non-mutating reads, searches, static analysis, and checks to ground the plan in the actual repository. Do not edit or write files, change configuration, run formatters or code generation that rewrites tracked files, commit, or otherwise carry out the plan. Prefer existing functions and patterns over new machinery.
+
+                    The tool catalog stays the same across modes for request-cache stability. These plan-mode rules override any later tool description or guidance that suggests using mutation tools; those tools remain listed to keep the tool catalog unchanged. Do not use todo_write to track this planning phase: it tracks implementation after an approved plan, while the plan itself belongs in exit_plan_mode.
+
+                    Resolve discoverable facts by inspection. Use ask_user_question only for user-owned choices or material ambiguity that inspection cannot answer. Do not ask the user where code lives or how current behavior works when you can find out.
+
+                    Make the plan decision-complete: state the goal and success criteria; group implementation changes by subsystem; identify public API, schema, and data-flow changes; cover edge cases, failure modes, tests, acceptance criteria, and explicit assumptions. Keep it concise enough to review but detailed enough that another engineer can implement it without making design decisions.
+
+                    When ready, call exit_plan_mode with the complete plan markdown, starting with a # title. Make exit_plan_mode the only and final tool call in that assistant response: it presents the plan for approval, and implementation begins only in a later step after approval. Do not paste the final plan as a plain reply or ask "should I proceed?" through prose or ask_user_question. If review rejects it, incorporate the feedback and present again. If the review channel is unavailable or aborted, stay in plan mode and ask the user to switch modes manually; do not proceed with implementation.
+          - id: compaction
+            name: cordis:group
+            group: true
+            isolate:
+              compaction: true
+              toolResultPruner: true
+            config:
+              - id: compaction-basic
+                name: '@deepseek-ai/dsh-compaction-basic'
+              - id: command-compact
+                name: '@deepseek-ai/dsh-command-compact'
+              - id: tool-result-pruner
+                name: '@deepseek-ai/dsh-compaction-tool-result-pruner'
+                config:
+                  thresholdChars: 8192
+                  headChars: 4096
+                  tailChars: 1024
+          - id: delegation
+            name: cordis:group
+            group: true
+            isolate:
+              workflowEngine: true
+            config:
+              - id: tool-subagent-control
+                name: '@deepseek-ai/dsh-tool-subagent-control'
+              - id: tool-subagent-list-agents
+                name: '@deepseek-ai/dsh-tool-subagent-control/list-agents'
+              - id: tool-subagent
+                name: '@deepseek-ai/dsh-tool-subagent'
+                config:
+                  provider: spawn
+                  toolName: subagent
+                  modelSelectionSettings: true
+                  backgroundMode: continuable
+              - id: tool-subagent-fork
+                name: '@deepseek-ai/dsh-tool-subagent'
+                config:
+                  provider: fork
+                  toolName: subagent_fork
+                  backgroundMode: continuable
+              - id: tool-subagent-codex
+                name: '@deepseek-ai/dsh-tool-subagent'
+                disabled: true
+                config:
+                  provider: codex
+                  toolName: subagent_codex
+                  backgroundMode: one-shot
+                  maxDepth: provider-managed
+              - id: tool-subagent-claude-code
+                name: '@deepseek-ai/dsh-tool-subagent'
+                disabled: true
+                config:
+                  provider: claude-code
+                  toolName: subagent_claude_code
+                  backgroundMode: one-shot
+                  maxDepth: provider-managed
+              - id: workflow-ptc
+                name: '@deepseek-ai/dsh-workflow-ptc'
+                config:
+                  provider: spawn
+              - id: tool-workflow
+                name: '@deepseek-ai/dsh-tool-workflow'
+              - id: tool-ralph
+                name: '@deepseek-ai/dsh-tool-ralph'
+                disabled: true
+                config:
+                  subagentProvider: spawn
+                  maxRounds: 64
+          - id: tool-ask-user
+            name: '@deepseek-ai/dsh-tool-ask-user'
+          - id: tool-todo
+            name: '@deepseek-ai/dsh-tool-todo'
+            config:
+              allowParallelInProgress: true
+          - id: tool-web
+            name: '@deepseek-ai/dsh-tool-web'
+            config:
+              fetch: true
+              searchTimeoutMs: 60000
+          - id: present
+            name: '@deepseek-ai/dsh-tool-present'
+          - id: tool-plugin-manager
+            name: '@deepseek-ai/dsh-plugin-manager/tools'
+            disabled: true
+          - id: task-engine-agent
+            name: '@godv61/dsh-task-engine/agent'