deepcodex 0.1.0 → 0.1.2

package/.codex-plugin/plugin.json

@@ -1,24 +1,26 @@
 {
-  "name": "opencodex",
-  "version": "0.1.0+codex.20260917024812",
+  "name": "deepcodex",
+  "version": "0.1.2",
   "description": "Delegates tasks to native DeepSeek Flash subagents inside Codex through a local router.",
   "author": {
-    "name": "OpenCodex"
+    "name": "DeepCodex"
   },
   "skills": "./skills/",
   "interface": {
-    "displayName": "OpenCodex",
+    "displayName": "DeepCodex",
+    "composerIcon": "./assets/deepcodex.png",
+    "logo": "./assets/deepcodex.png",
     "shortDescription": "Astra coordinates; DeepSeek Flash executes.",
     "longDescription": "Keeps the coordinator model and connects DeepSeek Flash as a native subagent, with tracking, tools, and results inside Codex.",
-    "developerName": "OpenCodex",
+    "developerName": "DeepCodex",
     "category": "Productivity",
     "capabilities": [
       "Read",
       "Write"
     ],
     "defaultPrompt": [
-      "Check whether OpenCodex is ready.",
-      "Delegate this implementation to Flash with OpenCodex."
+      "Check whether DeepCodex is ready.",
+      "Delegate this implementation to Flash with DeepCodex."
     ]
   }
 }

package/README.md

@@ -1,6 +1,6 @@
-# OpenCodex
+# DeepCodex
 
-OpenCodex keeps the coordinator on your selected native Codex model and runs
+DeepCodex keeps the coordinator on your selected native Codex model and runs
 DeepSeek Flash as an actual Codex subagent through a local loopback router. The
 subagent appears in the normal collaboration tools (`spawn_agent`,
 `followup_task`, `wait_agent`, `interrupt_agent`) under the model name
@@ -12,9 +12,13 @@ native coordinator model is not replaced.
 - macOS. The installer and the LaunchAgent service are macOS-only.
 - Node.js >= 22.15. The worker uses `node:sqlite`, `fetch` and
   `import.meta.resolve`.
-- A Codex CLI on `PATH` whose `codex exec` supports `--ignore-user-config`,
-  `--ephemeral`, `--json` and `--strict-config`. `opencodex doctor` verifies
-  this before anything else is activated.
+- A compatible Codex CLI, either on `PATH` or bundled with Codex Desktop.
+  When no CLI is on `PATH`, DeepCodex checks `Codex.app` and `ChatGPT.app`
+  under `~/Applications` and `/Applications`, in that order. No separate CLI
+  installation is needed when Desktop includes a compatible binary.
+  `codex exec` must support `--ignore-user-config`, `--ephemeral`, `--json`
+  and `--strict-config`; `deepcodex doctor` verifies this before activation.
+  A CLI on `PATH` takes priority, even if it is incompatible.
 - A DeepSeek API key.
 
 ## Install globally
@@ -22,24 +26,34 @@ native coordinator model is not replaced.
 Once the package is published to npm:
 
 ```sh
-npm install --global opencodex
-opencodex configure
-opencodex doctor
-opencodex install
+npm install --global deepcodex
+deepcodex configure
+deepcodex doctor
+deepcodex install
 ```
 
-The global installation adds `opencodex` to npm's global bin directory, which
+The global installation adds `deepcodex` to npm's global bin directory, which
 must be on your `PATH`. Run it from any directory; no checkout path is needed.
 
 To install the local checkout globally before publication, run these commands
-from the repository, then use the same `opencodex` commands above:
+from the repository, then use the same `deepcodex` commands above:
 
 ```sh
 pnpm install --frozen-lockfile
 npm install --global .
 ```
 
-### 1. `opencodex configure`
+### Upgrading from OpenCodex
+
+The npm package, command and plugin are now named `deepcodex`, and the service
+is `com.deepcodex.router`. Existing private paths (`~/.config/opencodex`,
+`~/.local/share/opencodex`) and provider IDs are retained, reusing your saved
+key and backup.
+
+Run `deepcodex doctor` and `deepcodex install` to refresh the runtime; there is
+no need to run `configure` again if your key is already saved.
+
+### 1. `deepcodex configure`
 
 `configure` asks for the DeepSeek API key with hidden input on the terminal and
 stores it in `~/.config/opencodex/.env`. It creates the directory with mode
@@ -57,7 +71,7 @@ the file, as does the installed desktop service. Credentials stay outside the
 repository. The file permissions restrict other users, but programs running as
 your user can still read it.
 
-### 2. `opencodex doctor`
+### 2. `deepcodex doctor`
 
 `doctor` checks the local prerequisites without running inference: that a
 compatible Codex CLI is reachable and that the DeepSeek credential is present.
@@ -66,7 +80,7 @@ unless the doctor reports `ready`.
 Neither `configure` nor `doctor` contacts DeepSeek to validate the key. A `ready`
 result confirms local prerequisites, not provider authentication or account credit.
 
-### 3. `opencodex install`
+### 3. `deepcodex install`
 
 `install` activates the desktop integration:
 
@@ -74,11 +88,14 @@ result confirms local prerequisites, not provider authentication or account cred
   dependency) to `~/.local/share/opencodex/runtime`;
 - writes private state, the model catalog and receipts to
   `~/.config/opencodex/desktop`;
-- installs and starts the `com.opencodex.router` LaunchAgent, bound only to
+- installs and starts the `com.deepcodex.router` LaunchAgent, bound only to
   `127.0.0.1:4207`;
 - updates `~/.codex/config.toml` with the local provider, the subagent defaults
   and the generated model catalog, keeping a pre-install backup at
-  `~/.config/opencodex/desktop/config.before.toml`.
+  `~/.config/opencodex/desktop/config.before.toml`;
+- registers and installs the bundled DeepCodex plugin in the personal marketplace,
+  including its current name, description, icon and delegation skill. An existing
+  local OpenCodex plugin in that marketplace is replaced after DeepCodex installs.
 
 The installer refuses to run when an unrelated custom provider is active or when
 an endpoint override is already configured, and it leaves your configuration
@@ -89,22 +106,24 @@ that were already open keep the provider and model catalog they started with.
 
 ## Plugin skill
 
-The delegation skill lives in `skills/delegate-flash/SKILL.md` and is loaded by
-installing the OpenCodex plugin through a Codex marketplace. Installing the npm
-package or running the commands above does not install the skill, and this
-checkout is not a marketplace source by itself.
+The delegation skill lives in `skills/delegate-flash/SKILL.md`. `deepcodex install`
+copies the plugin to `~/plugins/deepcodex`, registers it in
+`~/.agents/plugins/marketplace.json`, and installs it through the Codex CLI.
+Repeating the command refreshes the plugin cache even when the package version
+has not changed. Other personal marketplace entries are preserved.
 
 ## Commands
 
 | Command | Purpose |
 | --- | --- |
-| `opencodex configure` | Prompt for the DeepSeek API key and write `~/.config/opencodex/.env`. |
-| `opencodex doctor` | Check Codex CLI compatibility and credential presence without inference. |
-| `opencodex install` | Install the router runtime, the LaunchAgent and the user-level Codex settings. |
-| `opencodex status` | Query the installed router health endpoint without inference. |
-| `opencodex run --cwd PATH --task-file PATH [--write]` | Run one bounded isolated worker ticket against DeepSeek. Read-only unless `--write` is given. |
-| `opencodex pilot` | Run the opt-in live native-delegation test; consumes Codex and DeepSeek usage. |
-| `opencodex --version`, `opencodex --help` | Print the package version or the command list. |
+| `deepcodex configure` | Prompt for the DeepSeek API key and write `~/.config/opencodex/.env`. |
+| `deepcodex doctor` | Check Codex CLI compatibility and credential presence without inference. |
+| `deepcodex install` | Install the router runtime, LaunchAgent, Codex settings and current DeepCodex plugin. |
+| `deepcodex uninstall` | Stop and remove the router, restoring the saved Codex configuration. Credentials are preserved. Refuses if config changed since installation. Restart Codex afterward; remove the npm package separately with `npm uninstall -g deepcodex`. |
+| `deepcodex status` | Query the installed router health endpoint without inference. |
+| `deepcodex run --cwd PATH --task-file PATH [--write]` | Run one bounded isolated worker ticket against DeepSeek. Read-only unless `--write` is given. |
+| `deepcodex pilot` | Run the opt-in live native-delegation test; consumes Codex and DeepSeek usage. |
+| `deepcodex --version`, `deepcodex --help` | Print the package version or the command list. |
 
 `run` executes a single ticket and consumes DeepSeek API usage. It takes an
 exclusive per-user lock, so only one worker runs at a time.

package/bin/{opencodex.js → deepcodex.js}

@@ -3,21 +3,22 @@ import { readFileSync } from 'node:fs';
 
 const args = process.argv.slice(2);
 const command = args.shift();
-const help = `Usage: opencodex <command>
+const help = `Usage: deepcodex <command>
 
 Commands:
   configure  Save the DeepSeek key using a hidden terminal prompt
-  install  Activate the local macOS router and configure Codex
+  install  Activate the local macOS router and install the Codex plugin
+  uninstall  Remove the local router and restore Codex settings
   status   Check the installed router without inference
   doctor   Check worker prerequisites without inference
   run      Run an isolated worker ticket (consumes DeepSeek usage)
   pilot    Test native delegation (consumes Codex and DeepSeek usage)
 
-Requires macOS, Node.js >=22.15 and a compatible Codex CLI.
-Run opencodex configure to save the DeepSeek key in ~/.config/opencodex/.env.
-Installing this npm package does not activate the router or install the skill
-in Codex. Install the plugin through a Codex marketplace to load its skill.
-Use opencodex <command> --help for command options.
+Requires macOS, Node.js >=22.15 and a compatible Codex CLI (PATH or Desktop bundle).
+Run deepcodex configure to save the DeepSeek key in ~/.config/opencodex/.env.
+Run deepcodex install after installing this npm package to activate the router
+and install or update the DeepCodex plugin, including its icon and skill.
+Use deepcodex <command> --help for command options.
 `;
 
 if (!command || command === '--help' || command === '-h') {
@@ -26,24 +27,24 @@ if (!command || command === '--help' || command === '-h') {
   const manifest = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
   console.log(manifest.version);
 } else {
-  const scripts = { configure: 'credentials.js', install: 'desktop.js', status: 'desktop.js', doctor: 'worker.js', run: 'worker.js', pilot: 'pilot.js' };
+  const scripts = { configure: 'credentials.js', install: 'desktop.js', uninstall: 'desktop.js', status: 'desktop.js', doctor: 'worker.js', run: 'worker.js', pilot: 'pilot.js' };
   if (!Object.hasOwn(scripts, command)) {
     console.error(`Unknown command: ${command}\n${help}`);
     process.exit(2);
   }
   if (command === 'pilot' && args.length) {
     if (args.length === 1 && ['--help', '-h'].includes(args[0])) {
-      console.log('Usage: opencodex pilot\nRuns a live native delegation test; consumes Codex and DeepSeek usage.');
+      console.log('Usage: deepcodex pilot\nRuns a live native delegation test; consumes Codex and DeepSeek usage.');
       process.exit(0);
     }
-    console.error('Usage: opencodex pilot (no arguments)');
+    console.error('Usage: deepcodex pilot (no arguments)');
     process.exit(2);
   }
   try {
     const script = await import(new URL(`../scripts/${scripts[command]}`, import.meta.url));
     process.exitCode = command === 'pilot' ? await script.run() : await script.main([command, ...args]);
   } catch (error) {
-    console.error(`OpenCodex failed: ${error.message}`);
+    console.error(`DeepCodex failed: ${error.message}`);
     process.exitCode = 1;
   }
 }

package/config/desktop.json

@@ -4,6 +4,6 @@
   "request_timeout_ms": 300000,
   "max_request_bytes": 134217728,
   "max_response_bytes": 33554432,
-  "service_label": "com.opencodex.router",
+  "service_label": "com.deepcodex.router",
   "service_throttle_seconds": 10
 }

package/config/worker.json

@@ -39,7 +39,7 @@
     "sandbox_workspace_write": {"network_access": false}
   },
   "model_metadata": {
-    "display_name": "DeepSeek Flash (OpenCodex)",
+    "display_name": "DeepSeek Flash",
     "description": "Text worker using the direct DeepSeek API.",
     "default_reasoning_level": "high",
     "supported_reasoning_levels": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepcodex",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Native DeepSeek Flash subagents for Codex through a local router.",
   "license": "MIT",
   "keywords": [
@@ -17,11 +17,12 @@
   ],
   "type": "module",
   "bin": {
-    "deepcodex": "bin/opencodex.js"
+    "deepcodex": "bin/deepcodex.js"
   },
   "files": [
     "bin/*.js",
     ".codex-plugin/plugin.json",
+    "assets/deepcodex.png",
     "skills/delegate-flash/SKILL.md",
     "config/*.json",
     "prompts/worker.md",

package/prompts/worker.md

@@ -1,4 +1,4 @@
-You are the OpenCodex worker. Complete only the ticket you received and return
+You are the DeepCodex worker. Complete only the ticket you received and return
 evidence to the coordinator. Follow the communication language stated in the
 ticket for your reports; keep the language of the code unchanged.
 

package/scripts/credentials.js

@@ -87,16 +87,16 @@ export function saveCredentials(file, name, secret) {
 
 export async function main(args) {
   if (args.length === 2 && ['--help', '-h'].includes(args[1])) {
-    console.log('Usage: opencodex configure\nEnter the DeepSeek key in a hidden terminal prompt. Saves a private plaintext file outside the repository.');
+    console.log('Usage: deepcodex configure\nEnter the DeepSeek key in a hidden terminal prompt. Saves a private plaintext file outside the repository.');
     return 0;
   }
-  if (args.length !== 1 || args[0] !== 'configure') throw new Error('Usage: opencodex configure (no key arguments accepted)');
+  if (args.length !== 1 || args[0] !== 'configure') throw new Error('Usage: deepcodex configure (no key arguments accepted)');
   const config = loadConfig();
   const name = config.codex.model_providers[config.codex.model_provider].env_key;
   const configured = config.credentials.env_file;
   const file = configured.startsWith('~/') ? path.join(os.homedir(), configured.slice(2)) : configured;
   const secret = await readSecret();
   saveCredentials(file, name, secret);
-  console.log('DeepSeek key saved with owner-only permissions. Run opencodex install to activate it or reload an existing router.');
+  console.log('DeepSeek key saved with owner-only permissions. Run deepcodex install to activate it or reload an existing router.');
   return 0;
 }

package/scripts/desktop.js

@@ -11,6 +11,7 @@ import { parseToml } from './toml.js';
 import { startPilot } from './pilot-router.js';
 
 const STATE = path.join(os.homedir(), '.config/opencodex/desktop');
+const LSREGISTER = '/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister';
 const readJson = filename => JSON.parse(fs.readFileSync(filename, 'utf8'));
 const expandHome = filename => filename.startsWith('~/') ? path.join(os.homedir(), filename.slice(2)) : filename;
 
@@ -78,7 +79,7 @@ export function plistDocument(value) {
 
 export function copyRuntime(root, runtime) {
   fs.mkdirSync(runtime, { recursive: true, mode: 0o700 });
-  for (const directory of ['scripts', 'config', 'prompts', 'vendor']) {
+  for (const directory of ['scripts', 'config', 'prompts', 'vendor', '.codex-plugin', 'assets', 'skills']) {
     fs.cpSync(path.join(root, directory), path.join(runtime, directory), { recursive: true,
       filter: source => !['__pycache__', '.env', '.DS_Store'].includes(path.basename(source)) && !/\.py[cod]?$/.test(source) });
   }
@@ -87,6 +88,77 @@ export function copyRuntime(root, runtime) {
   fs.cpSync(dependency, path.join(runtime, 'node_modules/smol-toml'), { recursive: true });
 }
 
+function registerServiceApp(app, action) {
+  const result = spawnSync(LSREGISTER, [action, app], { encoding: 'utf8' });
+  if (result.error || result.status !== 0) throw new Error(`Cannot ${action === '-u' ? 'unregister' : 'register'} DeepCodex app: ${result.error?.message || result.stderr.trim() || `lsregister exited ${result.status}`}`);
+}
+
+function createServiceApp(runtime, label) {
+  const app = path.join(runtime, 'DeepCodex.app');
+  const contents = path.join(app, 'Contents');
+  const executable = path.join(contents, 'MacOS/DeepCodex');
+  fs.mkdirSync(path.dirname(executable), { recursive: true });
+  fs.mkdirSync(path.join(contents, 'Resources'), { recursive: true });
+  const version = readJson(path.join(runtime, 'package.json')).version;
+  privateWrite(path.join(contents, 'Info.plist'), plistDocument({
+    CFBundleIdentifier: label, CFBundleName: 'DeepCodex', CFBundleDisplayName: 'DeepCodex',
+    CFBundleExecutable: 'DeepCodex', CFBundlePackageType: 'APPL', CFBundleIconFile: 'DeepCodex.icns',
+    CFBundleVersion: version, CFBundleShortVersionString: version, LSUIElement: true,
+  }));
+  const command = [process.execPath, path.join(runtime, 'scripts/desktop.js')]
+    .map(value => "'" + value.replaceAll("'", "'\\''") + "'").join(' ');
+  privateWrite(executable, `#!/bin/sh\nexec ${command} "$@"\n`);
+  fs.chmodSync(executable, 0o700);
+  const icon = spawnSync('/usr/bin/sips', ['-z', '512', '512', '-s', 'format', 'icns',
+    path.join(runtime, 'assets/deepcodex.png'), '--out', path.join(contents, 'Resources/DeepCodex.icns')], { encoding: 'utf8' });
+  if (icon.error || icon.status !== 0) throw new Error(`Cannot create DeepCodex app icon: ${icon.error?.message || icon.stderr.trim() || `sips exited ${icon.status}`}`);
+  registerServiceApp(app, '-f');
+  return executable;
+}
+
+export function installPlugin(root, codex, env) {
+  const home = env.HOME || os.homedir();
+  const marketplacePath = path.join(home, '.agents/plugins/marketplace.json');
+  const marketplace = fs.existsSync(marketplacePath) ? readJson(marketplacePath) : {
+    name: 'personal', interface: { displayName: 'Personal' }, plugins: [],
+  };
+  if (typeof marketplace.name !== 'string' || !/^[A-Za-z0-9_-]+$/.test(marketplace.name) || !Array.isArray(marketplace.plugins)) {
+    throw new Error('Invalid personal plugin marketplace');
+  }
+  const manifest = readJson(path.join(root, '.codex-plugin/plugin.json'));
+  if (manifest.name !== 'deepcodex' || typeof manifest.version !== 'string') throw new Error('Invalid DeepCodex plugin manifest');
+  const pluginPath = path.join(home, 'plugins', manifest.name);
+  copyRuntime(root, pluginPath);
+  manifest.version = `${manifest.version.split('+')[0]}+codex.${new Date().toISOString().replace(/\D/g, '')}`;
+  privateWrite(path.join(pluginPath, '.codex-plugin/plugin.json'), JSON.stringify(manifest, null, 2) + '\n');
+  const entry = {
+    name: manifest.name, source: { source: 'local', path: `./plugins/${manifest.name}` },
+    policy: { installation: 'AVAILABLE', authentication: 'ON_INSTALL' }, category: manifest.interface.category,
+  };
+  const existing = marketplace.plugins.findIndex(plugin => plugin.name === manifest.name);
+  if (existing < 0) marketplace.plugins.push(entry);
+  else marketplace.plugins[existing] = { ...marketplace.plugins[existing], source: entry.source };
+  fs.mkdirSync(path.dirname(marketplacePath), { recursive: true });
+  privateWrite(marketplacePath, JSON.stringify(marketplace, null, 2) + '\n');
+  const run = (command, selector) => {
+    const result = spawnSync(codex, ['plugin', command, selector, '--json'], { env, encoding: 'utf8' });
+    if (result.error || result.status !== 0) throw new Error(`Cannot ${command} Codex plugin ${selector}; rerun deepcodex install after checking Codex plugin support`);
+    return JSON.parse(result.stdout);
+  };
+  const selector = `${manifest.name}@${marketplace.name}`;
+  const result = run('add', selector);
+  const configPath = path.join(env.CODEX_HOME || path.join(home, '.codex'), 'config.toml');
+  const config = parseToml(fs.readFileSync(configPath, 'utf8'));
+  const legacySelector = `opencodex@${marketplace.name}`;
+  if (Object.hasOwn(config.plugins || {}, legacySelector)) run('remove', legacySelector);
+  const legacy = marketplace.plugins.find(plugin => plugin.name === 'opencodex' && plugin.source?.source === 'local');
+  if (legacy) {
+    marketplace.plugins = marketplace.plugins.filter(plugin => plugin !== legacy);
+    privateWrite(marketplacePath, JSON.stringify(marketplace, null, 2) + '\n');
+  }
+  return result;
+}
+
 export async function health(state) {
   const response = await fetch(`http://127.0.0.1:${state.config.port}/health`, {
     headers: { 'x-opencodex-pilot': state.capability },
@@ -103,7 +175,9 @@ export async function install() {
   const env = workerEnvironment(process.env);
   loadCredentials(env, original);
   const diagnosis = doctor(original, env);
-  if (diagnosis.status !== 'ready') throw new Error('OpenCodex worker doctor must be ready before installation');
+  if (diagnosis.status !== 'ready') throw new Error(`DeepCodex prerequisites are not ready: ${diagnosis.errors.join(' ')}`);
+  const pluginSupport = spawnSync(diagnosis.codex, ['plugin', 'add', '--help'], { env, encoding: 'utf8' });
+  if (pluginSupport.error || pluginSupport.status !== 0) throw new Error('Codex CLI must support plugin add; update Codex Desktop before installing DeepCodex');
   const configPath = path.join(env.CODEX_HOME || path.join(os.homedir(), '.codex'), 'config.toml');
   const before = fs.readFileSync(configPath, 'utf8');
   const parsed = parseToml(before);
@@ -113,6 +187,7 @@ export async function install() {
   fs.chmodSync(STATE, 0o700);
   const runtime = path.join(os.homedir(), '.local/share/opencodex/runtime');
   copyRuntime(ROOT, runtime);
+  const executable = createServiceApp(runtime, config.service_label);
   let catalog;
   if (parsed.model_catalog_json && path.resolve(expandHome(parsed.model_catalog_json)) !== path.join(STATE, 'models.json')) {
     catalog = readJson(expandHome(parsed.model_catalog_json));
@@ -130,30 +205,35 @@ export async function install() {
     receipts: path.join(STATE, 'receipts.jsonl'), markers: [] });
   const statePath = path.join(STATE, 'state.json');
   const capability = fs.existsSync(statePath) ? readJson(statePath).capability : randomBytes(32).toString('base64url');
-  const state = { config, capability, node: process.execPath, runtime };
+  const state = { config, capability, node: process.execPath, runtime, configPath };
   const sections = {
     '': { model_provider: 'opencodex', model_catalog_json: path.join(STATE, 'models.json') },
     agents: { enabled: true, default_subagent_model: child.slug, default_subagent_reasoning_effort: 'high' },
     features: { multi_agent: true, multi_agent_v2: true },
-    'model_providers.opencodex': { name: 'OpenCodex', base_url: `http://127.0.0.1:${config.port}`, wire_api: 'responses',
+    'model_providers.opencodex': { name: 'DeepCodex', base_url: `http://127.0.0.1:${config.port}`, wire_api: 'responses',
       requires_openai_auth: true, supports_websockets: false, request_max_retries: 0, stream_max_retries: 0, stream_idle_timeout_ms: config.request_timeout_ms },
     'model_providers.opencodex.http_headers': { 'x-opencodex-pilot': capability },
   };
-  const updated = mergeConfig(before, sections);
+  let updated = mergeConfig(before, sections);
   privateWrite(path.join(STATE, 'config.proposed.toml'), updated);
   if (!fs.existsSync(path.join(STATE, 'config.before.toml'))) privateWrite(path.join(STATE, 'config.before.toml'), before);
   privateWrite(statePath, JSON.stringify(state));
   const label = config.service_label;
   const plist = path.join(os.homedir(), 'Library/LaunchAgents', label + '.plist');
   fs.mkdirSync(path.dirname(plist), { recursive: true });
-  privateWrite(plist, plistDocument({ Label: label, ProgramArguments: [process.execPath, path.join(runtime, 'scripts/desktop.js'), 'serve'],
+  privateWrite(plist, plistDocument({ Label: label, AssociatedBundleIdentifiers: [label], ProgramArguments: [executable, 'serve'],
     WorkingDirectory: runtime, RunAtLoad: true, KeepAlive: true, ThrottleInterval: config.service_throttle_seconds,
     StandardOutPath: path.join(STATE, 'service.log'), StandardErrorPath: path.join(STATE, 'service-errors.log'),
     EnvironmentVariables: { HOME: os.homedir(), PATH: env.PATH } }));
   const domain = `gui/${process.getuid()}`;
-  spawnSync('launchctl', ['bootout', `${domain}/${label}`]);
-  const bootstrap = spawnSync('launchctl', ['bootstrap', domain, plist]);
-  if (bootstrap.error || bootstrap.status !== 0) throw new Error('Cannot start OpenCodex LaunchAgent');
+  const stopped = spawnSync('launchctl', ['bootout', `${domain}/${label}`], { encoding: 'utf8' });
+  if (stopped.error || (stopped.status !== 0 && stopped.status !== 3)) {
+    throw new Error(`Cannot stop ${label}: ${stopped.error?.message || stopped.stderr.trim() || `launchctl exited ${stopped.status}`}`);
+  }
+  const bootstrap = spawnSync('launchctl', ['bootstrap', domain, plist], { encoding: 'utf8' });
+  if (bootstrap.error || bootstrap.status !== 0) {
+    throw new Error(`Cannot start DeepCodex LaunchAgent: ${bootstrap.error?.message || bootstrap.stderr.trim() || `launchctl exited ${bootstrap.status}`}`);
+  }
   const deadline = Date.now() + config.startup_timeout_seconds * 1000;
   let report;
   while (!report) {
@@ -167,18 +247,62 @@ export async function install() {
     }
   }
   if (fs.readFileSync(configPath, 'utf8') !== before) throw new Error('Codex config changed during installation; proposed config was not applied');
+  let plugin;
+  try {
+    plugin = installPlugin(ROOT, diagnosis.codex, env);
+    updated = mergeConfig(fs.readFileSync(configPath, 'utf8'), sections);
+    privateWrite(path.join(STATE, 'config.proposed.toml'), updated);
+  } catch (error) {
+    spawnSync('launchctl', ['bootout', `${domain}/${label}`]);
+    throw error;
+  }
   privateWrite(configPath, updated);
-  console.log(JSON.stringify({ ...report, service: label, port: config.port, cwd: runtime, owner: 'OpenCodex LaunchAgent',
-    native_models: nativeModels.length, subagent_model: child.slug, backup: path.join(STATE, 'config.before.toml'), restart_desktop_required: true }));
+  console.log(JSON.stringify({ ...report, service: label, port: config.port, cwd: runtime, owner: 'DeepCodex LaunchAgent',
+    native_models: nativeModels.length, subagent_model: child.slug, plugin, backup: path.join(STATE, 'config.before.toml'), restart_desktop_required: true }));
+}
+
+export function uninstall() {
+  if (process.platform !== 'darwin') throw new Error('The Desktop uninstaller requires macOS');
+  const statePath = path.join(STATE, 'state.json');
+  if (!fs.existsSync(statePath)) {
+    console.log(JSON.stringify({ status: 'not_installed' }));
+    return;
+  }
+  const state = readJson(statePath);
+  const configPath = state.configPath || path.join(process.env.CODEX_HOME || path.join(os.homedir(), '.codex'), 'config.toml');
+  const before = fs.readFileSync(path.join(STATE, 'config.before.toml'), 'utf8');
+  const proposed = fs.readFileSync(path.join(STATE, 'config.proposed.toml'), 'utf8');
+  const current = fs.readFileSync(configPath, 'utf8');
+  if (current !== proposed && current !== before) {
+    throw new Error('Codex configuration changed after installation; uninstall stopped without changes. Reconcile config.toml with the backup and proposed config in ' + STATE);
+  }
+  const runtime = path.join(os.homedir(), '.local/share/opencodex/runtime');
+  if (state.runtime !== runtime) throw new Error('Unexpected router runtime path; uninstall stopped');
+  const label = readJson(path.join(ROOT, 'config/desktop.json')).service_label;
+  if (state.config.service_label !== label) throw new Error('Unexpected router service label; uninstall stopped');
+  const service = `gui/${process.getuid()}/${label}`;
+  // Restore connectivity before stopping the router; a failed stop can be retried.
+  if (current !== before) privateWrite(configPath, before);
+  const stopped = spawnSync('launchctl', ['bootout', service]);
+  if (stopped.error || (stopped.status !== 0 && stopped.status !== 3)) {
+    throw new Error('Cannot stop DeepCodex LaunchAgent; Codex settings restored, runtime retained. Retry uninstall.');
+  }
+  fs.rmSync(path.join(os.homedir(), 'Library/LaunchAgents', label + '.plist'), { force: true });
+  const app = path.join(runtime, 'DeepCodex.app');
+  if (fs.existsSync(app)) registerServiceApp(app, '-u');
+  fs.rmSync(runtime, { recursive: true, force: true });
+  fs.rmSync(STATE, { recursive: true, force: true });
+  console.log(JSON.stringify({ status: 'uninstalled', restart_desktop_required: true, credentials_preserved: true }));
 }
 
 export async function main(args = process.argv.slice(2)) {
   if (args.includes('--help') || args.includes('-h')) {
-    console.log('Usage: opencodex <install|status>\nActivate or inspect the local macOS Desktop router.');
+    console.log('Usage: deepcodex <install|uninstall|status>\nActivate or inspect the local macOS Desktop router.');
     return 0;
   }
-  if (args.length !== 1 || !['install', 'serve', 'status'].includes(args[0])) throw new Error('Expected install, serve or status');
+  if (args.length !== 1 || !['install', 'uninstall', 'serve', 'status'].includes(args[0])) throw new Error('Expected install, uninstall, serve or status');
   if (args[0] === 'install') await install();
+  else if (args[0] === 'uninstall') uninstall();
   else {
     const state = readJson(path.join(STATE, 'state.json'));
     if (args[0] === 'status') console.log(JSON.stringify({ ...await health(state), port: state.config.port, cwd: state.runtime }));

package/scripts/pilot-router.js

@@ -223,7 +223,7 @@ export async function startPilot(config, deepseekKey, capability) {
         return;
       }
       receipt({ route: 'error', message: String(error.message).replaceAll(deepseekKey, '[REDACTED]').replaceAll(capability, '[REDACTED]') });
-      if (!response.headersSent) response.writeHead(502, { 'content-type': 'application/json' }).end(JSON.stringify({ error: { message: 'OpenCodex request failed; inspect local receipts.' } }));
+      if (!response.headersSent) response.writeHead(502, { 'content-type': 'application/json' }).end(JSON.stringify({ error: { message: 'DeepCodex request failed; inspect local receipts.' } }));
       else response.destroy();
     } finally { clearTimeout(timer); }
   });

package/scripts/pilot.js

@@ -120,7 +120,7 @@ export async function run() {
   const sourceEnv = workerEnvironment(process.env);
   loadCredentials(sourceEnv, workerConfig);
   const diagnosis = doctor(workerConfig, sourceEnv);
-  if (diagnosis.status !== 'ready') throw new Error('OpenCodex doctor is not ready');
+  if (diagnosis.status !== 'ready') throw new Error('DeepCodex doctor is not ready');
   const authSource = authFile(sourceEnv);
   if (!statSync(authSource, { throwIfNoEntry: false })?.isFile()) {
     throw new Error('Pilot requires the existing Codex auth.json login');
@@ -165,7 +165,7 @@ export async function run() {
         { env, cwd: workspace, stdio: ['pipe', 'pipe', routerErrors], detached: true });
       router.stdin.end(JSON.stringify({ config, capability }));
       const ready = await readRouterReadiness(router, config.startup_timeout_seconds * 1000, signals.signal);
-      emit({ event: 'pilot.router_started', ...ready, cwd: workspace, owner: 'OpenCodex isolated pilot',
+      emit({ event: 'pilot.router_started', ...ready, cwd: workspace, owner: 'DeepCodex isolated pilot',
         artifacts: runDir });
       const values = { ...workerConfig.codex };
       Object.assign(values, { model: config.parent_model, model_provider: 'opencodex-pilot',
@@ -175,7 +175,7 @@ export async function run() {
       values.features = { ...values.features, multi_agent: true, multi_agent_v2: true,
         enable_request_compression: false };
       values.model_providers = { 'opencodex-pilot': {
-        name: 'OpenCodex isolated pilot',
+        name: 'DeepCodex isolated pilot',
         base_url: `http://127.0.0.1:${ready.port}`,
         wire_api: 'responses',
         requires_openai_auth: true,

package/scripts/worker.js

@@ -99,8 +99,23 @@ export function redact(value, secret) {
   return value;
 }
 
-export function doctor(config, env) {
+// Desktop bundles the CLI but does not necessarily expose it on PATH.
+export function resolveCodex(env, { platform = process.platform, applicationDirs = [
+  path.join(env.HOME || os.homedir(), 'Applications'), '/Applications',
+] } = {}) {
   const binary = which('codex', env.PATH);
+  if (binary || platform !== 'darwin') return binary;
+  for (const directory of applicationDirs) {
+    for (const app of ['Codex.app', 'ChatGPT.app']) {
+      const bundled = which('codex', path.join(directory, app, 'Contents', 'Resources'));
+      if (bundled) return bundled;
+    }
+  }
+  return undefined;
+}
+
+export function doctor(config, env, discoveryOptions) {
+  const binary = resolveCodex(env, discoveryOptions);
   const report = { status: 'ready', codex: binary ?? null, api_key_present: Boolean(env.DEEPSEEK_API_KEY) };
   if (binary) {
     const timeout = config.limits.version_timeout_seconds * 1000;
@@ -110,7 +125,14 @@ export function doctor(config, env) {
     report.compatible_cli = version.status === 0 && help.status === 0
       && REQUIRED_CLI_FLAGS.every(flag => help.stdout.includes(flag));
   }
-  if (!binary || !report.compatible_cli || !report.api_key_present) report.status = 'not_ready';
+  const errors = [];
+  if (!binary) errors.push('Codex CLI not found on PATH or in Codex.app/ChatGPT.app under ~/Applications or /Applications. Install Codex Desktop or add a compatible codex CLI to PATH.');
+  else if (!report.compatible_cli) errors.push(`Codex CLI at ${binary} is incompatible; required exec flags: ${REQUIRED_CLI_FLAGS.join(', ')}. Update Codex Desktop or the CLI on PATH.`);
+  if (!report.api_key_present) errors.push('DeepSeek API key is missing. Run deepcodex configure.');
+  if (errors.length) {
+    report.status = 'not_ready';
+    report.errors = errors;
+  }
   return report;
 }
 
@@ -147,7 +169,7 @@ export async function workerLock() {
     database.exec('BEGIN EXCLUSIVE');
   } catch (error) {
     database.close();
-    if (error.errcode === SQLITE_BUSY) throw new Error('Another OpenCodex worker is running; wait for it or cancel that run');
+    if (error.errcode === SQLITE_BUSY) throw new Error('Another DeepCodex worker is running; wait for it or cancel that run');
     throw error;
   }
   let closed = false;

package/skills/delegate-flash/SKILL.md

@@ -1,12 +1,12 @@
 ---
 name: delegate-flash
-description: Delegate bounded coding tasks to native DeepSeek Flash subagents in Codex through OpenCodex. Use when OpenCodex or Flash delegation is requested, or when diagnosing the Desktop integration.
+description: Delegate bounded coding tasks to native DeepSeek Flash subagents in Codex through DeepCodex. Use when DeepCodex or Flash delegation is requested, or when diagnosing the Desktop integration.
 ---
 
-# OpenCodex
+# DeepCodex
 
 Keep the coordinator on the user's selected native model. DeepSeek Flash runs as
-an actual Codex subagent through the local OpenCodex router. Use the native
+an actual Codex subagent through the local DeepCodex router. Use the native
 collaboration tools for spawning, follow-ups, waiting, and interruption; the
 normal delegation path does not launch a separate `codex exec` worker.
 
@@ -42,7 +42,7 @@ is in `config/desktop.json`, shared transport defaults in `config/pilot.json`,
 and the DeepSeek model and credential path in `config/worker.json`.
 
 Run `node <plugin>/scripts/desktop.js status` to check the local service without
-inference. The service is `com.opencodex.router`, bound only to loopback. Private
+inference. The service is `com.deepcodex.router`, bound only to loopback. Private
 state and bounded metadata receipts live in `~/.config/opencodex/desktop`.
 Receipts contain routing and tool names, not prompts, tool arguments or tokens.
 Do not print `state.json`, provider headers, credential files or full user config.