@a5c-ai/babysitter-codex 0.1.11-staging.f6cb97d6 → 5.0.0

package/bin/install-shared.js

@@ -5,8 +5,196 @@ 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',
   'babysitter-codex',
@@ -49,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: {
@@ -58,12 +251,13 @@ const DEFAULT_MARKETPLACE = {
 };
 const PLUGIN_BUNDLE_ENTRIES = [
   '.codex-plugin',
-  '.app.json',
   'assets',
   'hooks',
   'hooks.json',
   'skills',
-  'babysitter.lock.json',
+  '.app.json',
+  'plugin.lock.json',
+  'README.md',
 ];
 
 function getCodexHome() {
@@ -71,24 +265,11 @@ 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);
   }
-  return path.join(getCodexHome(), 'plugins', PLUGIN_NAME);
+  return path.join(getUserHome(), '.agents', 'plugins', PLUGIN_NAME);
 }
 
 function getHomeMarketplacePath() {
@@ -98,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"',
@@ -118,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()) {
@@ -290,38 +467,77 @@ 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'));
+  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 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.
-  }
+function getMarketplaceRootDir(marketplacePath) {
+  const pluginsDir = path.dirname(marketplacePath);
+  const dotAgentsDir = path.dirname(pluginsDir);
+  return path.dirname(dotAgentsDir);
 }
 
 function normalizeMarketplaceSourcePath(marketplacePath, pluginSourcePath) {
-  let next = pluginSourcePath;
-  if (path.isAbsolute(next)) {
-    next = path.relative(path.dirname(marketplacePath), next);
-  }
+  let next = path.relative(getMarketplaceRootDir(marketplacePath), pluginSourcePath);
   next = String(next || '').replace(/\\/g, '/');
-  if (!next.startsWith('./') && !next.startsWith('../')) {
+  if (!next || next === '.' || next.startsWith('../')) {
+    throw new Error(
+      `Plugin source path must live under ${getMarketplaceRootDir(marketplacePath)} so Codex can load it via a ./-prefixed marketplace entry.`,
+    );
+  }
+  if (!next.startsWith('./')) {
     next = `./${next}`;
   }
   return next;
@@ -347,15 +563,15 @@ function ensureMarketplaceEntry(marketplacePath, pluginSourcePath) {
     },
     category: PLUGIN_CATEGORY,
   };
-  const existingIndex = Array.isArray(marketplace.plugins)
-    ? marketplace.plugins.findIndex((entry) => entry && entry.name === PLUGIN_NAME)
-    : -1;
   if (!Array.isArray(marketplace.plugins)) {
     marketplace.plugins = [nextEntry];
-  } else if (existingIndex >= 0) {
-    marketplace.plugins[existingIndex] = nextEntry;
   } else {
-    marketplace.plugins.push(nextEntry);
+    const sanitized = marketplace.plugins.filter((entry) => (
+      entry &&
+      entry.name !== PLUGIN_NAME &&
+      !LEGACY_MARKETPLACE_PLUGIN_NAMES.includes(entry.name)
+    ));
+    marketplace.plugins = [...sanitized, nextEntry];
   }
   writeJson(marketplacePath, marketplace);
   return nextEntry;
@@ -369,7 +585,11 @@ function removeMarketplaceEntry(marketplacePath) {
   if (!Array.isArray(marketplace.plugins)) {
     return;
   }
-  marketplace.plugins = marketplace.plugins.filter((entry) => entry && entry.name !== PLUGIN_NAME);
+  marketplace.plugins = marketplace.plugins.filter((entry) => (
+    entry &&
+    entry.name !== PLUGIN_NAME &&
+    !LEGACY_MARKETPLACE_PLUGIN_NAMES.includes(entry.name)
+  ));
   writeJson(marketplacePath, marketplace);
 }
 
@@ -469,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);
@@ -485,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;
@@ -496,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,45 +2,27 @@
 'use strict';
 
 const path = require('path');
-const {
-  copyPluginBundle,
-  ensureGlobalProcessLibrary,
-  ensureMarketplaceEntry,
-  getCodexHome,
-  getHomeMarketplacePath,
-  getHomePluginRoot,
-  installCodexSurface,
-  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'));
-    installCodexSurface(PACKAGE_ROOT, codexHome);
-
-    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.');
+    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();

package/hooks/babysitter-proxied-session-start.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+# Session Start — installs SDK if needed, then runs hook handler.
+set -euo pipefail
+PLUGIN_ROOT="${PLUGIN_ROOT:-$(cd "$(dirname "$0")/.." && pwd)}"
+SDK_VERSION=$(node -e "try{console.log(JSON.parse(require('fs').readFileSync('${PLUGIN_ROOT}/versions.json','utf8')).sdkVersion||'latest')}catch{console.log('latest')}" 2>/dev/null || echo "latest")
+if ! command -v babysitter &>/dev/null; then
+  npm i -g "@a5c-ai/babysitter-sdk@${SDK_VERSION}" --loglevel=error 2>/dev/null || \
+  npm i -g "@a5c-ai/babysitter-sdk@${SDK_VERSION}" --prefix "$HOME/.local" --loglevel=error 2>/dev/null || true
+  [ -d "$HOME/.local/bin" ] && export PATH="$HOME/.local/bin:$PATH"
+fi
+babysitter hook:run --harness unified --hook-type session-start --json

package/hooks/babysitter-proxied-stop.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+set -euo pipefail
+babysitter hook:run --harness unified --hook-type stop --json

package/hooks/babysitter-proxied-user-prompt-submit.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+set -euo pipefail
+babysitter hook:run --harness unified --hook-type user-prompt-submit --json