ultra-builder-pro-cli 0.5.0

package/adapters/_shared/tests/file-ops.test.cjs

@@ -0,0 +1,54 @@
+'use strict';
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const { copyTree, writeAtomic, removeTree } = require('../file-ops.cjs');
+
+function mk(prefix = 'ubp-shared-') {
+  return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+}
+
+test('copyTree copies recursively and skips .DS_Store', () => {
+  const src = mk();
+  const dst = mk();
+  try {
+    fs.mkdirSync(path.join(src, 'nested'));
+    fs.writeFileSync(path.join(src, 'a.txt'), 'A');
+    fs.writeFileSync(path.join(src, '.DS_Store'), 'junk');
+    fs.writeFileSync(path.join(src, 'nested', 'b.txt'), 'B');
+
+    const files = copyTree(src, dst);
+    assert.deepEqual(files.sort(), ['a.txt', path.join('nested', 'b.txt')]);
+    assert.equal(fs.readFileSync(path.join(dst, 'a.txt'), 'utf8'), 'A');
+    assert.equal(fs.readFileSync(path.join(dst, 'nested', 'b.txt'), 'utf8'), 'B');
+    assert.ok(!fs.existsSync(path.join(dst, '.DS_Store')));
+  } finally {
+    removeTree(src);
+    removeTree(dst);
+  }
+});
+
+test('writeAtomic never leaves a torn write — tmp file is renamed', () => {
+  const dir = mk();
+  try {
+    const target = path.join(dir, 'out', 'file.txt');
+    writeAtomic(target, 'hello');
+    assert.equal(fs.readFileSync(target, 'utf8'), 'hello');
+
+    const siblings = fs.readdirSync(path.dirname(target));
+    assert.deepEqual(siblings, ['file.txt']);  // no .tmp-* left behind
+  } finally {
+    removeTree(dir);
+  }
+});
+
+test('removeTree refuses to wipe filesystem root without allowRoot', () => {
+  assert.throws(
+    () => removeTree('/', { allowRoot: false }),
+    /refusing to remove filesystem root/,
+  );
+});

package/adapters/_shared/tests/frontmatter.test.cjs

@@ -0,0 +1,47 @@
+'use strict';
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+
+const { parse, serialize, lowercaseKeys, patch } = require('../frontmatter.cjs');
+
+test('parse extracts frontmatter and body; degraded inputs survive', () => {
+  const withFm = '---\ndescription: hi\nmodel: opus\n---\n\n# Hello\n';
+  const out = parse(withFm);
+  assert.equal(out.fm.description, 'hi');
+  assert.equal(out.fm.model, 'opus');
+  assert.ok(out.body.startsWith('# Hello'));
+
+  // no delimiter at all
+  const plain = parse('# No frontmatter\n');
+  assert.equal(plain.fm, null);
+  assert.equal(plain.body, '# No frontmatter\n');
+
+  // delimiter open but never closed — treat as plain text
+  const unclosed = parse('---\nfoo: 1\nno closing delimiter\n');
+  assert.equal(unclosed.fm, null);
+  assert.ok(unclosed.body.includes('no closing delimiter'));
+
+  // type guard
+  assert.throws(() => parse(42), /expects string/);
+});
+
+test('serialize → parse round-trip preserves data', () => {
+  const fm = { description: 'round-trip', tags: ['a', 'b'] };
+  const body = '# Body\n\nparagraph\n';
+  const text = serialize(fm, body);
+  const { fm: got, body: gotBody } = parse(text);
+  assert.deepEqual(got, fm);
+  assert.equal(gotBody, body);
+});
+
+test('lowercaseKeys normalizes nested frontmatter (OpenCode contract)', () => {
+  const input = { Name: 'X', TAGS: ['T1'], Nested: { Key: 1 } };
+  const out = lowercaseKeys(input);
+  assert.deepEqual(out, { name: 'X', tags: ['T1'], nested: { key: 1 } });
+
+  // patch() should let callers transform fm in-place
+  const patched = patch('---\nFoo: 1\n---\nbody', (fm) => ({ foo: fm.Foo }));
+  const { fm } = parse(patched);
+  assert.deepEqual(fm, { foo: 1 });
+});

package/adapters/_shared/tests/handbook.test.cjs

@@ -0,0 +1,86 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const test = require('node:test');
+
+const {
+  BEGIN_MARKER,
+  END_MARKER,
+  applyHandbook,
+  mergeHandbook,
+  renderHandbook,
+  resolveHandbookFile,
+} = require('../handbook.cjs');
+
+test('renders one common contract with host-native invocation syntax', () => {
+  const claude = renderHandbook('claude');
+  const codex = renderHandbook('codex');
+  const opencode = renderHandbook('opencode');
+
+  assert.match(claude, /\/ultra-plan/);
+  assert.match(codex, /\$ultra-builder-pro:ultra-plan/);
+  assert.match(opencode, /\/ultra-plan/);
+  for (const rendered of [claude, codex, opencode]) {
+    assert.match(rendered, /\.ultra\/state\.db/);
+    assert.match(rendered, /claude-mem|cloud-mem/);
+    assert.doesNotMatch(rendered, /\.ultra\/memory|memory\.retain|memory\.recall/);
+    assert.match(rendered, new RegExp(BEGIN_MARKER.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')));
+    assert.match(rendered, new RegExp(END_MARKER.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')));
+  }
+});
+
+test('merge preserves user content and is idempotent', () => {
+  const existing = '# User rules\n\nKeep this.\n';
+  const once = mergeHandbook(existing, 'claude');
+  const twice = mergeHandbook(once, 'claude');
+
+  assert.match(once, /^# User rules/m);
+  assert.match(once, /Keep this\./);
+  assert.equal(once, twice);
+  assert.equal(once.split(BEGIN_MARKER).length - 1, 1);
+});
+
+test('Codex legacy Ultra section is replaced without touching the next section', () => {
+  const existing = [
+    '# Handbook',
+    '',
+    '## Ultra Builder Pro Runtime Contract',
+    '',
+    'Old memory contract under `.ultra/memory/`.',
+    '',
+    '## Standard Operating Workflow',
+    '',
+    'Keep this workflow.',
+    '',
+  ].join('\n');
+
+  const merged = mergeHandbook(existing, 'codex');
+  assert.doesNotMatch(merged, /Old memory contract/);
+  assert.match(merged, /## Standard Operating Workflow\n\nKeep this workflow\./);
+  assert.equal(merged.split(BEGIN_MARKER).length - 1, 1);
+});
+
+test('apply creates a backup and reports a no-op on the second run', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-handbook-'));
+  const file = path.join(root, 'AGENTS.md');
+  fs.writeFileSync(file, '# Existing\n');
+
+  const first = applyHandbook({ runtime: 'codex', file, now: '20260715T120000Z' });
+  assert.equal(first.changed, true);
+  assert.equal(first.backup, `${file}.ubp-backup-20260715T120000Z`);
+  assert.equal(fs.readFileSync(first.backup, 'utf8'), '# Existing\n');
+
+  const second = applyHandbook({ runtime: 'codex', file, now: '20260715T120001Z' });
+  assert.equal(second.changed, false);
+  assert.equal(second.backup, null);
+});
+
+test('default handbook paths are host-specific', () => {
+  const homeDir = '/tmp/example-home';
+  assert.equal(resolveHandbookFile('claude', { homeDir }), path.join(homeDir, '.claude', 'CLAUDE.md'));
+  assert.equal(resolveHandbookFile('codex', { homeDir }), path.join(homeDir, '.codex', 'AGENTS.md'));
+  assert.equal(resolveHandbookFile('opencode', { homeDir }), path.join(homeDir, '.config', 'opencode', 'AGENTS.md'));
+});

package/adapters/_shared/tests/md-to-toml.test.cjs

@@ -0,0 +1,48 @@
+'use strict';
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+
+const { mdCommandToToml } = require('../md-to-toml.cjs');
+
+test('mdCommandToToml extracts description from frontmatter', () => {
+  const md = [
+    '---',
+    'description: Initialize project',
+    'workflow-ref: "@skills/ultra-init/SKILL.md"',
+    '---',
+    '',
+    '# /ultra-init',
+    'body content here',
+  ].join('\n');
+
+  const toml = mdCommandToToml(md);
+  assert.match(toml, /description = "Initialize project"/);
+  assert.match(toml, /prompt = """/);
+  assert.match(toml, /body content here/);
+  assert.match(toml, /workflow reference: @skills\/ultra-init\/SKILL\.md/);
+});
+
+test('mdCommandToToml includes mcp_tools_required and cli_fallback when present', () => {
+  const md = [
+    '---',
+    'description: plan tasks',
+    'mcp_tools_required:',
+    '  - task.create',
+    '  - ask.question',
+    'cli_fallback: "task create"',
+    '---',
+    'body',
+  ].join('\n');
+
+  const toml = mdCommandToToml(md);
+  assert.match(toml, /MCP tools required: task\.create, ask\.question/);
+  assert.match(toml, /CLI fallback: ultra-tools task create/);
+});
+
+test('mdCommandToToml defaults description when frontmatter absent', () => {
+  const md = '# plain markdown, no frontmatter';
+  const toml = mdCommandToToml(md);
+  assert.match(toml, /description = "Ultra Builder Pro command"/);
+  assert.match(toml, /plain markdown, no frontmatter/);
+});

package/adapters/_shared/tests/path-rewrite.test.cjs

@@ -0,0 +1,60 @@
+'use strict';
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const path = require('node:path');
+
+const {
+  parseSkillRef,
+  resolveSkillRef,
+  rewriteWorkflowRefInText,
+  resolveAssetTarget,
+} = require('../path-rewrite.cjs');
+
+test('parseSkillRef accepts canonical @skills/<slug>/SKILL.md only', () => {
+  assert.deepEqual(parseSkillRef('@skills/ultra-init/SKILL.md'), {
+    name: 'ultra-init',
+    filename: 'SKILL.md',
+  });
+  assert.equal(parseSkillRef('skills/ultra-init/SKILL.md'), null); // missing @
+  assert.equal(parseSkillRef('@skills/Bad-Case/SKILL.md'), null);   // uppercase slug
+  assert.equal(parseSkillRef(null), null);
+});
+
+test('resolveSkillRef routes to runtime-specific root under homeDir', () => {
+  const home = '/Users/test';
+  const claude = resolveSkillRef('@skills/ultra-init/SKILL.md', { runtime: 'claude', homeDir: home });
+  const opencode = resolveSkillRef('@skills/ultra-init/SKILL.md', { runtime: 'opencode', homeDir: home });
+  const codex = resolveSkillRef('@skills/ultra-init/SKILL.md', { runtime: 'codex', homeDir: home });
+  const gemini = resolveSkillRef('@skills/ultra-init/SKILL.md', { runtime: 'gemini', homeDir: home });
+
+  assert.equal(claude, path.join(home, '.claude/skills/ultra-init/SKILL.md'));
+  assert.equal(opencode, path.join(home, '.config/opencode/skills/ultra-init/SKILL.md'));
+  assert.equal(codex, path.join(home, '.agents/skills/ultra-init/SKILL.md'));
+  assert.equal(gemini, path.join(home, '.gemini/extensions/ultra-builder-pro/skills/ultra-init/SKILL.md'));
+
+  assert.throws(
+    () => resolveSkillRef('@skills/ultra-init/SKILL.md', { runtime: 'unknown', homeDir: home }),
+    /unknown runtime/,
+  );
+});
+
+test('rewriteWorkflowRefInText + resolveAssetTarget give predictable paths', () => {
+  const home = '/h';
+  const cwd = '/w';
+  const input = 'see @skills/ultra-init/SKILL.md for details';
+  const out = rewriteWorkflowRefInText(input, { runtime: 'claude', homeDir: home });
+  assert.equal(out, `see ${path.join(home, '.claude/skills/ultra-init/SKILL.md')} for details`);
+
+  // Cover every runtime × every scope so runtimeRoot/localRoot branches hit
+  for (const rt of ['claude', 'opencode', 'codex', 'gemini']) {
+    const g = resolveAssetTarget('x', { runtime: rt, scope: 'global', homeDir: home, cwd });
+    const l = resolveAssetTarget('x', { runtime: rt, scope: 'local', homeDir: home, cwd });
+    assert.ok(g.startsWith(home));
+    assert.ok(l.startsWith(cwd));
+  }
+  assert.throws(
+    () => resolveAssetTarget('x', { runtime: 'unknown', scope: 'global', homeDir: home, cwd }),
+    /unknown runtime/,
+  );
+});

package/adapters/_shared/tests/resolve-target.test.cjs

@@ -0,0 +1,85 @@
+'use strict';
+
+// Phase 4.6b reviewer suggestion — scope-precedence contract across all
+// four adapter.resolveTarget implementations.
+//
+// Each adapter honors the same ordering:
+//   ctx.configDir  >  ctx.scope='global' → env var or homeDir/.<runtime>
+//                  >  ctx.scope='local'  → cwd/.<runtime>
+//
+// Gemini also exposes resolveExtensionRoot that appends extensions/<NAME>.
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const path = require('node:path');
+
+const claude = require('../../../adapters/claude.js');
+const opencode = require('../../../adapters/opencode.js');
+const codex = require('../../../adapters/codex.js');
+const gemini = require('../../../adapters/gemini.js');
+
+// Stable fake values so assertions don't depend on real $HOME / $CWD.
+const FAKE_HOME = '/fake-home';
+const FAKE_CWD = '/fake-cwd';
+
+function withEnv(overrides, fn) {
+  const keys = Object.keys(overrides);
+  const backup = {};
+  for (const k of keys) { backup[k] = process.env[k]; }
+  for (const k of keys) {
+    if (overrides[k] === undefined) delete process.env[k];
+    else process.env[k] = overrides[k];
+  }
+  try { return fn(); }
+  finally {
+    for (const k of keys) {
+      if (backup[k] === undefined) delete process.env[k];
+      else process.env[k] = backup[k];
+    }
+  }
+}
+
+const CASES = [
+  { name: 'claude',   resolve: claude.resolveTarget,   localLeaf: '.claude',   globalHome: '.claude',   envKey: 'CLAUDE_CONFIG_DIR' },
+  { name: 'opencode', resolve: opencode.resolveTarget, localLeaf: '.opencode', globalHome: path.join('.config', 'opencode'), envKey: 'OPENCODE_CONFIG_DIR' },
+  { name: 'codex',    resolve: codex.resolveTarget,    localLeaf: '.codex',    globalHome: '.codex',    envKey: 'CODEX_HOME' },
+  { name: 'gemini',   resolve: gemini.resolveTarget,   localLeaf: '.gemini',   globalHome: '.gemini',   envKey: 'GEMINI_CONFIG_DIR' },
+];
+
+for (const tc of CASES) {
+  test(`${tc.name}.resolveTarget — configDir wins over scope/env/home`, () => {
+    withEnv({ [tc.envKey]: '/env-path', XDG_CONFIG_HOME: undefined, OPENCODE_CONFIG: undefined }, () => {
+      const out = tc.resolve({ configDir: '/explicit/path', scope: 'global', homeDir: FAKE_HOME, cwd: FAKE_CWD });
+      assert.equal(out, '/explicit/path');
+    });
+  });
+
+  test(`${tc.name}.resolveTarget — global scope picks env var`, () => {
+    withEnv({ [tc.envKey]: '/env-global', XDG_CONFIG_HOME: undefined, OPENCODE_CONFIG: undefined }, () => {
+      const out = tc.resolve({ scope: 'global', homeDir: FAKE_HOME, cwd: FAKE_CWD });
+      assert.equal(out, '/env-global');
+    });
+  });
+
+  test(`${tc.name}.resolveTarget — global scope falls back to home dir when env absent`, () => {
+    withEnv({ [tc.envKey]: undefined, XDG_CONFIG_HOME: undefined, OPENCODE_CONFIG: undefined }, () => {
+      const out = tc.resolve({ scope: 'global', homeDir: FAKE_HOME, cwd: FAKE_CWD });
+      assert.equal(out, path.join(FAKE_HOME, tc.globalHome));
+    });
+  });
+
+  test(`${tc.name}.resolveTarget — local scope uses cwd/<leaf>`, () => {
+    const out = tc.resolve({ scope: 'local', homeDir: FAKE_HOME, cwd: FAKE_CWD });
+    assert.equal(out, path.join(FAKE_CWD, tc.localLeaf));
+  });
+
+  test(`${tc.name}.resolveTarget — missing scope defaults to local (cwd)`, () => {
+    const out = tc.resolve({ homeDir: FAKE_HOME, cwd: FAKE_CWD });
+    assert.equal(out, path.join(FAKE_CWD, tc.localLeaf));
+  });
+}
+
+test('gemini.resolveExtensionRoot layers extensions/<NAME> on top of resolveTarget', () => {
+  const out = gemini.resolveExtensionRoot({ configDir: '/explicit' });
+  assert.equal(out, path.join('/explicit', 'extensions', 'ultra-builder-pro'));
+});

package/adapters/_shared/tests/rtk-detect.test.cjs

@@ -0,0 +1,116 @@
+'use strict';
+
+// Phase 6.1 — RTK soft dependency:
+//   • detectRtk(opts): locates the `rtk` binary via PATH; returns false
+//     (never throws) when missing or on any exec error.
+//   • initRtk(opts): runs `rtk init -g`; only call after detectRtk() true.
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const rtk = require('../rtk-detect.cjs');
+
+function mkEmptyBinDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-rtk-empty-bin-'));
+}
+
+function mkFakeBinDir({ succeed = true } = {}) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-rtk-fake-bin-'));
+  const script = succeed
+    ? '#!/usr/bin/env bash\nif [ "$1" = "--version" ]; then echo "rtk 1.2.3"; exit 0; fi\nif [ "$1" = "init" ]; then echo "init ok"; exit 0; fi\nexit 0\n'
+    : '#!/usr/bin/env bash\nexit 42\n';
+  const target = path.join(dir, 'rtk');
+  fs.writeFileSync(target, script);
+  fs.chmodSync(target, 0o755);
+  return dir;
+}
+
+test('detectRtk returns true when rtk --version succeeds', () => {
+  const binDir = mkFakeBinDir({ succeed: true });
+  try {
+    const result = rtk.detectRtk({ pathOverride: binDir });
+    assert.equal(result.available, true);
+    assert.match(result.version, /rtk/i);
+  } finally {
+    fs.rmSync(binDir, { recursive: true, force: true });
+  }
+});
+
+test('detectRtk returns false when rtk missing from PATH (no throw)', () => {
+  const binDir = mkEmptyBinDir();
+  try {
+    const result = rtk.detectRtk({ pathOverride: binDir });
+    assert.equal(result.available, false);
+    assert.ok(result.reason);
+  } finally {
+    fs.rmSync(binDir, { recursive: true, force: true });
+  }
+});
+
+test('detectRtk returns false when rtk exits non-zero (no throw)', () => {
+  const binDir = mkFakeBinDir({ succeed: false });
+  try {
+    const result = rtk.detectRtk({ pathOverride: binDir });
+    assert.equal(result.available, false);
+  } finally {
+    fs.rmSync(binDir, { recursive: true, force: true });
+  }
+});
+
+test('initRtk runs rtk init -g and returns success', () => {
+  const binDir = mkFakeBinDir({ succeed: true });
+  try {
+    const result = rtk.initRtk({ pathOverride: binDir, scope: 'global' });
+    assert.equal(result.ok, true);
+    assert.match(result.stdout, /init ok/);
+  } finally {
+    fs.rmSync(binDir, { recursive: true, force: true });
+  }
+});
+
+test('initRtk reports failure when binary is missing (does not throw)', () => {
+  const binDir = mkEmptyBinDir();
+  try {
+    const result = rtk.initRtk({ pathOverride: binDir, scope: 'global' });
+    assert.equal(result.ok, false);
+    assert.ok(result.error);
+  } finally {
+    fs.rmSync(binDir, { recursive: true, force: true });
+  }
+});
+
+test('installHook: skip=true short-circuits with a skipped=true record', () => {
+  const binDir = mkEmptyBinDir();
+  try {
+    const result = rtk.installHook({ skip: true, pathOverride: binDir });
+    assert.equal(result.skipped, true);
+    assert.equal(result.available, undefined);
+  } finally {
+    fs.rmSync(binDir, { recursive: true, force: true });
+  }
+});
+
+test('installHook: missing rtk → returns {available:false} with install hint', () => {
+  const binDir = mkEmptyBinDir();
+  try {
+    const result = rtk.installHook({ skip: false, pathOverride: binDir });
+    assert.equal(result.available, false);
+    assert.ok(result.hint, 'should surface an install hint');
+  } finally {
+    fs.rmSync(binDir, { recursive: true, force: true });
+  }
+});
+
+test('installHook: present rtk → runs init and returns {available:true, initialized:true}', () => {
+  const binDir = mkFakeBinDir({ succeed: true });
+  try {
+    const result = rtk.installHook({ skip: false, pathOverride: binDir, scope: 'global' });
+    assert.equal(result.available, true);
+    assert.equal(result.initialized, true);
+  } finally {
+    fs.rmSync(binDir, { recursive: true, force: true });
+  }
+});

package/adapters/_shared/tests/runtime-assets.test.cjs

@@ -0,0 +1,107 @@
+'use strict';
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..', '..');
+const {
+  CORE_PUBLIC_SKILLS,
+  INTERNAL_AGENT_SKILLS,
+  COLLAB_SKILLS_BY_RUNTIME,
+  RETIRED_SKILLS,
+  WORKFLOW_HOOK_FILES,
+  skillsForRuntime,
+} = require('../runtime-assets.cjs');
+
+const CORE = [
+  'learn',
+  'ultra-init',
+  'ultra-research',
+  'ultra-plan',
+  'ultra-dev',
+  'ultra-test',
+  'ultra-review',
+  'ultra-deliver',
+  'ultra-status',
+  'ultra-think',
+];
+
+const INTERNAL = [
+  'code-review-expert',
+  'security-rules',
+  'integration-rules',
+  'testing-rules',
+];
+
+const RETIRED = [
+  'agent-browser',
+  'find-skills',
+  'recall',
+  'use-railway',
+  'vercel-composition-patterns',
+  'vercel-react-best-practices',
+  'vercel-react-native-skills',
+];
+
+test('runtime asset manifest exposes only Ultra-owned core and internal skills', () => {
+  assert.deepEqual(CORE_PUBLIC_SKILLS, CORE);
+  assert.deepEqual(INTERNAL_AGENT_SKILLS, INTERNAL);
+  assert.deepEqual(RETIRED_SKILLS, RETIRED);
+
+  assert.deepEqual(COLLAB_SKILLS_BY_RUNTIME.claude, [
+    'codex-collab', 'gemini-collab', 'ultra-verify',
+  ]);
+  assert.deepEqual(COLLAB_SKILLS_BY_RUNTIME.codex, [
+    'cc-collab', 'gemini-collab', 'ultra-verify',
+  ]);
+  assert.deepEqual(COLLAB_SKILLS_BY_RUNTIME.opencode, [
+    'cc-collab', 'codex-collab', 'gemini-collab', 'ultra-verify',
+  ]);
+  assert.deepEqual(COLLAB_SKILLS_BY_RUNTIME.gemini, [
+    'cc-collab', 'codex-collab', 'ultra-verify',
+  ]);
+
+  for (const runtime of ['claude', 'codex', 'opencode', 'gemini']) {
+    const names = skillsForRuntime(runtime);
+    for (const retired of RETIRED) assert.ok(!names.includes(retired));
+    assert.ok(!names.some((name) => /impeccable/i.test(name)));
+  }
+});
+
+test('code-review-expert and rule skills are internal, never implicitly exposed', () => {
+  const codexAssets = fs.readFileSync(path.join(REPO_ROOT, 'adapters', '_shared', 'codex-assets.cjs'), 'utf8');
+  assert.match(codexAssets, /const INTERNAL_SKILLS = new Set\(INTERNAL_AGENT_SKILLS\)/);
+  assert.match(codexAssets, /INTERNAL_SKILLS\.has\(name\)/);
+});
+
+test('workflow hook allowlist contains no memory, prompt capture, or generic policy hook', () => {
+  assert.deepEqual(WORKFLOW_HOOK_FILES, [
+    'active_task_context.py',
+    'health_check.py',
+    'pre_stop_check.py',
+    'subagent_tracker.py',
+    'workflow_checkpoint.py',
+    'workflow_context.py',
+    'workflow_resume.py',
+  ]);
+  assert.doesNotMatch(WORKFLOW_HOOK_FILES.join('\n'), /memory|recall|journal|observation|prompt|dangerous|post_edit/);
+});
+
+test('npm publish list uses the same explicit skill boundary', () => {
+  const pkg = JSON.parse(fs.readFileSync(path.join(REPO_ROOT, 'package.json'), 'utf8'));
+  const publishedSkills = pkg.files
+    .filter((entry) => entry.startsWith('skills/'))
+    .map((entry) => entry.slice('skills/'.length))
+    .sort();
+  const expected = [...new Set([
+    ...CORE_PUBLIC_SKILLS,
+    ...INTERNAL_AGENT_SKILLS,
+    ...Object.values(COLLAB_SKILLS_BY_RUNTIME).flat(),
+  ])].sort();
+
+  assert.ok(!pkg.files.includes('skills'));
+  assert.ok(!pkg.files.includes('CLAUDE.md'));
+  assert.deepEqual(publishedSkills, expected);
+});