@xulthekl/team-flow 0.22.4

package/tests/lib/cmd-sync-paths.test.mjs

@@ -0,0 +1,84 @@
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, existsSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { deriveCapabilityDir } from '../../scripts/lib/cmd-sync.mjs';
+
+const CLI = join(process.cwd(), 'scripts/team-flow.mjs');
+let tempRoot;
+
+function runSync(cwd, changeDir) {
+  try {
+    const stdout = execFileSync(process.execPath, [CLI, 'sync', changeDir], {
+      cwd,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    return { exitCode: 0, stdout, stderr: '' };
+  } catch (err) {
+    return {
+      exitCode: err.status || 1,
+      stdout: err.stdout?.toString() || '',
+      stderr: err.stderr?.toString() || err.message,
+    };
+  }
+}
+
+function writeSpec(path) {
+  writeFileSync(path, '## ADDED Requirements\n\n### Requirement: Sync path\n\nThe system SHALL sync canonical paths.\n\n#### Scenario: Sync\n- **WHEN** sync runs\n- **THEN** the main spec is written');
+}
+
+describe('cmd-sync: canonical spec paths', () => {
+  before(() => {
+    tempRoot = mkdtempSync(join(tmpdir(), 'tf-sync-paths-'));
+  });
+
+  after(() => {
+    if (tempRoot) rmSync(tempRoot, { recursive: true, force: true });
+  });
+
+  it('syncs canonical specs to main specs/<capability>/spec.md', () => {
+    const repo = mkdtempSync(join(tempRoot, 'repo-'));
+    const change = join(repo, 'changes', 'canonical');
+    mkdirSync(join(change, 'specs', 'ui-theme'), { recursive: true });
+    writeSpec(join(change, 'specs', 'ui-theme', 'spec.md'));
+
+    const result = runSync(repo, change);
+    assert.equal(result.exitCode, 0, result.stdout + result.stderr);
+    assert.equal(existsSync(join(repo, 'specs', 'ui-theme', 'spec.md')), true);
+    assert.match(readFileSync(join(repo, 'specs', 'ui-theme', 'spec.md'), 'utf-8'), /Sync path/);
+  });
+
+  it('derives capability dirs from Windows-style spec paths', () => {
+    assert.equal(
+      deriveCapabilityDir('C:\\repo\\changes\\feature\\specs', 'C:\\repo\\changes\\feature\\specs\\ui-theme\\spec.md'),
+      'ui-theme',
+    );
+  });
+
+  it('rejects flat specs before syncing', () => {
+    const repo = mkdtempSync(join(tempRoot, 'repo-flat-'));
+    const change = join(repo, 'changes', 'flat');
+    mkdirSync(join(change, 'specs'), { recursive: true });
+    writeSpec(join(change, 'specs', 'ui-theme.md'));
+
+    const result = runSync(repo, change);
+    assert.equal(result.exitCode, 1);
+    assert.match(result.stdout + result.stderr, /Invalid spec path: specs\/ui-theme\.md/);
+    assert.equal(existsSync(join(repo, 'specs', 'ui-theme', 'spec.md')), false);
+  });
+
+  it('rejects root specs/spec.md before syncing', () => {
+    const repo = mkdtempSync(join(tempRoot, 'repo-root-'));
+    const change = join(repo, 'changes', 'root-spec');
+    mkdirSync(join(change, 'specs'), { recursive: true });
+    writeSpec(join(change, 'specs', 'spec.md'));
+
+    const result = runSync(repo, change);
+    assert.equal(result.exitCode, 1);
+    assert.match(result.stdout + result.stderr, /Invalid spec path: specs\/spec\.md/);
+    assert.equal(existsSync(join(repo, 'specs', 'spec.md')), false);
+  });
+});

package/tests/lib/cmd-validate-paths.test.mjs

@@ -0,0 +1,90 @@
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+const CLI = join(process.cwd(), 'scripts/team-flow.mjs');
+const LEGACY = join(process.cwd(), 'scripts/validate-artifacts');
+let tempRoot;
+
+function runNode(args) {
+  try {
+    const stdout = execFileSync(process.execPath, args, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
+    return { exitCode: 0, stdout, stderr: '' };
+  } catch (err) {
+    return { exitCode: err.status || 1, stdout: err.stdout?.toString() || '', stderr: err.stderr?.toString() || err.message };
+  }
+}
+
+function writeBaseChange(dir) {
+  writeFileSync(join(dir, 'proposal.md'), '## Why\nThis proposal is long enough to pass validation because it explains the user problem clearly.\n## What Changes\n- Add validated behavior');
+  writeFileSync(join(dir, 'design.md'), '## Context\nValidation fixture.\n## Goals\nKeep paths canonical.\n## Decisions\n### D1\n- Choice: canonical specs\n- Rationale: one path');
+  writeFileSync(join(dir, 'tasks.md'), '## File Structure\n- Modify: scripts/example.mjs\n## Tasks\n- [x] Validate paths');
+}
+
+function writeValidSpec(file) {
+  writeFileSync(file, '## ADDED Requirements\n\n### Requirement: Canonical path\n\nThe system SHALL validate canonical specs.\n\n#### Scenario: Valid spec\n- **WHEN** validation runs\n- **THEN** the spec is checked');
+}
+
+describe('validate commands: spec paths', () => {
+  before(() => {
+    tempRoot = mkdtempSync(join(tmpdir(), 'tf-validate-paths-'));
+  });
+
+  after(() => {
+    if (tempRoot) rmSync(tempRoot, { recursive: true, force: true });
+  });
+
+  it('tf validate rejects flat specs/<capability>.md', () => {
+    const dir = mkdtempSync(join(tempRoot, 'flat-'));
+    writeBaseChange(dir);
+    mkdirSync(join(dir, 'specs'), { recursive: true });
+    writeValidSpec(join(dir, 'specs', 'ui-theme.md'));
+
+    const result = runNode([CLI, 'validate', dir]);
+    assert.equal(result.exitCode, 1);
+    assert.match(result.stdout + result.stderr, /Invalid spec path: specs\/ui-theme\.md/);
+    assert.match(result.stdout + result.stderr, /specs\/ui-theme\/spec\.md/);
+  });
+
+  it('validate-artifacts rejects specs/ with no canonical spec.md', () => {
+    const dir = mkdtempSync(join(tempRoot, 'empty-specs-'));
+    writeBaseChange(dir);
+    mkdirSync(join(dir, 'specs'), { recursive: true });
+
+    const result = runNode([LEGACY, dir]);
+    assert.equal(result.exitCode, 1);
+    assert.match(result.stdout + result.stderr, /No canonical spec files found/);
+  });
+
+  it('tf validate rejects a change with no specs/ directory', () => {
+    const dir = mkdtempSync(join(tempRoot, 'missing-specs-cli-'));
+    writeBaseChange(dir);
+
+    const result = runNode([CLI, 'validate', dir]);
+    assert.equal(result.exitCode, 1);
+    assert.match(result.stdout + result.stderr, /No canonical spec files found/);
+  });
+
+  it('validate-artifacts rejects a change with no specs/ directory', () => {
+    const dir = mkdtempSync(join(tempRoot, 'missing-specs-legacy-'));
+    writeBaseChange(dir);
+
+    const result = runNode([LEGACY, dir]);
+    assert.equal(result.exitCode, 1);
+    assert.match(result.stdout + result.stderr, /No canonical spec files found/);
+  });
+
+  it('tf validate accepts canonical specs/<capability>/spec.md', () => {
+    const dir = mkdtempSync(join(tempRoot, 'canonical-'));
+    writeBaseChange(dir);
+    mkdirSync(join(dir, 'specs', 'ui-theme'), { recursive: true });
+    writeValidSpec(join(dir, 'specs', 'ui-theme', 'spec.md'));
+
+    const result = runNode([CLI, 'validate', dir]);
+    assert.equal(result.exitCode, 0, result.stdout + result.stderr);
+    assert.match(result.stdout, /specs\/ui-theme\/spec\.md/);
+  });
+});

package/tests/lib/config-loader.test.mjs

@@ -0,0 +1,175 @@
+// tests/lib/config-loader.test.mjs
+// Tests for scripts/lib/config-loader.mjs
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+// We need to import from the scripts directory. Since config-loader uses
+// relative imports only (no path manipulation), we can test its pure logic
+// by importing and controlling cwd.
+
+// Store original cwd
+const originalCwd = process.cwd;
+let tempDir;
+
+describe('config-loader: getDefaults()', () => {
+  let configLoader;
+
+  before(async () => {
+    // Dynamic import to get fresh module
+    const modulePath = join(process.cwd(), 'scripts/lib/config-loader.mjs');
+    configLoader = await import(modulePath);
+  });
+
+  it('returns DEFAULTS object with expected shape', () => {
+    const defaults = configLoader.getDefaults();
+    assert.ok(defaults.artifacts);
+    assert.deepStrictEqual(defaults.artifacts.order, ['proposal', 'specs', 'design', 'tasks']);
+    assert.deepStrictEqual(defaults.artifacts.skip, []);
+    assert.ok(defaults.execution);
+    assert.equal(defaults.execution.inlineThreshold, 3);
+    assert.equal(defaults.execution.abandonmentReasonMinLength, 50);
+    assert.equal(defaults.execution.defaultLanguage, 'auto');
+    assert.ok(defaults.verification);
+    assert.equal(defaults.verification.language, 'auto');
+  });
+
+  it('returns a deep copy, not a reference', () => {
+    const d1 = configLoader.getDefaults();
+    const d2 = configLoader.getDefaults();
+    d1.artifacts.order.push('execution-contract');
+    assert.notDeepStrictEqual(d1.artifacts.order, d2.artifacts.order);
+  });
+});
+
+describe('config-loader: resolveModelProfile()', () => {
+  let configLoader;
+
+  before(async () => {
+    const modulePath = join(process.cwd(), 'scripts/lib/config-loader.mjs');
+    configLoader = await import(modulePath);
+  });
+
+  it('exposes the supported model profiles in order', () => {
+    assert.deepStrictEqual(configLoader.MODEL_PROFILES, [
+      'mechanical', 'standard', 'strong', 'review',
+    ]);
+  });
+
+  it('resolves all four configured profiles without changing their model identifiers', () => {
+    const config = {
+      models: {
+        mechanical: 'vendor-small', standard: 'vendor-standard',
+        strong: 'vendor-strong', review: 'vendor-review',
+      },
+    };
+    assert.deepStrictEqual(configLoader.resolveModelProfile(config, 'mechanical'), {
+      profile: 'mechanical', model: 'vendor-small', configured: true,
+    });
+    assert.deepStrictEqual(configLoader.resolveModelProfile(config, 'standard'), {
+      profile: 'standard', model: 'vendor-standard', configured: true,
+    });
+    assert.deepStrictEqual(configLoader.resolveModelProfile(config, 'strong'), {
+      profile: 'strong', model: 'vendor-strong', configured: true,
+    });
+    assert.deepStrictEqual(configLoader.resolveModelProfile(config, 'review'), {
+      profile: 'review', model: 'vendor-review', configured: true,
+    });
+  });
+
+  it('returns an explicit unmapped result for a known profile', () => {
+    assert.deepStrictEqual(configLoader.resolveModelProfile({}, 'strong'), {
+      profile: 'strong', model: null, configured: false,
+    });
+  });
+
+  it('does not let partial model mappings affect missing known profiles', () => {
+    assert.deepStrictEqual(
+      configLoader.resolveModelProfile({ models: { review: 'vendor-review' } }, 'standard'),
+      { profile: 'standard', model: null, configured: false },
+    );
+  });
+
+  it('rejects unknown and malformed mappings deterministically', () => {
+    assert.throws(() => configLoader.resolveModelProfile({}, 'fast'),
+      /Unknown model profile 'fast'.*mechanical.*standard.*strong.*review/);
+    assert.throws(() => configLoader.resolveModelProfile({ models: { review: '   ' } }, 'review'),
+      /models\.review must be a non-empty string/);
+    assert.throws(() => configLoader.resolveModelProfile({ models: { review: 42 } }, 'review'),
+      /models\.review must be a non-empty string/);
+  });
+});
+
+describe('config-loader: loadConfig()', () => {
+  let configLoader;
+
+  before(async () => {
+    tempDir = mkdtempSync(join(tmpdir(), 'tf-config-test-'));
+    const modulePath = join(process.cwd(), 'scripts/lib/config-loader.mjs');
+    configLoader = await import(modulePath);
+  });
+
+  after(() => {
+    if (tempDir) rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('returns defaults when no config file exists', () => {
+    const config = configLoader.loadConfig(tempDir);
+    assert.deepStrictEqual(config.artifacts.order, ['proposal', 'specs', 'design', 'tasks']);
+    assert.equal(config.execution.inlineThreshold, 3);
+  });
+
+  it('merges user config with defaults', () => {
+    const userConfig = {
+      artifacts: {
+        order: ['proposal', 'design', 'tasks'],
+        skip: ['specs'],
+      },
+      execution: {
+        inlineThreshold: 5,
+      },
+    };
+    writeFileSync(join(tempDir, 'team-flow.config.json'), JSON.stringify(userConfig));
+
+    const config = configLoader.loadConfig(tempDir);
+
+    // User values override
+    assert.deepStrictEqual(config.artifacts.order, ['proposal', 'design', 'tasks']);
+    assert.deepStrictEqual(config.artifacts.skip, ['specs']);
+    assert.equal(config.execution.inlineThreshold, 5);
+
+    // Unspecified defaults preserved
+    assert.equal(config.execution.abandonmentReasonMinLength, 50);
+    assert.equal(config.verification.language, 'auto');
+  });
+
+  it('handles partial user config without crashing', () => {
+    // Clean up previous config
+    rmSync(join(tempDir, 'team-flow.config.json'), { force: true });
+
+    const userConfig = {
+      execution: {
+        inlineThreshold: 10,
+      },
+    };
+    writeFileSync(join(tempDir, 'team-flow.config.json'), JSON.stringify(userConfig));
+
+    const config = configLoader.loadConfig(tempDir);
+
+    assert.equal(config.execution.inlineThreshold, 10);
+    // artifacts should still have defaults
+    assert.deepStrictEqual(config.artifacts.order, ['proposal', 'specs', 'design', 'tasks']);
+  });
+
+  it('handles invalid JSON gracefully, returning defaults', () => {
+    writeFileSync(join(tempDir, 'team-flow.config.json'), 'not valid json {{{');
+
+    const config = configLoader.loadConfig(tempDir);
+
+    // Should fall back to defaults on parse error
+    assert.deepStrictEqual(config.artifacts.order, ['proposal', 'specs', 'design', 'tasks']);
+    assert.equal(config.execution.inlineThreshold, 3);
+  });
+});

package/tests/lib/ensure-branch.test.mjs

@@ -0,0 +1,59 @@
+// tests/lib/ensure-branch.test.mjs
+// Regression for #15: git branch isolation must be enforceable, not just advised.
+// `ensure-branch.mjs` must refuse to proceed on a protected branch when it cannot
+// isolate, and must allow work on a non-protected branch.
+
+import { describe, it, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { execSync } from 'node:child_process';
+import { mkdtempSync, rmSync, existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = join(__dirname, '..', '..');
+const ENSURE = join(ROOT, 'scripts', 'ensure-branch.mjs');
+
+function run(args) {
+  try {
+    const out = execSync(`node ${ENSURE} ${args}`, { encoding: 'utf-8', stdio: 'pipe', timeout: 10000 });
+    return { ok: true, out };
+  } catch (e) {
+    return { ok: false, out: `${e.stdout || ''}\n${e.stderr || ''}` || e.message };
+  }
+}
+
+function git(dir, ...args) {
+  execSync(`git -c user.email=t@t -c user.name=test ${args.join(' ')}`, { cwd: dir, stdio: 'pipe', timeout: 10000 });
+}
+
+describe('BUG/#15: ensure-branch enforces isolation', () => {
+  let plainDir, repoDir;
+  before(() => {
+    plainDir = mkdtempSync(join(tmpdir(), 'tf-ensure-plain-'));
+    repoDir = mkdtempSync(join(tmpdir(), 'tf-ensure-repo-'));
+    mkdirSync(join(repoDir, 'specs'), { recursive: true });
+    writeFileSync(join(repoDir, 'README.md'), 'x');
+    git(repoDir, 'init', '-q');
+    git(repoDir, 'add', '-A');
+    git(repoDir, 'commit', '-q', '-m', 'init');
+    git(repoDir, 'checkout', '-q', '-b', 'feature/work');
+  });
+  after(() => {
+    if (existsSync(plainDir)) rmSync(plainDir, { recursive: true, force: true });
+    if (existsSync(repoDir)) rmSync(repoDir, { recursive: true, force: true });
+  });
+
+  it('SHALL refuse (non-zero) when not inside a git repository', () => {
+    const r = run(`"${plainDir}"`);
+    assert.equal(r.ok, false, 'ensure-branch must fail outside a git repo');
+  });
+
+  it('SHALL allow (zero) work on a non-protected branch', () => {
+    const r = run(`"${repoDir}"`);
+    assert.equal(r.ok, true, `ensure-branch should pass on feature branch, got: ${r.out}`);
+    assert.match(r.out, /already isolated/i);
+  });
+});

package/tests/lib/execution-control-plane.test.mjs

@@ -0,0 +1,168 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const root = process.cwd();
+const read = path => readFileSync(join(root, path), 'utf8');
+
+describe('execution control plane instructions', () => {
+  it('documents #45 guarded execution without claiming #47 slash commands', () => {
+    const documents = [
+      'README.md',
+      'docs/README_en.md',
+      'INSTALL.md',
+      'templates/execution-contract.md',
+      'docs/state-machine.md',
+      'docs/artifact-contract.md',
+    ];
+
+    for (const path of documents) {
+      const content = read(path);
+      assert.match(content, /execution[ -]plan/i, `${path} documents execution plans`);
+      assert.match(content, /execution recommend|execution-recommendation|执行模式推荐/i, `${path} documents execution-mode recommendations`);
+      assert.match(content, /execution-recommendation\.json|recommendation receipt|推荐凭据/i, `${path} documents persisted recommendation evidence`);
+      assert.match(content, /--confirm|用户.*确认|user.*confirm/is, `${path} documents user confirmation`);
+      assert.match(content, /acknowledge-recommendation|确认.*风险|acknowledg/is, `${path} documents acknowledgement for a non-recommended choice`);
+      assert.match(content, /review receipt/i, `${path} documents review receipts`);
+    }
+
+    assert.match(read('templates/execution-contract.md'), /Execution Waves/);
+    assert.match(read('CHANGELOG.md'), /#45/);
+    assert.doesNotMatch(read('README.md'), /\/tf:resume/);
+    assert.doesNotMatch(read('docs/README_en.md'), /\/tf:resume/);
+    assert.doesNotMatch(read('INSTALL.md'), /\/tf:resume/);
+
+    for (const path of documents) {
+      assert.doesNotMatch(read(path), /automatic(?:ally)?\s+(?:defaults?\s+to\s+)?Batch Inline/i,
+        `${path} does not advertise automatic Batch Inline`);
+    }
+  });
+
+  it('documents only the persisted execution-plan contract that #45 implements', () => {
+    const documents = [
+      'README.md',
+      'docs/README_en.md',
+      'INSTALL.md',
+      'templates/execution-contract.md',
+      'docs/state-machine.md',
+      'docs/artifact-contract.md',
+      'CHANGELOG.md',
+    ];
+
+    for (const path of documents) {
+      const content = read(path);
+      assert.match(content, /\.superpowers\/sdd\/execution-plan\.json/,
+        `${path} identifies the persisted execution-plan path`);
+      assert.doesNotMatch(content, /write[- ]?conflict/i,
+        `${path} does not claim an unpersisted write-conflict check`);
+    }
+
+    for (const path of ['README.md', 'docs/README_en.md', 'INSTALL.md']) {
+      const content = read(path);
+      assert.match(content, /execution revise/i, `${path} documents execution revise`);
+      assert.match(content,
+        /retains?\/upgrades?.*sdd.*replan|inline\/batch-inline.*(?:upgrades?|升级).*sdd.*(?:or|或).*(?:replans?|重规划).*sdd/is,
+        `${path} allows SDD replanning while retaining the no-downgrade contract`);
+      assert.match(content, /downgrade|降级/i, `${path} keeps SDD downgrade rejection explicit`);
+    }
+
+    assert.match(read('scripts/team-flow.mjs'), /upgrade inline\/batch.*replan existing sdd.*new revision/is,
+      'CLI help describes SDD replanning instead of only inline upgrades');
+  });
+
+  it('documents portable and auditable review receipt evidence', () => {
+    const localizedDocuments = ['README.md', 'INSTALL.md'];
+
+    for (const path of localizedDocuments) {
+      const content = read(path);
+      assert.match(content,
+        /--report.*相对于.*<change>.*解析.*<change>\/.superpowers\/sdd\/reviews/is,
+        `${path} resolves review reports from the change directory into its reviews overlay`);
+      assert.match(content, /--base.*--head.*真实.*commit/is,
+        `${path} requires real commits for review ranges`);
+      assert.match(content, /<change>.*Git.*工作树/is,
+        `${path} binds review ranges to the change worktree`);
+      assert.match(content, /base.*head.*祖先/is,
+        `${path} requires base to precede head`);
+      assert.match(content,
+        /<change>\/.superpowers\/sdd\/reviews\/.*物理.*非符号链接/is,
+        `${path} requires physical, non-symlink review overlay directories`);
+      assert.match(content,
+        /report.*普通.*非空.*非符号链接.*文件/is,
+        `${path} requires review reports to be regular, non-empty, non-symlink files`);
+    }
+
+    const english = read('docs/README_en.md');
+    assert.match(english,
+      /--report.*resolved relative to.*<change>.*must remain under.*<change>\/.superpowers\/sdd\/reviews/is,
+      'English documentation resolves review reports from the change directory into its reviews overlay');
+    assert.match(english, /--base.*--head.*real commits/is,
+      'English documentation requires real commits for review ranges');
+    assert.match(english, /<change>.*Git worktree/is,
+      'English documentation binds review ranges to the change worktree');
+    assert.match(english, /base.*ancestor.*head/is,
+      'English documentation requires base to precede head');
+    assert.match(english,
+      /<change>\/.superpowers\/sdd\/reviews\/.*physical.*non-symlink/is,
+      'English documentation requires physical, non-symlink review overlay directories');
+    assert.match(english,
+      /report.*regular.*non-empty.*non-symlink.*file/is,
+      'English documentation requires review reports to be regular, non-empty, non-symlink files');
+  });
+
+  it('keeps execution mode and review gates machine-backed in every entry point', () => {
+    const workflowStart = read('skills/workflow-start/SKILL.md');
+    const buildExecutor = read('skills/build-executor/SKILL.md');
+    const codeReviewer = read('skills/code-reviewer/SKILL.md');
+    const inject = read('scripts/lib/cmd-inject.mjs');
+
+    assert.match(workflowStart, /execution show <change-dir> --json/);
+    assert.match(workflowStart, /execution plan <change-dir>/);
+    assert.match(buildExecutor, /execution recommend/i);
+    assert.match(buildExecutor, /user.*confirm|用户.*确认/is);
+    assert.match(buildExecutor, /acknowledge-recommendation/i);
+    assert.match(buildExecutor, /parallel.*wave/is);
+    assert.match(buildExecutor, /concurren(?:cy|t).*unavailable/i);
+    assert.match(buildExecutor, /retryable.*replacement.*pass/is);
+    assert.doesNotMatch(buildExecutor, />3 tasks, same module/);
+    assert.match(codeReviewer, /execution review <change-dir>.*--verdict <pass\|fail>/s);
+    assert.match(codeReviewer, /Critical\/Important.*fail.*receipt/is);
+    assert.match(inject, /execution plan/);
+    assert.match(inject, /pass.*review receipts.*closing/is);
+    assert.match(buildExecutor, /<wave-id>:<parallel\|serial>:<task,.+>\[:<depends-on/i);
+  });
+
+  it('gives every packaged installer the same planned-execution gate', () => {
+    for (const path of [
+      'scripts/lib/install.mjs',
+      'scripts/lib/cmd-install-workbuddy.mjs',
+      'scripts/install-cursor.mjs',
+      'scripts/install-zcode.mjs',
+    ]) {
+      const content = read(path);
+      assert.match(content, /execution recommend/);
+      assert.match(content, /--confirm/);
+      assert.match(content, /acknowledge-recommendation/);
+      assert.match(content, /all.*pass.*review receipt.*closing/is);
+      assert.match(content, /full\/hotfix.*tweak.*exempt/is);
+    }
+  });
+
+  it('keeps task implementer and reviewer prompts aligned with planned waves and receipts', () => {
+    const implementer = read('skills/build-executor/implementer-prompt.md');
+    const taskReviewer = read('skills/build-executor/task-reviewer-prompt.md');
+    const reviewerPrompt = read('skills/code-reviewer/code-reviewer-prompt.md');
+
+    assert.match(implementer, /planned wave/i);
+    assert.match(implementer, /implementer report path/i);
+    assert.match(taskReviewer, /execution review <change-dir>/);
+    assert.match(taskReviewer, /--verdict <pass\|fail>/);
+    assert.match(taskReviewer, /review report\s+path/i);
+    assert.match(taskReviewer, /persisted.*review report/i);
+    assert.match(reviewerPrompt, /execution review <change-dir>/);
+    assert.match(reviewerPrompt, /wave ID/i);
+    assert.match(reviewerPrompt, /review report\s+path/i);
+    assert.match(reviewerPrompt, /persisted.*review report/i);
+  });
+});