@godv61/dsh-task-engine 0.26.1 → 0.27.0

package/.enforce-test.mjs

@@ -86,17 +86,13 @@ test('enforce: a task WITHOUT a snapshot cannot advance while a bound rule is un
   )
 })
 
-test('enforce: a task WITH a snapshot still advances after its source rule is deleted', async () => {
-  // The other side of the same rule: the frozen copy IS the constraint, so a
-  // deleted source is drift to report, not a reason to block. Without this the
-  // freeze would be pointless — the task would be blocked by a file it no longer
-  // needs.
-  const f = await project()
-  await satistfyDevelopment(f)
-  f.records.delete(f.rule())
-  await f.call({ operation: 'advance', target_stage: '交付' })
-  assert.equal(f.current().stage, '交付', 'the frozen task advances on its own copy')
-})
+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
@@ -136,4 +132,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

@@ -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/.freeze-test.mjs

@@ -150,34 +150,29 @@ async function atDevelopmentWithProjectRule() {
   }
 }
 
-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('live: a running task reads the latest rule body at the same reference', async () => {
+  const f = await atDevelopmentWithProjectRule()
+  const before = await f.disclosed()
+  assert.equal(before.mine?.content, 'ORIGINAL RULE')
+
+  f.records.set(f.rule(), 'CHANGED RULE')
+  const after = await f.disclosed()
+  assert.equal(after.mine?.content, 'CHANGED RULE',
+    'the next interaction must disclose the edited body')
+  assert.ok((after.status.stale_source_rules ?? []).some(r => r.includes('edited')),
+    'the difference from the creation-time audit copy must be visible')
+  assert.match(after.status.resource_update_notice, /current source body is in force/u)
+})
+
+test('live: deleting a source rule makes the binding unresolved', async () => {
+  const f = await atDevelopmentWithProjectRule()
+  f.records.delete(f.rule())
+  const { status, mine } = await f.disclosed()
+  assert.equal(mine, undefined)
+  assert.ok(status.missing_rules.includes('project:mine'))
+  assert.ok((status.stale_source_rules ?? []).some(r => r.includes('deleted')),
+    'the deletion is also reported against the creation-time audit copy')
+})
 
 test('freeze: an unfrozen task falls back to live resolution and reports a missing file', async () => {
   // Tasks created before freezing have no snapshot. They must keep working, and a
@@ -196,4 +191,4 @@ test('freeze: an unfrozen task falls back to live resolution and reports a missi
   assert.equal(mine, undefined, 'with no snapshot and no file, the rule cannot resolve')
   assert.ok((status.missing_rules ?? []).includes('project:mine'),
     'it is reported as missing so the gate can block on it')
-})
+})

package/.revision-test.mjs

@@ -92,7 +92,7 @@ test('rework: fixing a defect keeps the agreed requirement and solution', () =>
   assert.deepEqual(state.commits, [], 'the commit described a superseded tree')
 })
 
-test('rework: clearing evidence returns an item to unfinished, not to done-without-audit', () => {
+test('rework: clearing evidence returns an item to unfinished, not to done-without-audit', () => {
   // A cleared review means the item is no longer proven done. Leaving it `done`
   // would let todos_done pass on work whose audit had just been discarded.
   const state = loadedTask()
@@ -111,18 +111,18 @@ test('rework: history records what was invalidated, for audit', () => {
   assert.equal(state.revisions[0].from, '代码审核')
   assert.equal(state.revisions[0].to, '设计')
   assert.deepEqual(state.revisions[0].invalidated, invalidatedBy('solution'))
-})
-
-test('rework: skill results from revised stages are invalidated', () => {
-  const state = loadedTask()
-  state.flow = { flow: 'standard', version: 3, config: adoptedFlow('standard') }
-  state.skill_results = {
-    '需求评审': { analysis: { evidence: ['still agreed'] } },
-    '开发': { implementation: { evidence: ['old implementation'] } },
-    '代码审核': { audit: { evidence: ['old audit'] } },
-  }
-  applyRevision(state, rework('defect', '开发'))
-  assert.ok(state.skill_results['需求评审'])
-  assert.equal(state.skill_results['开发'], undefined)
-  assert.equal(state.skill_results['代码审核'], undefined)
-})
+})
+
+test('rework: skill results from revised stages are invalidated', () => {
+  const state = loadedTask()
+  state.flow = { flow: 'standard', version: 3, config: adoptedFlow('standard') }
+  state.skill_results = {
+    '需求评审': { analysis: { evidence: ['still agreed'] } },
+    '开发': { implementation: { evidence: ['old implementation'] } },
+    '代码审核': { audit: { evidence: ['old audit'] } },
+  }
+  applyRevision(state, rework('defect', '开发'))
+  assert.ok(state.skill_results['需求评审'])
+  assert.equal(state.skill_results['开发'], undefined)
+  assert.equal(state.skill_results['代码审核'], undefined)
+})

package/.roundtrip-test.mjs

@@ -5,127 +5,266 @@
  * 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'
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { dirname, join, resolve, sep } from 'node:path'
+import { resolveFlow, adoptRecommendation, compactProjectConfig, materializeBundledReferences } from './lib/workflows.js'
+import Controller from './lib/controller.js'
+import { assertAdvance, validateWorkflow } from './lib/engine.js'
+import { TYPERT_REMOTE } from './src/client/remote.ts'
 
 /** 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)
-})
+const FIELDS = ['flow', 'stage_bindings', 'commit', 'artifacts', 'review_depth', 'commit_required']
+
+test('browser remote codec retains source-qualified bindings and all saved fields', () => {
+  const write = TYPERT_REMOTE.descriptors.find(descriptor => descriptor.method === 'write')
+  const read = TYPERT_REMOTE.descriptors.find(descriptor => descriptor.method === 'read')
+  const adopted = compactProjectConfig(adoptRecommendation('minimal'))
+  const request = { path: 'project', ...adopted, review_depth: 'single', commit_required: false,
+    materialize_bundled: 'project' }
+  assert.deepEqual(write.parameters[0].codec.schema.parse(request), request)
+  const resolved = resolveFlow('minimal', request).config
+  const view = { ok: true, source: 'project', flow: 'minimal', config: resolved, problems: [] }
+  assert.deepEqual(read.result.schema.parse(view), view)
+  const catalog = TYPERT_REMOTE.descriptors.find(descriptor => descriptor.method === 'listSkills')
+  const skill = { name: 'mine', description: 'test', source: 'project',
+    ref: { source: 'project', name: 'mine' }, sourceLabel: '项目' }
+  assert.deepEqual(catalog.result.schema.parse({ skills: [skill] }), { skills: [skill] })
+  const saveUserProfile = TYPERT_REMOTE.descriptors.find(descriptor => descriptor.method === 'writeUserSkillProfile')
+  const profileRequest = { name: 'mine', profile: { rules: [{ source: 'user', name: 'my-rule' }], evidence: 'manual' } }
+  assert.deepEqual(saveUserProfile.parameters[0].codec.schema.parse(profileRequest), profileRequest)
+})
+
+test('one user skill profile is shared across workspaces and cannot depend on a project rule', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'dsh-user-profile-'))
+  assert.ok(resolve(root).startsWith(resolve(tmpdir()) + sep))
+  const priorHome = process.env.DSH_HOME
+  const userHome = join(root, 'user-home')
+  process.env.DSH_HOME = userHome
+  const skill = { source: 'user', name: 'my-skill' }
+  const config = { flow: 'minimal', stage_bindings: {
+    '开发': { skill_refs: [skill] }, '交付': { skill_refs: [skill] },
+  } }
+  const fs = {
+    resolve: async (path, { cwd }) => join(cwd, path),
+    readText: async path => { try { return readFileSync(path, 'utf8') } catch { return undefined } },
+    writeText: async (path, body) => { mkdirSync(dirname(path), { recursive: true }); writeFileSync(path, body) },
+  }
+  const receiver = { authorizedPath: async path => path, fs: () => fs }
+  try {
+    const skillDir = join(userHome, 'skills', skill.name)
+    mkdirSync(skillDir, { recursive: true })
+    writeFileSync(join(skillDir, 'SKILL.md'), '---\nname: my-skill\ndescription: test\n---\nbody\n')
+    const profile = { rules: [{ source: 'user', name: 'my-rule' }], evidence: 'manual' }
+    const saved = await Controller.prototype.writeUserSkillProfile.call(receiver, { name: skill.name, profile })
+    assert.equal(saved.ok, true)
+    for (const projectName of ['one', 'two']) {
+      const project = join(root, projectName)
+      mkdirSync(join(project, '.dsh'), { recursive: true })
+      writeFileSync(join(project, '.dsh', 'eng.json'), JSON.stringify(config))
+      const loaded = await Controller.prototype.read.call(receiver, project)
+      assert.equal(loaded.ok, true)
+      assert.deepEqual(loaded.config.stage_bindings['开发'].skills[0].rules, profile.rules)
+    }
+    const updatedProfile = { rules: [{ source: 'user', name: 'other-rule' }], evidence: 'none' }
+    const updated = await Controller.prototype.writeUserSkillProfile.call(receiver,
+      { name: skill.name, profile: updatedProfile })
+    assert.equal(updated.ok, true)
+    for (const projectName of ['one', 'two']) {
+      const loaded = await Controller.prototype.read.call(receiver, join(root, projectName))
+      assert.equal(loaded.ok, true)
+      assert.deepEqual(loaded.config.stage_bindings['开发'].skills[0].rules, updatedProfile.rules)
+    }
+    const bad = await Controller.prototype.writeUserSkillProfile.call(receiver, { name: skill.name,
+      profile: { rules: [{ source: 'project', name: 'local-rule' }] } })
+    assert.equal(bad.ok, false)
+    assert.deepEqual(JSON.parse(readFileSync(join(skillDir, 'profile.json'), 'utf8')), updatedProfile)
+  } finally {
+    if (priorHome === undefined) delete process.env.DSH_HOME
+    else process.env.DSH_HOME = priorHome
+    rmSync(root, { recursive: true, force: true })
+  }
+})
+
+test('recommendation adoption copies each shared bundled rule once and rewrites every reference', () => {
+  const { config, copies } = materializeBundledReferences(adoptRecommendation('standard'), 'project')
+  assert.equal(copies.filter(copy => copy.kind === 'skill').length, 6)
+  assert.equal(copies.filter(copy => copy.kind === 'rule').length, 3)
+  const refs = Object.values(config.stage_bindings).flatMap(binding => binding.skill_refs)
+  assert.ok(refs.every(ref => ref.source === 'project'))
+  const rules = Object.values(config.skill_profiles).flatMap(profile => profile.rules)
+  assert.ok(rules.every(ref => ref.source === 'project'))
+  const shared = rules.filter(ref => ref.name === 'security-redlines-copy')
+  assert.equal(shared.length, 3)
+  assert.equal(copies.filter(copy => copy.kind === 'rule' && copy.name === 'security-redlines').length, 1)
+  assert.deepEqual(validateWorkflow(resolveFlow('standard', config).config), [])
+})
+
+test('project migration leaves a global user skill profile and its bundled rules untouched', () => {
+  const userSkill = { source: 'user', name: 'global-check' }
+  const bundledRule = { source: 'bundled', name: 'security-redlines' }
+  const project = { flow: 'minimal', stage_bindings: { '开发': { skill_refs: [userSkill] } },
+    skill_profiles: { 'user:global-check': { rules: [bundledRule] } } }
+  const { config, copies } = materializeBundledReferences(project, 'project')
+  assert.deepEqual(config.skill_profiles['user:global-check'].rules, [bundledRule])
+  assert.deepEqual(copies, [])
+})
+
+test('adoption saves editable project copies, preserves edited files on repeat, and leaves legacy bundled configs alone', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'dsh-adopt-'))
+  assert.ok(resolve(root).startsWith(resolve(tmpdir()) + sep))
+  const fs = {
+    resolve: async (path, { cwd }) => join(cwd, path),
+    readText: async path => { try { return readFileSync(path, 'utf8') } catch { return undefined } },
+    writeText: async (path, text) => { mkdirSync(dirname(path), { recursive: true }); writeFileSync(path, text) },
+  }
+  const receiver = { authorizedPath: async path => path, fs: () => fs }
+  try {
+    const recommended = adoptRecommendation('standard')
+    const first = await Controller.prototype.write.call(receiver,
+      { path: root, ...recommended, materialize_bundled: 'project' })
+    assert.equal(first.ok, true)
+    assert.equal(first.adoption.created.length, 9)
+    const file = join(root, '.dsh', 'eng.json')
+    const saved = JSON.parse(readFileSync(file, 'utf8'))
+    assert.equal(JSON.stringify(saved).includes('"bundled"'), false)
+    const shared = join(root, '.dsh', 'rules', 'security-redlines-copy.md')
+    assert.ok(readFileSync(shared, 'utf8').length > 0)
+    writeFileSync(shared, 'user edited shared rule\n')
+    const second = await Controller.prototype.write.call(receiver,
+      { path: root, ...recommended, materialize_bundled: 'project' })
+    assert.equal(second.ok, true)
+    assert.equal(second.adoption.created.length, 0)
+    assert.equal(second.adoption.reused.length, 9)
+    assert.equal(readFileSync(shared, 'utf8'), 'user edited shared rule\n')
+    const loaded = await Controller.prototype.read.call(receiver, root)
+    assert.equal(loaded.ok, true)
+    const sharedRefs = Object.values(loaded.config.skill_profiles).flatMap(profile => profile.rules)
+      .filter(rule => rule.name === 'security-redlines-copy')
+    assert.equal(sharedRefs.length, 3)
+    writeFileSync(file, JSON.stringify(compactProjectConfig(recommended)))
+    const legacy = await Controller.prototype.read.call(receiver, root)
+    assert.equal(legacy.ok, true)
+    assert.ok(JSON.stringify(legacy.config).includes('"bundled"'))
+  } finally {
+    rmSync(root, { recursive: true, force: true })
+  }
+})
+
+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
@@ -175,4 +314,4 @@ test('round-trip: the payload the panel sends contains every edited 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')
-})
+})