@godv61/dsh-task-engine 0.25.0 → 0.26.1

package/.preset-test.mjs

@@ -1,161 +1,161 @@
-/**
- * Tests for the `eng` preset derivation.
- *
- * The preset must track the RUNNING harness's `standard`, because a copy that
- * freezes once goes stale the moment DSH edits its own composition, and a stale
- * preset fails to load entirely. Two real regressions motivate these cases:
- *
- *   - DSH 2026-09-06 moved the persona row from `text:` to `prefix`/`suffix`.
- *   - DSH 2026-09-13 replaced the `workflow-worker-thread` row with
- *     `workflow-ptc`; the plugin kept emitting the removed row, whose package
- *     had also left `apps/cli`'s dependencies, so the roster could not resolve
- *     it and reported "加载失败" for the whole preset.
- *
- * Run: `node --test .preset-test.mjs`
- * @module dsh-task-engine/.preset-test
- */
-
-import assert from 'node:assert/strict'
-import { mkdtempSync, readFileSync, rmSync, writeFileSync, mkdirSync, existsSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join, resolve, sep } from 'node:path'
-import { test } from 'node:test'
-import { derivedEngComposition, wasSeeded, applyPersona, personaFieldOf } from './lib/seed-preset.js'
-
-/**
- * The live derivation resolves `@deepseek-ai/dsh-agent-presets`, a PEER the
- * running harness provides. In a consumer's install it may be absent or a
- * different version, so the assertions that read a real `standard` skip when it
- * is unavailable rather than failing —the fixture-driven cases below cover the
- * logic itself and always run.
- */
-const derived = derivedEngComposition()
-const liveSource = derived !== undefined
-const live = { skip: liveSource ? false : 'no resolvable @deepseek-ai/dsh-agent-presets in this install' }
-
-test('the derivation reads a readable standard composition', live, () => {
-  assert.ok(derived !== undefined, 'standard must be resolvable when a peer provides it')
-  assert.ok(derived.text.length > 0, 'the derived composition must not be empty')
-})
-
-test('the engineering persona replaces the shipped one', live, () => {
-  assert.equal(derived.personaApplied, true, 'the persona row must be found and rewritten')
-  assert.match(derived.text, /engineering-delivery coding agent/u, 'the persona body must be the engineering one')
-  // The shipped prose must be gone, in whichever field the source used.
-  assert.doesNotMatch(derived.text, /You are a coding agent powered by the \{\{model\}\} model/u,
-    'the shipped persona prose must be replaced, not merely shadowed')
-})
-
-test('the derived persona row is well formed and never sets complete', live, () => {
-  // Which field is correct depends on the running harness, so assert the SHAPE
-  // (a block scalar under `config:`) rather than one field name —the field
-  // itself is pinned by the two fixtures below.
-  assert.match(derived.text, /- id: persona\n {2}name: '@deepseek-ai\/dsh-persona'\n {2}config:\n(?: {4}suffix: .*\n)? {4}(?:text|prefix): [|>]-/u,
-    'the persona row must carry a block scalar under config')
-  // `complete: true` would make this prose the ENTIRE system prompt and
-  // suppress every other section, silently gutting the agent.
-  assert.doesNotMatch(derived.text, /complete: true/u, 'complete must not be set')
-})
-
-test('the agent row is appended exactly once', live, () => {
-  const matches = derived.text.match(/id: task-engine-agent/gu) ?? []
-  assert.equal(matches.length, 1, 'task-engine-agent must appear once')
-  assert.match(derived.text, /name: '@godv61\/dsh-task-engine\/agent'/u, 'the row must name the agent entry')
-})
-
-test('every top-level row of standard survives the derivation', live, () => {
-  // The point of deriving rather than hand-writing: the preset must inherit the
-  // harness's whole tool roster, not a remembered subset of it.
-  const ids = (text) => (text.match(/^- id: (\S+)$/gmu) ?? []).map(line => line.replace(/^- id: /u, ''))
-  const derivedIds = ids(derived.text)
-  assert.ok(derivedIds.length > 10, `expected the full roster, saw ${derivedIds.length} rows`)
-  assert.ok(derivedIds.includes('persona'), 'persona must be present')
-  assert.equal(new Set(derivedIds).size, derivedIds.length, 'row ids must be unique')
-})
-
-test('a composition carrying the agent row is recognised as seeded', () => {
-  assert.equal(wasSeeded("  - id: task-engine-agent\n    name: 'x'\n"), true, 'the agent row marks a seeded file')
-  assert.equal(wasSeeded('- id: persona\n  name: y\n'), false, 'a hand-authored composition is not ours')
-})
-
-test('re-deriving is stable: the same standard yields the same text', live, () => {
-  // Idempotence is what lets the seed run on every boot without rewriting.
-  const again = derivedEngComposition()
-  assert.equal(again.text, derived.text, 'two derivations of one source must agree')
-})
-
-// The persona plugin renamed `text` to `prefix`/`suffix` in DSH commit 40792330c0
-// (2026-09-06, first shipped in dsh-v0.1.3-alpha.2). The two schemas are mutually
-// exclusive: a preset written with `prefix` is rejected by an older persona
-// plugin with "$.text missing required value", and vice versa. The seed must
-// therefore follow whichever field the SOURCE composition uses, which is what
-// these two fixtures pin.
-const PERSONA_FIXTURE_LEGACY = [
-  '- id: persona',
-  "  name: '@deepseek-ai/dsh-persona'",
-  '  config:',
-  '    text: >-',
-  '      You are a coding agent powered by the {{model}} model.',
-  '',
-  '- id: agent-instructions',
-  "  name: '@deepseek-ai/dsh-agent-instructions'",
-  '',
-].join('\n')
-
-const PERSONA_FIXTURE_MODERN = [
-  '- id: persona',
-  "  name: '@deepseek-ai/dsh-persona'",
-  '  config:',
-  '    suffix: Your working directory is {{cwd}}.',
-  '    prefix: >-',
-  '      You are a coding agent powered by the {{model}} model.',
-  '',
-  '- id: agent-instructions',
-  "  name: '@deepseek-ai/dsh-agent-instructions'",
-  '',
-].join('\n')
-
-/** Read the scalar keys of a persona row's `config:` mapping. */
-function personaConfig(text) {
-  const lines = text.split('\n')
-  const start = lines.findIndex(line => line.trimEnd() === '- id: persona')
-  assert.ok(start >= 0, 'the fixture must carry a persona row')
-  let end = start + 1
-  while (end < lines.length && !/^- /u.test(lines[end] ?? '')) end++
-  const config = {}
-  for (const line of lines.slice(start, end)) {
-    const match = /^ {4}([a-z]+):(.*)$/u.exec(line)
-    if (match !== null) config[match[1]] = match[2].trim()
-  }
-  return config
-}
-
-test('the persona field follows the source schema, both generations', () => {
-  assert.equal(personaFieldOf(PERSONA_FIXTURE_LEGACY), 'text', 'a text-based source is detected')
-  assert.equal(personaFieldOf(PERSONA_FIXTURE_MODERN), 'prefix', 'a prefix-based source is detected')
-
-  const legacy = applyPersona(PERSONA_FIXTURE_LEGACY, 'ENGINEER')
-  assert.equal(legacy.applied, true, 'the legacy persona row is rewritten')
-  const legacyConfig = personaConfig(legacy.text)
-  assert.equal(legacyConfig.text, '>-', 'the legacy shape keeps `text`, never `prefix`')
-  assert.equal(legacyConfig.prefix, undefined, 'no prefix field is introduced for an old harness')
-
-  const modern = applyPersona(PERSONA_FIXTURE_MODERN, 'ENGINEER')
-  const modernConfig = personaConfig(modern.text)
-  assert.equal(modernConfig.prefix, '>-', 'the modern shape uses `prefix`')
-  assert.equal(modernConfig.text, undefined, 'no text field is introduced for a new harness')
-  assert.equal(modernConfig.suffix, 'Your working directory is {{cwd}}.', 'the shipped suffix is carried over')
-})
-
-test('the rewritten persona row keeps valid indentation for both shapes', () => {
-  // A mis-indented `suffix:` under `config:` silently changes the YAML shape,
-  // so assert the exact lines rather than trusting the mapping parse alone.
-  const modern = applyPersona(PERSONA_FIXTURE_MODERN, 'ENGINEER').text
-  assert.match(modern, /- id: persona\n {2}name: '@deepseek-ai\/dsh-persona'\n {2}config:\n {4}suffix: /u,
-    'suffix sits at four spaces under config')
-  assert.match(modern, /\n {4}prefix: [|>]-\n {6}ENGINEER\n/u, 'prefix and its body are indented correctly')
-
-  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')
+/**
+ * Tests for the `eng` preset derivation.
+ *
+ * The preset must track the RUNNING harness's `standard`, because a copy that
+ * freezes once goes stale the moment DSH edits its own composition, and a stale
+ * preset fails to load entirely. Two real regressions motivate these cases:
+ *
+ *   - DSH 2026-09-06 moved the persona row from `text:` to `prefix`/`suffix`.
+ *   - DSH 2026-09-13 replaced the `workflow-worker-thread` row with
+ *     `workflow-ptc`; the plugin kept emitting the removed row, whose package
+ *     had also left `apps/cli`'s dependencies, so the roster could not resolve
+ *     it and reported "加载失败" for the whole preset.
+ *
+ * Run: `node --test .preset-test.mjs`
+ * @module dsh-task-engine/.preset-test
+ */
+
+import assert from 'node:assert/strict'
+import { mkdtempSync, readFileSync, rmSync, writeFileSync, mkdirSync, existsSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join, resolve, sep } from 'node:path'
+import { test } from 'node:test'
+import { derivedEngComposition, wasSeeded, applyPersona, personaFieldOf } from './lib/seed-preset.js'
+
+/**
+ * The live derivation resolves `@deepseek-ai/dsh-agent-presets`, a PEER the
+ * running harness provides. In a consumer's install it may be absent or a
+ * different version, so the assertions that read a real `standard` skip when it
+ * is unavailable rather than failing —the fixture-driven cases below cover the
+ * logic itself and always run.
+ */
+const derived = derivedEngComposition()
+const liveSource = derived !== undefined
+const live = { skip: liveSource ? false : 'no resolvable @deepseek-ai/dsh-agent-presets in this install' }
+
+test('the derivation reads a readable standard composition', live, () => {
+  assert.ok(derived !== undefined, 'standard must be resolvable when a peer provides it')
+  assert.ok(derived.text.length > 0, 'the derived composition must not be empty')
+})
+
+test('the engineering persona replaces the shipped one', live, () => {
+  assert.equal(derived.personaApplied, true, 'the persona row must be found and rewritten')
+  assert.match(derived.text, /engineering-delivery coding agent/u, 'the persona body must be the engineering one')
+  // The shipped prose must be gone, in whichever field the source used.
+  assert.doesNotMatch(derived.text, /You are a coding agent powered by the \{\{model\}\} model/u,
+    'the shipped persona prose must be replaced, not merely shadowed')
+})
+
+test('the derived persona row is well formed and never sets complete', live, () => {
+  // Which field is correct depends on the running harness, so assert the SHAPE
+  // (a block scalar under `config:`) rather than one field name —the field
+  // itself is pinned by the two fixtures below.
+  assert.match(derived.text, /- id: persona\n {2}name: '@deepseek-ai\/dsh-persona'\n {2}config:\n(?: {4}suffix: .*\n)? {4}(?:text|prefix): [|>]-/u,
+    'the persona row must carry a block scalar under config')
+  // `complete: true` would make this prose the ENTIRE system prompt and
+  // suppress every other section, silently gutting the agent.
+  assert.doesNotMatch(derived.text, /complete: true/u, 'complete must not be set')
+})
+
+test('the agent row is appended exactly once', live, () => {
+  const matches = derived.text.match(/id: task-engine-agent/gu) ?? []
+  assert.equal(matches.length, 1, 'task-engine-agent must appear once')
+  assert.match(derived.text, /name: '@godv61\/dsh-task-engine\/agent'/u, 'the row must name the agent entry')
+})
+
+test('every top-level row of standard survives the derivation', live, () => {
+  // The point of deriving rather than hand-writing: the preset must inherit the
+  // harness's whole tool roster, not a remembered subset of it.
+  const ids = (text) => (text.match(/^- id: (\S+)$/gmu) ?? []).map(line => line.replace(/^- id: /u, ''))
+  const derivedIds = ids(derived.text)
+  assert.ok(derivedIds.length > 10, `expected the full roster, saw ${derivedIds.length} rows`)
+  assert.ok(derivedIds.includes('persona'), 'persona must be present')
+  assert.equal(new Set(derivedIds).size, derivedIds.length, 'row ids must be unique')
+})
+
+test('a composition carrying the agent row is recognised as seeded', () => {
+  assert.equal(wasSeeded("  - id: task-engine-agent\n    name: 'x'\n"), true, 'the agent row marks a seeded file')
+  assert.equal(wasSeeded('- id: persona\n  name: y\n'), false, 'a hand-authored composition is not ours')
+})
+
+test('re-deriving is stable: the same standard yields the same text', live, () => {
+  // Idempotence is what lets the seed run on every boot without rewriting.
+  const again = derivedEngComposition()
+  assert.equal(again.text, derived.text, 'two derivations of one source must agree')
+})
+
+// The persona plugin renamed `text` to `prefix`/`suffix` in DSH commit 40792330c0
+// (2026-09-06, first shipped in dsh-v0.1.3-alpha.2). The two schemas are mutually
+// exclusive: a preset written with `prefix` is rejected by an older persona
+// plugin with "$.text missing required value", and vice versa. The seed must
+// therefore follow whichever field the SOURCE composition uses, which is what
+// these two fixtures pin.
+const PERSONA_FIXTURE_LEGACY = [
+  '- id: persona',
+  "  name: '@deepseek-ai/dsh-persona'",
+  '  config:',
+  '    text: >-',
+  '      You are a coding agent powered by the {{model}} model.',
+  '',
+  '- id: agent-instructions',
+  "  name: '@deepseek-ai/dsh-agent-instructions'",
+  '',
+].join('\n')
+
+const PERSONA_FIXTURE_MODERN = [
+  '- id: persona',
+  "  name: '@deepseek-ai/dsh-persona'",
+  '  config:',
+  '    suffix: Your working directory is {{cwd}}.',
+  '    prefix: >-',
+  '      You are a coding agent powered by the {{model}} model.',
+  '',
+  '- id: agent-instructions',
+  "  name: '@deepseek-ai/dsh-agent-instructions'",
+  '',
+].join('\n')
+
+/** Read the scalar keys of a persona row's `config:` mapping. */
+function personaConfig(text) {
+  const lines = text.split('\n')
+  const start = lines.findIndex(line => line.trimEnd() === '- id: persona')
+  assert.ok(start >= 0, 'the fixture must carry a persona row')
+  let end = start + 1
+  while (end < lines.length && !/^- /u.test(lines[end] ?? '')) end++
+  const config = {}
+  for (const line of lines.slice(start, end)) {
+    const match = /^ {4}([a-z]+):(.*)$/u.exec(line)
+    if (match !== null) config[match[1]] = match[2].trim()
+  }
+  return config
+}
+
+test('the persona field follows the source schema, both generations', () => {
+  assert.equal(personaFieldOf(PERSONA_FIXTURE_LEGACY), 'text', 'a text-based source is detected')
+  assert.equal(personaFieldOf(PERSONA_FIXTURE_MODERN), 'prefix', 'a prefix-based source is detected')
+
+  const legacy = applyPersona(PERSONA_FIXTURE_LEGACY, 'ENGINEER')
+  assert.equal(legacy.applied, true, 'the legacy persona row is rewritten')
+  const legacyConfig = personaConfig(legacy.text)
+  assert.equal(legacyConfig.text, '>-', 'the legacy shape keeps `text`, never `prefix`')
+  assert.equal(legacyConfig.prefix, undefined, 'no prefix field is introduced for an old harness')
+
+  const modern = applyPersona(PERSONA_FIXTURE_MODERN, 'ENGINEER')
+  const modernConfig = personaConfig(modern.text)
+  assert.equal(modernConfig.prefix, '>-', 'the modern shape uses `prefix`')
+  assert.equal(modernConfig.text, undefined, 'no text field is introduced for a new harness')
+  assert.equal(modernConfig.suffix, 'Your working directory is {{cwd}}.', 'the shipped suffix is carried over')
+})
+
+test('the rewritten persona row keeps valid indentation for both shapes', () => {
+  // A mis-indented `suffix:` under `config:` silently changes the YAML shape,
+  // so assert the exact lines rather than trusting the mapping parse alone.
+  const modern = applyPersona(PERSONA_FIXTURE_MODERN, 'ENGINEER').text
+  assert.match(modern, /- id: persona\n {2}name: '@deepseek-ai\/dsh-persona'\n {2}config:\n {4}suffix: /u,
+    'suffix sits at four spaces under config')
+  assert.match(modern, /\n {4}prefix: [|>]-\n {6}ENGINEER\n/u, 'prefix and its body are indented correctly')
+
+  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')
 })

package/.revision-test.mjs

@@ -12,21 +12,21 @@ import test from 'node:test'
 import assert from 'node:assert/strict'
 import { applyRevision, invalidatedBy, completionBlockers } from './lib/engine.js'
 import { adoptRecommendation, resolveFlow } from './lib/workflows.js'
-
-/**
- * The preset as a project would actually run it: the skeleton plus the shipped
- * recommendation, adopted exactly the way a user adopts it. A test that asserts
- * on bindings, commit rules or artifacts wants this, because those no longer come
- * from the preset itself.
- * @param {string} id - preset id.
- * @returns {import('./lib/engine.js').WorkflowConfig} the adopted config.
- */
-function adoptedFlow(id, extra) {
-  const base = adoptRecommendation(id)
-  if (base === undefined) throw new Error('unknown preset: ' + id)
-  return resolveFlow(id, { ...base, ...extra }).config
-}
-
+
+/**
+ * The preset as a project would actually run it: the skeleton plus the shipped
+ * recommendation, adopted exactly the way a user adopts it. A test that asserts
+ * on bindings, commit rules or artifacts wants this, because those no longer come
+ * from the preset itself.
+ * @param {string} id - preset id.
+ * @returns {import('./lib/engine.js').WorkflowConfig} the adopted config.
+ */
+function adoptedFlow(id, extra) {
+  const base = adoptRecommendation(id)
+  if (base === undefined) throw new Error('unknown preset: ' + id)
+  return resolveFlow(id, { ...base, ...extra }).config
+}
+
 
 /** A task carrying every conclusion, so a rework has something to invalidate. */
 function loadedTask() {
@@ -111,4 +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)
+})

package/.roundtrip-test.mjs

@@ -1,63 +1,178 @@
-/**
- * Config round-trip: what the panel shows is what the file holds.
- *
- * The write path and the panel both carried only `flow` + `stage_bindings`, so a
- * commit rule, artifact declarations or a review depth were resolved for the preview
- * and then dropped on save. A user could set them, see them applied, and lose them.
- */
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import { resolveFlow, adoptRecommendation } from './lib/workflows.js'
-
-/** The fields a project config can carry, so a round-trip is checked on all of them. */
-const FIELDS = ['flow', 'stage_bindings', 'commit', 'artifacts', 'review_depth', 'commit_required']
-
-test('round-trip: every configurable field survives being written and read back', () => {
-  // The save path serialises the payload and the read path parses it back through
-  // resolveFlow, so this asserts exactly those two steps.
-  const adopted = adoptRecommendation('standard')
-  const written = {
-    flow: 'standard',
-    stage_bindings: adopted.stage_bindings,
-    commit: adopted.commit,
-    artifacts: adopted.artifacts,
-    review_depth: 'single',
-    commit_required: false,
-  }
-  const serialised = JSON.stringify(written, null, 2)
-  const readBack = JSON.parse(serialised)
-  for (const field of FIELDS) {
-    assert.ok(field in readBack, `${field} must survive serialisation`)
-  }
-
-  const resolved = resolveFlow(readBack.flow, readBack)
-  assert.equal(resolved.ok, true)
-  assert.deepEqual(resolved.config.stage_bindings, written.stage_bindings, 'bindings round-trip')
-  assert.equal(resolved.config.commit.message_pattern, written.commit.message_pattern, 'the commit text convention round-trips')
-  assert.equal(resolved.config.commit.policy, 'task', 'the flow-control half of the commit rule is preserved')
-  assert.deepEqual(resolved.config.artifacts, written.artifacts, 'artifacts round-trip')
-  assert.equal(resolved.config.review_depth, 'single', 'review depth round-trips')
-  assert.equal(resolved.config.commit_required, false, 'commit_required round-trips')
-})
-
-test('round-trip: the payload the panel sends contains every edited field', () => {
-  // Mirrors the panel's save payload, so a field added to the config but not to the
-  // payload is caught here rather than by a user losing their settings.
-  const adopted = adoptRecommendation('standard')
-  const commitRule = adopted.commit
-  const artifacts = adopted.artifacts
-  const reviewDepth = 'single'
-  const payload = {
-    flow: 'standard',
-    stage_bindings: adopted.stage_bindings,
-    ...(commitRule !== undefined ? { commit: commitRule } : {}),
-    ...(artifacts !== undefined ? { artifacts } : {}),
-    ...(reviewDepth !== undefined ? { review_depth: reviewDepth } : {}),
-  }
-  for (const field of ['flow', 'stage_bindings', 'commit', 'artifacts', 'review_depth']) {
-    assert.ok(field in payload, `the panel must send ${field}`)
-  }
-  // And the whole payload must be accepted by the resolver the write path uses.
-  const resolved = resolveFlow(payload.flow, payload)
-  assert.equal(resolved.ok, true, 'the payload the panel sends must resolve without problems')
-})
+/**
+ * Config round-trip: what the panel shows is what the file holds.
+ *
+ * The write path and the panel both carried only `flow` + `stage_bindings`, so a
+ * commit rule, artifact declarations or a review depth were resolved for the preview
+ * and then dropped on save. A user could set them, see them applied, and lose them.
+ */
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { resolveFlow, adoptRecommendation, compactProjectConfig } from './lib/workflows.js'
+import Controller from './lib/controller.js'
+import { assertAdvance, validateWorkflow } from './lib/engine.js'
+
+/** The fields a project config can carry, so a round-trip is checked on all of them. */
+const FIELDS = ['flow', 'stage_bindings', 'commit', 'artifacts', 'review_depth', 'commit_required']
+
+test('round-trip: stages store references while skill rules have one owner', () => {
+  const adopted = adoptRecommendation('standard')
+  const compact = compactProjectConfig(adopted)
+  assert.ok(compact.stage_bindings['开发'].skill_refs.length > 0)
+  assert.equal(compact.stage_bindings['开发'].skills, undefined)
+  assert.ok(compact.skill_profiles['bundled:code-implement'].rules.length > 0)
+  const readBack = resolveFlow('standard', JSON.parse(JSON.stringify(compact)))
+  assert.deepEqual(readBack.config.stage_bindings, resolveFlow('standard', adopted).config.stage_bindings)
+  const custom = { flow: 'standard', stage_bindings: {
+    '开发': { skills: [{ skill: { source: 'project', name: 'same' }, rules: [{ source: 'project', name: 'r1' }] }] },
+    '交付': { skills: [{ skill: { source: 'project', name: 'same' }, rules: [{ source: 'project', name: 'r2' }] }] },
+  } }
+  const invalid = resolveFlow('standard', custom)
+  assert.ok(invalid.config.configuration_errors.some(problem => problem.includes('different rules')))
+})
+
+test('remote write stores canonical skill profiles and read expands them', async () => {
+  let stored
+  const fs = {
+    resolve: async path => path,
+    readText: async () => stored,
+    writeText: async (_target, text) => { stored = text },
+  }
+  const receiver = { authorizedPath: async path => path, fs: () => fs }
+  const adopted = adoptRecommendation('standard')
+  const written = await Controller.prototype.write.call(receiver, { path: 'project', ...adopted })
+  assert.equal(written.ok, true)
+  const onDisk = JSON.parse(stored)
+  assert.ok(onDisk.stage_bindings['开发'].skill_refs.length > 0)
+  assert.equal(onDisk.stage_bindings['开发'].skills, undefined)
+  assert.ok(onDisk.skill_profiles['bundled:code-implement'].rules.length > 0)
+  const loaded = await Controller.prototype.read.call(receiver, 'project')
+  assert.equal(loaded.ok, true)
+  assert.deepEqual(loaded.config.stage_bindings, written.config.stage_bindings)
+  assert.deepEqual(loaded.config.skill_profiles, written.config.skill_profiles)
+})
+
+test('an explicit skill profile governs every stage even when inline bindings are stale', () => {
+  const skill = { source: 'project', name: 'my-skill' }
+  const rule = { source: 'project', name: 'my-rule' }
+  const project = { flow: 'minimal',
+    stage_bindings: {
+      '开发': { skills: [{ skill, rules: [] }] },
+      '交付': { skills: [{ skill, rules: [] }] },
+    },
+    skill_profiles: { 'project:my-skill': { rules: [rule] } },
+  }
+  const resolved = resolveFlow('minimal', project)
+  assert.equal(resolved.ok, true)
+  assert.deepEqual(validateWorkflow(resolved.config), [])
+  assert.deepEqual(resolved.config.stage_bindings['开发'].skills[0].rules, [rule])
+  assert.deepEqual(resolved.config.stage_bindings['交付'].skills[0].rules, [rule])
+  const compact = compactProjectConfig(project)
+  assert.deepEqual(compact.stage_bindings['开发'].skill_refs, [skill])
+  assert.deepEqual(resolveFlow('minimal', compact).config.stage_bindings['交付'].skills[0].rules, [rule])
+})
+
+test('canonical references to one skill share its rule list without a false conflict', () => {
+  const skill = { source: 'project', name: 'my-skill' }
+  const rule = { source: 'project', name: 'my-rule' }
+  const resolved = resolveFlow('minimal', { flow: 'minimal', stage_bindings: {
+    '开发': { skill_refs: [skill] },
+    '交付': { skill_refs: [skill] },
+  }, skill_profiles: { 'project:my-skill': { rules: [rule] } } })
+  assert.deepEqual(validateWorkflow(resolved.config), [])
+  assert.deepEqual(resolved.config.stage_bindings['开发'].skills[0].rules, [rule])
+  assert.deepEqual(resolved.config.stage_bindings['交付'].skills[0].rules, [rule])
+})
+
+test('skill editor save persists one changed profile and read expands it into every stage', async () => {
+  let stored
+  const fs = { resolve: async path => path, readText: async () => stored,
+    writeText: async (_target, content) => { stored = content } }
+  const receiver = { authorizedPath: async path => path, fs: () => fs }
+  const skill = { source: 'project', name: 'my-skill' }
+  const rule = { source: 'project', name: 'my-rule' }
+  const initial = compactProjectConfig({ flow: 'minimal', stage_bindings: {
+    '开发': { skills: [{ skill, rules: [] }] },
+    '交付': { skills: [{ skill, rules: [] }] },
+  } })
+  const edited = { ...initial, skill_profiles: { ...initial.skill_profiles,
+    'project:my-skill': { rules: [rule], evidence: 'none' } } }
+  const written = await Controller.prototype.write.call(receiver, { path: 'project', ...edited })
+  assert.equal(written.ok, true)
+  assert.deepEqual(JSON.parse(stored).stage_bindings['开发'].skill_refs, [skill])
+  const loaded = await Controller.prototype.read.call(receiver, 'project')
+  assert.equal(loaded.ok, true)
+  assert.deepEqual(loaded.config.stage_bindings['开发'].skills[0].rules, [rule])
+  assert.deepEqual(loaded.config.stage_bindings['交付'].skills[0].rules, [rule])
+})
+
+test('adopting a recommendation retains the user-owned skill profiles', () => {
+  const custom = { 'project:my-skill': { rules: [{ source: 'project', name: 'my-rule' }], evidence: 'manual' } }
+  const adopted = adoptRecommendation('standard', { flow: 'standard', skill_profiles: custom })
+  assert.deepEqual(adopted.skill_profiles, custom)
+})
+
+test('malformed canonical skill profiles fail validation without crashing resolution', () => {
+  const malformed = resolveFlow('standard', { flow: 'standard',
+    stage_bindings: { '开发': { skill_refs: [{ source: 'project', name: 'my-skill' }] } },
+    skill_profiles: { 'project:my-skill': { rules: 'not-an-array' } },
+  })
+  assert.ok(validateWorkflow(malformed.config).some(problem => problem.includes('rules array')))
+})
+
+test('commit_required false also removes the checkpoint exit requirement', () => {
+  const adopted = adoptRecommendation('standard')
+  const config = resolveFlow('standard', { ...adopted, commit_required: false }).config
+  const state = { stage: '代码审核', execution_version: 1, review: { outcome: 'pass' },
+    artifacts: { review: { conclusion: 'pass', issues: 'none' } }, commits: [] }
+  assert.equal(assertAdvance(state, '完成', config).ok, true)
+})
+
+test('round-trip: every configurable field survives being written and read back', () => {
+  // The save path serialises the payload and the read path parses it back through
+  // resolveFlow, so this asserts exactly those two steps.
+  const adopted = adoptRecommendation('standard')
+  const written = {
+    flow: 'standard',
+    stage_bindings: adopted.stage_bindings,
+    commit: adopted.commit,
+    artifacts: adopted.artifacts,
+    review_depth: 'single',
+    commit_required: false,
+  }
+  const serialised = JSON.stringify(written, null, 2)
+  const readBack = JSON.parse(serialised)
+  for (const field of FIELDS) {
+    assert.ok(field in readBack, `${field} must survive serialisation`)
+  }
+
+  const resolved = resolveFlow(readBack.flow, readBack)
+  assert.equal(resolved.ok, true)
+  assert.deepEqual(resolved.config.stage_bindings, written.stage_bindings, 'bindings round-trip')
+  assert.equal(resolved.config.commit.message_pattern, written.commit.message_pattern, 'the commit text convention round-trips')
+  assert.equal(resolved.config.commit.policy, 'task', 'the flow-control half of the commit rule is preserved')
+  assert.deepEqual(resolved.config.artifacts, written.artifacts, 'artifacts round-trip')
+  assert.equal(resolved.config.review_depth, 'single', 'review depth round-trips')
+  assert.equal(resolved.config.commit_required, false, 'commit_required round-trips')
+})
+
+test('round-trip: the payload the panel sends contains every edited field', () => {
+  // Mirrors the panel's save payload, so a field added to the config but not to the
+  // payload is caught here rather than by a user losing their settings.
+  const adopted = adoptRecommendation('standard')
+  const commitRule = adopted.commit
+  const artifacts = adopted.artifacts
+  const reviewDepth = 'single'
+  const payload = {
+    flow: 'standard',
+    stage_bindings: adopted.stage_bindings,
+    ...(commitRule !== undefined ? { commit: commitRule } : {}),
+    ...(artifacts !== undefined ? { artifacts } : {}),
+    ...(reviewDepth !== undefined ? { review_depth: reviewDepth } : {}),
+  }
+  for (const field of ['flow', 'stage_bindings', 'commit', 'artifacts', 'review_depth']) {
+    assert.ok(field in payload, `the panel must send ${field}`)
+  }
+  // And the whole payload must be accepted by the resolver the write path uses.
+  const resolved = resolveFlow(payload.flow, payload)
+  assert.equal(resolved.ok, true, 'the payload the panel sends must resolve without problems')
+})