@godv61/dsh-task-engine 0.24.0 → 0.26.0

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

@@ -1,191 +1,196 @@
-/**
- * End-to-end test for the installed commit-msg hook.
- *
- * The P0 suite asserts on the hook SOURCE (that it disables path quoting, reads
- * NUL-separated paths, bundles the frozen snapshot). Those assertions catch a
- * hand-mirror regressing, but they cannot show the gate actually blocks a commit
- * — a hook that refuses everything, or nothing, passes every one of them.
- *
- * This runs the real bundled hook inside a throwaway git repository and asserts
- * both directions: an illegal commit is refused, a legal one proceeds.
- *
- * Run: `node --test .hook-test.mjs`
- * @module dsh-task-engine/.hook-test
- */
-
-import assert from 'node:assert/strict'
-import { execFileSync } from 'node:child_process'
-import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join, resolve, sep } from 'node:path'
-import { test } from 'node:test'
-
-const HOOK = resolve('hooks/commit-msg')
-
-/**
- * Git runs a hook by handing it to its own POSIX shell, which resolves
- * `#!/usr/bin/env node` against PATH. On Windows a `node.cmd` shim on PATH is
- * not executable from that shell, so the installed hook is wrapped in a
- * launcher that names the very interpreter running this test. Without it the
- * suite would read as the gate refusing everything, when in truth the hook
- * never started.
- */
-const NODE = process.execPath.replace(/\\/gu, '/')
-
-/** Run a git command in `cwd`, returning stdout (throws on non-zero exit). */
-function git(cwd, args) {
-  return execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] })
-}
-
-/**
- * Run `git commit` and report whether the hook allowed it.
- * A refused commit surfaces as a non-zero exit whose stderr carries the gate's
- * own Chinese refusal banner.
- */
-function tryCommit(cwd, message) {
-  try {
-    execFileSync('git', ['commit', '-m', message], { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] })
-    return { allowed: true, stderr: '' }
-  } catch (error) {
-    return { allowed: false, stderr: String(error.stderr ?? '') }
-  }
-}
-
-/** Build a throwaway repository with the real hook installed and one staged file. */
-function repo(name, task) {
-  const root = mkdtempSync(join(tmpdir(), `engine-hook-${name}-`))
-  git(root, ['init', '-q', '-b', 'main'])
-  git(root, ['config', 'user.email', 'test@example.com'])
-  git(root, ['config', 'user.name', 'Test'])
-  git(root, ['config', 'commit.gpgsign', 'false'])
-  mkdirSync(join(root, '.dsh'), { recursive: true })
-  mkdirSync(join(root, 'src'), { recursive: true })
-  // The gate body stays byte-identical to the shipped hook; only the shebang is
-  // replaced, so the test exercises the real gate under a runnable interpreter.
-  const gate = readFileSync(HOOK, 'utf8').replace(/^#![^\n]*\n/u, '')
-  writeFileSync(join(root, '.git', 'hooks', 'commit-msg'), `#!${NODE}\n${gate}`)
-  writeFileSync(join(root, '.git', 'hooks', 'package.json'), '{\n  "type": "commonjs"\n}\n')
-  writeFileSync(join(root, '.dsh', `task-${task.id}.json`), JSON.stringify(task, null, 2))
-  writeFileSync(join(root, 'src', 'app.js'), 'console.log(1)\n')
-  git(root, ['add', 'src/app.js'])
-  return root
-}
-
-/**
- * A standard-flow task that has reached the commit checkpoint with a declared
- * scope. `代码审核` is the checkpoint stage, and the engine only permits a
- * commit there once that stage's OUTGOING guards already hold — so the fixture
- * must also satisfy the review artifact and the review verdict.
- */
-function approvedTask(overrides = {}) {
-  return {
-    schema: 1,
-    id: 'HOOK-1',
-    title: 'hook probe',
-    branch: 'main',
-    work_size: 'standard',
-    risk_level: 'standard',
-    stage: '代码审核',
-    requirement_confirmed: true,
-    solution_confirmed: true,
-    items: [{ id: 'i1', title: 'do the thing', status: 'done', review: { spec: { outcome: 'pass' }, quality: { outcome: 'pass' } } }],
-    verification: { passed: true, evidence: [] },
-    review: { outcome: 'pass' },
-    // The `代码审核 -> 完成` edge requires `review_passed` and `artifacts_present`.
-    artifacts: { review: { conclusion: 'looks good', issues: 'none' } },
-    files: ['src/app.js'],
-    commits: [],
-    flow: { flow: 'standard', version: 2, config: null },
-    ...overrides,
-  }
-}
-
-/** Resolve the standard preset's config the same way the hook does. */
-async function standardConfig() {
-  const { resolveFlow } = await import('./lib/workflows.js')
-  const resolved = resolveFlow('standard')
-  assert.equal(resolved.ok, true, 'the built-in standard preset resolves')
-  return resolved.config
-}
-
-test('a task at its checkpoint with the right message commits', async () => {
-  const config = await standardConfig()
-  const root = repo('allow', approvedTask({ flow: { flow: 'standard', version: 2, config } }))
-  try {
-    const result = tryCommit(root, '【HOOK-1】【TASK】probe the hook')
-    assert.equal(result.allowed, true, `expected the commit to proceed, stderr: ${result.stderr}`)
-  } finally {
-    assert.ok(resolve(root).startsWith(resolve(tmpdir()) + sep))
-    rmSync(root, { recursive: true, force: true })
-  }
-})
-
-test('a message that violates the configured pattern is refused', async () => {
-  const config = await standardConfig()
-  const root = repo('badmsg', approvedTask({ flow: { flow: 'standard', version: 2, config } }))
-  try {
-    const result = tryCommit(root, 'no task id here')
-    assert.equal(result.allowed, false, 'a malformed summary must be refused')
-    assert.match(result.stderr, /提交门禁拒绝/, 'the gate states its own refusal reason')
-  } finally {
-    rmSync(root, { recursive: true, force: true })
-  }
-})
-
-test('a commit touching files outside the declared scope is refused', async () => {
-  const config = await standardConfig()
-  const root = repo('scope', approvedTask({ flow: { flow: 'standard', version: 2, config } }))
-  try {
-    writeFileSync(join(root, 'src', 'other.js'), 'console.log(2)\n')
-    git(root, ['add', 'src/other.js'])
-    const result = tryCommit(root, '【HOOK-1】【TASK】probe the hook')
-    assert.equal(result.allowed, false, 'an out-of-scope path must be refused')
-    assert.match(result.stderr, /任务范围之外/, 'the refusal names the scope violation')
-  } finally {
-    rmSync(root, { recursive: true, force: true })
-  }
-})
-
-test('a commit before the checkpoint stage is refused', async () => {
-  const config = await standardConfig()
-  const root = repo('stage', approvedTask({ stage: '开发', flow: { flow: 'standard', version: 2, config } }))
-  try {
-    const result = tryCommit(root, '【HOOK-1】【TASK】probe the hook')
-    assert.equal(result.allowed, false, 'committing before the checkpoint must be refused')
-    assert.match(result.stderr, /提交门禁拒绝/, 'the gate states its refusal reason')
-  } finally {
-    rmSync(root, { recursive: true, force: true })
-  }
-})
-
-test('a task whose frozen snapshot was edited is refused', async () => {
-  const config = await standardConfig()
-  const tampered = { ...config, start_stage: '开发' }
-  const root = repo('tamper', approvedTask({
-    flow: { flow: 'standard', version: 2, config: tampered, hash: 'not-the-real-hash' },
-  }))
-  try {
-    const result = tryCommit(root, '【HOOK-1】【TASK】probe the hook')
-    assert.equal(result.allowed, false, 'a snapshot hash mismatch must be refused')
-    assert.match(result.stderr, /hash 不匹配/, 'the refusal names the integrity failure')
-  } finally {
-    rmSync(root, { recursive: true, force: true })
-  }
-})
-
-test('touching a sensitive path without a high-risk receipt is refused', async () => {
-  const config = await standardConfig()
-  const root = repo('sensitive', approvedTask({
-    files: ['src/app.js', '.env'],
-    flow: { flow: 'standard', version: 2, config },
-  }))
-  try {
-    writeFileSync(join(root, '.env'), 'SECRET=1\n')
-    git(root, ['add', '.env'])
-    const result = tryCommit(root, '【HOOK-1】【TASK】probe the hook')
-    assert.equal(result.allowed, false, 'a sensitive path without a high-risk receipt must be refused')
-    assert.match(result.stderr, /敏感路径/, 'the refusal names the sensitive path')
-  } finally {
-    rmSync(root, { recursive: true, force: true })
-  }
+/**
+ * End-to-end test for the installed commit-msg hook.
+ *
+ * The P0 suite asserts on the hook SOURCE (that it disables path quoting, reads
+ * NUL-separated paths, bundles the frozen snapshot). Those assertions catch a
+ * hand-mirror regressing, but they cannot show the gate actually blocks a commit
+ * — a hook that refuses everything, or nothing, passes every one of them.
+ *
+ * This runs the real bundled hook inside a throwaway git repository and asserts
+ * both directions: an illegal commit is refused, a legal one proceeds.
+ *
+ * Run: `node --test .hook-test.mjs`
+ * @module dsh-task-engine/.hook-test
+ */
+
+import assert from 'node:assert/strict'
+import { execFileSync } from 'node:child_process'
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join, resolve, sep } from 'node:path'
+import { test } from 'node:test'
+
+const HOOK = resolve('hooks/commit-msg')
+
+/**
+ * Git runs a hook by handing it to its own POSIX shell, which resolves
+ * `#!/usr/bin/env node` against PATH. On Windows a `node.cmd` shim on PATH is
+ * not executable from that shell, so the installed hook is wrapped in a
+ * launcher that names the very interpreter running this test. Without it the
+ * suite would read as the gate refusing everything, when in truth the hook
+ * never started.
+ */
+const NODE = process.execPath.replace(/\\/gu, '/')
+
+/** Run a git command in `cwd`, returning stdout (throws on non-zero exit). */
+function git(cwd, args) {
+  return execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] })
+}
+
+/**
+ * Run `git commit` and report whether the hook allowed it.
+ * A refused commit surfaces as a non-zero exit whose stderr carries the gate's
+ * own Chinese refusal banner.
+ */
+function tryCommit(cwd, message) {
+  try {
+    execFileSync('git', ['commit', '-m', message], { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] })
+    return { allowed: true, stderr: '' }
+  } catch (error) {
+    return { allowed: false, stderr: String(error.stderr ?? '') }
+  }
+}
+
+/** Build a throwaway repository with the real hook installed and one staged file. */
+function repo(name, task) {
+  const root = mkdtempSync(join(tmpdir(), `engine-hook-${name}-`))
+  git(root, ['init', '-q', '-b', 'main'])
+  git(root, ['config', 'user.email', 'test@example.com'])
+  git(root, ['config', 'user.name', 'Test'])
+  git(root, ['config', 'commit.gpgsign', 'false'])
+  mkdirSync(join(root, '.dsh'), { recursive: true })
+  mkdirSync(join(root, 'src'), { recursive: true })
+  // The gate body stays byte-identical to the shipped hook; only the shebang is
+  // replaced, so the test exercises the real gate under a runnable interpreter.
+  const gate = readFileSync(HOOK, 'utf8').replace(/^#![^\n]*\n/u, '')
+  writeFileSync(join(root, '.git', 'hooks', 'commit-msg'), `#!${NODE}\n${gate}`)
+  writeFileSync(join(root, '.git', 'hooks', 'package.json'), '{\n  "type": "commonjs"\n}\n')
+  writeFileSync(join(root, '.dsh', `task-${task.id}.json`), JSON.stringify(task, null, 2))
+  writeFileSync(join(root, 'src', 'app.js'), 'console.log(1)\n')
+  git(root, ['add', 'src/app.js'])
+  return root
+}
+
+/**
+ * A standard-flow task that has reached the commit checkpoint with a declared
+ * scope. `代码审核` is the checkpoint stage, and the engine only permits a
+ * commit there once that stage's OUTGOING guards already hold — so the fixture
+ * must also satisfy the review artifact and the review verdict.
+ */
+function approvedTask(overrides = {}) {
+  return {
+    schema: 1,
+    id: 'HOOK-1',
+    title: 'hook probe',
+    branch: 'main',
+    work_size: 'standard',
+    risk_level: 'standard',
+    stage: '代码审核',
+    requirement_confirmed: true,
+    solution_confirmed: true,
+    items: [{ id: 'i1', title: 'do the thing', status: 'done', review: { spec: { outcome: 'pass' }, quality: { outcome: 'pass' } } }],
+    verification: { passed: true, evidence: [] },
+    review: { outcome: 'pass' },
+    // The `代码审核 -> 完成` edge requires `review_passed` and `artifacts_present`.
+    artifacts: { review: { conclusion: 'looks good', issues: 'none' } },
+    files: ['src/app.js'],
+    commits: [],
+    flow: { flow: 'standard', version: 2, config: null },
+    ...overrides,
+  }
+}
+
+/**
+ * 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, 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
+}
+
+test('a task at its checkpoint with the right message commits', async () => {
+  const config = await standardConfig()
+  const root = repo('allow', approvedTask({ flow: { flow: 'standard', version: 2, config } }))
+  try {
+    const result = tryCommit(root, '【HOOK-1】【TASK】probe the hook')
+    assert.equal(result.allowed, true, `expected the commit to proceed, stderr: ${result.stderr}`)
+  } finally {
+    assert.ok(resolve(root).startsWith(resolve(tmpdir()) + sep))
+    rmSync(root, { recursive: true, force: true })
+  }
+})
+
+test('a message that violates the configured pattern is refused', async () => {
+  const config = await standardConfig()
+  const root = repo('badmsg', approvedTask({ flow: { flow: 'standard', version: 2, config } }))
+  try {
+    const result = tryCommit(root, 'no task id here')
+    assert.equal(result.allowed, false, 'a malformed summary must be refused')
+    assert.match(result.stderr, /提交门禁拒绝/, 'the gate states its own refusal reason')
+  } finally {
+    rmSync(root, { recursive: true, force: true })
+  }
+})
+
+test('a commit touching files outside the declared scope is refused', async () => {
+  const config = await standardConfig()
+  const root = repo('scope', approvedTask({ flow: { flow: 'standard', version: 2, config } }))
+  try {
+    writeFileSync(join(root, 'src', 'other.js'), 'console.log(2)\n')
+    git(root, ['add', 'src/other.js'])
+    const result = tryCommit(root, '【HOOK-1】【TASK】probe the hook')
+    assert.equal(result.allowed, false, 'an out-of-scope path must be refused')
+    assert.match(result.stderr, /任务范围之外/, 'the refusal names the scope violation')
+  } finally {
+    rmSync(root, { recursive: true, force: true })
+  }
+})
+
+test('a commit before the checkpoint stage is refused', async () => {
+  const config = await standardConfig()
+  const root = repo('stage', approvedTask({ stage: '开发', flow: { flow: 'standard', version: 2, config } }))
+  try {
+    const result = tryCommit(root, '【HOOK-1】【TASK】probe the hook')
+    assert.equal(result.allowed, false, 'committing before the checkpoint must be refused')
+    assert.match(result.stderr, /提交门禁拒绝/, 'the gate states its refusal reason')
+  } finally {
+    rmSync(root, { recursive: true, force: true })
+  }
+})
+
+test('a task whose frozen snapshot was edited is refused', async () => {
+  const config = await standardConfig()
+  const tampered = { ...config, start_stage: '开发' }
+  const root = repo('tamper', approvedTask({
+    flow: { flow: 'standard', version: 2, config: tampered, hash: 'not-the-real-hash' },
+  }))
+  try {
+    const result = tryCommit(root, '【HOOK-1】【TASK】probe the hook')
+    assert.equal(result.allowed, false, 'a snapshot hash mismatch must be refused')
+    assert.match(result.stderr, /hash 不匹配/, 'the refusal names the integrity failure')
+  } finally {
+    rmSync(root, { recursive: true, force: true })
+  }
+})
+
+test('touching a sensitive path without a high-risk receipt is refused', async () => {
+  const config = await standardConfig()
+  const root = repo('sensitive', approvedTask({
+    files: ['src/app.js', '.env'],
+    flow: { flow: 'standard', version: 2, config },
+  }))
+  try {
+    writeFileSync(join(root, '.env'), 'SECRET=1\n')
+    git(root, ['add', '.env'])
+    const result = tryCommit(root, '【HOOK-1】【TASK】probe the hook')
+    assert.equal(result.allowed, false, 'a sensitive path without a high-risk receipt must be refused')
+    assert.match(result.stderr, /敏感路径/, 'the refusal names the sensitive path')
+  } finally {
+    rmSync(root, { recursive: true, force: true })
+  }
 })