@godv61/dsh-task-engine 0.27.0 → 0.28.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,10 +309,8 @@ test('记录字段来自冻结流程，精简流程不硬编码标准字段，
   assert.deepEqual(JSON.parse(await fixture('设计').call({ operation: 'status' })).artifact_requirements[0].fields, ['approach', 'risks', 'impact'])
 })
 
-test('可选内置技能回执不会因范围变更升级成额外流转门禁', async () => {
+test('空绑定流程不会因范围变更产生额外技能门禁', async () => {
   const f = fixture('需求评审', { artifacts: { requirement: { scope: 'device picker', acceptance_criteria: 'contract and selection' } } })
-  f.load('requirement-analysis')
-  await f.call({ operation: 'skill_result', skill_name: 'requirement-analysis', command: 'check', evidence: ['optional check'] })
   await f.call({ operation: 'scope', files: ['app.js', 'new-vo.java'] })
   await f.call({ operation: 'advance', target_stage: '设计' })
   assert.equal(f.state().stage, '设计')
@@ -413,12 +411,12 @@ 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 = ['code-commit', 'code-implement', 'code-review', 'code-verify', 'eng-delivery', 'requirement-analysis', 'solution-design']
+  const expected = ['eng-delivery']
   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(), expected)
+  assert.deepEqual(catalog.skills.filter(skill => skill.source === 'bundled').map(skill => skill.name).sort(), [])
 })

package/README.md

@@ -27,7 +27,7 @@
 让 AI 修改代码时，你可以先明确需求，再检查方案、推进实施、验证结果，最后审核提交。DSH Task Engine 把这些步骤组织成可检查、可追踪的任务流程，适合在本机使用 DeepSeek Harness 开发个人项目。
 
 - **知道下一步做什么**：按所选流程推进，当前阶段需要的条件和产物清楚可查。
-- **复用自己的工作方法**：把技能和规则安装到项目或个人目录，将规则配置在技能下，再把技能挂到节点上；同一技能在任何节点都使用同一套约束。
+- **复用自己的工作方法**：把技能和规则安装到项目或个人目录，将规则配置在技能下，再把技能挂到节点上；同一技能在任何节点都使用同一套约束。
 - **找得到过程记录**：任务台账集中查看阶段、实施项、验证与审核状态。
 
 ## 快速开始
@@ -53,22 +53,22 @@ dsh plugin --profile web add @godv61/dsh-task-engine
 | **项目初始化** | 查看或编辑 `AGENTS.md`，让 AI 生成项目说明，预览后保存。 |
 | **流程配置** | 选择流程骨架，给节点挂技能，并在技能上配置它遵循的规则。需要现成起点时可「采用推荐配置」。 |
 | **任务台账** | 查看实施、验证和审核记录，按关键词、阶段或风险筛选。 |
-| **技能** | 安装、编辑技能，并集中维护每个技能唯一的规则列表。 |
+| **技能** | 安装、编辑技能，并集中维护每个技能唯一的规则列表。 |
 | **规则** | 选择 Markdown 文件安装规则，维护项目或个人开发约定。 |
 
-内置技能和规则是只读样本，可用“以此为模板新建”复制正文到项目或个人目录后编辑；新资源的规则和阶段绑定由你单独配置。安装、删除都会明确展示目标位置。
+插件只内置负责会话编排的 `eng-delivery`。阶段技能和规则由使用者创建或安装，可放在项目或个人目录；安装、删除都会明确展示目标位置。
 
-**流程与工作方法是两回事。** 流程只决定工作怎么流转（阶段顺序与门禁），预设不自带任何技能或提交格式。要用什么技能、遵守哪些规则、提交信息写什么，都由你配置。「采用推荐配置」并保存时，内置样本各复制一份到项目目录，配置改为引用项目资源；之后可编辑，升级不覆盖。同一条规则仍可由多个技能共享。用户级技能及其规则配置由所有项目和会话共用。任务的流程与资源引用在创建时确定；Skill/Rule 正文在每次交互读取最新版本，创建时副本仅用于审计。[配置细节](docs/configuration.md)
+**流程与工作方法是两回事。** 流程只决定工作怎么流转（阶段顺序与门禁），预设不自带任何技能或提交格式。要用什么技能、遵守哪些规则，都由你配置。「采用推荐配置」只填写可修改的提交文本、产物字段和评审深度，不改变技能与规则绑定。同一条规则可由多个技能共享。用户级技能及其规则配置由所有项目和会话共用。任务的流程与资源引用在创建时确定；Skill/Rule 正文在每次交互读取最新版本，创建时副本仅用于审计。[配置细节](docs/configuration.md)
 
 ## 选择适合这次任务的流程
 
 | 预设 | 阶段顺序 | 适用场景 |
 | :--- | :--- | :--- |
-| **完整研发** `standard` | 需求评审 → 设计 → 开发 → 交付 → 代码审核 → 完成 | 需要需求、方案和交付检查的完整开发任务。 |
-| **日常迭代** `agile` | 需求 → 开发 → 交付 → 审查 | 目标明确的日常开发任务。 |
-| **快速修改** `minimal` | 开发 → 交付 | 已明确做法的小改动。 |
+| **完整研发** `standard` | 需求评审 → 设计 → 开发 → 交付 → 代码审核 → 完成 | 需要需求、方案和交付检查的完整开发任务。 |
+| **日常迭代** `agile` | 需求 → 开发 → 交付 → 审查 | 目标明确的日常开发任务。 |
+| **快速修改** `minimal` | 开发 → 交付 | 已明确做法的小改动。 |
 
-阶段顺序和检查条件由预设固定；技能与规则由用户配置。选择流程不会强制加入内置技能；需要现成起点时可显式采用推荐配置。**可视化自定义流程不在计划内**，详见[功能规划](docs/roadmap.md)。
+阶段顺序和检查条件由预设固定；技能与规则由用户配置。空绑定也能运行流程。需要提交文本和产物字段的起点时可显式采用推荐配置。**可视化自定义流程不在计划内**，详见[功能规划](docs/roadmap.md)。
 
 ## 把自己的技能和规则带进来
 
@@ -78,9 +78,11 @@ dsh plugin --profile web add @godv61/dsh-task-engine
 
 | 安装范围 | 存放位置 | 用途 |
 | :--- | :--- | :--- |
-| 项目 | 工作区 `.dsh/skills`、`.dsh/rules` | 当前项目的工作方法与约定。 |
+| 项目 | 工作区 `.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)。
 
 ## 使用文档
@@ -98,7 +100,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'

package/defaults/eng.json

@@ -1,97 +1 @@
-{
-  "flow": "standard",
-  "stage_bindings": {
-    "需求评审": {
-      "skill_refs": [
-        {
-          "source": "bundled",
-          "name": "requirement-analysis"
-        }
-      ]
-    },
-    "设计": {
-      "skill_refs": [
-        {
-          "source": "bundled",
-          "name": "solution-design"
-        }
-      ]
-    },
-    "开发": {
-      "skill_refs": [
-        {
-          "source": "bundled",
-          "name": "code-implement"
-        }
-      ]
-    },
-    "交付": {
-      "skill_refs": [
-        {
-          "source": "bundled",
-          "name": "code-verify"
-        }
-      ]
-    },
-    "代码审核": {
-      "skill_refs": [
-        {
-          "source": "bundled",
-          "name": "code-review"
-        },
-        {
-          "source": "bundled",
-          "name": "code-commit"
-        }
-      ]
-    }
-  },
-  "skill_profiles": {
-    "bundled:requirement-analysis": {
-      "rules": [
-        {
-          "source": "bundled",
-          "name": "security-redlines"
-        }
-      ]
-    },
-    "bundled:solution-design": {
-      "rules": []
-    },
-    "bundled:code-implement": {
-      "rules": [
-        {
-          "source": "bundled",
-          "name": "coding-conventions"
-        },
-        {
-          "source": "bundled",
-          "name": "security-redlines"
-        }
-      ]
-    },
-    "bundled:code-verify": {
-      "rules": []
-    },
-    "bundled:code-review": {
-      "rules": [
-        {
-          "source": "bundled",
-          "name": "coding-conventions"
-        },
-        {
-          "source": "bundled",
-          "name": "security-redlines"
-        }
-      ]
-    },
-    "bundled:code-commit": {
-      "rules": [
-        {
-          "source": "bundled",
-          "name": "commit-conventions"
-        }
-      ]
-    }
-  }
-}
+{"flow":"standard"}