@godv61/dsh-task-engine 0.25.0 → 0.26.1

package/.evidence-test.mjs

@@ -1,119 +1,118 @@
-/**
- * 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)}`)
-})
+/**
+ * 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 adopted setup declares an artifact for. Missing
+  // declarations and incomplete fields must both remain blockers.
+  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]: 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')
+})
+
+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'], approved: true } } } })
+  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

@@ -1,93 +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)
+/**
+ * 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)
 })