@godv61/dsh-task-engine 0.27.0 → 0.28.0

package/.acceptance.mjs

@@ -44,7 +44,12 @@ console.log('')
 console.log('=== 3. 采用后完全可编辑、可删除 ===')
 for (const id of ['standard', 'agile', 'minimal']) {
   const adopted = adoptRecommendation(id)
-  check(`${id} 采用后带推荐技能`, Object.keys(adopted.stage_bindings ?? {}).length > 0)
+  check(`${id} 采用后仍不绑定业务技能`, Object.keys(adopted.stage_bindings ?? {}).length === 0)
+  const retained = adoptRecommendation(id, { flow: id, stage_bindings: {
+    开发: { skill_refs: [{ source: 'project', name: 'mine' }] },
+  } })
+  check(`${id} 采用推荐文本时保留用户技能`, retained.stage_bindings.开发.skill_refs[0].name === 'mine')
+  if (id !== 'minimal') check(`${id} 推荐提交文本实际写入`, retained.commit.message_pattern !== '')
   const replaced = resolveFlow(id, { ...adopted, stage_bindings: {} }).config
   check(`${id} 清空后为空（不补回）`, Object.keys(replaced.stage_bindings ?? {}).length === 0)
   const mine = resolveFlow(id, {
@@ -101,13 +106,13 @@ for (const id of ['standard', 'agile', 'minimal']) {
 }
 
 console.log('')
-console.log('=== 7. defaults/eng.json 是采用后的配置示例 ===')
+console.log('=== 7. defaults/eng.json 是空绑定配置示例 ===')
 const doc = JSON.parse(readFileSync('defaults/eng.json', 'utf8'))
 const merged = resolveFlow(doc.flow, doc)
 check('defaults/eng.json 可解析', merged.ok)
 if (merged.ok) {
   check('defaults/eng.json 无验证问题', validateWorkflow(merged.config).length === 0)
-  check('defaults/eng.json 含技能（是采用后的样子）', Object.keys(merged.config.stage_bindings ?? {}).length > 0)
+  check('defaults/eng.json 不含技能', Object.keys(merged.config.stage_bindings ?? {}).length === 0)
 }
 
 console.log('')
@@ -148,4 +153,4 @@ check('三者范围互不相同', new Set([r.join(), s.join(), d.join()]).size =
 
 console.log('')
 console.log(failures === 0 ? '✅ 全部验收项通过' : `❌ ${failures} 项未通过`)
-process.exit(failures === 0 ? 0 : 1)
+process.exit(failures === 0 ? 0 : 1)

package/.assessment-batch1.mjs

@@ -320,16 +320,18 @@ test('batch3: the same skill carries identical rules wherever it is bound', () =
 test('batch3: a rule shared by two skills is one resource, referenced twice', () => {
   // Reuse must not duplicate the rule body: two skills referencing one rule point
   // at the same source-qualified reference.
-  const config = adoptedFlow('standard')
-  const review = config.stage_bindings['代码审核'].skills
-  const reviewRules = review.find(entry => entry.skill.name === 'code-review').rules.map(formatResourceRef)
-  const implementRules = config.stage_bindings['开发'].skills
-    .find(entry => entry.skill.name === 'code-implement').rules.map(formatResourceRef)
+  const sharedRule = { source: 'project', name: 'shared-rule' }
+  const config = resolveFlow('standard', { flow: 'standard', stage_bindings: {
+    '开发': { skills: [{ skill: { source: 'project', name: 'implement' }, rules: [sharedRule] }] },
+    '代码审核': { skills: [{ skill: { source: 'project', name: 'review' }, rules: [sharedRule] }] },
+  } }).config
+  const reviewRules = config.stage_bindings['代码审核'].skills[0].rules.map(formatResourceRef)
+  const implementRules = config.stage_bindings['开发'].skills[0].rules.map(formatResourceRef)
   const shared = reviewRules.filter(rule => implementRules.includes(rule))
   assert.ok(shared.length > 0,
     'coding-conventions and security-redlines apply to both implementing and reviewing code, so at least one rule must be shared by reference')
-  assert.ok(shared.includes('bundled:security-redlines'),
-    `security-redlines is the clear shared case; saw ${JSON.stringify(shared)}`)
+  assert.ok(shared.includes('project:shared-rule'),
+    `the shared project rule is one reference; saw ${JSON.stringify(shared)}`)
 })
 
 test('batch3: legacy stage-level rules stay in force and are named as unassigned', async () => {
@@ -337,16 +339,17 @@ test('batch3: legacy stage-level rules stay in force and are named as unassigned
   // invent an answer the config never had; dropping them would lose a constraint.
   const f = fixture('standard', '开发', {}, {})
   const state = f.state()
-  state.flow.config.stage_bindings = { 开发: { skills: [], legacy_rules: ['security-redlines'] } }
+  state.flow.config.stage_bindings = { 开发: { skills: [], legacy_rules: ['shared-rule'] } }
+  f.records.set(join(f.cwd, '.dsh/rules/shared-rule.md'), '# shared legacy rule')
   f.records.set(join(f.cwd, '.dsh/task-LIVE-1.json'), JSON.stringify(state))
   const status = JSON.parse(await f.call({ operation: 'status' }))
   assert.ok(
-    (status.unassigned_legacy_rules ?? []).includes('security-redlines'),
+    (status.unassigned_legacy_rules ?? []).includes('shared-rule'),
     `the legacy rule must be reported as unassigned; saw ${JSON.stringify(status.unassigned_legacy_rules)}`,
   )
   // Still enforced: it resolves and appears among the rules in force.
   assert.ok(
-    (status.rules ?? []).some(rule => rule.name === 'security-redlines'),
+    (status.rules ?? []).some(rule => rule.name === 'shared-rule'),
     `a legacy rule must keep applying; saw ${JSON.stringify(status.rules)}`,
   )
 })
@@ -420,4 +423,4 @@ test('P2: an unknown review_depth is a configuration error, not a silent downgra
   const problems = validateWorkflow(config)
   assert.ok(problems.some(p => /review_depth/u.test(p)),
     `a typo must be reported; saw ${JSON.stringify(problems)}`)
-})
+})

package/.codex-project-test.mjs

@@ -0,0 +1,80 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtempSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { dirname, join, resolve, sep } from 'node:path'
+import Controller from './lib/controller.js'
+import { registerDevTask } from './lib/dev-task.js'
+import { loadedSkills, skillBlockers } from './lib/skill-audit.js'
+import { resolveFlow } from './lib/workflows.js'
+import { validateWorkflow } from './lib/engine.js'
+
+function fixture(t) {
+  const root = mkdtempSync(join(tmpdir(), 'dsh-codex-project-'))
+  assert.ok(resolve(root).startsWith(resolve(tmpdir()) + sep))
+  t.after(() => rmSync(root, { recursive: true, force: true }))
+  return root
+}
+function put(path, body) {
+  mkdirSync(dirname(path), { recursive: true })
+  writeFileSync(path, body)
+}
+function diskFs() {
+  return {
+    resolve: async (path, options) => resolve(options?.cwd ?? '', path),
+    readText: async path => { try { return readFileSync(path, 'utf8') } catch { return undefined } },
+    lstat: async (path, options) => { try { return { version: String(statSync(resolve(options?.cwd ?? '', path)).mtimeMs) } } catch { return undefined } },
+    writeText: async (path, body) => put(path, body),
+    listDir: async path => readdirSync(path, { withFileTypes: true }).map(entry => ({ name: entry.name })),
+  }
+}
+
+test('Codex project Skills are discovered separately; new DSH Skills stay in .dsh', async t => {
+  const root = fixture(t)
+  const body = '---\nname: same\ndescription: Codex method\n---\nCodex body v1\n'
+  put(join(root, '.agents/skills/same/SKILL.md'), body)
+  put(join(root, '.dsh/skills/same/SKILL.md'), '---\nname: same\ndescription: DSH method\n---\nDSH body\n')
+  const receiver = { authorizedPath: async path => path }
+  const catalog = await Controller.prototype.listSkills.call(receiver, root)
+  assert.deepEqual(catalog.skills.filter(skill => skill.name === 'same').map(skill => skill.ref.source).sort(), ['codex-project', 'project'])
+  const read = await Controller.prototype.readSkill.call(receiver, { level: 'codex-project', name: 'same', path: root })
+  assert.equal(read.content, 'Codex body v1')
+  const created = await Controller.prototype.writeSkill.call(receiver, { level: 'project', name: 'new-one', description: 'New DSH method', whenToUse: '', content: 'body', path: root })
+  assert.equal(created.ok, true)
+  assert.equal(readFileSync(join(root, '.dsh/skills/new-one/SKILL.md'), 'utf8').includes('body'), true)
+})
+
+test('a bound Codex Skill loads its attached DSH Rule and reads edits next time', async t => {
+  const root = fixture(t)
+  const skillFile = join(root, '.agents/skills/sample/SKILL.md')
+  const ruleFile = join(root, '.dsh/rules/shared.md')
+  put(skillFile, '---\nname: sample\ndescription: Sample\n---\nSkill v1\n')
+  put(ruleFile, 'Rule v1')
+  const ref = { source: 'codex-project', name: 'sample' }
+  const rule = { source: 'project', name: 'shared' }
+  const project = { flow: 'minimal', stage_bindings: { '开发': { skill_refs: [ref] } }, skill_profiles: { 'codex-project:sample': { rules: [rule], evidence: 'none' } } }
+  put(join(root, '.dsh/eng.json'), JSON.stringify(project))
+  assert.deepEqual(validateWorkflow(resolveFlow('minimal', project).config), [])
+  const fs = diskFs(), tools = []
+  registerDevTask({ fs, tools: { register(tool) { tools.push(tool) } }, get() { return undefined } })
+  const execute = tools[0].execute
+  const events = []
+  const session = { id: 'test-session', header: { cwd: root }, snapshotEvents: () => events }
+  const run = (args, callId = 'call') => execute(args, { agent: { session }, callId, signal: undefined })
+  await run({ operation: 'create', task_id: 'T1', title: 'Test', branch: 'main' })
+  const first = await run({ operation: 'load_skill', task_id: 'T1', skill_name: 'codex-project:sample' }, 'load-1')
+  assert.match(first, /Skill v1/)
+  assert.match(first, /Rule v1/)
+  events.push({ type: 'tool/call', data: { name: 'dev_task', callId: 'load-1', arguments: JSON.stringify({ operation: 'load_skill', task_id: 'T1', skill_name: 'codex-project:sample' }) } })
+  events.push({ type: 'tool/result', data: { message: { content: [{ type: 'tool-result', toolCallId: 'load-1', isError: false }] } } })
+  assert.equal(loadedSkills(session).get('T1#codex-project:sample'), 'load-1')
+  const state = JSON.parse(readFileSync(join(root, '.dsh/task-T1.json'), 'utf8'))
+  assert.deepEqual(skillBlockers(state, state.flow.config, session), [])
+  assert.match(skillBlockers({ ...state, id: 'T2' }, state.flow.config, session).join('; '), /load_skill/,
+    'loading a Skill for one task must not satisfy another task with a different Rule profile')
+  put(skillFile, '---\nname: sample\ndescription: Sample\n---\nSkill v2\n')
+  put(ruleFile, 'Rule v2')
+  const second = await run({ operation: 'load_skill', task_id: 'T1', skill_name: 'codex-project:sample' }, 'load-2')
+  assert.match(second, /Skill v2/)
+  assert.match(second, /Rule v2/)
+})

package/.enforce-test.mjs

@@ -15,14 +15,13 @@ import { completionBlockers, terminalRequirements, resourceBlockers } from './li
 async function project() {
   const cwd = resolve('enforce-project')
   const adopted = adoptRecommendation('standard')
-  const skills = adopted.stage_bindings['开发'].skills.map(entry => ({
-    ...entry,
-    rules: [...entry.rules, { source: 'project', name: 'mine' }],
-  }))
+  const skills = [{ skill: { source: 'project', name: 'my-implementation' },
+    rules: [{ source: 'project', name: 'mine' }], evidence: 'none' }]
   const stage_bindings = { ...adopted.stage_bindings, '开发': { skills } }
   const records = new Map([
     [join(cwd, '.dsh/eng.json'), JSON.stringify({ ...adopted, stage_bindings })],
     [join(cwd, '.dsh/rules/mine.md'), 'RULE'],
+    [join(cwd, '.dsh/skills/my-implementation/SKILL.md'), '---\nname: my-implementation\n---\nImplement.'],
     [join(cwd, 'a.js'), 'source'],
   ])
   const events = []
@@ -86,13 +85,13 @@ test('enforce: a task WITHOUT a snapshot cannot advance while a bound rule is un
   )
 })
 
-test('enforce: a task WITH a snapshot blocks when its live source rule is deleted', async () => {
-  const f = await project()
-  await satistfyDevelopment(f)
-  f.records.delete(f.rule())
-  await assert.rejects(() => f.call({ operation: 'advance', target_stage: '交付' }), /resolves nowhere/u)
-  assert.equal(f.current().stage, '开发')
-})
+test('enforce: a task WITH a snapshot blocks when its live source rule is deleted', async () => {
+  const f = await project()
+  await satistfyDevelopment(f)
+  f.records.delete(f.rule())
+  await assert.rejects(() => f.call({ operation: 'advance', target_stage: '交付' }), /resolves nowhere/u)
+  assert.equal(f.current().stage, '开发')
+})
 
 test('enforce: completion requires the review and verification the flow declared', async () => {
   // Arriving at the last stage used to be enough. The agile flow declares a review
@@ -132,4 +131,4 @@ test('enforce: the resource blocker names the stage, the reference and the fix',
   assert.match(blockers[0], /Restore the file|remove the binding/u,
     'a blocker must say what to do, not only what is wrong')
   assert.deepEqual(resourceBlockers([], '开发'), [], 'a resolvable stage has no blocker')
-})
+})

package/.evidence-test.mjs

@@ -24,7 +24,7 @@ function sessionWith(names) {
 /** A standard-flow config with one extra skill on 开发 carrying the given evidence. */
 function withEvidence(evidence) {
   const adopted = adoptRecommendation('standard')
-  const skills = [...adopted.stage_bindings['开发'].skills, { skill: { source: 'project', name: 'doc-skill' }, rules: [], ...(evidence !== undefined ? { evidence } : {}) }]
+  const skills = [{ skill: { source: 'project', name: 'doc-skill' }, rules: [], ...(evidence !== undefined ? { evidence } : {}) }]
   return resolveFlow('standard', { ...adopted, stage_bindings: { ...adopted.stage_bindings, '开发': { skills } } }).config
 }
 
@@ -42,8 +42,8 @@ function state(extra = {}) {
 }
 
 test('evidence: needsSkillReceipt honours a declared non-command kind', () => {
-  // Core skills keep their exemption; a declared kind overrides the default.
-  assert.equal(needsSkillReceipt('code-implement'), false, 'a core skill owes no separate receipt')
+  // No name-based exemption remains; a declared kind overrides the default.
+  assert.equal(needsSkillReceipt('code-implement'), true, 'skill names do not exempt command evidence')
   assert.equal(needsSkillReceipt('doc-skill'), true, 'an undeclared extra skill defaults to a command receipt')
   assert.equal(needsSkillReceipt('doc-skill', 'command'), true)
   assert.equal(needsSkillReceipt('doc-skill', 'artifact'), false)
@@ -56,8 +56,8 @@ test('evidence: a document-producing skill is satisfied by a recorded artifact',
   // The blocker is the point: without an artifact it blocks, and with one it does
   // not — so the declared kind is genuinely enforced rather than merely accepted.
   //
-  // Mounted on 设计, which the adopted setup declares an artifact for. Missing
-  // declarations and incomplete fields must both remain blockers.
+  // Mounted on 设计, which the adopted setup declares an artifact for. Missing
+  // declarations and incomplete fields must both remain blockers.
   const adopted = adoptRecommendation('standard')
   const config = resolveFlow('standard', {
     ...adopted,
@@ -78,7 +78,7 @@ test('evidence: a document-producing skill is satisfied by a recorded artifact',
   // Record what the stage declares and the blocker clears.
   const declared = config.artifacts.find(artifact => artifact.stage === '设计')
   assert.ok(declared !== undefined, 'the standard flow declares an artifact at 设计')
-  const cleared = skillBlockers(atDesign({ artifacts: { [declared.id]: Object.fromEntries(declared.fields.map(field => [field, 'checked'])) } }), config, session)
+  const cleared = skillBlockers(atDesign({ artifacts: { [declared.id]: Object.fromEntries(declared.fields.map(field => [field, 'checked'])) } }), config, session)
   assert.deepEqual(cleared.filter(b => b.includes('doc-skill')), [],
     'a recorded artifact satisfies artifact evidence')
 })
@@ -98,7 +98,7 @@ test('evidence: manual evidence needs an explicit statement, none needs nothing'
   const session = sessionWith(['code-implement', 'doc-skill'])
   assert.ok(skillBlockers(state(), manual, session).some(b => b.includes('manual evidence')),
     'manual evidence is absent until something is recorded')
-  const recorded = state({ skill_results: { '开发': { 'doc-skill': { evidence: ['reviewed by the lead'], approved: true } } } })
+  const recorded = state({ skill_results: { '开发': { 'doc-skill': { evidence: ['reviewed by the lead'], approved: true } } } })
   assert.deepEqual(skillBlockers(recorded, manual, session).filter(b => b.includes('doc-skill')), [],
     'a recorded statement satisfies manual evidence')
 
@@ -115,4 +115,4 @@ test('evidence: an undeclared extra skill still owes a command receipt', () => {
   const blockers = skillBlockers(state(), config, session)
   assert.ok(blockers.some(b => b.includes('validation command')),
     `an undeclared skill must still owe a command receipt; got ${JSON.stringify(blockers)}`)
-})
+})

package/.filter-test.mjs

@@ -83,11 +83,9 @@ test('filter: only-selected combined with a query still keeps what is in force',
   assert.ok(!shown.some(e => e.name === 'code-implement'), 'an unbound non-matching skill is dropped')
 })
 
-test('filter: the shipped catalog is small enough that the default view shows it all', () => {
-  // Sanity: the initial view of a fresh project is the shipped set, unfiltered.
+test('filter: a fresh project has no prebound business skill', () => {
   const adopted = adoptRecommendation('standard')
   const resolved = resolveFlow('standard', adopted).config
   const binding = bindingsForStage('开发', resolved)
-  assert.ok(binding !== undefined, 'the adopted config binds 开发')
-  assert.ok((binding.skills ?? []).length > 0)
-})
+  assert.equal(binding, undefined)
+})

package/.freeze-test.mjs

@@ -15,11 +15,21 @@ 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([
     // 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(adoptRecommendation(flow))],
+    [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 = []
@@ -75,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 () => {
-  // security-redlines is referenced by two skills; the body must not be copied twice.
+  // 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 === 'security-redlines'),
+  assert.ok(resources.some(r => r.ref.name === 'shared-rule'),
     'the shared rule must be present')
 })
 
@@ -103,14 +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 = adopted.stage_bindings['开发'].skills.map(entry => ({
-    ...entry,
-    rules: [...entry.rules, { source: 'project', name: 'mine' }],
-  }))
+  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, 'a.js'), 'source'],
   ])
   let execute
@@ -150,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
@@ -191,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/.p0-test.mjs

@@ -152,20 +152,20 @@ assert(emptied.ok && (emptied.config.stage_bindings['开发'].skills ?? []).leng
   'a project that binds nothing to a stage keeps it empty; nothing is merged back in')
 
 const adopted = adoptedFlow('standard')
-assert(adopted.stage_bindings['开发'].skills.some(entry => entry.skill.name === 'code-implement'),
-  'adopting the recommendation is what supplies the shipped skills')
+assert(Object.keys(adopted.stage_bindings ?? {}).length === 0,
+  'adopting the recommendation does not supply skills')
 
-// And a user who gives a shipped 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: 'bundled', name: 'code-implement' }, 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 === 'code-implement')
+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 shipped 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,8 +267,6 @@ 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 bundled = readFileSync('./rules/security-redlines.md', 'utf8')
-  assert(bundled.includes('服务端'), 'bundled security-redlines exists as expected')
   const fs = makeFs({
     // A project file with the same NAME but a different body. Under the old
     // bare-name lookup this would have replaced the bundled rule silently.
@@ -276,12 +274,13 @@ await assertThrows(
       flow: 'standard',
       stage_bindings: {
         '需求评审': { skills: [{
-          skill: { source: 'bundled', 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',
   })
   const exe = await registered(fs)
   await exe({ operation: 'create', task_id: 'T9', title: 'x', branch: 'main' }, EXEC)
@@ -292,26 +291,24 @@ await assertThrows(
   assert(sec.content.includes('前端校验即可'), 'the PROJECT body is what gets disclosed, because the reference names the project layer')
 }
 
-// ── 11b. a bundled reference keeps resolving the bundled body ───────────────
+// ── 11b. a deleted bundled rule is reported as missing ───────────────────────
 {
   const fs = makeFs({
     '.dsh/eng.json': JSON.stringify({
       flow: 'standard',
       stage_bindings: {
         '需求评审': { skills: [{
-          skill: { source: 'bundled', 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',
   })
   const exe = await registered(fs)
-  await exe({ operation: 'create', task_id: 'T10', title: 'x', branch: 'main' }, EXEC)
-  const status = JSON.parse(await exe({ operation: 'status', task_id: 'T10' }, EXEC))
-  const sec = status.bindings.rules.find(r => r.name === 'security-redlines')
-  assert(sec !== undefined && sec.source === 'bundled', 'a bundled reference resolves to the bundled layer')
-  assert(sec.content.includes('服务端'), 'the bundled body is used, untouched by the same-named project file')
+  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) ──────────
@@ -602,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 shows no bindings drift')
+  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(typeof record.bindings_fingerprint === 'string' && record.bindings_fingerprint.length === 64,
-    'create records the bundled-rules fingerprint')
+  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)
+})