ultra-builder-pro-cli 0.5.0

package/adapters/tests/codex-hook.test.cjs

@@ -0,0 +1,90 @@
+'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 { spawnSync } = require('node:child_process');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+const ADAPTER = path.join(REPO_ROOT, 'hooks', 'adapters', 'codex.py');
+
+function run(feature, payload) {
+  return spawnSync('python3', [ADAPTER, feature], {
+    cwd: REPO_ROOT,
+    input: JSON.stringify(payload),
+    encoding: 'utf8',
+    env: { ...process.env, PLUGIN_DATA: path.join(REPO_ROOT, '.tmp-codex-hook-test') },
+  });
+}
+
+test('Codex hook adapter rejects retired generic policy hooks', () => {
+  const result = run('block_dangerous_commands.py', {
+    session_id: 'session-1',
+    turn_id: 'turn-1',
+    cwd: REPO_ROOT,
+    hook_event_name: 'PreToolUse',
+    tool_name: 'Bash',
+    tool_input: { command: 'git reset --hard' },
+  });
+  assert.equal(result.status, 0, result.stderr);
+  const output = JSON.parse(result.stdout);
+  assert.match(output.systemMessage, /refused unknown feature/);
+});
+
+test('Codex hook adapter injects only an active Ultra task boundary before edits', () => {
+  const project = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-codex-hook-'));
+  try {
+    fs.mkdirSync(path.join(project, '.ultra'));
+    fs.writeFileSync(path.join(project, '.ultra', 'workflow-state.json'), JSON.stringify({
+      command: 'ultra-dev', task_id: 'task-7', step: '4.5', status: 'review_pending',
+    }));
+    const result = run('active_task_context.py', {
+      session_id: 'session-2',
+      cwd: project,
+      hook_event_name: 'PreToolUse',
+      tool_name: 'apply_patch',
+      tool_input: { command: '*** Begin Patch\n*** Update File: src/a.py\n*** End Patch' },
+    });
+    assert.equal(result.status, 0, result.stderr);
+    const output = JSON.parse(result.stdout);
+    assert.equal(output.hookSpecificOutput.hookEventName, 'PreToolUse');
+    assert.match(output.hookSpecificOutput.additionalContext, /task-7/);
+    assert.doesNotMatch(JSON.stringify(output), /memory|recall|journal/);
+  } finally {
+    fs.rmSync(project, { recursive: true, force: true });
+  }
+});
+
+test('Codex hook adapter maps apply_patch payloads to Edit-compatible file inputs', () => {
+  const script = [
+    'import importlib.util, json, pathlib',
+    `p = pathlib.Path(${JSON.stringify(ADAPTER)})`,
+    's = importlib.util.spec_from_file_location("codex_hook_adapter", p)',
+    'm = importlib.util.module_from_spec(s)',
+    's.loader.exec_module(m)',
+    'payload = {"hook_event_name":"PostToolUse","tool_name":"apply_patch","tool_input":{"patch":"*** Begin Patch\\n*** Update File: src/a.py\\n*** Add File: src/b.py\\n*** End Patch"}}',
+    'print(json.dumps(m.normalize_inputs(payload)))',
+  ].join('; ');
+  const result = spawnSync('python3', ['-c', script], { cwd: REPO_ROOT, encoding: 'utf8' });
+  assert.equal(result.status, 0, result.stderr);
+  const outputs = JSON.parse(result.stdout);
+  assert.deepEqual(outputs.map((entry) => entry.tool_input.file_path), ['src/a.py', 'src/b.py']);
+  assert.ok(outputs.every((entry) => entry.tool_name === 'Edit'));
+});
+
+test('Codex hook adapter converts compact recovery context to PostCompact schema', () => {
+  const script = [
+    'import importlib.util, json, pathlib',
+    `p = pathlib.Path(${JSON.stringify(ADAPTER)})`,
+    's = importlib.util.spec_from_file_location("codex_hook_adapter", p)',
+    'm = importlib.util.module_from_spec(s)',
+    's.loader.exec_module(m)',
+    'legacy = {"hookSpecificOutput":{"hookEventName":"SessionStart","additionalContext":"restored"}}',
+    'print(json.dumps(m.adapt_output(legacy, "PostCompact")))',
+  ].join('; ');
+  const result = spawnSync('python3', ['-c', script], { cwd: REPO_ROOT, encoding: 'utf8' });
+  assert.equal(result.status, 0, result.stderr);
+  assert.deepEqual(JSON.parse(result.stdout), { systemMessage: 'restored' });
+});

package/adapters/tests/codex.test.cjs

@@ -0,0 +1,356 @@
+'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 { spawnSync } = require('node:child_process');
+const yaml = require('js-yaml');
+const { Client } = require('@modelcontextprotocol/sdk/client/index.js');
+const { StdioClientTransport } = require('@modelcontextprotocol/sdk/client/stdio.js');
+
+const codex = require('../codex.js');
+const { parse: parseFrontmatter } = require('../_shared/frontmatter.cjs');
+const PACKAGE_VERSION = require('../../package.json').version;
+const {
+  skillsForRuntime,
+  WORKFLOW_HOOK_FILES,
+} = require('../_shared/runtime-assets.cjs');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+const COMMANDS = [
+  'learn',
+  'ultra-deliver',
+  'ultra-dev',
+  'ultra-init',
+  'ultra-plan',
+  'ultra-research',
+  'ultra-status',
+  'ultra-test',
+  'ultra-think',
+];
+const AGENTS = [
+  'code-reviewer',
+  'debugger',
+  'review-code',
+  'review-comments',
+  'review-coordinator',
+  'review-design',
+  'review-errors',
+  'review-tests',
+  'tdd-runner',
+];
+
+function mkLayout() {
+  const homeDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-codex-home-'));
+  return {
+    homeDir,
+    configDir: path.join(homeDir, '.codex'),
+    pluginRoot: path.join(homeDir, 'plugins', 'ultra-builder-pro'),
+    marketplaceFile: path.join(homeDir, '.agents', 'plugins', 'marketplace.json'),
+  };
+}
+
+function cleanup(layout) {
+  fs.rmSync(layout.homeDir, { recursive: true, force: true });
+}
+
+function install(layout) {
+  return codex.install({
+    configDir: layout.configDir,
+    homeDir: layout.homeDir,
+    scope: 'global',
+    repoRoot: REPO_ROOT,
+    runPluginCli: false,
+  });
+}
+
+function skillNames(pluginRoot) {
+  return fs.readdirSync(path.join(pluginRoot, 'skills'), { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && fs.existsSync(path.join(pluginRoot, 'skills', entry.name, 'SKILL.md')))
+    .map((entry) => entry.name)
+    .sort();
+}
+
+test('install builds one Codex-native plugin with complete skill and command coverage', () => {
+  const layout = mkLayout();
+  try {
+    const report = install(layout);
+    assert.equal(report.plugin.root, layout.pluginRoot);
+
+    const manifest = JSON.parse(fs.readFileSync(path.join(layout.pluginRoot, '.codex-plugin', 'plugin.json'), 'utf8'));
+    assert.equal(manifest.name, 'ultra-builder-pro');
+    const escapedVersion = PACKAGE_VERSION.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    assert.match(manifest.version, new RegExp(`^${escapedVersion}\\+codex\\.[0-9a-f]{12}$`));
+    assert.equal(manifest.skills, './skills/');
+    assert.equal(manifest.mcpServers, './.mcp.json');
+    assert.ok(!Object.hasOwn(manifest, 'hooks'), 'default hooks/hooks.json discovery avoids unsupported manifest field');
+
+    const expectedSkills = skillsForRuntime('codex').sort();
+    assert.deepEqual(skillNames(layout.pluginRoot), expectedSkills);
+    assert.equal(expectedSkills.length, 17);
+    assert.ok(!fs.existsSync(path.join(layout.pluginRoot, 'skills', 'codex-collab')));
+    assert.ok(!fs.existsSync(path.join(layout.pluginRoot, 'skills', 'learned')));
+
+    const commandMap = JSON.parse(fs.readFileSync(path.join(layout.pluginRoot, 'command-map.json'), 'utf8'));
+    assert.deepEqual(Object.keys(commandMap).sort(), COMMANDS.map((name) => `/${name}`).sort());
+    for (const command of COMMANDS) {
+      assert.equal(commandMap[`/${command}`], `$ultra-builder-pro:${command}`);
+      assert.ok(fs.existsSync(path.join(layout.pluginRoot, 'skills', command, 'SKILL.md')));
+    }
+    assert.ok(!fs.existsSync(path.join(layout.configDir, 'prompts')), 'deprecated Codex prompts must not be installed');
+  } finally {
+    cleanup(layout);
+  }
+});
+
+test('every generated skill is Codex-valid, UI-visible, and free of Claude host bindings', () => {
+  const layout = mkLayout();
+  try {
+    install(layout);
+    for (const name of skillNames(layout.pluginRoot)) {
+      const skillDir = path.join(layout.pluginRoot, 'skills', name);
+      const text = fs.readFileSync(path.join(skillDir, 'SKILL.md'), 'utf8');
+      const { fm } = parseFrontmatter(text);
+      assert.deepEqual(Object.keys(fm).sort(), ['description', 'name'], `${name} should use Codex skill frontmatter only`);
+      assert.equal(fm.name, name);
+      assert.doesNotMatch(
+        text,
+        /~\/\.claude|CLAUDE\.md|AskUserQuestion|(^|[\s`(>])\/(?:ultra-[a-z-]+|recall|learn|gemini-collab|codex-collab)(?=$|[\s`,.;):])/m,
+      );
+      assert.doesNotMatch(text, /TaskCreate|TaskUpdate|TaskList|TaskOutput|run_in_background|~\/\.codex\/skills|mcp__claude/);
+
+      const openai = yaml.load(fs.readFileSync(path.join(skillDir, 'agents', 'openai.yaml'), 'utf8'));
+      assert.ok(openai.interface.display_name);
+      assert.ok(openai.interface.short_description);
+      assert.match(openai.interface.default_prompt, new RegExp(`\\$ultra-builder-pro:${name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`));
+      assert.equal(typeof openai.policy.allow_implicit_invocation, 'boolean');
+    }
+
+    const cc = fs.readFileSync(path.join(layout.pluginRoot, 'skills', 'cc-collab', 'SKILL.md'), 'utf8');
+    assert.match(cc, /Claude Code/);
+    assert.match(cc, /claude --safe-mode/);
+
+    const verify = fs.readFileSync(path.join(layout.pluginRoot, 'skills', 'ultra-verify', 'SKILL.md'), 'utf8');
+    assert.match(verify, /Codex owns the task/);
+    assert.match(verify, /claude --safe-mode/);
+    assert.match(verify, /gemini --approval-mode plan/);
+    assert.match(verify, /codex-analysis\.md/);
+    assert.doesNotMatch(verify, /codex-output\.md|Claude synthesizes|Claude-only/);
+
+    const waiter = fs.readFileSync(path.join(layout.pluginRoot, 'skills', 'ultra-verify', 'scripts', 'verify_wait.py'), 'utf8');
+    assert.match(waiter, /"claude": "claude-output\.md"/);
+    assert.doesNotMatch(waiter, /"codex": "codex-output\.md"/);
+
+    const review = fs.readFileSync(path.join(layout.pluginRoot, 'skills', 'ultra-review', 'SKILL.md'), 'utf8');
+    assert.match(review, /native Codex custom agents/);
+    assert.match(review, /~\/plugins\/ultra-builder-pro\/skills\/ultra-review/);
+
+    const coreWorkflowText = [
+      ...COMMANDS,
+      'ultra-review',
+    ].map((name) => fs.readFileSync(path.join(layout.pluginRoot, 'skills', name, 'SKILL.md'), 'utf8')).join('\n');
+    assert.doesNotMatch(coreWorkflowText, /Phase (?:3\.7|5|7) placeholder|not yet implemented|UNKNOWN_TOOL/);
+    assert.doesNotMatch(coreWorkflowText, /session\.checkpoint|review\.run|ultra-tools subagent/);
+    assert.doesNotMatch(coreWorkflowText, /ask\.question|ultra-tools task (?:create|update|list|get)/);
+    assert.doesNotMatch(coreWorkflowText, /Context7 MCP|mcp__context7|Exa MCP|mcp__exa|Playwright via Bash/);
+    assert.doesNotMatch(coreWorkflowText, /`\/{command}`/);
+  } finally {
+    cleanup(layout);
+  }
+});
+
+test('install converts all nine Claude agents into native Codex agent TOML', () => {
+  const layout = mkLayout();
+  try {
+    const report = install(layout);
+    assert.deepEqual(report.agents.installed.sort(), AGENTS.map((name) => `${name}.toml`).sort());
+    for (const name of AGENTS) {
+      const text = fs.readFileSync(path.join(layout.configDir, 'agents', `${name}.toml`), 'utf8');
+      assert.match(text, new RegExp(`^name = "${name}"`, 'm'));
+      assert.match(text, /^description = /m);
+      assert.match(text, /^developer_instructions = """/m);
+      assert.doesNotMatch(
+        text,
+        /model = "opus"|^tools =|^memory =|maxTurns|CLAUDE\.md|AskUserQuestion|(^|[\s`(>])\/(?:ultra-[a-z-]+|recall|learn|gemini-collab|codex-collab)(?=$|[\s`,.;):])/m,
+      );
+    }
+  } finally {
+    cleanup(layout);
+  }
+});
+
+test('plugin declares current Codex hooks and a project-local Ultra MCP server', () => {
+  const layout = mkLayout();
+  try {
+    install(layout);
+    const hooks = JSON.parse(fs.readFileSync(path.join(layout.pluginRoot, 'hooks', 'hooks.json'), 'utf8')).hooks;
+    assert.deepEqual(Object.keys(hooks).sort(), [
+      'PostCompact', 'PreCompact', 'PreToolUse', 'SessionStart', 'Stop',
+      'SubagentStart', 'SubagentStop',
+    ].sort());
+    const serializedHooks = JSON.stringify(hooks);
+    for (const feature of WORKFLOW_HOOK_FILES) {
+      assert.match(serializedHooks, new RegExp(feature.replace('.', '\\.')));
+    }
+    assert.doesNotMatch(serializedHooks, /memory|recall|journal|observation_capture|user_prompt_capture|block_dangerous|post_edit_guard/);
+    assert.match(serializedHooks, /\$PLUGIN_ROOT\/hooks\/adapters\/codex\.py/);
+
+    const mcp = JSON.parse(fs.readFileSync(path.join(layout.pluginRoot, '.mcp.json'), 'utf8'));
+    const server = mcp.mcpServers['ultra-builder-pro'];
+    assert.equal(server.type, 'stdio');
+    assert.ok(path.isAbsolute(server.command));
+    assert.ok(path.isAbsolute(server.args[0]));
+    assert.equal(server.args[0], path.join(layout.pluginRoot, 'runtime', 'launch.cjs'));
+    assert.doesNotMatch(server.args[0], new RegExp(REPO_ROOT.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')));
+    assert.ok(!server.env, 'MCP must use each Codex task cwd so .ultra/state.db stays project-local');
+
+    for (const rel of [
+      'runtime/index.cjs',
+      'runtime/launch.cjs',
+      'runtime/ultra-tools.cjs',
+      'runtime/build/Release/better_sqlite3.node',
+      'spec/mcp-tools.yaml',
+      'spec/upstream-mcp-tools.yaml',
+      'spec/codex-capability-map.json',
+      'spec/schemas/state-db.sql',
+      'templates/.ultra/tasks/tasks.json',
+    ]) {
+      assert.ok(fs.existsSync(path.join(layout.pluginRoot, rel)), `missing bundled MCP asset ${rel}`);
+    }
+
+    const liveSpec = yaml.load(fs.readFileSync(path.join(layout.pluginRoot, 'spec', 'mcp-tools.yaml'), 'utf8'));
+    const upstreamSpec = yaml.load(fs.readFileSync(path.join(layout.pluginRoot, 'spec', 'upstream-mcp-tools.yaml'), 'utf8'));
+    const capabilityMap = JSON.parse(fs.readFileSync(path.join(layout.pluginRoot, 'spec', 'codex-capability-map.json'), 'utf8'));
+    assert.equal(liveSpec.tools.length, 21);
+    assert.equal(upstreamSpec.tools.length, 21);
+    assert.deepEqual(upstreamSpec.tools.map((tool) => tool.name).sort(), liveSpec.tools.map((tool) => tool.name).sort());
+    assert.deepEqual(capabilityMap.live_mcp_tools.sort(), liveSpec.tools.map((tool) => tool.name).sort());
+    assert.equal(Object.keys(capabilityMap.codex_native_replacements).length, 9);
+    assert.equal(capabilityMap.codex_native_replacements['review.run'].surface, 'native_custom_agents');
+    assert.equal(capabilityMap.codex_native_replacements['ask.question'].surface, 'direct_user_interaction');
+  } finally {
+    cleanup(layout);
+  }
+});
+
+test('bundled plugin MCP runs outside the source checkout and keeps state in the Codex task cwd', async () => {
+  const layout = mkLayout();
+  const projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-codex-mcp-project-'));
+  let client;
+  try {
+    install(layout);
+    const mcp = JSON.parse(fs.readFileSync(path.join(layout.pluginRoot, '.mcp.json'), 'utf8'));
+    const server = mcp.mcpServers['ultra-builder-pro'];
+    const env = { ...process.env };
+    delete env.UBP_DB_PATH;
+    delete env.UBP_ROOT_DIR;
+    delete env.UBP_RUNTIME_ROOT;
+    const transport = new StdioClientTransport({
+      command: server.command,
+      args: server.args,
+      cwd: projectDir,
+      env,
+      stderr: 'pipe',
+    });
+    client = new Client({ name: 'ubp-codex-adapter-test', version: '0.0.0' }, { capabilities: {} });
+    await client.connect(transport);
+
+    const tools = await client.listTools();
+    assert.ok(tools.tools.some((tool) => tool.name === 'task.create'));
+    const created = await client.callTool({
+      name: 'task.create',
+      arguments: { id: 'codex-bundle-1', title: 'bundled runtime', type: 'feature', priority: 'P1' },
+    });
+    assert.equal(created.isError, undefined);
+    assert.ok(fs.existsSync(path.join(projectDir, '.ultra', 'state.db')));
+    assert.ok(!fs.existsSync(path.join(layout.pluginRoot, '.ultra', 'state.db')));
+
+    const status = spawnSync(process.execPath, [
+      path.join(layout.pluginRoot, 'runtime', 'ultra-tools.cjs'),
+      'status', '--cost', '--json',
+    ], { cwd: projectDir, encoding: 'utf8' });
+    assert.equal(status.status, 0, status.stderr);
+    assert.equal(JSON.parse(status.stdout).ok, true);
+
+    const freshTarget = path.join(projectDir, 'fresh-project');
+    const initialized = await client.callTool({
+      name: 'task.init_project',
+      arguments: { target_dir: freshTarget, project_name: 'Codex bundle', project_type: 'cli' },
+    });
+    assert.equal(initialized.isError, undefined);
+    assert.ok(fs.existsSync(path.join(freshTarget, '.ultra', 'tasks', 'tasks.json')));
+  } finally {
+    if (client) await client.close();
+    fs.rmSync(projectDir, { recursive: true, force: true });
+    cleanup(layout);
+  }
+});
+
+test('install preserves user config and marketplace entries and is byte-idempotent', () => {
+  const layout = mkLayout();
+  try {
+    fs.mkdirSync(layout.configDir, { recursive: true });
+    const configFile = path.join(layout.configDir, 'config.toml');
+    fs.writeFileSync(configFile, '[profile]\nname = "dev"\n');
+    fs.mkdirSync(path.dirname(layout.marketplaceFile), { recursive: true });
+    fs.writeFileSync(layout.marketplaceFile, JSON.stringify({
+      name: 'personal',
+      interface: { displayName: 'Personal' },
+      plugins: [{
+        name: 'mine',
+        source: { source: 'local', path: './plugins/mine' },
+        policy: { installation: 'AVAILABLE', authentication: 'ON_INSTALL' },
+        category: 'Developer Tools',
+      }],
+    }, null, 2) + '\n');
+
+    install(layout);
+    const firstConfig = fs.readFileSync(configFile, 'utf8');
+    const firstMarketplace = fs.readFileSync(layout.marketplaceFile, 'utf8');
+    const firstManifest = fs.readFileSync(path.join(layout.pluginRoot, '.codex-plugin', 'plugin.json'), 'utf8');
+    const firstAgent = fs.readFileSync(path.join(layout.configDir, 'agents', 'review-code.toml'), 'utf8');
+    install(layout);
+
+    assert.equal(fs.readFileSync(configFile, 'utf8'), firstConfig);
+    assert.equal(fs.readFileSync(layout.marketplaceFile, 'utf8'), firstMarketplace);
+    assert.equal(fs.readFileSync(path.join(layout.pluginRoot, '.codex-plugin', 'plugin.json'), 'utf8'), firstManifest);
+    assert.equal(fs.readFileSync(path.join(layout.configDir, 'agents', 'review-code.toml'), 'utf8'), firstAgent);
+
+    const marketplace = JSON.parse(firstMarketplace);
+    assert.deepEqual(marketplace.plugins.map((entry) => entry.name), ['mine', 'ultra-builder-pro']);
+    assert.equal(marketplace.plugins[1].source.path, './plugins/ultra-builder-pro');
+  } finally {
+    cleanup(layout);
+  }
+});
+
+test('uninstall removes only UBP-managed plugin and agents', () => {
+  const layout = mkLayout();
+  try {
+    fs.mkdirSync(layout.configDir, { recursive: true });
+    const configFile = path.join(layout.configDir, 'config.toml');
+    fs.writeFileSync(configFile, '[profile]\nname = "dev"\n');
+    install(layout);
+    fs.writeFileSync(path.join(layout.configDir, 'agents', 'mine.toml'), 'name = "mine"\n');
+
+    codex.uninstall({
+      configDir: layout.configDir,
+      homeDir: layout.homeDir,
+      scope: 'global',
+      runPluginCli: false,
+    });
+
+    assert.ok(!fs.existsSync(layout.pluginRoot));
+    for (const name of AGENTS) {
+      assert.ok(!fs.existsSync(path.join(layout.configDir, 'agents', `${name}.toml`)));
+    }
+    assert.ok(fs.existsSync(path.join(layout.configDir, 'agents', 'mine.toml')));
+    assert.equal(fs.readFileSync(configFile, 'utf8'), '[profile]\nname = "dev"\n');
+    const marketplace = JSON.parse(fs.readFileSync(layout.marketplaceFile, 'utf8'));
+    assert.ok(!marketplace.plugins.some((entry) => entry.name === 'ultra-builder-pro'));
+  } finally {
+    cleanup(layout);
+  }
+});

package/adapters/tests/gemini.test.cjs

@@ -0,0 +1,112 @@
+'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 gemini = require('../gemini.js');
+const { RETIRED_SKILLS, skillsForRuntime } = require('../_shared/runtime-assets.cjs');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+
+function mkTarget() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'ubp-gemini-'));
+}
+
+test('install packages into extensions/ultra-builder-pro with manifest + commands.toml + skills', () => {
+  const target = mkTarget();
+  try {
+    const r = gemini.install({ configDir: target, repoRoot: REPO_ROOT });
+    const extRoot = r.target;
+    assert.equal(extRoot, path.join(target, 'extensions', 'ultra-builder-pro'));
+    assert.ok(fs.existsSync(path.join(extRoot, 'gemini-extension.json')));
+    assert.ok(fs.existsSync(path.join(extRoot, 'GEMINI.md')));
+    assert.ok(r.copied.commands.includes('ultra-init.toml'));
+    assert.ok(r.copied.skills.some((p) => p.includes('ultra-init/SKILL.md')));
+
+    const installedSkills = fs.readdirSync(path.join(extRoot, 'skills')).sort();
+    assert.deepEqual(installedSkills, skillsForRuntime('gemini').sort());
+    for (const retired of RETIRED_SKILLS) assert.ok(!installedSkills.includes(retired));
+
+    const tomlContent = fs.readFileSync(path.join(extRoot, 'commands', 'ultra-init.toml'), 'utf8');
+    assert.match(tomlContent, /description = "/);
+    assert.match(tomlContent, /prompt = """/);
+  } finally {
+    fs.rmSync(target, { recursive: true, force: true });
+  }
+});
+
+test('reinstall removes stale managed skill assets while preserving runtime state', () => {
+  const target = mkTarget();
+  try {
+    gemini.install({ configDir: target, repoRoot: REPO_ROOT });
+    const extRoot = gemini.resolveExtensionRoot({ configDir: target });
+    const stale = path.join(extRoot, 'skills', 'recall');
+    fs.mkdirSync(stale, { recursive: true });
+    fs.writeFileSync(path.join(stale, 'SKILL.md'), 'retired');
+    fs.writeFileSync(path.join(extRoot, 'state.db'), 'preserve');
+
+    gemini.install({ configDir: target, repoRoot: REPO_ROOT });
+    assert.equal(fs.existsSync(stale), false);
+    assert.equal(fs.readFileSync(path.join(extRoot, 'state.db'), 'utf8'), 'preserve');
+  } finally {
+    fs.rmSync(target, { recursive: true, force: true });
+  }
+});
+
+test('manifest declares mcpServers with _ubp tag (not in env — P2 #9)', () => {
+  const target = mkTarget();
+  try {
+    gemini.install({ configDir: target, repoRoot: REPO_ROOT });
+    const extRoot = gemini.resolveExtensionRoot({ configDir: target });
+    const manifest = JSON.parse(fs.readFileSync(path.join(extRoot, 'gemini-extension.json'), 'utf8'));
+    assert.equal(manifest.name, gemini.EXTENSION_NAME);
+    assert.equal(manifest._ubp.source, gemini.SOURCE_TAG);
+    assert.ok(manifest.mcpServers[gemini.MCP_SERVER_NAME]);
+    // D45: identification lives outside env so it never leaks into spawned MCP server.
+    assert.equal(manifest.mcpServers[gemini.MCP_SERVER_NAME]._ubp.source, gemini.SOURCE_TAG);
+    assert.equal(manifest.mcpServers[gemini.MCP_SERVER_NAME].env, undefined, 'project cwd must own MCP state');
+    assert.equal(manifest.contextFileName, 'GEMINI.md');
+  } finally {
+    fs.rmSync(target, { recursive: true, force: true });
+  }
+});
+
+test('manifest uses a durable bundled MCP runtime and project-local state defaults', () => {
+  const target = mkTarget();
+  try {
+    gemini.install({ configDir: target, repoRoot: REPO_ROOT });
+    const extRoot = gemini.resolveExtensionRoot({ configDir: target });
+    const manifest = JSON.parse(fs.readFileSync(path.join(extRoot, 'gemini-extension.json'), 'utf8'));
+    const server = manifest.mcpServers[gemini.MCP_SERVER_NAME];
+    const launcher = server.args[0];
+    assert.ok(launcher.startsWith(path.join(extRoot, 'runtime') + path.sep));
+    assert.ok(fs.existsSync(launcher), 'bundled launcher must survive the installer source directory');
+    assert.equal(server.env, undefined, 'Gemini must resolve .ultra/state.db from the active project cwd');
+  } finally {
+    fs.rmSync(target, { recursive: true, force: true });
+  }
+});
+
+test('uninstall removes extension dir; refuses on foreign manifest', () => {
+  const target = mkTarget();
+  const extRoot = gemini.resolveExtensionRoot({ configDir: target });
+  try {
+    gemini.install({ configDir: target, repoRoot: REPO_ROOT });
+    assert.ok(fs.existsSync(extRoot));
+    gemini.uninstall({ configDir: target });
+    assert.ok(!fs.existsSync(extRoot));
+
+    // Re-install then tamper with the manifest's _ubp identification block.
+    gemini.install({ configDir: target, repoRoot: REPO_ROOT });
+    const manifestFile = path.join(extRoot, 'gemini-extension.json');
+    const m = JSON.parse(fs.readFileSync(manifestFile, 'utf8'));
+    m._ubp = { source: 'someone-else' };
+    fs.writeFileSync(manifestFile, JSON.stringify(m, null, 2));
+    assert.throws(() => gemini.uninstall({ configDir: target }), /refusing to uninstall/);
+  } finally {
+    fs.rmSync(target, { recursive: true, force: true });
+  }
+});