@godv61/dsh-task-engine 0.24.0 → 0.25.0

package/.evidence-test.mjs

@@ -0,0 +1,119 @@
+/**
+ * Evidence kinds: a skill is judged against the proof it actually declares.
+ *
+ * Demanding a "real validation command" from every non-core skill forced an
+ * irrelevant command from a requirement or design skill, whose output is a
+ * document. The evidence existed — in another form.
+ */
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { needsSkillReceipt, skillBlockers } from './lib/skill-audit.js'
+import { adoptRecommendation, resolveFlow } from './lib/workflows.js'
+
+/** A session that has loaded the named skills. */
+function sessionWith(names) {
+  const events = []
+  for (const name of names) {
+    const callId = 'c' + events.length
+    events.push({ type: 'tool/call', data: { name: 'skill', callId, arguments: JSON.stringify({ name }) } })
+    events.push({ type: 'tool/result', data: { message: { content: [{ type: 'tool-result', toolCallId: callId, isError: false }] } } })
+  }
+  return { id: 's', snapshotEvents: () => events }
+}
+
+/** 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 } : {}) }]
+  return resolveFlow('standard', { ...adopted, stage_bindings: { ...adopted.stage_bindings, '开发': { skills } } }).config
+}
+
+/** A task at 开发 with everything else satisfied. */
+function state(extra = {}) {
+  return {
+    schema: 1, id: 'E-1', title: 't', branch: 'main', work_size: 'standard', risk_level: 'standard',
+    stage: '开发', execution_version: 1,
+    requirement_confirmed: true, solution_confirmed: true,
+    items: [], artifacts: {}, files: [], commits: [],
+    verification: { passed: false, evidence: [] },
+    review: { outcome: 'pending' },
+    ...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')
+  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)
+  assert.equal(needsSkillReceipt('doc-skill', 'review'), false)
+  assert.equal(needsSkillReceipt('doc-skill', 'manual'), false)
+  assert.equal(needsSkillReceipt('doc-skill', 'none'), false)
+})
+
+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 standard flow declares an artifact for. A stage with
+  // no declared artifact has nothing to satisfy artifact evidence against, and the
+  // audit deliberately stays silent there rather than inventing a requirement.
+  const adopted = adoptRecommendation('standard')
+  const config = resolveFlow('standard', {
+    ...adopted,
+    stage_bindings: {
+      ...adopted.stage_bindings,
+      '设计': { skills: [{ skill: { source: 'project', name: 'doc-skill' }, rules: [], evidence: 'artifact' }] },
+    },
+  }).config
+  const session = sessionWith(['doc-skill'])
+  const atDesign = extra => ({ ...state({ stage: '设计', ...extra }) })
+
+  const missing = skillBlockers(atDesign(), config, session)
+  assert.ok(missing.some(b => b.includes('artifact evidence')),
+    `an artifact-evidence skill must ask for an artifact; got ${JSON.stringify(missing)}`)
+  assert.ok(!missing.some(b => b.includes('validation command')),
+    'it must NOT ask for a shell command')
+
+  // 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]: { fields: { approach: 'x' } } } }), config, session)
+  assert.deepEqual(cleared.filter(b => b.includes('doc-skill')), [],
+    'a recorded artifact satisfies artifact evidence')
+})
+
+test('evidence: a judging skill is satisfied by a passing review', () => {
+  const config = withEvidence('review')
+  const session = sessionWith(['code-implement', 'doc-skill'])
+  assert.ok(skillBlockers(state(), config, session).some(b => b.includes('review evidence')),
+    'no review recorded means the review evidence is absent')
+  assert.deepEqual(
+    skillBlockers(state({ review: { outcome: 'pass' } }), config, session).filter(b => b.includes('doc-skill')), [],
+    'a passing review satisfies it')
+})
+
+test('evidence: manual evidence needs an explicit statement, none needs nothing', () => {
+  const manual = withEvidence('manual')
+  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'] } } } })
+  assert.deepEqual(skillBlockers(recorded, manual, session).filter(b => b.includes('doc-skill')), [],
+    'a recorded statement satisfies manual evidence')
+
+  const none = withEvidence('none')
+  assert.deepEqual(skillBlockers(state(), none, session).filter(b => b.includes('doc-skill')), [],
+    'an advisory skill needs no proof beyond being loaded')
+})
+
+test('evidence: an undeclared extra skill still owes a command receipt', () => {
+  // The historical behaviour must survive: a config that says nothing keeps getting
+  // the command requirement, so existing setups are unaffected.
+  const config = withEvidence(undefined)
+  const session = sessionWith(['code-implement', 'doc-skill'])
+  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

@@ -0,0 +1,93 @@
+/**
+ * Catalog filtering: search and filters must narrow the list without ever hiding
+ * something that is currently in force.
+ *
+ * The panel shows the configuration; a filter that hid a bound skill would make the
+ * panel disagree with the config it is displaying, which is worse than a long list.
+ */
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { bindingsForStage, formatResourceRef } from './lib/engine.js'
+import { adoptRecommendation, resolveFlow } from './lib/workflows.js'
+
+/**
+ * The filter the panel applies, lifted so it can be tested without a DOM.
+ *
+ * Mirrors `visibleSkills` in TaskEngineSection: an entry that is bound or shipped
+ * always matches; otherwise the query must appear in its name, description or layer.
+ */
+function visibleSkills(catalog, binding, presetSkills, query, onlySelected) {
+  const boundKeys = new Set((binding?.skills ?? []).map(entry => formatResourceRef(entry.skill)))
+  const presetKeys = new Set(presetSkills.map(entry => formatResourceRef(entry.skill)))
+  const needle = query.trim().toLowerCase()
+  return catalog.filter(entry => {
+    const raw = formatResourceRef(entry.ref)
+    const inForce = boundKeys.has(raw) || presetKeys.has(raw)
+    if (onlySelected && !inForce) return false
+    if (needle === '') return true
+    return inForce
+      || entry.name.toLowerCase().includes(needle)
+      || entry.description.toLowerCase().includes(needle)
+      || entry.sourceLabel.toLowerCase().includes(needle)
+  })
+}
+
+const catalog = [
+  { ref: { source: 'bundled', name: 'code-implement' }, name: 'code-implement', description: '实现', sourceLabel: '内置' },
+  { ref: { source: 'bundled', name: 'code-review' }, name: 'code-review', description: '评审变更', sourceLabel: '内置' },
+  { ref: { source: 'project', name: 'api-audit' }, name: 'api-audit', description: '审计接口契约', sourceLabel: '项目' },
+  { ref: { source: 'user', name: 'doc-writer' }, name: 'doc-writer', description: '写文档', sourceLabel: '用户' },
+]
+const binding = { skills: [{ skill: { source: 'project', name: 'api-audit' }, rules: [] }] }
+
+test('filter: no query shows everything', () => {
+  assert.equal(visibleSkills(catalog, binding, [], '', false).length, 4)
+})
+
+test('filter: the query narrows by name, description and layer', () => {
+  // `api-audit` is bound in this fixture, so it stays visible whatever the query —
+  // that rule is asserted separately, and these expectations include it.
+  const names = (...args) => visibleSkills(...args).map(e => e.name).sort()
+  assert.deepEqual(names(catalog, binding, [], 'writer', false), ['api-audit', 'doc-writer'],
+    'name matches')
+  assert.deepEqual(names(catalog, binding, [], '写文档', false), ['api-audit', 'doc-writer'],
+    'description matches')
+  assert.deepEqual(names(catalog, binding, [], '用户', false), ['api-audit', 'doc-writer'],
+    'the layer label matches, so a user can list one layer')
+  assert.deepEqual(names(catalog, binding, [], '审计', false), ['api-audit'],
+    'a bound skill matching by its own description is shown')
+  assert.deepEqual(names(catalog, binding, [], 'nothing-matches-this', false), ['api-audit'],
+    'a query matching nothing still shows the skill that is in force')
+})
+
+test('filter: a BOUND skill is never hidden by the query', () => {
+  // The panel shows the configuration. A search that hid a skill currently in force
+  // would make the panel disagree with the config it is displaying.
+  const shown = visibleSkills(catalog, binding, [], 'doc', false)
+  assert.ok(shown.some(e => e.name === 'api-audit'),
+    'the bound skill stays visible even though it does not match the query')
+  assert.ok(shown.some(e => e.name === 'doc-writer'), 'and the matching one is shown too')
+})
+
+test('filter: only-selected keeps bound and preset skills, drops the rest', () => {
+  const shown = visibleSkills(catalog, binding, [{ skill: { source: 'bundled', name: 'code-review' } }], '', true)
+  const names = shown.map(e => e.name).sort()
+  assert.deepEqual(names, ['api-audit', 'code-review'],
+    'a bound skill and a preset-shipped one are both in force; the other two are not')
+})
+
+test('filter: only-selected combined with a query still keeps what is in force', () => {
+  const shown = visibleSkills(catalog, binding, [], 'doc', true)
+  assert.ok(shown.some(e => e.name === 'api-audit'),
+    'the filter must not drop a bound skill even when a query is active')
+  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.
+  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)
+})

package/.freeze-test.mjs

@@ -5,6 +5,7 @@
  * running task used silently changed what that task was doing, and deleting one
  * made a configured constraint disappear without the task recording anything.
  */
+import { adoptRecommendation } from './lib/workflows.js'
 import test from 'node:test'
 import assert from 'node:assert/strict'
 import { join, resolve } from 'node:path'
@@ -15,7 +16,10 @@ import { hashText } from './lib/snapshot.js'
 async function created(flow) {
   const cwd = resolve('freeze-project')
   const records = new Map([
-    [join(cwd, '.dsh/eng.json'), JSON.stringify({ flow })],
+    // 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, 'a.js'), 'source'],
   ])
   const events = []
@@ -87,4 +91,109 @@ test('freeze: every preset freezes a complete, non-empty set', async () => {
     assert.ok((state.flow.resources ?? []).length >= 3,
       `${flow} must freeze its resources; saw ${(state.flow.resources ?? []).length}`)
   }
+})
+
+/**
+ * A task carrying one project rule on a skill, parked at the stage that uses it.
+ *
+ * Built from the adopted recommendation so the binding is one the resolver really
+ * accepts, then given a project rule of its own — exactly what the workbench
+ * writes when a user edits a skill's rule list.
+ */
+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 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, 'a.js'), 'source'],
+  ])
+  let execute
+  const key = (p, options) => join(options?.cwd ?? cwd, p)
+  const fs = {
+    resolve: async (p, options) => ({ targetKey: key(p, options) }),
+    readText: async target => records.get(target.targetKey),
+    listDir: async () => [],
+    lstat: async (p, options) => records.has(key(p, options)) ? { version: 'v' } : undefined,
+    writeText: async (target, content) => { records.set(target.targetKey, content) },
+  }
+  const ctx = {
+    fs,
+    tools: { register(tool) { execute = tool.execute; return () => {} } },
+    get: name => name === 'sandboxPolicy'
+      ? { resolve: () => ({ mode: 'workspace-write', workspaceRoot: cwd, sessionId: 'f' }) }
+      : undefined,
+  }
+  registerDevTask(ctx)
+  const exec = { agent: { session: { id: 'f', header: { cwd }, snapshotEvents: () => [] } }, signal: new AbortController().signal }
+  const call = async args => execute(JSON.parse(JSON.stringify({ task_id: 'FZ-2', ...args })), exec)
+  await call({ operation: 'create', title: 'freeze', branch: 'main', files: ['a.js'] })
+  const state = JSON.parse(records.get(join(cwd, '.dsh/task-FZ-2.json')))
+  state.stage = '开发'
+  state.requirement_confirmed = true
+  state.solution_confirmed = true
+  records.set(join(cwd, '.dsh/task-FZ-2.json'), JSON.stringify(state))
+  return {
+    call,
+    records,
+    cwd,
+    rule: () => join(cwd, '.dsh/rules/mine.md'),
+    disclosed: async () => {
+      const status = JSON.parse(await call({ operation: 'status' }))
+      return { status, mine: status.bindings.rules.find(r => r.name === 'mine') }
+    },
+  }
+}
+
+test('freeze: a running task follows the FROZEN body after its source is edited', async () => {
+  // Freezing that only archives the content is not freezing: status and the stage
+  // disclosure used to read the live files, so editing a rule silently changed what
+  // a running task was told to follow — the instability the snapshot exists to stop.
+  const f = await atDevelopmentWithProjectRule()
+  const before = await f.disclosed()
+  assert.equal(before.mine?.content, 'ORIGINAL RULE', 'the frozen body is what gets disclosed')
+
+  f.records.set(f.rule(), 'CHANGED RULE')
+  const after = await f.disclosed()
+  assert.equal(after.mine?.content, 'ORIGINAL RULE',
+    'an edit to the source must not change what the running task is told to follow')
+  assert.ok((after.status.stale_source_rules ?? []).some(r => r.includes('edited')),
+    'the drift is reported so it is visible rather than silently authoritative')
+})
+
+test('freeze: a running task survives its source rule being deleted', async () => {
+  // The frozen copy exists precisely so a deleted file is not a missing
+  // constraint. Reporting it as missing would be wrong: the task has the body.
+  const f = await atDevelopmentWithProjectRule()
+  f.records.delete(f.rule())
+  const { status, mine } = await f.disclosed()
+  assert.equal(mine?.content, 'ORIGINAL RULE', 'the frozen body is still in force')
+  assert.deepEqual(status.missing_rules, [],
+    'a frozen rule is not missing; the task already holds its content')
+  assert.ok((status.stale_source_rules ?? []).some(r => r.includes('deleted')),
+    'the deletion is reported as drift')
+})
+
+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
+  // deleted rule must be reported as missing rather than silently unbound — the
+  // two paths are distinguishable and neither silently degrades into the other.
+  const f = await atDevelopmentWithProjectRule()
+  const state = JSON.parse(f.records.get(join(f.cwd, '.dsh/task-FZ-2.json')))
+  delete state.flow.resources
+  f.records.set(join(f.cwd, '.dsh/task-FZ-2.json'), JSON.stringify(state))
+
+  const live = await f.disclosed()
+  assert.equal(live.mine?.content, 'ORIGINAL RULE', 'an unfrozen task reads the live file')
+
+  f.records.delete(f.rule())
+  const { status, mine } = await f.disclosed()
+  assert.equal(mine, undefined, 'with no snapshot and no file, the rule cannot resolve')
+  assert.ok((status.missing_rules ?? []).includes('project:mine'),
+    'it is reported as missing so the gate can block on it')
 })

package/.hook-test.mjs

@@ -100,10 +100,15 @@ function approvedTask(overrides = {}) {
   }
 }
 
-/** Resolve the standard preset's config the same way the hook does. */
+/**
+ * Resolve the standard preset's config the way a real project has it: the skeleton
+ * plus the shipped recommendation, adopted. The hook reads the project's config
+ * from disk, so a project that adopted the recommendation is what these tests
+ * describe — the bare skeleton has no commit rule or artifacts to check.
+ */
 async function standardConfig() {
-  const { resolveFlow } = await import('./lib/workflows.js')
-  const resolved = resolveFlow('standard')
+  const { resolveFlow, adoptRecommendation } = await import('./lib/workflows.js')
+  const resolved = resolveFlow('standard', adoptRecommendation('standard'))
   assert.equal(resolved.ok, true, 'the built-in standard preset resolves')
   return resolved.config
 }