@godv61/dsh-task-engine 0.27.1 → 0.29.0

package/.acceptance.mjs

@@ -42,14 +42,14 @@ check('选流程不产生绑定', Object.keys(resolveFlow('standard', { flow: 's
 
 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)
-  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 !== '')
+for (const id of ['standard', 'agile', 'minimal']) {
+  const adopted = adoptRecommendation(id)
+  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, {
@@ -106,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('')
@@ -153,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/.adaptive-test.mjs

@@ -0,0 +1,189 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { join, resolve } from 'node:path'
+import { mkdtempSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { adaptiveWorkflow, COMPLEXITY_OPTIONS } from './lib/adaptive.js'
+import { validateWorkflow } from './lib/engine.js'
+import { registerDevTask } from './lib/dev-task.js'
+import { inspectSonar } from './lib/sonar.js'
+import Controller from './lib/controller.js'
+
+const home = mkdtempSync(join(tmpdir(), 'dsh-adaptive-'))
+process.env.DSH_HOME = home
+process.on('exit', () => rmSync(home, { recursive: true, force: true }))
+
+function fixture(extra = {}) {
+  const cwd = resolve('adaptive-project')
+  const files = new Map([[join(cwd, 'package.json'), '{"name":"adaptive-project","dependencies":{"vue":"^2.7.0"}}'],
+    [join(cwd, '.git/HEAD'), 'ref: refs/heads/feature'] , ...Object.entries(extra).map(([p, content]) => [join(cwd, p), content])])
+  const events = []
+  const session = { id: 'adaptive', header: { cwd }, snapshotEvents: () => events }
+  const key = (path, options) => join(options?.cwd ?? cwd, path)
+  let execute
+  const fs = {
+    resolve: async (path, options) => ({ path: key(path, options) }),
+    readText: async target => files.get(target.path),
+    lstat: async (path, options) => files.has(key(path, options)) ? { version: 'v1' } : undefined,
+    writeText: async (target, content, intent) => {
+      if (intent?.kind === 'createIfAbsent' && files.has(target.path)) throw new Error('already exists')
+      files.set(target.path, content)
+    },
+    listDir: async target => [...new Set([...files.keys()].filter(path => path.startsWith(target.path + '\\'))
+      .map(path => path.slice(target.path.length + 1).split('\\')[0]))].map(name => ({ name })),
+  }
+  const ctx = { fs, tools: { register(tool) { execute = tool.execute; return () => {} } }, get(name) {
+    if (name === 'sandboxPolicy') return { resolve: () => ({ mode: 'workspace-write', workspaceRoot: cwd, sessionId: session.id }) }
+    return undefined
+  } }
+  registerDevTask(ctx)
+  const exec = { agent: { session }, signal: new AbortController().signal }
+  return { cwd, files, fs, events, call: args => execute(args, exec), state: id => JSON.parse(files.get(join(cwd, `.dsh/task-${id}.json`))) }
+}
+
+test('each task grade has a valid and increasing meta-skill sequence', () => {
+  assert.deepEqual(COMPLEXITY_OPTIONS.map(option => option.id), ['low', 'medium', 'high', 'ultra'])
+  const configs = COMPLEXITY_OPTIONS.map(option => adaptiveWorkflow(option.id))
+  for (const config of configs) assert.deepEqual(validateWorkflow(config), [])
+  assert.deepEqual(configs.map(config => config.stages.length), [4, 5, 6, 7])
+  assert.ok(configs[2].stages.includes('任务编排'))
+  assert.ok(configs[3].stages.includes('架构设计'))
+  assert.ok(configs.every(config => config.transitions.some(edge => edge.requires?.includes('verified'))))
+  assert.ok(configs.every(config => config.commit.checkpoints.includes('测试')))
+})
+
+test('adaptive task freezes a project override and its own Rules, not the bundled same-name Skill', async () => {
+  const f = fixture({
+    '.dsh/skills/requirements-analysis/SKILL.md': '# Project requirement method',
+    '.dsh/skills/requirements-analysis/profile.json': JSON.stringify({ rules: [{ source: 'project', name: 'team-scope' }], evidence: 'artifact' }),
+    '.dsh/rules/team-scope.md': '# Team scope rule',
+    '.dsh/meta.json': JSON.stringify({ meta_bindings: { 'code-development': ['adaptive-project-project-map'] } }),
+    '.dsh/skills/adaptive-project-project-map/SKILL.md': '# Project map',
+    '.dsh/skills/adaptive-project-project-map/profile.json': JSON.stringify({ rules: [], evidence: 'none' }),
+  })
+  const preview = JSON.parse(await f.call({ operation: 'assess', complexity: 'high' }))
+  assert.equal(preview.meta_skills['需求分析'][0].effective_source, 'project')
+  assert.ok(preview.meta_skills['代码开发'].some(skill => skill.logical_name === 'adaptive-project-project-map'))
+  await f.call({ operation: 'create', task_id: 'A-1', title: 'cross-module change', branch: 'feature',
+    complexity: 'high', complexity_reason: 'Several implementation steps depend on earlier interfaces', files: ['app.js'] })
+  const state = f.state('A-1')
+  assert.equal(state.flow.flow, 'adaptive-high')
+  assert.equal(state.flow.config.stage_bindings['需求分析'].skills[0].skill.source, 'project')
+  assert.ok(state.flow.resources.some(entry => entry.ref.name === 'team-scope' && entry.ref.source === 'project'))
+  assert.match(await f.call({ operation: 'load_skill', task_id: 'A-1', skill_name: 'project:requirements-analysis' }), /Project requirement method/)
+  await assert.rejects(f.call({ operation: 'load_skill', task_id: 'A-1', skill_name: 'bundled:requirements-analysis' }), /exact source:name/)
+})
+
+test('init_project proposes project-specific Skills and binds reviewed resources', async () => {
+  const f = fixture()
+  const inventory = JSON.parse(await f.call({ operation: 'init_project', phase: 'inspect' }))
+  assert.ok(inventory.suggestions.some(entry => entry.name === 'adaptive-project-project-map'))
+  assert.ok(inventory.manifests.some(entry => entry.facts.includes('vue=^2.7.0')))
+  const resources = [
+    { kind: 'rule', name: 'component-boundary', content: 'Keep component boundary calls behind the existing service interface.' },
+    { kind: 'skill', name: 'adaptive-project-project-map', description: 'Project structure and entry points',
+      content: 'The root package.json declares Vue 2.7; inspect src for the actual component layout.',
+      meta_skills: ['requirements-analysis', 'code-development'], rules: ['component-boundary'] },
+  ]
+  const proposed = JSON.parse(await f.call({ operation: 'init_project', phase: 'propose', resources }))
+  assert.equal(f.files.has(join(f.cwd, '.dsh/meta.json')), false)
+  await f.call({ operation: 'init_project', phase: 'apply', resources, expected_hash: proposed.expected_hash,
+    existing_hash: proposed.existing_hash })
+  const meta = JSON.parse(f.files.get(join(f.cwd, '.dsh/meta.json')))
+  assert.deepEqual(meta.meta_bindings['code-development'], ['adaptive-project-project-map'])
+  assert.ok(f.files.has(join(f.cwd, '.dsh/skills/adaptive-project-project-map/profile.json')))
+})
+
+test('workbench adaptive settings persist meta bindings with a version check', async () => {
+  const f = fixture()
+  const receiver = { authorizedPath: async path => path, fs: () => f.fs,
+    listSkills: async () => ({ skills: [{ name: 'adaptive-project-project-map', source: 'project' }] }),
+    readAdaptive: Controller.prototype.readAdaptive }
+  const before = await Controller.prototype.readAdaptive.call(receiver, f.cwd)
+  assert.equal(before.source, 'default')
+  const config = { meta_bindings: { 'code-development': ['adaptive-project-project-map'] }, sonar: { enabled: false } }
+  const after = await Controller.prototype.writeAdaptive.call(receiver,
+    { path: f.cwd, config, expected_hash: before.hash })
+  assert.equal(after.ok, true)
+  assert.deepEqual(after.config.meta_bindings['code-development'], ['adaptive-project-project-map'])
+  await assert.rejects(Controller.prototype.writeAdaptive.call(receiver,
+    { path: f.cwd, config, expected_hash: before.hash }), /已被其他会话修改/)
+})
+
+test('Sonar audit reads the exact CI analysis gate and filters new-code medium/high findings', async () => {
+  const calls = []
+  const fetcher = async (url, options) => {
+    calls.push({ url: String(url), authorization: options.headers.Authorization })
+    const body = String(url).includes('/ce/task')
+      ? { task: { status: 'SUCCESS', analysisId: 'AN-1', componentKey: 'project' } }
+      : String(url).includes('/qualitygates/project_status')
+        ? { projectStatus: { status: 'ERROR' } }
+        : { paging: { total: 2 }, issues: [
+          { key: 'ISSUE-1', rule: 'java:S111', message: 'problem', severity: 'MAJOR', component: 'project:src/A.java', line: 3 },
+          { key: 'ISSUE-2', rule: 'java:S222', message: 'minor', severity: 'MINOR', component: 'project:src/B.java' },
+        ] }
+    return { ok: true, json: async () => body }
+  }
+  const policy = { enabled: true, host_url: 'https://sonar.example', project_key: 'project', mode: 'branch', token_env: 'SONAR_TOKEN' }
+  const audit = await inspectSonar(policy, 'secret-token', 'CE-TASK-123', 'feature', 'scope-hash', fetcher)
+  assert.equal(audit.analysis_id, 'AN-1')
+  assert.equal(audit.gate, 'ERROR')
+  assert.deepEqual(audit.blocking.map(issue => issue.key), ['ISSUE-1'])
+  assert.ok(calls[2].url.includes('inNewCodePeriod=true'))
+  assert.ok(calls.every(call => call.authorization === 'Bearer secret-token'))
+  assert.equal(JSON.stringify(audit).includes('secret-token'), false)
+})
+
+test('review-only Sonar gate blocks pass until the task records a passing CI analysis', async () => {
+  const f = fixture({ '.dsh/meta.json': JSON.stringify({ sonar: { enabled: true, host_url: 'https://sonar.example',
+    project_key: 'project', mode: 'branch', token_env: 'SONAR_TOKEN' } }) })
+  await f.call({ operation: 'create', task_id: 'S-1', title: 'change', branch: 'feature', complexity: 'low',
+    complexity_reason: 'One local change', files: ['app.js'], items: [{ id: 'one', title: 'change', status: 'done' }] })
+  const state = f.state('S-1')
+  state.stage = '代码审核'
+  state.verification = { passed: true, evidence: ['verified'] }
+  state.commits = [{ label: 'TASK', hash: 'abcdef1234567890' }]
+  f.files.set(join(f.cwd, '.dsh/task-S-1.json'), JSON.stringify(state))
+  await assert.rejects(f.call({ operation: 'review', task_id: 'S-1', outcome: 'pass' }), /SonarQube audit is enabled/)
+  const oldFetch = globalThis.fetch
+  const oldToken = process.env.SONAR_TOKEN
+  process.env.SONAR_TOKEN = 'secret-token'
+  globalThis.fetch = async url => ({ ok: true, json: async () => String(url).includes('/ce/task')
+    ? { task: { status: 'SUCCESS', analysisId: 'AN-2', componentKey: 'project' } }
+    : String(url).includes('/qualitygates/project_status') ? { projectStatus: { status: 'OK' } }
+      : { paging: { total: 0 }, issues: [] } })
+  try {
+    await f.call({ operation: 'sonar_check', task_id: 'S-1', ce_task_id: 'CE-123456' })
+    await f.call({ operation: 'review', task_id: 'S-1', outcome: 'pass' })
+    assert.equal(f.state('S-1').review.outcome, 'pass')
+  } finally {
+    globalThis.fetch = oldFetch
+    if (oldToken === undefined) delete process.env.SONAR_TOKEN
+    else process.env.SONAR_TOKEN = oldToken
+  }
+})
+
+test('a failed Sonar finding becomes a reviewed project Rule attached to the coding Skill', async () => {
+  const f = fixture()
+  await f.call({ operation: 'create', task_id: 'L-1', title: 'change', branch: 'feature', complexity: 'low',
+    complexity_reason: 'One local change', files: ['app.js'] })
+  const state = f.state('L-1')
+  const finding = { key: 'ISSUE-9', rule: 'java:S999', message: 'Handle null', severity: 'MAJOR', file: 'A.java' }
+  state.stage = '代码审核'
+  state.sonar_audit = { ce_task_id: 'CE-123456', analysis_id: 'AN-9', gate: 'ERROR', checked_at: 'now',
+    scope_hash: 'old', findings: [finding], blocking: [finding], target: 'feature' }
+  f.files.set(join(f.cwd, '.dsh/task-L-1.json'), JSON.stringify(state))
+  await f.call({ operation: 'revise', task_id: 'L-1', target_stage: '代码开发',
+    revision_kind: 'defect', revision_reason: 'Fix the SonarQube issue' })
+  assert.equal(f.state('L-1').sonar_history[0].blocking[0].key, 'ISSUE-9')
+  const args = { operation: 'learn_rule', task_id: 'L-1', issue_key: 'ISSUE-9', skill_name: 'bundled:code-development',
+    rule_name: 'handle-null-boundary', learning_reason: 'This boundary appears in several service methods',
+    content: 'At a service boundary, check for null before dereferencing. Show the failing call and a guarded call in the review example.' }
+  const proposal = JSON.parse(await f.call({ ...args, phase: 'propose' }))
+  assert.equal(f.files.has(join(f.cwd, '.dsh/rules/handle-null-boundary.md')), false)
+  await f.call({ ...args, phase: 'apply', expected_hash: proposal.expected_hash })
+  assert.match(f.files.get(join(f.cwd, '.dsh/rules/handle-null-boundary.md')), /java:S999/)
+  assert.ok(f.files.has(join(f.cwd, '.dsh/skills/code-development/SKILL.md')))
+  assert.deepEqual(JSON.parse(f.files.get(join(f.cwd, '.dsh/skills/code-development/profile.json'))).rules,
+    [{ source: 'project', name: 'handle-null-boundary' }])
+})

package/.assessment-batch1.mjs

@@ -320,18 +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 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 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('project:shared-rule'),
-    `the shared project rule is one reference; 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 () => {
@@ -339,17 +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: ['shared-rule'] } }
-  f.records.set(join(f.cwd, '.dsh/rules/shared-rule.md'), '# shared legacy rule')
+  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('shared-rule'),
+    (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 === 'shared-rule'),
+    (status.rules ?? []).some(rule => rule.name === 'shared-rule'),
     `a legacy rule must keep applying; saw ${JSON.stringify(status.rules)}`,
   )
 })
@@ -423,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

@@ -1,80 +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/)
-})
+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,13 +15,13 @@ import { completionBlockers, terminalRequirements, resourceBlockers } from './li
 async function project() {
   const cwd = resolve('enforce-project')
   const adopted = adoptRecommendation('standard')
-  const skills = [{ skill: { source: 'project', name: 'my-implementation' },
-    rules: [{ source: 'project', name: 'mine' }], evidence: 'none' }]
+  const skills = [{ skill: { source: 'project', name: 'my-implementation' },
+    rules: [{ source: 'project', name: 'mine' }], evidence: 'none' }]
   const 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, '.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 = []
@@ -85,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
@@ -131,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 = [{ 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', () => {
-  // No name-based exemption remains; a declared kind overrides the default.
-  assert.equal(needsSkillReceipt('code-implement'), true, 'skill names do not exempt command evidence')
+  // 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,9 +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: a fresh project has no prebound business skill', () => {
-  const adopted = adoptRecommendation('standard')
-  const resolved = resolveFlow('standard', adopted).config
-  const binding = bindingsForStage('开发', resolved)
-  assert.equal(binding, undefined)
-})
+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.equal(binding, undefined)
+})