ultra-builder-pro-cli 0.13.0 → 0.15.0

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

@@ -1,133 +0,0 @@
-'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 { execFileSync } = require('node:child_process');
-
-const provenance = require('../provenance.cjs');
-
-function fixture() {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-provenance-'));
-  fs.mkdirSync(path.join(root, 'runtime'), { recursive: true });
-  fs.mkdirSync(path.join(root, 'hooks'), { recursive: true });
-  fs.writeFileSync(path.join(root, 'runtime', 'launch.cjs'), 'module.exports = true;\n');
-  fs.writeFileSync(path.join(root, 'hooks', 'hooks.json'), '{}\n');
-  const file = path.join(root, 'provenance.json');
-  provenance.writeProvenance({
-    file,
-    adapter: 'claude',
-    packageInfo: { name: 'ultra-builder-pro-cli', version: '1.2.3' },
-    repository: 'https://example.test/ultra-builder-pro',
-    sourceCommit: '0123456789abcdef0123456789abcdef01234567',
-    roots: { plugin: root },
-    assets: [
-      { root: 'plugin', path: 'hooks/hooks.json' },
-      { root: 'plugin', path: 'runtime/launch.cjs' },
-    ],
-    contracts: {
-      hooks_manifest: { root: 'plugin', path: 'hooks/hooks.json' },
-      mcp_launcher: { root: 'plugin', path: 'runtime/launch.cjs' },
-    },
-  });
-  return { root, file };
-}
-
-test('writeProvenance + inspectProvenance produce a normalized healthy report', () => {
-  const fx = fixture();
-  try {
-    const manifest = JSON.parse(fs.readFileSync(fx.file, 'utf8'));
-    assert.equal(manifest.schema_version, 1);
-    assert.equal(manifest.adapter, 'claude');
-    assert.equal(manifest.package.version, '1.2.3');
-    assert.equal(manifest.source.repository, 'https://example.test/ultra-builder-pro');
-    assert.match(manifest.content.digest, /^[0-9a-f]{64}$/);
-    assert.deepEqual(manifest.assets.map((asset) => asset.path), [
-      'hooks/hooks.json', 'runtime/launch.cjs',
-    ]);
-
-    const report = provenance.inspectProvenance({
-      file: fx.file,
-      expectedAdapter: 'claude',
-      expectedPackageVersion: '1.2.3',
-    });
-    assert.equal(report.status, 'healthy');
-    assert.deepEqual(report.issues, []);
-    assert.equal(report.checks.assets.checked, 2);
-    assert.equal(report.checks.contracts.checked, 2);
-  } finally {
-    fs.rmSync(fx.root, { recursive: true, force: true });
-  }
-});
-
-test('inspectProvenance detects content drift and missing contract targets', () => {
-  const fx = fixture();
-  try {
-    fs.writeFileSync(path.join(fx.root, 'runtime', 'launch.cjs'), 'tampered\n');
-    fs.unlinkSync(path.join(fx.root, 'hooks', 'hooks.json'));
-    const report = provenance.inspectProvenance({
-      file: fx.file,
-      expectedAdapter: 'claude',
-      expectedPackageVersion: '1.2.3',
-    });
-    assert.equal(report.status, 'degraded');
-    assert.ok(report.issues.some((issue) => issue.code === 'ASSET_HASH_MISMATCH'));
-    assert.ok(report.issues.some(
-      (issue) => issue.code === 'CONTRACT_TARGET_MISSING' && issue.contract === 'hooks_manifest',
-    ));
-  } finally {
-    fs.rmSync(fx.root, { recursive: true, force: true });
-  }
-});
-
-test('inspectProvenance fails closed for missing, corrupt, or mismatched manifests', () => {
-  const fx = fixture();
-  try {
-    const mismatch = provenance.inspectProvenance({
-      file: fx.file,
-      expectedAdapter: 'codex',
-      expectedPackageVersion: '9.9.9',
-    });
-    assert.equal(mismatch.status, 'degraded');
-    assert.ok(mismatch.issues.some((issue) => issue.code === 'ADAPTER_MISMATCH'));
-    assert.ok(mismatch.issues.some((issue) => issue.code === 'PACKAGE_VERSION_MISMATCH'));
-
-    fs.writeFileSync(fx.file, 'not-json');
-    const corrupt = provenance.inspectProvenance({ file: fx.file });
-    assert.equal(corrupt.status, 'degraded');
-    assert.equal(corrupt.issues[0].code, 'PROVENANCE_INVALID');
-
-    fs.unlinkSync(fx.file);
-    const missing = provenance.inspectProvenance({ file: fx.file });
-    assert.equal(missing.status, 'missing');
-    assert.equal(missing.issues[0].code, 'PROVENANCE_MISSING');
-  } finally {
-    fs.rmSync(fx.root, { recursive: true, force: true });
-  }
-});
-
-test('packageSource never attributes an enclosing consumer repository commit to the package', () => {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-provenance-source-'));
-  try {
-    execFileSync('git', ['init', '-q'], { cwd: root });
-    execFileSync('git', ['config', 'user.email', 'test@ubp.dev'], { cwd: root });
-    execFileSync('git', ['config', 'user.name', 'ubp-test'], { cwd: root });
-    fs.writeFileSync(path.join(root, 'README.md'), '# consumer\n');
-    execFileSync('git', ['add', 'README.md'], { cwd: root });
-    execFileSync('git', ['commit', '-q', '-m', 'seed'], { cwd: root });
-    const packageRoot = path.join(root, 'node_modules', 'ultra-builder-pro-cli');
-    fs.mkdirSync(packageRoot, { recursive: true });
-    fs.writeFileSync(path.join(packageRoot, 'package.json'), JSON.stringify({
-      name: 'ultra-builder-pro-cli',
-      version: '1.2.3',
-      repository: { url: 'https://example.test/ultra-builder-pro' },
-    }));
-
-    const source = provenance.packageSource(packageRoot);
-    assert.equal(source.sourceCommit, null);
-  } finally {
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-});

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

@@ -1,75 +0,0 @@
-'use strict';
-
-// Scope-precedence contract across every supported adapter.resolveTarget.
-//
-// Each adapter honors the same ordering:
-//   ctx.configDir  >  ctx.scope='global' → env var or homeDir/.<runtime>
-//                  >  ctx.scope='local'  → cwd/.<runtime>
-
-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');
-
-// 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' },
-];
-
-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));
-  });
-}

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

@@ -1,131 +0,0 @@
-'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,
-  SUPPORTED_RUNTIMES,
-  COLLAB_SKILLS_BY_RUNTIME,
-  MCP_DEPENDENT_SKILLS,
-  RETIRED_SKILLS,
-  WORKFLOW_HOOK_FILES,
-  skillPolicy,
-  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',
-  'ultra-change',
-  'ultra-doctor',
-];
-
-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', 'ultra-verify',
-  ]);
-  assert.deepEqual(COLLAB_SKILLS_BY_RUNTIME.codex, [
-    'cc-collab', 'ultra-verify',
-  ]);
-  assert.deepEqual(COLLAB_SKILLS_BY_RUNTIME.opencode, [
-    'cc-collab', 'codex-collab', 'ultra-verify',
-  ]);
-  assert.deepEqual(COLLAB_SKILLS_BY_RUNTIME.kimi, [
-    'cc-collab', 'codex-collab', 'ultra-verify',
-  ]);
-  assert.deepEqual(SUPPORTED_RUNTIMES, ['claude', 'opencode', 'codex', 'kimi']);
-
-  for (const runtime of SUPPORTED_RUNTIMES) {
-    const names = skillsForRuntime(runtime);
-    for (const retired of RETIRED) assert.ok(!names.includes(retired));
-    assert.ok(!names.some((name) => /impeccable/i.test(name)));
-  }
-});
-
-test('host invocation and MCP metadata live outside source SKILL frontmatter', () => {
-  const all = new Set(SUPPORTED_RUNTIMES.flatMap((runtime) => skillsForRuntime(runtime)));
-  for (const name of all) {
-    const policy = skillPolicy(name);
-    assert.equal(policy.allowImplicitInvocation, false, name);
-    assert.equal(policy.userInvocable, !INTERNAL_AGENT_SKILLS.includes(name), name);
-    assert.equal(policy.requiresUltraMcp, MCP_DEPENDENT_SKILLS.includes(name), name);
-  }
-  assert.throws(() => skillPolicy('not-packaged'), /unknown packaged Ultra skill/);
-});
-
-test('workflow hook allowlist contains no memory, prompt capture, or generic policy hook', () => {
-  assert.deepEqual(WORKFLOW_HOOK_FILES, [
-    'active_task_context.py',
-    'context_spine.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('bundled agents never instruct workers to own persistent memory', () => {
-  const agentsDir = path.join(REPO_ROOT, 'agents');
-  const agentText = fs.readdirSync(agentsDir)
-    .filter((name) => name.endsWith('.md'))
-    .map((name) => fs.readFileSync(path.join(agentsDir, name), 'utf8'))
-    .join('\n');
-
-  assert.doesNotMatch(agentText, /^## Memory$/m);
-  assert.doesNotMatch(agentText, /Update your project memory|Consult memory before starting work/);
-  assert.doesNotMatch(agentText, /\.ultra\/memory|\/recall(?:\s|`|$)/m);
-});
-
-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);
-});

package/adapters/_shared/tests/settings-merge.test.cjs

@@ -1,85 +0,0 @@
-'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 {
-  SENTINEL_VERSION,
-  readJsonSafe,
-  withSentinelBlock,
-  removeSentinelBlock,
-  hasSentinelBlock,
-  mergeArrayField,
-} = require('../settings-merge.cjs');
-
-test('withSentinelBlock writes under the sentinel key only; user config untouched', () => {
-  const existing = { user_prop: 'keep me', hooks: [{ name: 'user-hook' }] };
-  const out = withSentinelBlock(existing, 'ultra_builder_pro', {
-    mcp: { ubp: { command: 'node' } },
-  });
-
-  assert.equal(out.user_prop, 'keep me');
-  assert.deepEqual(out.hooks, [{ name: 'user-hook' }]);
-  assert.equal(out.ultra_builder_pro.__sentinel, SENTINEL_VERSION);
-  assert.equal(out.ultra_builder_pro.__generated_by, 'ultra-builder-pro-cli');
-  assert.deepEqual(out.ultra_builder_pro.mcp.ubp, { command: 'node' });
-});
-
-test('removeSentinelBlock leaves unrelated keys intact; noop if absent', () => {
-  const with_ = { a: 1, mine: { __sentinel: 1, x: 2 } };
-  const stripped = removeSentinelBlock(with_, 'mine');
-  assert.deepEqual(stripped, { a: 1 });
-  assert.ok(!hasSentinelBlock(stripped, 'mine'));
-
-  const noop = removeSentinelBlock({ a: 1 }, 'mine');
-  assert.deepEqual(noop, { a: 1 });
-});
-
-test('mergeArrayField dedupes; readJsonSafe handles missing/empty/malformed', () => {
-  const existing = { hooks: [{ name: 'user' }, { name: 'ubp-one' }] };
-  const out = mergeArrayField(existing, 'hooks', [
-    { name: 'ubp-one' }, // dup — skipped
-    { name: 'ubp-two' },
-  ]);
-  assert.deepEqual(out.hooks, [
-    { name: 'user' },
-    { name: 'ubp-one' },
-    { name: 'ubp-two' },
-  ]);
-
-  // readJsonSafe: missing file → empty object
-  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-merge-'));
-  try {
-    assert.deepEqual(readJsonSafe(path.join(tmp, 'none.json')), {});
-
-    const p = path.join(tmp, 'existing.json');
-    fs.writeFileSync(p, '{"a":1}');
-    assert.deepEqual(readJsonSafe(p), { a: 1 });
-
-    // empty file treated as empty object
-    fs.writeFileSync(p, '   \n  ');
-    assert.deepEqual(readJsonSafe(p), {});
-
-    // malformed → throws
-    fs.writeFileSync(p, '{not json');
-    assert.throws(() => readJsonSafe(p), /cannot parse/);
-
-    // P2 #7 / D45: rescue mode backs up corrupt file and returns {} instead
-    // of throwing — lets `install` finish even if the user's settings.json
-    // is syntactically broken.
-    fs.writeFileSync(p, '{still not json');
-    const rescued = readJsonSafe(p, { rescue: true });
-    assert.deepEqual(rescued, {});
-    const backups = fs.readdirSync(tmp).filter((f) => f.startsWith('existing.json.bak-'));
-    assert.ok(backups.length > 0, `expected a .bak-* file in ${tmp}, saw ${fs.readdirSync(tmp).join(',')}`);
-  } finally {
-    fs.rmSync(tmp, { recursive: true, force: true });
-  }
-
-  // withSentinelBlock rejects bad key
-  assert.throws(() => withSentinelBlock({}, '', {}), /non-empty string/);
-});

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

@@ -1,30 +0,0 @@
-'use strict';
-
-// Phase 4 backlog P3 #13 / D45 — configDir validator.
-
-const { test } = require('node:test');
-const assert = require('node:assert/strict');
-
-const { validateConfigDir } = require('../validate.cjs');
-
-test('validateConfigDir: null/undefined → ok with configDir=null', () => {
-  assert.deepEqual(validateConfigDir(null), { ok: true, configDir: null });
-  assert.deepEqual(validateConfigDir(undefined), { ok: true, configDir: null });
-});
-
-test('validateConfigDir: normal path → ok', () => {
-  const out = validateConfigDir('/tmp/work');
-  assert.equal(out.ok, true);
-  assert.equal(out.configDir, '/tmp/work');
-});
-
-test('validateConfigDir: rejects NUL byte', () => {
-  const out = validateConfigDir('/tmp/foo\u0000bar');
-  assert.equal(out.ok, false);
-  assert.match(out.error, /NUL bytes/);
-});
-
-test('validateConfigDir: rejects non-string', () => {
-  assert.equal(validateConfigDir(42).ok, false);
-  assert.equal(validateConfigDir({}).ok, false);
-});

package/adapters/tests/claude.test.cjs

@@ -1,137 +0,0 @@
-'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 claude = require('../claude.js');
-const { parse: parseFrontmatter } = require('../_shared/frontmatter.cjs');
-const {
-  INTERNAL_AGENT_SKILLS,
-  skillsForRuntime,
-  WORKFLOW_HOOK_FILES,
-} = require('../_shared/runtime-assets.cjs');
-
-const REPO_ROOT = path.resolve(__dirname, '..', '..');
-
-function mkTarget() {
-  return fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-claude-'));
-}
-
-function skillNames(root) {
-  return fs.readdirSync(path.join(root, 'skills'), { withFileTypes: true })
-    .filter((entry) => entry.isDirectory() && fs.existsSync(path.join(root, 'skills', entry.name, 'SKILL.md')))
-    .map((entry) => entry.name)
-    .sort();
-}
-
-test('install builds the Claude-native plugin from the explicit Ultra allowlist', () => {
-  const parent = mkTarget();
-  const target = path.join(parent, 'skills', 'ultra-builder-pro');
-  try {
-    const report = claude.install({ configDir: parent, repoRoot: REPO_ROOT });
-    assert.deepEqual(skillNames(target), skillsForRuntime('claude').sort());
-    assert.deepEqual(report.copied.hooks.sort(), WORKFLOW_HOOK_FILES.slice().sort());
-    assert.ok(fs.existsSync(path.join(target, '.claude-plugin', 'plugin.json')));
-    assert.ok(fs.existsSync(path.join(target, 'hooks', 'hooks.json')));
-    assert.ok(fs.existsSync(path.join(target, '.mcp.json')));
-    assert.ok(fs.existsSync(path.join(target, 'agents', 'code-reviewer.md')));
-
-    const hooks = JSON.parse(fs.readFileSync(path.join(target, 'hooks', 'hooks.json'), 'utf8'));
-    const serialized = JSON.stringify(hooks);
-    for (const name of WORKFLOW_HOOK_FILES.filter((value) => value !== 'context_spine.py')) {
-      assert.match(serialized, new RegExp(name.replace('.', '\\.')));
-    }
-    assert.ok(fs.existsSync(path.join(target, 'hooks', 'context_spine.py')));
-    assert.doesNotMatch(serialized, /memory|recall|journal|observation_capture|user_prompt_capture|block_dangerous|post_edit_guard/);
-    assert.match(serialized, /\$\{CLAUDE_PLUGIN_ROOT\}/);
-  } finally {
-    fs.rmSync(parent, { recursive: true, force: true });
-  }
-});
-
-test('Claude plugin collaboration and learn workflows are safe native plugin assets', () => {
-  const parent = mkTarget();
-  const target = path.join(parent, 'skills', 'ultra-builder-pro');
-  try {
-    claude.install({ configDir: parent, repoRoot: REPO_ROOT });
-    const read = (name) => fs.readFileSync(path.join(target, 'skills', name, 'SKILL.md'), 'utf8');
-    const learn = read('learn');
-    const codexCollab = read('codex-collab');
-    const verify = read('ultra-verify');
-    const review = read('ultra-review');
-    const plan = read('ultra-plan');
-    const status = read('ultra-status');
-
-    assert.match(learn, /`~\/.claude\/skills`/);
-    assert.doesNotMatch(learn, /_unverified|learned-[^\s/]*-unverified/i);
-    assert.match(codexCollab, /-s read-only/);
-    assert.match(codexCollab, /--ephemeral/);
-    assert.match(codexCollab, /--ignore-user-config/);
-    assert.match(verify, /-s read-only/);
-    assert.match(verify, /--ephemeral/);
-    assert.match(verify, /scripts\/verify_wait\.py/);
-    assert.match(review, /Claude Code Task workers/);
-    assert.match(review, /scripts\/review_wait\.py/);
-    assert.doesNotMatch(plan, /LEGACY_STATE_MIGRATION_REQUIRED|v4\.4|v4\.5/);
-    assert.match(plan, /Never read or\s+write .*tasks\.json/i);
-    assert.match(status, /Never fall\s+back to generated task JSON/i);
-    assert.doesNotMatch(plan, /ultra-tools task create/);
-
-    for (const name of skillsForRuntime('claude')) {
-      const { fm } = parseFrontmatter(read(name));
-      assert.equal(fm['user-invocable'], !INTERNAL_AGENT_SKILLS.includes(name), name);
-    }
-
-    for (const [name, contents] of Object.entries({ codexCollab, verify })) {
-      assert.doesNotMatch(contents, /--yolo|--full-auto|\/codex:/, name);
-    }
-  } finally {
-    fs.rmSync(parent, { recursive: true, force: true });
-  }
-});
-
-test('global target is a Claude skills-directory plugin', () => {
-  const homeDir = mkTarget();
-  try {
-    const ctx = { scope: 'global', homeDir };
-    assert.equal(claude.resolveTarget(ctx), path.join(homeDir, '.claude'));
-    assert.equal(claude.resolvePluginRoot(ctx), path.join(homeDir, '.claude', 'skills', 'ultra-builder-pro'));
-  } finally {
-    fs.rmSync(homeDir, { recursive: true, force: true });
-  }
-});
-
-test('reinstall is deterministic and uninstall removes only the managed plugin root', () => {
-  const parent = mkTarget();
-  const target = path.join(parent, 'skills', 'ultra-builder-pro');
-  const sibling = path.join(parent, 'user-plugin');
-  try {
-    fs.mkdirSync(sibling);
-    fs.writeFileSync(path.join(sibling, 'keep.txt'), 'keep');
-    claude.install({ configDir: parent, repoRoot: REPO_ROOT });
-    claude.install({ configDir: parent, repoRoot: REPO_ROOT });
-    claude.uninstall({ configDir: parent });
-    assert.ok(!fs.existsSync(target));
-    assert.equal(fs.readFileSync(path.join(sibling, 'keep.txt'), 'utf8'), 'keep');
-  } finally {
-    fs.rmSync(parent, { recursive: true, force: true });
-  }
-});
-
-test('install refuses to replace an unmanaged directory', () => {
-  const parent = mkTarget();
-  const target = path.join(parent, 'skills', 'ultra-builder-pro');
-  try {
-    fs.mkdirSync(target, { recursive: true });
-    fs.writeFileSync(path.join(target, 'user.txt'), 'keep');
-    assert.throws(
-      () => claude.install({ configDir: parent, repoRoot: REPO_ROOT }),
-      /unmanaged Claude plugin/,
-    );
-  } finally {
-    fs.rmSync(parent, { recursive: true, force: true });
-  }
-});