ultra-builder-pro-cli 0.5.2 → 0.6.0

package/skills/ultra-verify/scripts/verify_wait.py

@@ -1,23 +1,8 @@
 #!/usr/bin/env python3
-"""Verify Wait - File-based completion waiter for /ultra-verify pipeline.
+"""File-based completion waiter for the Ultra Verify advisor.
 
-Polls the session directory for expected AI output files.
-Blocks until both AIs produce output OR timeout. Returns structured JSON on stdout.
-
-Two exit conditions only:
-    1. Both AIs have output (non-empty + stable size) → exit 0, status="complete"
-    2. Timeout → exit 0, status="timeout" (JSON status field tells the story)
-
-Expected files:
-    - gemini-output.md  (Gemini)
-    - codex-output.md   (Codex)
-
-Usage:
-    python3 verify_wait.py <session_path> [--timeout SECONDS]
-
-Exit codes:
-    0 - Always (result expressed via JSON status field)
-    2 - Invalid arguments (missing path, bad --timeout)
+Poll the session directory until the expected output is non-empty and stable, or until timeout.
+The JSON result carries the operational status; timeout is not a process error.
 """
 
 import json
@@ -25,106 +10,84 @@ import sys
 import time
 from pathlib import Path
 
-POLL_INTERVAL = 3  # seconds
-DEFAULT_TIMEOUT = 1200  # 20 min — runs via run_in_background (no Bash 600s limit)
-
-# Each AI produces exactly one output file
-EXPECTED = {
-    "gemini": "gemini-output.md",
-    "codex": "codex-output.md",
-}
+POLL_INTERVAL = 3
+DEFAULT_TIMEOUT = 1200
+ADVISOR = "codex"
+OUTPUT_FILE = "codex-output.md"
 
 
 def _file_size(path: Path) -> int:
-    """Return file size in bytes, or -1 if not found."""
     try:
         return path.stat().st_size
     except (FileNotFoundError, OSError):
         return -1
 
 
-def _check_output(session_path: Path, name: str) -> dict:
-    """Check if an AI has produced non-empty output."""
-    output = session_path / EXPECTED[name]
+def _check_output(session_path: Path) -> dict:
+    output = session_path / OUTPUT_FILE
     if _file_size(output) > 0:
-        return {"name": name, "status": "complete", "file": str(output)}
-    return {"name": name, "status": "pending", "file": None}
+        return {"name": ADVISOR, "status": "complete", "file": str(output)}
+    return {"name": ADVISOR, "status": "pending", "file": None}
 
 
-def _timeout_status(session_path: Path, name: str) -> dict:
-    """Determine final status at timeout. Check error logs and empty files."""
-    output = session_path / EXPECTED[name]
-    error = session_path / f"{name}-error.log"
+def _timeout_status(session_path: Path) -> dict:
+    output = session_path / OUTPUT_FILE
+    error = session_path / f"{ADVISOR}-error.log"
     output_size = _file_size(output)
     if output_size > 0:
-        return {"name": name, "status": "complete", "file": str(output)}
+        return {"name": ADVISOR, "status": "complete", "file": str(output)}
     if _file_size(error) > 0:
-        return {"name": name, "status": "failed", "file": str(error)}
+        return {"name": ADVISOR, "status": "failed", "file": str(error)}
     if output_size == 0:
-        return {"name": name, "status": "empty", "file": str(output)}
-    return {"name": name, "status": "pending", "file": None}
+        return {"name": ADVISOR, "status": "empty", "file": str(output)}
+    return {"name": ADVISOR, "status": "pending", "file": None}
 
 
-def main():
+def main() -> None:
     if len(sys.argv) < 2:
         print(__doc__, file=sys.stderr)
         sys.exit(2)
 
     session_path = Path(sys.argv[1])
     timeout = DEFAULT_TIMEOUT
-
     if "--timeout" in sys.argv:
         idx = sys.argv.index("--timeout")
-        if idx + 1 < len(sys.argv):
-            try:
-                timeout = int(sys.argv[idx + 1])
-            except ValueError:
-                print(f"Error: --timeout must be integer: {sys.argv[idx + 1]}", file=sys.stderr)
-                sys.exit(2)
+        if idx + 1 >= len(sys.argv):
+            print("Error: --timeout requires an integer", file=sys.stderr)
+            sys.exit(2)
+        try:
+            timeout = int(sys.argv[idx + 1])
+        except ValueError:
+            print(f"Error: --timeout must be integer: {sys.argv[idx + 1]}", file=sys.stderr)
+            sys.exit(2)
+        if timeout < 0:
+            print("Error: --timeout must be non-negative", file=sys.stderr)
+            sys.exit(2)
 
     if not session_path.is_dir():
         print(f"Error: session directory not found: {session_path}", file=sys.stderr)
         sys.exit(2)
 
     deadline = time.monotonic() + timeout
-    prev_sizes = {name: _file_size(session_path / f) for name, f in EXPECTED.items()}
-
-    # Poll loop — exit condition 1: both outputs ready + stable
+    previous_size = _file_size(session_path / OUTPUT_FILE)
     while time.monotonic() < deadline:
-        cur_sizes = {name: _file_size(session_path / f) for name, f in EXPECTED.items()}
-        gemini = _check_output(session_path, "gemini")
-        codex = _check_output(session_path, "codex")
-
-        gemini_done = gemini["status"] == "complete" and cur_sizes["gemini"] == prev_sizes["gemini"]
-        codex_done = codex["status"] == "complete" and cur_sizes["codex"] == prev_sizes["codex"]
-
-        if gemini_done and codex_done:
+        current_size = _file_size(session_path / OUTPUT_FILE)
+        advisor = _check_output(session_path)
+        stable = advisor["status"] == "complete" and current_size == previous_size
+        if stable:
             elapsed = int(timeout - (deadline - time.monotonic()))
-            print(json.dumps({"status": "complete", "gemini": gemini, "codex": codex, "elapsed_seconds": elapsed}))
-            sys.exit(0)
-
-        prev_sizes = cur_sizes
-
-        # Progress display
-        remaining = int(deadline - time.monotonic())
-        parts = []
-        for name, done, result in [("gemini", gemini_done, gemini), ("codex", codex_done, codex)]:
-            if done:
-                parts.append(f"{name}:complete")
-            elif result["status"] == "complete":
-                parts.append(f"{name}:stabilizing")
-            else:
-                parts.append(f"{name}:waiting")
-        done_count = int(gemini_done) + int(codex_done)
-        sys.stderr.write(f"\r  [{done_count}/2] {' | '.join(parts)} ({remaining}s remaining)  ")
+            print(json.dumps({"status": "complete", ADVISOR: advisor, "elapsed_seconds": elapsed}))
+            return
+
+        state = "stabilizing" if advisor["status"] == "complete" else "waiting"
+        remaining = max(0, int(deadline - time.monotonic()))
+        sys.stderr.write(f"\r  [0/1] {ADVISOR}:{state} ({remaining}s remaining)  ")
         sys.stderr.flush()
+        previous_size = current_size
         time.sleep(POLL_INTERVAL)
 
-    # Exit condition 2: timeout — check error logs NOW for final status
-    gemini = _timeout_status(session_path, "gemini")
-    codex = _timeout_status(session_path, "codex")
-    print(json.dumps({"status": "timeout", "gemini": gemini, "codex": codex, "elapsed_seconds": timeout}))
-    sys.exit(0)
+    advisor = _timeout_status(session_path)
+    print(json.dumps({"status": "timeout", ADVISOR: advisor, "elapsed_seconds": timeout}))
 
 
 if __name__ == "__main__":

package/spec/mcp-tools.yaml

@@ -359,7 +359,7 @@ tools:
       properties:
         task_id:    { type: string }
         session_id: { type: string }
-        runtime:    { type: string, enum: [claude, opencode, codex, gemini] }
+        runtime:    { type: string, enum: [claude, opencode, codex] }
         type:
           type: string
           enum:
@@ -439,7 +439,7 @@ tools:
       additionalProperties: false
       properties:
         task_id:  { type: string }
-        runtime:  { type: string, enum: [claude, opencode, codex, gemini] }
+        runtime:  { type: string, enum: [claude, opencode, codex] }
         takeover: { type: boolean, default: false, description: 'override active lease (D33 takeover strategy)' }
         worktree_base: { type: string }
     output_schema:
@@ -541,7 +541,7 @@ tools:
       additionalProperties: false
       properties:
         task_id: { type: string }
-        runtime: { type: string, enum: [claude, opencode, codex, gemini] }
+        runtime: { type: string, enum: [claude, opencode, codex] }
     output_schema:
       type: object
       required: [can_spawn, recommended_action]

package/spec/schemas/skill-manifest.schema.json

@@ -19,10 +19,10 @@
     },
     "runtime": {
       "oneOf": [
-        { "type": "string", "enum": ["claude", "opencode", "codex", "gemini", "all"] },
+        { "type": "string", "enum": ["claude", "opencode", "codex", "all"] },
         {
           "type": "array",
-          "items": { "type": "string", "enum": ["claude", "opencode", "codex", "gemini"] },
+          "items": { "type": "string", "enum": ["claude", "opencode", "codex"] },
           "minItems": 1,
           "uniqueItems": true
         }

package/spec/schemas/state-db.sql

@@ -54,7 +54,7 @@ CREATE TABLE IF NOT EXISTS events (
   type          TEXT    NOT NULL,
   task_id       TEXT,
   session_id    TEXT,
-  runtime       TEXT CHECK (runtime IS NULL OR runtime IN ('claude', 'opencode', 'codex', 'gemini')),
+  runtime       TEXT CHECK (runtime IS NULL OR runtime IN ('claude', 'opencode', 'codex')),
   payload_json  TEXT
 );
 
@@ -69,7 +69,7 @@ CREATE INDEX IF NOT EXISTS events_session ON events(session_id, id);
 CREATE TABLE IF NOT EXISTS sessions (
   sid               TEXT PRIMARY KEY,
   task_id           TEXT NOT NULL REFERENCES tasks(id),
-  runtime           TEXT NOT NULL CHECK (runtime IN ('claude', 'opencode', 'codex', 'gemini')),
+  runtime           TEXT NOT NULL CHECK (runtime IN ('claude', 'opencode', 'codex')),
   pid               INTEGER,
   worktree_path     TEXT NOT NULL,
   artifact_dir      TEXT NOT NULL,

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

@@ -1,54 +0,0 @@
-'use strict';
-
-// Convert a thin-shell command .md file to a Gemini custom-command TOML.
-// Gemini commands live in `~/.gemini/commands/<name>.toml` with shape:
-//
-//   description = "…"
-//   prompt = """
-//   <command body>
-//   """
-//
-// Only the description (from frontmatter) and the body text cross over.
-// Frontmatter keys like `workflow-ref` are inlined into the prompt so the
-// agent still sees the skill reference.
-
-const { parse: parseFrontmatter } = require('./frontmatter.cjs');
-
-function escapeTomlLiteral(str) {
-  // Gemini accepts """multi-line""" literals. Escape any triple-quote to be safe.
-  return String(str).replace(/"""/g, '\\"\\"\\"');
-}
-
-function buildPromptSection(fm, body) {
-  const lines = [];
-  if (fm && fm['workflow-ref']) {
-    lines.push(`[ultra-builder-pro] workflow reference: ${fm['workflow-ref']}`);
-  }
-  if (fm && Array.isArray(fm.mcp_tools_required) && fm.mcp_tools_required.length > 0) {
-    lines.push(`[ultra-builder-pro] MCP tools required: ${fm.mcp_tools_required.join(', ')}`);
-  }
-  if (fm && fm.cli_fallback) {
-    lines.push(`[ultra-builder-pro] CLI fallback: ultra-tools ${fm.cli_fallback}`);
-  }
-  if (lines.length > 0) lines.push('');
-  lines.push(body.trimEnd());
-  return lines.join('\n');
-}
-
-function mdCommandToToml(mdText) {
-  if (typeof mdText !== 'string') throw new TypeError('mdCommandToToml: expects string');
-  const { fm, body } = parseFrontmatter(mdText);
-  const description = (fm && fm.description) || 'Ultra Builder Pro command';
-  const prompt = buildPromptSection(fm, body);
-
-  const tomlLines = [
-    `description = ${JSON.stringify(description)}`,
-    'prompt = """',
-    escapeTomlLiteral(prompt),
-    '"""',
-    '',
-  ];
-  return tomlLines.join('\n');
-}
-
-module.exports = { mdCommandToToml };

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

@@ -1,48 +0,0 @@
-'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/gemini.js

@@ -1,204 +0,0 @@
-'use strict';
-
-/**
- * Gemini CLI adapter — Phase 4.5 installer (extension-packaged).
- *
- * Target config dirs:
- *   global: $GEMINI_CONFIG_DIR → ~/.gemini
- *   local:  <cwd>/.gemini
- *
- * Layout — everything is packaged as a Gemini extension under
- * <target>/extensions/ultra-builder-pro/:
- *
- *   gemini-extension.json  → extension manifest (mcpServers declared here)
- *   commands/*.toml        → generated from commands/*.md via md-to-toml
- *   skills/**              → Ultra-owned allowlist (Gemini reads these as prompt includes)
- *   GEMINI.md              → canonical agent context (docs/AGENT-CONTEXT.md copy)
- *   hooks/                 → NOT installed; Gemini has no hook surface.
- *                            prompt-guard downgrade is described inside GEMINI.md.
- *
- * Scope boundaries (documented):
- *   - Gemini has no hook event loop; runtime-enforced guards degrade to
- *     prompt-level guidance (hooks/adapters/gemini.py explains).
- *   - Subagent registration requires the upstream spec to settle — Phase 4.5
- *     spike captures whatever shape lands.
- */
-
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-const {
-  copyTree,
-  writeAtomic,
-  ensureDir,
-  removeTree,
-} = require('./_shared/file-ops.cjs');
-const { mdCommandToToml } = require('./_shared/md-to-toml.cjs');
-const { buildMcpRuntime } = require('./_shared/codex-assets.cjs');
-const { skillsForRuntime } = require('./_shared/runtime-assets.cjs');
-
-const EXTENSION_NAME = 'ultra-builder-pro';
-const MCP_SERVER_NAME = 'ultra-builder-pro';
-const SOURCE_TAG = 'ubp';
-
-function resolveTarget(ctx) {
-  if (ctx.configDir) return ctx.configDir;
-  if (ctx.scope === 'global') {
-    return process.env.GEMINI_CONFIG_DIR || path.join(ctx.homeDir || os.homedir(), '.gemini');
-  }
-  return path.join(ctx.cwd || process.cwd(), '.gemini');
-}
-
-function resolveExtensionRoot(ctx) {
-  return path.join(resolveTarget(ctx), 'extensions', EXTENSION_NAME);
-}
-
-function resolveRepoRoot(ctx) {
-  return ctx.repoRoot || path.resolve(__dirname, '..');
-}
-
-function loadPkgVersion(repoRoot) {
-  try {
-    return JSON.parse(fs.readFileSync(path.join(repoRoot, 'package.json'), 'utf8')).version;
-  } catch (err) {
-    // Fall back to 0.0.0 but surface the reason — silent swallow hid a
-    // real "package.json moved" regression in a Phase 4 code review.
-    process.stderr.write(`gemini adapter: loadPkgVersion fell back to 0.0.0 (${err.message})\n`);
-    return '0.0.0';
-  }
-}
-
-function buildManifest(repoRoot, runtime) {
-  return {
-    name: EXTENSION_NAME,
-    version: loadPkgVersion(repoRoot),
-    description: 'Ultra Builder Pro — skill/MCP/CLI agent engineering system (Gemini packaging).',
-    // Sibling identification block — outside env so it cannot leak into the
-    // MCP server's child process (P2 #9). Uninstall reads manifest._ubp.source.
-    _ubp: { source: SOURCE_TAG },
-    mcpServers: {
-      [MCP_SERVER_NAME]: {
-        command: process.execPath,
-        args: [runtime.launcher],
-        _ubp: { source: SOURCE_TAG },
-      },
-    },
-    contextFileName: 'GEMINI.md',
-  };
-}
-
-function ownsExtension(extensionRoot) {
-  const manifestFile = path.join(extensionRoot, 'gemini-extension.json');
-  if (!fs.existsSync(manifestFile)) return false;
-  try {
-    const manifest = JSON.parse(fs.readFileSync(manifestFile, 'utf8'));
-    return manifest?._ubp?.source === SOURCE_TAG;
-  } catch (_error) {
-    return false;
-  }
-}
-
-function install(ctx) {
-  const extensionRoot = resolveExtensionRoot(ctx);
-  const repoRoot = resolveRepoRoot(ctx);
-  if (fs.existsSync(extensionRoot)) {
-    const entries = fs.readdirSync(extensionRoot);
-    if (entries.length > 0 && !ownsExtension(extensionRoot)) {
-      throw new Error(`refusing to replace unmanaged Gemini extension: ${extensionRoot}`);
-    }
-    if (entries.length > 0) {
-      for (const managed of ['skills', 'commands', 'runtime', 'spec', 'templates']) {
-        removeTree(path.join(extensionRoot, managed));
-      }
-      for (const managed of ['GEMINI.md', 'gemini-extension.json']) {
-        const file = path.join(extensionRoot, managed);
-        if (fs.existsSync(file)) fs.unlinkSync(file);
-      }
-    }
-  }
-  ensureDir(extensionRoot);
-
-  const report = { target: extensionRoot, copied: {}, config: { updated: false } };
-
-  // 1. Skills — copy only the canonical Ultra-owned allowlist.
-  const skillsSrc = path.join(repoRoot, 'skills');
-  report.copied.skills = [];
-  for (const name of skillsForRuntime('gemini')) {
-    const source = path.join(skillsSrc, name);
-    if (!fs.existsSync(path.join(source, 'SKILL.md'))) {
-      throw new Error(`missing allowlisted Gemini skill: ${name}`);
-    }
-    const files = copyTree(source, path.join(extensionRoot, 'skills', name));
-    report.copied.skills.push(...files.map((file) => path.join(name, file)));
-  }
-
-  // 2. Commands — md → toml
-  const commandsSrc = path.join(repoRoot, 'commands');
-  if (fs.existsSync(commandsSrc)) {
-    const dstCommands = path.join(extensionRoot, 'commands');
-    ensureDir(dstCommands);
-    const tomlFiles = [];
-    for (const f of fs.readdirSync(commandsSrc)) {
-      if (!f.endsWith('.md')) continue;
-      const md = fs.readFileSync(path.join(commandsSrc, f), 'utf8');
-      const tomlName = f.replace(/\.md$/, '.toml');
-      writeAtomic(path.join(dstCommands, tomlName), mdCommandToToml(md));
-      tomlFiles.push(tomlName);
-    }
-    report.copied.commands = tomlFiles;
-  }
-
-  // 3. GEMINI.md — copy docs/AGENT-CONTEXT.md into the extension context file
-  const agentContext = path.join(repoRoot, 'docs', 'AGENT-CONTEXT.md');
-  if (fs.existsSync(agentContext)) {
-    const dst = path.join(extensionRoot, 'GEMINI.md');
-    fs.copyFileSync(agentContext, dst);
-    report.copied.context = 'GEMINI.md';
-  }
-
-  // 4. Manifest
-  const runtime = buildMcpRuntime(repoRoot, extensionRoot, { runtime: 'gemini' });
-  const manifest = buildManifest(repoRoot, runtime);
-  writeAtomic(
-    path.join(extensionRoot, 'gemini-extension.json'),
-    JSON.stringify(manifest, null, 2) + '\n',
-  );
-  report.config.updated = true;
-  return report;
-}
-
-function uninstall(ctx) {
-  const extensionRoot = resolveExtensionRoot(ctx);
-  const report = { target: extensionRoot, removed: {}, config: { updated: false } };
-  if (fs.existsSync(extensionRoot)) {
-    // Manifest carries the _ubp sibling block — if tampered with, bail loud.
-    const manifestFile = path.join(extensionRoot, 'gemini-extension.json');
-    if (fs.existsSync(manifestFile)) {
-      try {
-        const manifest = JSON.parse(fs.readFileSync(manifestFile, 'utf8'));
-        if (!manifest._ubp || manifest._ubp.source !== SOURCE_TAG) {
-          throw new Error(`refusing to uninstall: ${manifestFile} was not generated by this adapter`);
-        }
-      } catch (err) {
-        if (err.message.startsWith('refusing')) throw err;
-        // malformed manifest: proceed — we still own the directory name
-      }
-    }
-    removeTree(extensionRoot);
-    report.removed.extension = true;
-    report.config.updated = true;
-  }
-  return report;
-}
-
-module.exports = {
-  name: 'gemini',
-  EXTENSION_NAME,
-  MCP_SERVER_NAME,
-  SOURCE_TAG,
-  resolveTarget,
-  resolveExtensionRoot,
-  install,
-  uninstall,
-};

package/adapters/tests/gemini.test.cjs

@@ -1,112 +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 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 });
-  }
-});