@a5c-ai/babysitter-codex 5.0.1-staging.e4f17eff → 5.0.1-staging.ef4e872c

package/.codex-plugin/plugin.json

@@ -1,21 +1,23 @@
 {
   "name": "babysitter",
-  "version": "0.1.5",
-  "description": "Babysitter orchestration plugin for Codex with skill entrypoints and lifecycle hooks.",
+  "version": "5.0.0",
+  "description": "Orchestrate complex, multi-step workflows with event-sourced state management, hook-based extensibility, and human-in-the-loop approval",
   "author": {
     "name": "a5c.ai",
-    "email": "support@a5c.ai",
-    "url": "https://github.com/a5c-ai/babysitter"
+    "email": "support@a5c.ai"
   },
-  "homepage": "https://github.com/a5c-ai/babysitter/tree/main/plugins/babysitter-codex#readme",
-  "repository": "https://github.com/a5c-ai/babysitter",
   "license": "MIT",
+  "repository": "https://github.com/a5c-ai/babysitter",
   "keywords": [
-    "babysitter",
-    "codex",
     "orchestration",
+    "workflow",
+    "automation",
+    "event-sourced",
     "hooks",
-    "skills"
+    "TDD",
+    "quality-convergence",
+    "agent",
+    "LLM"
   ],
   "skills": "./skills/",
   "hooks": "./hooks.json",
@@ -41,7 +43,7 @@
     ],
     "brandColor": "#0F766E",
     "composerIcon": "./assets/icon.svg",
-    "logo": "./assets/logo.png",
-    "screenshots": []
-  }
+    "logo": "./assets/logo.png"
+  },
+  "homepage": "https://github.com/a5c-ai/babysitter/tree/main/plugins/babysitter-codex#readme"
 }

package/README.md

@@ -74,7 +74,7 @@ Verify the installed plugin bundle:
 npm ls -g @a5c-ai/babysitter-codex --depth=0
 test -f ~/.agents/plugins/babysitter/.codex-plugin/plugin.json
 test -f ~/.agents/plugins/babysitter/hooks.json
-test -f ~/.agents/plugins/babysitter/hooks/babysitter-stop-hook.sh
+test -f ~/.agents/plugins/babysitter/hooks/babysitter-proxied-stop.sh
 test -f ~/.agents/plugins/babysitter/skills/babysit/SKILL.md
 test -f ~/.agents/plugins/marketplace.json
 ```

package/bin/cli.js

@@ -5,6 +5,8 @@ const path = require('path');
 const { spawnSync } = require('child_process');
 
 const PACKAGE_ROOT = path.resolve(__dirname, '..');
+let shared;
+try { shared = require('./install-shared'); } catch {}
 
 function printUsage() {
   console.error([
@@ -23,16 +25,10 @@ function parseInstallArgs(argv) {
   for (let i = 0; i < argv.length; i += 1) {
     const arg = argv[i];
     if (arg === '--global') {
-      if (scope === 'workspace') {
-        throw new Error('install accepts either --global or --workspace, not both');
-      }
       scope = 'global';
       continue;
     }
     if (arg === '--workspace') {
-      if (scope === 'global' && workspace !== null) {
-        throw new Error('install accepts either --global or --workspace, not both');
-      }
       scope = 'workspace';
       const next = argv[i + 1];
       if (next && !next.startsWith('-')) {
@@ -46,21 +42,14 @@ function parseInstallArgs(argv) {
     passthrough.push(arg);
   }
 
-  return {
-    scope,
-    workspace,
-    passthrough,
-  };
+  return { scope, workspace, passthrough };
 }
 
 function runNodeScript(scriptPath, args, extraEnv = {}) {
   const result = spawnSync(process.execPath, [scriptPath, ...args], {
     cwd: process.cwd(),
     stdio: 'inherit',
-    env: {
-      ...process.env,
-      ...extraEnv,
-    },
+    env: { ...process.env, ...extraEnv },
   });
   process.exitCode = result.status ?? 1;
 }
@@ -74,6 +63,9 @@ function main() {
   }
 
   if (command === 'install') {
+    if (shared && typeof shared.harnessCliRoute === 'function' && shared.harnessCliRoute(rest, PACKAGE_ROOT, runNodeScript)) {
+      return;
+    }
     const parsed = parseInstallArgs(rest);
     if (parsed.scope === 'workspace') {
       const args = [];
@@ -84,7 +76,7 @@ function main() {
       runNodeScript(
         path.join(PACKAGE_ROOT, 'scripts', 'team-install.js'),
         args,
-        { BABYSITTER_PACKAGE_ROOT: PACKAGE_ROOT },
+        { PLUGIN_PACKAGE_ROOT: PACKAGE_ROOT },
       );
       return;
     }

package/bin/install-shared.js

@@ -5,8 +5,195 @@ const os = require('os');
 const path = require('path');
 const { spawnSync } = require('child_process');
 
-const PLUGIN_NAME = 'babysitter';
+const PLUGIN_NAME = "babysitter";
 const PLUGIN_CATEGORY = 'Coding';
+
+function getUserHome() {
+  return os.homedir();
+}
+
+function getHarnessHome() {
+  return path.join(os.homedir(), ".codex");
+}
+
+function getHomePluginRoot(scope) {
+  if (scope === 'workspace') return path.join(process.cwd(), '.a5c', 'plugins', PLUGIN_NAME);
+  return path.join(path.join(os.homedir(), ".agents/plugins"), PLUGIN_NAME);
+}
+
+function getHomeMarketplacePath() {
+  return path.join(os.homedir(), ".agents/plugins/marketplace.json");
+}
+
+function writeFileIfChanged(filePath, contents) {
+  try {
+    const existing = fs.readFileSync(filePath, 'utf8');
+    if (existing === contents) return false;
+  } catch {}
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, contents);
+  return true;
+}
+
+function copyRecursive(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    if (entry.name === 'node_modules' || entry.name === '.git') continue;
+    const s = path.join(src, entry.name);
+    const d = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyRecursive(s, d);
+    } else {
+      fs.copyFileSync(s, d);
+    }
+  }
+}
+
+function copyPluginBundle(packageRoot, pluginRoot) {
+  const bundleEntries = fs.readdirSync(packageRoot).filter(
+    e => !['node_modules', '.git', 'test', 'dist'].includes(e)
+  );
+  fs.mkdirSync(pluginRoot, { recursive: true });
+  for (const entry of bundleEntries) {
+    const src = path.join(packageRoot, entry);
+    const dest = path.join(pluginRoot, entry);
+    const stat = fs.statSync(src);
+    if (stat.isDirectory()) {
+      copyRecursive(src, dest);
+    } else {
+      fs.copyFileSync(src, dest);
+    }
+  }
+}
+
+function readJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function writeJson(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(value, null, 2) + '\n');
+}
+
+function ensureExecutable(filePath) {
+  try {
+    fs.chmodSync(filePath, 0o755);
+  } catch {}
+}
+
+function normalizeMarketplaceSourcePath(source, marketplacePath) {
+  if (typeof source === 'string') {
+    return path.relative(path.dirname(marketplacePath), source).replace(/\\/g, '/');
+  }
+  return source;
+}
+
+function ensureMarketplaceEntry(marketplacePath, pluginRoot) {
+  let marketplace = readJson(marketplacePath) || {
+    name: "a5c.ai",
+    plugins: [],
+  };
+  if (!Array.isArray(marketplace.plugins)) marketplace.plugins = [];
+  const idx = marketplace.plugins.findIndex(p => p.name === PLUGIN_NAME);
+  const relSource = './' + normalizeMarketplaceSourcePath(pluginRoot, marketplacePath);
+  const entry = {
+    name: PLUGIN_NAME,
+    source: relSource,
+    description: "Orchestrate complex, multi-step workflows with event-sourced state management, hook-based extensibility, and human-in-the-loop approval",
+    version: "5.0.0",
+    author: { name: "a5c.ai" },
+  };
+  if (idx >= 0) marketplace.plugins[idx] = entry;
+  else marketplace.plugins.push(entry);
+  writeJson(marketplacePath, marketplace);
+}
+
+function removeMarketplaceEntry(marketplacePath) {
+  const marketplace = readJson(marketplacePath);
+  if (!marketplace || !Array.isArray(marketplace.plugins)) return;
+  marketplace.plugins = marketplace.plugins.filter(p => p.name !== PLUGIN_NAME);
+  writeJson(marketplacePath, marketplace);
+}
+
+function warnWindowsHooks() {
+  if (process.platform === 'win32') {
+    console.warn('[' + PLUGIN_NAME + '] Windows detected — shell hooks (.sh) require Git Bash or WSL.');
+  }
+}
+
+function runPostInstall(pluginRoot) {
+  const postInstall = path.join(pluginRoot, 'scripts', 'post-install.js');
+  if (fs.existsSync(postInstall)) {
+    spawnSync(process.execPath, [postInstall], {
+      cwd: pluginRoot, stdio: 'inherit',
+      env: { ...process.env, PLUGIN_ROOT: pluginRoot },
+    });
+  }
+}
+
+function getGlobalStateDir() {
+  return process.env.BABYSITTER_GLOBAL_STATE_DIR || path.join(getUserHome(), '.a5c');
+}
+
+function resolveCliCommand(packageRoot) {
+  try {
+    const result = spawnSync('babysitter', ['--version'], { stdio: 'pipe', timeout: 10000 });
+    if (result.status === 0) return 'babysitter';
+  } catch {}
+  const versionsPath = path.join(packageRoot, 'versions.json');
+  const versions = readJson(versionsPath) || {};
+  const ver = versions.sdkVersion || 'latest';
+  return `npx -y @a5c-ai/babysitter-sdk@${ver}`;
+}
+
+function runCli(packageRoot, cliArgs, options = {}) {
+  const cmd = resolveCliCommand(packageRoot);
+  const parts = cmd.split(' ');
+  const result = spawnSync(parts[0], [...parts.slice(1), ...cliArgs], {
+    stdio: options.stdio || 'inherit',
+    timeout: options.timeout || 120000,
+    cwd: options.cwd || process.cwd(),
+    env: { ...process.env, ...options.env },
+  });
+  return result;
+}
+
+function ensureGlobalProcessLibrary(packageRoot) {
+  const stateDir = getGlobalStateDir();
+  const activeFile = path.join(stateDir, 'active', 'process-library.json');
+  let active = readJson(activeFile);
+  if (active && active.binding && active.binding.dir) {
+    return active;
+  }
+  const defaultSpec = readJson(path.join(stateDir, 'process-library-defaults.json'));
+  const cloneDir = defaultSpec && defaultSpec.cloneDir
+    ? defaultSpec.cloneDir
+    : path.join(stateDir, 'process-library', PLUGIN_NAME + '-repo');
+  runCli(packageRoot, [
+    'process-library:clone',
+    '--dir', cloneDir,
+    '--state-dir', stateDir,
+    '--json',
+  ], { stdio: 'pipe' });
+  runCli(packageRoot, [
+    'process-library:use',
+    '--dir', cloneDir,
+    '--state-dir', stateDir,
+    '--json',
+  ], { stdio: 'pipe' });
+  active = readJson(activeFile);
+  return {
+    binding: active && active.binding ? active.binding : { dir: cloneDir },
+    defaultSpec: defaultSpec || { cloneDir },
+    stateFile: activeFile,
+  };
+}
+
+
 const LEGACY_MARKETPLACE_PLUGIN_NAMES = ['babysitter-codex'];
 const LEGACY_SKILL_NAMES = [
   'babysit',
@@ -50,6 +237,11 @@ const LEGACY_HOOK_SCRIPT_NAMES = [
   'babysitter-stop-hook.sh',
   'user-prompt-submit.sh',
 ];
+const MANAGED_HOOK_SCRIPT_NAMES = [
+  'babysitter-proxied-session-start.sh',
+  'babysitter-proxied-stop.sh',
+  'babysitter-proxied-user-prompt-submit.sh',
+];
 const DEFAULT_MARKETPLACE = {
   name: 'local-plugins',
   interface: {
@@ -73,19 +265,6 @@ function getCodexHome() {
   return path.join(os.homedir(), '.codex');
 }
 
-function getUserHome() {
-  if (process.env.USERPROFILE) return path.resolve(process.env.USERPROFILE);
-  if (process.env.HOME) return path.resolve(process.env.HOME);
-  return os.homedir();
-}
-
-function getGlobalStateDir() {
-  if (process.env.BABYSITTER_GLOBAL_STATE_DIR) {
-    return path.resolve(process.env.BABYSITTER_GLOBAL_STATE_DIR);
-  }
-  return path.join(getUserHome(), '.a5c');
-}
-
 function getHomePluginRoot() {
   if (process.env.BABYSITTER_CODEX_PLUGIN_DIR) {
     return path.resolve(process.env.BABYSITTER_CODEX_PLUGIN_DIR, PLUGIN_NAME);
@@ -100,6 +279,14 @@ function getHomeMarketplacePath() {
   return path.join(getUserHome(), '.agents', 'plugins', 'marketplace.json');
 }
 
+function getWorkspacePluginRoot(workspaceRoot) {
+  return path.join(path.resolve(workspaceRoot), '.agents', 'plugins', PLUGIN_NAME);
+}
+
+function getWorkspaceMarketplacePath(workspaceRoot) {
+  return path.join(path.resolve(workspaceRoot), '.agents', 'plugins', 'marketplace.json');
+}
+
 function renderCodexConfigToml() {
   return [
     'approval_policy = "on-request"',
@@ -120,18 +307,6 @@ function renderCodexConfigToml() {
   ].join('\n');
 }
 
-function writeFileIfChanged(filePath, contents) {
-  if (fs.existsSync(filePath)) {
-    const current = fs.readFileSync(filePath, 'utf8');
-    if (current === contents) {
-      return false;
-    }
-  }
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  fs.writeFileSync(filePath, contents, 'utf8');
-  return true;
-}
-
 function copyRecursive(src, dest) {
   const stat = fs.statSync(src);
   if (stat.isDirectory()) {
@@ -292,29 +467,60 @@ function runBabysitterCli(packageRoot, cliArgs, options = {}) {
 }
 
 function ensureGlobalProcessLibrary(packageRoot) {
-  return JSON.parse(
+  const stateDir = getGlobalStateDir();
+  const activeFile = path.join(stateDir, 'active', 'process-library.json');
+  const current = readJson(activeFile);
+  if (current && current.defaultBinding && current.defaultBinding.dir) {
+    return {
+      stateFile: activeFile,
+      binding: current.defaultBinding,
+      defaultSpec: {
+        stateDir,
+        repo: current.defaultBinding.repoUrl,
+        cloneDir: current.defaultBinding.dir,
+      },
+    };
+  }
+
+  const cloneDir = path.join(stateDir, 'process-library', `${PLUGIN_NAME}-repo`);
+  runBabysitterCli(
+    packageRoot,
+    [
+      'process-library:clone',
+      '--dir', cloneDir,
+      '--state-dir', stateDir,
+      '--json',
+    ],
+    { cwd: packageRoot },
+  );
+  runBabysitterCli(
+    packageRoot,
+    [
+      'process-library:use',
+      '--dir', cloneDir,
+      '--state-dir', stateDir,
+      '--json',
+    ],
+    { cwd: packageRoot },
+  );
+
+  const active = JSON.parse(
     runBabysitterCli(
       packageRoot,
-      ['process-library:active', '--state-dir', getGlobalStateDir(), '--json'],
+      ['process-library:active', '--state-dir', stateDir, '--json'],
       { cwd: packageRoot },
     ),
   );
-}
-
-function readJson(filePath) {
-  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
-}
-
-function writeJson(filePath, value) {
-  writeFileIfChanged(filePath, `${JSON.stringify(value, null, 2)}\n`);
-}
 
-function ensureExecutable(filePath) {
-  try {
-    fs.chmodSync(filePath, 0o755);
-  } catch {
-    // Best-effort only. Windows and some filesystems may ignore mode changes.
-  }
+  return {
+    stateFile: active.stateFile || activeFile,
+    binding: active.binding || active.defaultBinding || { dir: cloneDir },
+    defaultSpec: active.defaultSpec || {
+      stateDir,
+      repo: process.env.BABYSITTER_PROCESS_LIBRARY_REPO || null,
+      cloneDir,
+    },
+  };
 }
 
 function getMarketplaceRootDir(marketplacePath) {
@@ -483,7 +689,7 @@ function installManagedHooks(packageRoot, codexHome) {
   const targetRoot = path.join(codexHome, 'hooks');
   fs.mkdirSync(targetRoot, { recursive: true });
 
-  for (const scriptName of LEGACY_HOOK_SCRIPT_NAMES) {
+  for (const scriptName of MANAGED_HOOK_SCRIPT_NAMES) {
     const sourcePath = path.join(sourceRoot, scriptName);
     const targetPath = path.join(targetRoot, scriptName);
     copyRecursive(sourcePath, targetPath);
@@ -499,6 +705,46 @@ function installCodexSurface(packageRoot, codexHome) {
   installManagedHooks(packageRoot, codexHome);
 }
 
+function harnessTeamInstall(packageRoot, pluginRoot, workspace) {
+  var workspaceRoot = path.resolve(workspace);
+  var resolvedPluginRoot = pluginRoot ? path.resolve(pluginRoot) : getWorkspacePluginRoot(workspaceRoot);
+  var marketplacePath = getWorkspaceMarketplacePath(workspaceRoot);
+  var codexHome = path.join(workspaceRoot, '.codex');
+  var codexConfigPath = path.join(codexHome, 'config.toml');
+  var teamDir = path.join(workspaceRoot, '.a5c', 'team');
+
+  var processLibraryState = ensureGlobalProcessLibrary(packageRoot);
+  ensureMarketplaceEntry(marketplacePath, resolvedPluginRoot);
+  mergeCodexConfigFile(codexConfigPath);
+  installCodexSurface(packageRoot, codexHome);
+  warnWindowsHooks();
+
+  writeJson(path.join(teamDir, 'install.json'), {
+    packageRoot: packageRoot,
+    workspaceRoot: workspaceRoot,
+    pluginRoot: resolvedPluginRoot,
+    marketplacePath: marketplacePath,
+    codexConfigPath: codexConfigPath,
+    processLibraryCloneDir: (processLibraryState.defaultSpec && processLibraryState.defaultSpec.cloneDir)
+      || (processLibraryState.binding && processLibraryState.binding.dir),
+    processLibraryStateFile: processLibraryState.stateFile
+      || path.join(getGlobalStateDir(), 'active', 'process-library.json'),
+  });
+  writeJson(path.join(teamDir, 'profile.json'), {
+    pluginRoot: resolvedPluginRoot,
+    marketplacePath: marketplacePath,
+    codexConfigPath: codexConfigPath,
+    processLibraryLookupCommand: 'babysitter process-library:active --json',
+  });
+}
+
+function harnessInstall(packageRoot, _pluginRoot) {
+  const codexConfigPath = path.join(getCodexHome(), 'config.toml');
+  mergeCodexConfigFile(codexConfigPath);
+  ensureGlobalProcessLibrary(packageRoot);
+  warnWindowsHooks();
+}
+
 function warnWindowsHooks() {
   if (process.platform !== 'win32') {
     return;
@@ -510,17 +756,54 @@ function warnWindowsHooks() {
   console.warn('[babysitter] If hooks do not fire, run `codex --version` and upgrade if you are below 0.119.0.');
 }
 
+
 module.exports = {
-  copyPluginBundle,
+  PLUGIN_NAME,
+  PLUGIN_CATEGORY,
+  getUserHome,
+  getHarnessHome,
+  writeFileIfChanged,
+  readJson,
+  writeJson,
+  ensureExecutable,
+  runPostInstall,
+  getGlobalStateDir,
+  resolveCliCommand,
+  runCli,
   ensureGlobalProcessLibrary,
+  PLUGIN_BUNDLE_ENTRIES,
+  copyRecursive,
+  copyPluginBundle,
+  DEFAULT_MARKETPLACE,
+  normalizeMarketplaceSourcePath,
   ensureMarketplaceEntry,
+  removeMarketplaceEntry,
+  installManagedSkills,
+  mergeManagedHooksConfig,
+  installManagedHooks,
+  warnWindowsHooks,
+  LEGACY_MARKETPLACE_PLUGIN_NAMES,
+  LEGACY_SKILL_NAMES,
+  LEGACY_PROMPT_NAMES,
+  LEGACY_HOOK_SCRIPT_NAMES,
+  MANAGED_HOOK_SCRIPT_NAMES,
   getCodexHome,
-  getHomeMarketplacePath,
   getHomePluginRoot,
-  installCodexSurface,
+  getHomeMarketplacePath,
+  getWorkspacePluginRoot,
+  getWorkspaceMarketplacePath,
+  renderCodexConfigToml,
+  insertRootKey,
+  ensureSectionLine,
+  ensureWritableRoots,
+  mergeCodexConfig,
   mergeCodexConfigFile,
+  resolveBabysitterCommand,
+  runBabysitterCli,
+  ensureGlobalProcessLibrary,
+  getMarketplaceRootDir,
   removeLegacyCodexSurface,
-  removeMarketplaceEntry,
-  warnWindowsHooks,
-  writeJson,
+  installCodexSurface,
+  harnessInstall,
+  harnessTeamInstall,
 };

package/bin/install.js

@@ -2,44 +2,27 @@
 'use strict';
 
 const path = require('path');
-const {
-  copyPluginBundle,
-  ensureGlobalProcessLibrary,
-  ensureMarketplaceEntry,
-  getCodexHome,
-  getHomeMarketplacePath,
-  getHomePluginRoot,
-  mergeCodexConfigFile,
-  warnWindowsHooks,
-} = require('./install-shared');
+const shared = require('./install-shared');
 
 const PACKAGE_ROOT = path.resolve(__dirname, '..');
 
 function main() {
-  const codexHome = getCodexHome();
-  const pluginRoot = getHomePluginRoot();
-  const marketplacePath = getHomeMarketplacePath();
+  const pluginRoot = shared.getHomePluginRoot();
+  const marketplacePath = shared.getHomeMarketplacePath();
 
-  console.log(`[babysitter] Installing plugin to ${pluginRoot}`);
+  console.log(`[${shared.PLUGIN_NAME}] Installing plugin to ${pluginRoot}`);
 
   try {
-    copyPluginBundle(PACKAGE_ROOT, pluginRoot);
-    ensureMarketplaceEntry(marketplacePath, pluginRoot);
-    mergeCodexConfigFile(path.join(codexHome, 'config.toml'));
-
-    const active = ensureGlobalProcessLibrary(PACKAGE_ROOT);
-    console.log(`[babysitter]   marketplace: ${marketplacePath}`);
-    console.log(`[babysitter]   process library: ${active.binding?.dir}`);
-    if (active.defaultSpec?.cloneDir) {
-      console.log(`[babysitter]   process library clone: ${active.defaultSpec.cloneDir}`);
+    shared.copyPluginBundle(PACKAGE_ROOT, pluginRoot);
+    shared.ensureMarketplaceEntry(marketplacePath, pluginRoot);
+    if (typeof shared.harnessInstall === 'function') {
+      shared.harnessInstall(PACKAGE_ROOT, pluginRoot);
     }
-    console.log(`[babysitter]   process library state: ${active.stateFile}`);
-    warnWindowsHooks();
-    console.log('[babysitter] Installation complete!');
-    console.log('[babysitter] Restart Codex to pick up the installed plugin and config changes, then run Codex and install Babysitter from `/plugins`.');
-    console.log('[babysitter] If Codex was already open, start a new thread after install before expecting `babysitter:*` skills such as `$babysitter:babysit` or `$babysitter:call` to appear.');
+    shared.runPostInstall && shared.runPostInstall(pluginRoot);
+    console.log(`[${shared.PLUGIN_NAME}] Installation complete!`);
+    console.log(`[${shared.PLUGIN_NAME}] Restart your IDE/CLI to pick up the plugin.`);
   } catch (err) {
-    console.error(`[babysitter] Failed to install plugin: ${err.message}`);
+    console.error(`[${shared.PLUGIN_NAME}] Failed to install: ${err.message}`);
     process.exitCode = 1;
   }
 }

package/bin/uninstall.js

@@ -2,39 +2,23 @@
 'use strict';
 
 const fs = require('fs');
-const {
-  getCodexHome,
-  getHomeMarketplacePath,
-  getHomePluginRoot,
-  removeLegacyCodexSurface,
-  removeMarketplaceEntry,
-} = require('./install-shared');
+const shared = require('./install-shared');
 
 function main() {
-  const codexHome = getCodexHome();
-  const pluginRoot = getHomePluginRoot();
-  const marketplacePath = getHomeMarketplacePath();
-  let removedPlugin = false;
+  const pluginRoot = shared.getHomePluginRoot();
 
-  if (fs.existsSync(pluginRoot)) {
-    try {
-      fs.rmSync(pluginRoot, { recursive: true, force: true });
-      console.log(`[babysitter] Removed ${pluginRoot}`);
-      removedPlugin = true;
-    } catch (err) {
-      console.warn(`[babysitter] Warning: Could not remove plugin directory ${pluginRoot}: ${err.message}`);
-    }
-  }
-
-  removeMarketplaceEntry(marketplacePath);
-  removeLegacyCodexSurface(codexHome);
-
-  if (!removedPlugin) {
-    console.log('[babysitter] Plugin directory not found, legacy Codex surface cleaned if present.');
+  if (!fs.existsSync(pluginRoot)) {
+    console.log(`[${shared.PLUGIN_NAME}] Plugin not installed at ${pluginRoot}`);
     return;
   }
 
-  console.log('[babysitter] Restart Codex to complete uninstallation.');
+  try {
+    fs.rmSync(pluginRoot, { recursive: true, force: true });
+    console.log(`[${shared.PLUGIN_NAME}] Uninstalled from ${pluginRoot}`);
+  } catch (err) {
+    console.error(`[${shared.PLUGIN_NAME}] Failed to uninstall: ${err.message}`);
+    process.exitCode = 1;
+  }
 }
 
 main();