ultra-builder-pro-cli 5.0.1 → 6.0.0

package/adapters/_shared/plugin-core.cjs

@@ -21,17 +21,6 @@ const {
 } = require('./runtime-assets.cjs');
 
 const PROVENANCE_FILE = 'provenance.json';
-const DELEGATION_RUNNER_FILES = Object.freeze([
-  'delegate.cjs',
-  'delegate-worker.cjs',
-  'host-profile.cjs',
-  'agent-execution-driver.cjs',
-  'acp-driver.cjs',
-  'cli-driver.cjs',
-  path.join('delegate-profiles', 'kimi-read-only.md'),
-  path.join('delegate-profiles', 'kimi-write.md'),
-]);
-
 function titleCase(name) {
   return name.split('-').map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(' ');
 }
@@ -39,24 +28,20 @@ function titleCase(name) {
 function skillFrontmatter(runtime, name, fm) {
   const base = { name, description: String(fm.description || '') };
   const policy = skillPolicy(name);
-  if (runtime === 'claude' || runtime === 'grok') {
+  if (runtime === 'claude') {
     return {
       ...base,
       'user-invocable': policy.userInvocable,
       ...(!policy.allowImplicitInvocation ? { 'disable-model-invocation': true } : {}),
     };
   }
-  if (runtime === 'kimi') {
-    return {
-      ...base,
-      ...(!policy.allowImplicitInvocation ? { disableModelInvocation: true } : {}),
-    };
-  }
   return base;
 }
 
 function codexMetadata(name, description) {
-  const short = String(description).replace(/\s+/g, ' ').trim().slice(0, 64).replace(/[\s.,;:]+$/, '');
+  const full = String(description).replace(/\s+/g, ' ').trim();
+  const limit = full.length > 64 ? full.lastIndexOf(' ', 64) : full.length;
+  const short = full.slice(0, limit > 0 ? limit : 64).replace(/[\s.,;:]+$/, '');
   return [
     'interface:',
     `  display_name: ${JSON.stringify(titleCase(name))}`,
@@ -68,7 +53,11 @@ function codexMetadata(name, description) {
   ].join('\n');
 }
 
-function copySkills({ runtime, repoRoot, skillRoot }) {
+function copySkills({ runtime, repoRoot, skillRoot, publishedRoot }) {
+  copyTree(path.join(repoRoot, 'engine'), path.join(skillRoot, '..', 'engine'));
+  const cli = path.join(publishedRoot, 'engine', 'cli.cjs');
+  const formats = path.join(publishedRoot, 'engine', 'FORMATS.md');
+  const quotedCli = "'" + cli.replaceAll("'", "'\\''") + "'";
   const installed = [];
   for (const name of skillsForRuntime(runtime)) {
     const source = path.join(repoRoot, 'skills', name);
@@ -81,14 +70,13 @@ function copySkills({ runtime, repoRoot, skillRoot }) {
         if (relative !== 'SKILL.md') return buffer;
         const { fm, body } = parse(buffer.toString('utf8'));
         if (!fm) throw new Error(`missing frontmatter in ${name}`);
-        return Buffer.from(serialize(skillFrontmatter(runtime, name, fm), body));
+        return Buffer.from(serialize(
+          skillFrontmatter(runtime, name, fm), body
+            .replaceAll('__UBP_ENGINE_CLI__', quotedCli)
+            .replaceAll('__UBP_ENGINE_FORMATS__', formats),
+        ));
       },
     });
-    if (name === 'ultra-init') {
-      const template = path.join(repoRoot, '.ultra-template');
-      if (!fs.existsSync(template)) throw new Error('missing canonical .ultra-template');
-      copyTree(template, path.join(target, 'assets', 'project-template'));
-    }
     if (runtime === 'codex') {
       const { fm } = parse(fs.readFileSync(path.join(source, 'SKILL.md'), 'utf8'));
       writeAtomic(
@@ -101,20 +89,13 @@ function copySkills({ runtime, repoRoot, skillRoot }) {
   return installed;
 }
 
-function copyHooks({ runtime, repoRoot, hookRoot, hooksManifest }) {
+function copyHooks({ repoRoot, hookRoot, hooksManifest }) {
   ensureDir(hookRoot);
-  for (const name of [...WORKFLOW_HOOK_FILES, '_common.py']) {
+  for (const name of WORKFLOW_HOOK_FILES) {
     const source = path.join(repoRoot, 'hooks', name);
     if (!fs.existsSync(source)) throw new Error(`missing allowlisted hook: ${name}`);
     fs.copyFileSync(source, path.join(hookRoot, name));
   }
-  if (['codex', 'kimi', 'grok', 'zcode'].includes(runtime)) {
-    ensureDir(path.join(hookRoot, 'adapters'));
-    fs.copyFileSync(
-      path.join(repoRoot, 'hooks', 'adapters', `${runtime}.py`),
-      path.join(hookRoot, 'adapters', `${runtime}.py`),
-    );
-  }
   writeAtomic(path.join(hookRoot, 'hooks.json'), `${JSON.stringify(hooksManifest, null, 2)}\n`);
   return [...WORKFLOW_HOOK_FILES];
 }
@@ -175,19 +156,7 @@ function inspectPlugin({ adapter, repoRoot, pluginRoot, skillRoot, hookRoot, man
       issue('SKILL_MISSING', { skill: name });
     }
   }
-  const delegationRunnerRoot = path.join(skillRoot, 'ultra-delegate', 'scripts');
-  const missingDelegationRunnerFiles = DELEGATION_RUNNER_FILES.filter((relative) => {
-    const candidate = path.join(delegationRunnerRoot, relative);
-    return !fs.existsSync(candidate) || !fs.statSync(candidate).isFile();
-  });
-  if (missingDelegationRunnerFiles.length > 0) {
-    issue('DELEGATION_RUNNER_MISSING', {
-      paths: missingDelegationRunnerFiles.map((relative) => (
-        path.join(delegationRunnerRoot, relative)
-      )),
-    });
-  }
-  for (const name of [...WORKFLOW_HOOK_FILES, '_common.py']) {
+  for (const name of WORKFLOW_HOOK_FILES) {
     if (!fs.existsSync(path.join(hookRoot, name))) issue('HOOK_MISSING', { hook: name });
   }
   for (const retired of ['commands', 'agents', 'runtime', '.mcp.json']) {
@@ -202,41 +171,6 @@ function inspectPlugin({ adapter, repoRoot, pluginRoot, skillRoot, hookRoot, man
   report.checks.plugin_manifest = {
     status: fs.existsSync(manifestFile) ? 'pass' : 'fail',
   };
-  report.checks.delegation_runner = {
-    status: missingDelegationRunnerFiles.length === 0 ? 'pass' : 'fail',
-    entrypoint: path.join(delegationRunnerRoot, 'delegate.cjs'),
-  };
-  try {
-    const installedProfiles = require(path.join(delegationRunnerRoot, 'host-profile.cjs'));
-    const installedDrivers = require(path.join(delegationRunnerRoot, 'agent-execution-driver.cjs'));
-    const profile = installedProfiles.hostProfile(adapter);
-    const selection = installedDrivers.selectExecutionDriver({
-      host: adapter,
-      profile,
-      cliCommand: profile.binary,
-      env: process.env,
-    });
-    report.checks.acp_capability = {
-      status: 'pass',
-      ...selection.acpCapability,
-    };
-    report.checks.agent_execution_driver = {
-      status: 'pass',
-      selected: selection.driver,
-      fallback_reason: selection.fallbackReason,
-    };
-    if (adapter === 'zcode') {
-      report.checks.zcode_transport_maturity = {
-        status: profile.transportMaturity,
-        installed_runtime_only: profile.installedRuntimeOnly === true,
-        surface: profile.acp?.surface || null,
-      };
-    }
-  } catch (error) {
-    issue('EXECUTION_DRIVER_INSPECTION_FAILED', { message: error.message });
-    report.checks.acp_capability = { status: 'fail' };
-    report.checks.agent_execution_driver = { status: 'fail' };
-  }
   report.status = report.issues.length === 0 ? 'healthy' : 'degraded';
   return report;
 }

package/adapters/_shared/runtime-assets.cjs

@@ -1,132 +1,18 @@
 'use strict';
 
-/**
- * Canonical package and invocation boundary.
- *
- * Skills carry semantic workflow. Hooks are optional acceleration and safety.
- * There is no prompt projection, worker registry, MCP kernel, or runtime daemon.
- */
-
-const USER_INVOKED_SKILLS = Object.freeze([
-  'ultra-init',
-  'ultra-research',
-  'ultra-change',
-  'ultra-plan',
-  'ultra-dev',
-  'ultra-test',
-  'ultra-deliver',
-  'ultra-delegate',
-]);
-
-const MODEL_INVOKED_SKILLS = Object.freeze([
-  'ultra-grilling',
-  'ultra-domain-modeling',
-  'ultra-tdd',
-  'ultra-review',
-  'ultra-think',
-]);
-
-const ROUTER_SKILLS = Object.freeze(['ultra-status']);
-const PUBLIC_SKILL_INVOCATION_MODES = Object.freeze({
-  'ultra-init': Object.freeze({
-    create: 'explicit-entry',
-    recover: 'explicit-entry',
-  }),
-  'ultra-research': Object.freeze({
-    baseline: 'explicit-entry',
-    'change-scoped': 'grant-continuable',
-  }),
-  'ultra-change': Object.freeze({
-    intake: 'explicit-entry',
-    'evidence-needed': 'explicit-entry',
-    reconcile: 'grant-continuable',
-    accepted: 'explicit-entry',
-  }),
-  'ultra-plan': Object.freeze({
-    decompose: 'grant-continuable',
-    recover: 'grant-continuable',
-  }),
-  'ultra-dev': Object.freeze({
-    execute: 'grant-continuable',
-    resume: 'grant-continuable',
-    reopen: 'grant-continuable',
-  }),
-  'ultra-test': Object.freeze({
-    audit: 'grant-continuable',
-    reaudit: 'grant-continuable',
-  }),
-  'ultra-deliver': Object.freeze({
-    reconcile: 'grant-continuable',
-    finalize: 'explicit-entry',
-  }),
-  'ultra-delegate': Object.freeze({
-    task: 'explicit-entry',
-    research: 'explicit-entry',
-    aggregate: 'explicit-entry',
-  }),
-  'ultra-status': Object.freeze({
-    route: 'router',
-    history: 'router',
-    installation: 'router',
-    delegation: 'router',
-    recovery: 'router',
-  }),
-});
-const GRANT_CONTINUABLE_SKILLS = Object.freeze(USER_INVOKED_SKILLS.filter((name) => (
-  Object.values(PUBLIC_SKILL_INVOCATION_MODES[name]).includes('grant-continuable')
-)));
-const SUPPORTED_RUNTIMES = Object.freeze(['claude', 'opencode', 'codex', 'kimi', 'grok', 'zcode']);
-
-const WORKFLOW_HOOK_FILES = Object.freeze([
-  'session_context.py',
-  'mid_workflow_recall.py',
-  'compact_context.py',
-  'post_edit_guard.py',
-  'block_dangerous_commands.py',
-]);
+const SUPPORTED_RUNTIMES = Object.freeze(['claude', 'codex']);
+const WORKFLOW_HOOK_FILES = Object.freeze(['session-start.cjs']);
 
 function skillsForRuntime(runtime) {
   if (!SUPPORTED_RUNTIMES.includes(runtime)) {
     throw new Error(`unsupported Ultra runtime: ${runtime}`);
   }
-  return [...USER_INVOKED_SKILLS, ...MODEL_INVOKED_SKILLS, ...ROUTER_SKILLS];
-}
-
-function isSupportedRuntime(runtime) {
-  return SUPPORTED_RUNTIMES.includes(runtime);
+  return ['ultra'];
 }
 
 function skillPolicy(name) {
-  if (!skillsForRuntime(SUPPORTED_RUNTIMES[0]).includes(name)) {
-    throw new Error(`unknown packaged Ultra skill: ${name}`);
-  }
-  if (MODEL_INVOKED_SKILLS.includes(name)) {
-    return {
-      userInvocable: false,
-      allowImplicitInvocation: true,
-      invocationClasses: ['model-discipline'],
-      modes: {},
-    };
-  }
-  const modes = PUBLIC_SKILL_INVOCATION_MODES[name];
-  const invocationClasses = [...new Set(Object.values(modes))];
-  return {
-    userInvocable: true,
-    allowImplicitInvocation: invocationClasses.includes('grant-continuable'),
-    invocationClasses,
-    modes,
-  };
+  if (name !== 'ultra') throw new Error(`unknown packaged Ultra skill: ${name}`);
+  return { userInvocable: true, allowImplicitInvocation: true };
 }
 
-module.exports = {
-  GRANT_CONTINUABLE_SKILLS,
-  USER_INVOKED_SKILLS,
-  MODEL_INVOKED_SKILLS,
-  PUBLIC_SKILL_INVOCATION_MODES,
-  ROUTER_SKILLS,
-  SUPPORTED_RUNTIMES,
-  WORKFLOW_HOOK_FILES,
-  isSupportedRuntime,
-  skillPolicy,
-  skillsForRuntime,
-};
+module.exports = { SUPPORTED_RUNTIMES, WORKFLOW_HOOK_FILES, skillsForRuntime, skillPolicy };

package/adapters/claude.js

@@ -41,30 +41,14 @@ function resolveRepoRoot(ctx = {}) {
   return ctx.repoRoot || path.resolve(__dirname, '..');
 }
 
-function hookCommand(name) {
-  return {
-    type: 'command',
-    command: `python3 "\${CLAUDE_PLUGIN_ROOT}/hooks/${name}"`,
-    timeout: 10,
-  };
-}
-
 function buildHooksManifest() {
   return {
-    description: 'Ultra file-first context sensors and narrow effect protection.',
     hooks: {
-      SessionStart: [
-        { matcher: 'startup|resume|clear', hooks: [hookCommand('session_context.py')] },
-        { matcher: 'compact', hooks: [hookCommand('compact_context.py')] },
-      ],
-      PreToolUse: [
-        { matcher: 'Write|Edit|Grep', hooks: [hookCommand('mid_workflow_recall.py')] },
-        { matcher: 'Bash', hooks: [hookCommand('block_dangerous_commands.py')] },
-      ],
-      PostToolUse: [
-        { matcher: 'Write|Edit', hooks: [hookCommand('post_edit_guard.py')] },
-      ],
-      PreCompact: [{ hooks: [hookCommand('compact_context.py')] }],
+      SessionStart: [{ hooks: [{
+        type: 'command',
+        command: `node "\${CLAUDE_PLUGIN_ROOT}/hooks/session-start.cjs"`,
+        timeout: 10,
+      }] }],
     },
   };
 }
@@ -73,13 +57,13 @@ function buildStaging(repoRoot, staging, publishedRoot) {
   const skillRoot = path.join(staging, 'skills');
   const hookRoot = path.join(staging, 'hooks');
   const hooks = buildHooksManifest();
-  const skills = copySkills({ runtime: 'claude', repoRoot, skillRoot });
-  copyHooks({ runtime: 'claude', repoRoot, hookRoot, hooksManifest: hooks });
+  const skills = copySkills({ runtime: 'claude', repoRoot, skillRoot, publishedRoot });
+  copyHooks({ repoRoot, hookRoot, hooksManifest: hooks });
   const pkg = JSON.parse(fs.readFileSync(path.join(repoRoot, 'package.json'), 'utf8'));
   writeAtomic(path.join(staging, '.claude-plugin', 'plugin.json'), `${JSON.stringify({
     name: PLUGIN_NAME,
     version: pkg.version,
-    description: 'File-first Ultra Builder Pro workflows for Claude Code.',
+    description: 'UBP v6 method, engine and session status line for Claude Code.',
     author: { name: pkg.author },
     repository: pkg.homepage,
     license: pkg.license,

package/adapters/codex.js

@@ -77,6 +77,7 @@ function installCleanupRoots(ctx, pluginRoot) {
   add(resolveTarget(ctx), [
     '.', 'config.toml', 'plugins', path.join('plugins', 'cache'),
     path.join('plugins', 'cache', 'personal'), 'tmp', path.join('tmp', 'arg0'),
+    path.join('tmp', 'arg0-macos'),
   ]);
   return [...groups].map(([root, candidates]) => ({
     root,
@@ -101,31 +102,14 @@ function shellQuote(value) {
   return `'${String(value).replaceAll("'", "'\"'\"'")}'`;
 }
 
-function hookCommand(pluginRoot, name) {
-  const adapter = path.join(pluginRoot, 'hooks', 'adapters', 'codex.py');
-  return {
-    type: 'command',
-    command: `python3 ${shellQuote(adapter)} ${shellQuote(name)}`,
-    timeout: 10,
-  };
-}
-
-function buildHooksManifest(pluginRoot = '${CODEX_PLUGIN_ROOT}') {
+function buildHooksManifest(pluginRoot) {
   return {
     hooks: {
-      SessionStart: [
-        { matcher: 'startup|resume|clear', hooks: [hookCommand(pluginRoot, 'session_context.py')] },
-        { matcher: 'compact', hooks: [hookCommand(pluginRoot, 'compact_context.py')] },
-      ],
-      PreToolUse: [
-        { matcher: 'Write|Edit|Grep|apply_patch', hooks: [hookCommand(pluginRoot, 'mid_workflow_recall.py')] },
-        { matcher: 'Bash', hooks: [hookCommand(pluginRoot, 'block_dangerous_commands.py')] },
-      ],
-      PostToolUse: [
-        { matcher: 'Write|Edit|apply_patch', hooks: [hookCommand(pluginRoot, 'post_edit_guard.py')] },
-      ],
-      PreCompact: [{ matcher: 'manual|auto', hooks: [hookCommand(pluginRoot, 'compact_context.py')] }],
-      PostCompact: [{ hooks: [hookCommand(pluginRoot, 'compact_context.py')] }],
+      SessionStart: [{ hooks: [{
+        type: 'command',
+        command: `node ${shellQuote(path.join(pluginRoot, 'hooks', 'session-start.cjs'))}`,
+        timeout: 10,
+      }] }],
     },
   };
 }
@@ -142,9 +126,9 @@ function contentHash(root, version) {
 function buildStaging(repoRoot, staging, publishedRoot) {
   const skillRoot = path.join(staging, 'skills');
   const hookRoot = path.join(staging, 'hooks');
-  const skills = copySkills({ runtime: 'codex', repoRoot, skillRoot });
+  const skills = copySkills({ runtime: 'codex', repoRoot, skillRoot, publishedRoot });
   copyHooks({
-    runtime: 'codex', repoRoot, hookRoot,
+    repoRoot, hookRoot,
     hooksManifest: buildHooksManifest(publishedRoot),
   });
   if (fs.existsSync(path.join(repoRoot, 'LICENSE'))) {
@@ -155,7 +139,7 @@ function buildStaging(repoRoot, staging, publishedRoot) {
   writeAtomic(path.join(staging, '.codex-plugin', 'plugin.json'), `${JSON.stringify({
     name: PLUGIN_NAME,
     version,
-    description: 'File-first Ultra Builder Pro workflows for Codex.',
+    description: 'UBP v6 method, engine and session status line for Codex.',
     author: { name: pkg.author },
     homepage: pkg.homepage,
     repository: pkg.repository?.url || pkg.repository,
@@ -164,16 +148,14 @@ function buildStaging(repoRoot, staging, publishedRoot) {
     skills: './skills/',
     interface: {
       displayName: 'Ultra Builder Pro',
-      shortDescription: 'File-first project workflows and evidence.',
-      longDescription: 'Resume product and engineering work across sessions and coding-agent hosts through portable Skills, repository files, and Git.',
+      shortDescription: 'UBP v6 method, engine and session status line.',
+      longDescription: 'UBP v6 method, engine and session status line for Codex.',
       developerName: pkg.author,
       category: 'Developer Tools',
       capabilities: ['Interactive', 'Write'],
       websiteURL: pkg.homepage,
       defaultPrompt: [
-        'Start a new project with $ultra-builder-pro:ultra-init.',
-        'Reconcile this change with $ultra-builder-pro:ultra-change.',
-        'Show workflow status with $ultra-builder-pro:ultra-status.',
+        'Drive this project with $ultra-builder-pro:ultra.',
       ],
     },
   }, null, 2)}\n`);
@@ -183,7 +165,6 @@ function buildStaging(repoRoot, staging, publishedRoot) {
     contracts: {
       plugin_manifest: { root: 'plugin', path: '.codex-plugin/plugin.json' },
       hooks_manifest: { root: 'plugin', path: 'hooks/hooks.json' },
-      hook_adapter: { root: 'plugin', path: 'hooks/adapters/codex.py' },
     },
   });
   return { skills, version };

package/bin/install.js

@@ -1,25 +1,6 @@
 #!/usr/bin/env node
 
-/**
- * ultra-builder-pro-cli — multi-runtime installer.
- *
- * Distributes fourteen Skills and five hooks to Claude Code, OpenCode, Codex CLI,
- * Kimi Code, Grok Build, and ZCode through runtime-specific adapters under adapters/.
- * Install is idempotent and atomic; uninstall removes only managed assets.
- *
- * Usage:
- *   npx ultra-builder-pro-cli [options]
- *
- *   --claude / --opencode / --codex / --kimi / --grok / --zcode select runtime(s)
- *   --all                                         install to all supported runtimes
- *   -g, --global                                  install to runtime's global config dir
- *   -l, --local                                   project scope where the host supports it
- *   -u, --uninstall                               remove installed assets
- *   -d, --doctor                                  inspect installation provenance without mutation
- *   --json                                        emit machine-readable doctor output
- *   -c, --config-dir <path>                       override config directory
- *   -h, --help                                    show help
- */
+// UBP v6 installer for Claude Code and Codex; engine commands dispatch below.
 
 'use strict';
 
@@ -57,7 +38,7 @@ function printBanner() {
     paint('cyan', '   ╚═════╝ ╚═════╝ ╚═╝         ╚═════╝╚══════╝╚═╝'),
     '',
     `  ${paint('bold', 'Ultra Builder Pro CLI')} ${paint('dim', 'v' + pkg.version)}`,
-    `  ${paint('dim', 'Multi-runtime installer for Claude Code, OpenCode, Codex, Kimi Code, Grok Build, and ZCode')}`,
+    `  ${paint('dim', 'Project engine and method for Claude Code and Codex')}`,
     '',
   ];
   console.log(banner.join('\n'));
@@ -66,23 +47,32 @@ function printBanner() {
 function printHelp() {
   console.log(`  ${paint('yellow', 'Usage:')} npx ultra-builder-pro-cli [options]
 
+  ${paint('yellow', 'Progress:')}
+    ${paint('cyan', 'status')}                show progress computed from project files
+    ${paint('cyan', 'gate')}                  validate the plan and record its snapshot
+    ${paint('cyan', 'check')}                 run registered checks and record evidence
+    ${paint('cyan', 'node done <id>')}        complete a ready node with green requirements
+    ${paint('cyan', 'milestone close <id>')}  close a milestone after its journey and review
+    ${paint('cyan', 'context <id>')}          compile the brief for a node
+    ${paint('cyan', 'approve <items>')}       record the Owner's approval of reductions
+    ${paint('cyan', 'drive')}                 run unattended until the next Owner touch
+    ${paint('cyan', 'retro')}                 list failure classes since the latest closure
+    ${paint('cyan', 'merge <branch>')}        merge after verifying the expected HEAD and checks
+
   ${paint('yellow', 'Runtime selection (pick ≥1, or --all):')}
     ${paint('cyan', '--claude')}           Claude Code
-    ${paint('cyan', '--opencode')}         OpenCode
     ${paint('cyan', '--codex')}            Codex CLI (OpenAI)
-    ${paint('cyan', '--kimi')}             Kimi Code (Moonshot AI)
-    ${paint('cyan', '--grok')}             Grok Build (xAI)
-    ${paint('cyan', '--zcode')}            ZCode (Z.AI)
     ${paint('cyan', '--all')}              all supported runtimes
 
   ${paint('yellow', 'Scope:')}
     ${paint('cyan', '-g, --global')}       install to runtime's global config directory
-    ${paint('cyan', '-l, --local')}        project scope (Claude, OpenCode, and Codex)
+    ${paint('cyan', '-l, --local')}        project scope (Claude Code only)
 
   ${paint('yellow', 'Other:')}
     ${paint('cyan', '-u, --uninstall')}    remove installed assets
     ${paint('cyan', '-d, --doctor')}       verify installed version, provenance, managed assets, and live entry points
-    ${paint('cyan', '--json')}             emit machine-readable doctor output (doctor only)
+    ${paint('cyan', '--json')}             emit machine-readable output (doctor and engine commands)
+    ${paint('cyan', '--root <dir>')}       engine commands: the project root (default: current directory)
     ${paint('cyan', '-c, --config-dir')}   override one runtime's config directory; multi-runtime installs use <path>/<runtime>
     ${paint('cyan', '-h, --help')}         show this help
     ${paint('cyan', '-v, --version')}      show CLI version
@@ -91,21 +81,9 @@ function printHelp() {
     ${paint('dim', '# Install to Claude Code globally')}
     npx ultra-builder-pro-cli --claude --global
 
-    ${paint('dim', '# Install all six native plugins in their user scopes')}
+    ${paint('dim', '# Install both plugins in their user scopes')}
     npx ultra-builder-pro-cli --all --global
 
-    ${paint('dim', '# Uninstall from OpenCode')}
-    npx ultra-builder-pro-cli --opencode --global --uninstall
-
-    ${paint('dim', '# Install to Kimi Code globally')}
-    npx ultra-builder-pro-cli --kimi --global
-
-    ${paint('dim', '# Install to Grok Build globally')}
-    npx ultra-builder-pro-cli --grok --global
-
-    ${paint('dim', '# Install to ZCode globally')}
-    npx ultra-builder-pro-cli --zcode --global
-
     ${paint('dim', '# Verify all host installations without changing them')}
     npx ultra-builder-pro-cli --all --global --doctor
 `);
@@ -129,11 +107,7 @@ function parseArgs(argv) {
     const a = args[i];
     switch (a) {
       case '--claude': runtimes.add('claude'); break;
-      case '--opencode': runtimes.add('opencode'); break;
       case '--codex': runtimes.add('codex'); break;
-      case '--kimi': runtimes.add('kimi'); break;
-      case '--grok': runtimes.add('grok'); break;
-      case '--zcode': runtimes.add('zcode'); break;
       case '--all':
         SUPPORTED_RUNTIMES.forEach(r => runtimes.add(r));
         break;
@@ -189,16 +163,18 @@ function loadAdapter(runtime) {
   return require(adapterPath);
 }
 
-function resolveScope(flags) {
+function resolveScope(flags, runtime) {
   if (flags.global && flags.local) bail('cannot use --global and --local together');
-  if (!flags.global && !flags.local) return 'local';
+  if (!flags.global && !flags.local) return runtime === 'codex' ? 'global' : 'local';
   return flags.global ? 'global' : 'local';
 }
 
 async function main() {
-  if (process.argv[2] === 'delegate') {
-    const { handle } = require('./delegate.cjs');
-    process.stdout.write(`${JSON.stringify(handle(process.argv.slice(2)))}\n`);
+  if (['status', 'gate', 'check', 'node', 'milestone', 'context', 'approve', 'retro', 'merge',
+    'drive']
+    .includes(process.argv[2])) {
+    const { handle } = require('../engine/cli.cjs');
+    process.exitCode = await handle(process.argv.slice(2));
     return;
   }
   const { runtimes, flags } = parseArgs(process.argv);
@@ -218,22 +194,24 @@ async function main() {
   if (flags.json && !flags.doctor) bail('--json is available only with --doctor');
 
   if (runtimes.length === 0) {
-    bail('no runtime selected; use --claude / --opencode / --codex / --kimi / --grok / --zcode / --all');
+    bail('no runtime selected; use --claude / --codex / --all');
   }
 
-  const scope = resolveScope(flags);
+  const scopes = Object.fromEntries(runtimes.map((r) => [r, resolveScope(flags, r)]));
+  if (runtimes.includes('codex') && flags.local && !flags.configDir) {
+    bail('Codex is user-scope only; --local requires an isolated --config-dir');
+  }
   const repoRoot = path.resolve(__dirname, '..');
   const configDir = flags.configDir ? expandTilde(flags.configDir) : null;
-  const userScopedOnly = runtimes.filter((runtime) => ['kimi', 'grok', 'zcode'].includes(runtime));
-  if (scope === 'local' && !configDir && userScopedOnly.length) {
-    bail(`${userScopedOnly.join(', ')} plugins are user-scoped by their hosts; use --global or an isolated --config-dir`);
-  }
-
   if (!flags.json) printBanner();
 
   const mode = flags.doctor ? 'doctor' : flags.uninstall ? 'uninstall' : 'install';
   if (!flags.json) {
     console.log(`  ${paint('bold', 'Mode:')}     ${mode}`);
+    const scope = runtimes.map((r) => {
+      const label = scopes[r] === 'global' ? 'global (user)' : 'local';
+      return `${r}=${label}`;
+    }).join(', ');
     console.log(`  ${paint('bold', 'Scope:')}    ${scope}`);
     console.log(`  ${paint('bold', 'Runtimes:')} ${runtimes.join(', ')}`);
     if (configDir) {
@@ -253,7 +231,7 @@ async function main() {
       : configDir;
     return {
       repoRoot,
-      scope,
+      scope: scopes[runtime],
       configDir: runtimeConfigDir,
       homeDir: runtimeConfigDir || os.homedir(),
     };