@a5c-ai/babysitter-codex 0.1.6-staging.05b1f6af

package/bin/install-shared.js

@@ -0,0 +1,509 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const PLUGIN_NAME = 'babysitter-codex';
+const PLUGIN_CATEGORY = 'Coding';
+const LEGACY_SKILL_NAMES = [
+  'babysit',
+  'babysitter-codex',
+  'assimilate',
+  'call',
+  'doctor',
+  'forever',
+  'help',
+  'issue',
+  'model',
+  'observe',
+  'plan',
+  'project-install',
+  'resume',
+  'retrospect',
+  'team-install',
+  'user-install',
+  'yolo',
+];
+const LEGACY_PROMPT_NAMES = [
+  'assimilate.md',
+  'call.md',
+  'doctor.md',
+  'forever.md',
+  'help.md',
+  'issue.md',
+  'model.md',
+  'observe.md',
+  'plan.md',
+  'project-install.md',
+  'resume.md',
+  'retrospect.md',
+  'team-install.md',
+  'user-install.md',
+  'yolo.md',
+  'babysit.md',
+];
+const LEGACY_HOOK_SCRIPT_NAMES = [
+  'babysitter-session-start.sh',
+  'babysitter-stop-hook.sh',
+  'user-prompt-submit.sh',
+];
+const DEFAULT_MARKETPLACE = {
+  name: 'local-plugins',
+  interface: {
+    displayName: 'Local Plugins',
+  },
+  plugins: [],
+};
+const PLUGIN_BUNDLE_ENTRIES = [
+  '.codex-plugin',
+  '.app.json',
+  'assets',
+  'hooks',
+  'hooks.json',
+  'skills',
+  'babysitter.lock.json',
+];
+
+function getCodexHome() {
+  if (process.env.CODEX_HOME) return path.resolve(process.env.CODEX_HOME);
+  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);
+}
+
+function getHomeMarketplacePath() {
+  if (process.env.BABYSITTER_CODEX_MARKETPLACE_PATH) {
+    return path.resolve(process.env.BABYSITTER_CODEX_MARKETPLACE_PATH);
+  }
+  return path.join(getUserHome(), '.agents', 'plugins', 'marketplace.json');
+}
+
+function renderCodexConfigToml() {
+  return [
+    'approval_policy = "on-request"',
+    'sandbox_mode = "workspace-write"',
+    'project_doc_max_bytes = 65536',
+    '',
+    '[sandbox_workspace_write]',
+    'writable_roots = [".a5c", ".codex"]',
+    '',
+    '[features]',
+    'codex_hooks = true',
+    'multi_agent = true',
+    '',
+    '[agents]',
+    'max_depth = 3',
+    'max_threads = 4',
+    '',
+  ].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()) {
+    fs.mkdirSync(dest, { recursive: true });
+    for (const entry of fs.readdirSync(src)) {
+      if (['node_modules', '.git', 'test', '.a5c'].includes(entry)) continue;
+      copyRecursive(path.join(src, entry), path.join(dest, entry));
+    }
+    return;
+  }
+
+  if (path.basename(src) === 'SKILL.md') {
+    const file = fs.readFileSync(src);
+    const hasBom = file.length >= 3 && file[0] === 0xef && file[1] === 0xbb && file[2] === 0xbf;
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    fs.writeFileSync(dest, hasBom ? file.subarray(3) : file);
+    return;
+  }
+
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  fs.copyFileSync(src, dest);
+}
+
+function copyPluginBundle(packageRoot, pluginRoot) {
+  if (path.resolve(packageRoot) === path.resolve(pluginRoot)) {
+    return;
+  }
+  fs.rmSync(pluginRoot, { recursive: true, force: true });
+  fs.mkdirSync(pluginRoot, { recursive: true });
+  for (const entry of PLUGIN_BUNDLE_ENTRIES) {
+    copyRecursive(path.join(packageRoot, entry), path.join(pluginRoot, entry));
+  }
+}
+
+function insertRootKey(content, key, line) {
+  const keyPattern = new RegExp(`^\\s*${key}\\s*=`, 'm');
+  if (keyPattern.test(content)) {
+    return content;
+  }
+  const sectionMatch = content.match(/^\[[^\]]+\]\s*$/m);
+  if (!sectionMatch || sectionMatch.index === undefined) {
+    return content.trim() ? `${content.trimEnd()}\n${line}\n` : `${line}\n`;
+  }
+  const before = content.slice(0, sectionMatch.index).trimEnd();
+  const after = content.slice(sectionMatch.index);
+  return before ? `${before}\n${line}\n\n${after}` : `${line}\n\n${after}`;
+}
+
+function ensureSectionLine(content, sectionName, lineKey, line) {
+  const keyPattern = new RegExp(`^\\s*${lineKey}\\s*=`, 'm');
+  if (keyPattern.test(content)) {
+    return content;
+  }
+  const sectionHeader = `[${sectionName}]`;
+  const escapedSection = sectionName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const sectionPattern = new RegExp(`^\\[${escapedSection}\\]\\s*$`, 'm');
+  if (sectionPattern.test(content)) {
+    return content.replace(sectionPattern, `${sectionHeader}\n${line}`);
+  }
+  return content.trim()
+    ? `${content.trimEnd()}\n\n${sectionHeader}\n${line}\n`
+    : `${sectionHeader}\n${line}\n`;
+}
+
+function ensureWritableRoots(content) {
+  const sectionPattern = /^\[sandbox_workspace_write\]\s*$/m;
+  const rootsPattern = /^writable_roots\s*=\s*\[(.*?)\]\s*$/m;
+  const requiredRoots = ['.a5c', '.codex'];
+
+  if (!sectionPattern.test(content)) {
+    return content.trim()
+      ? `${content.trimEnd()}\n\n[sandbox_workspace_write]\nwritable_roots = [".a5c", ".codex"]\n`
+      : '[sandbox_workspace_write]\nwritable_roots = [".a5c", ".codex"]\n';
+  }
+
+  if (!rootsPattern.test(content)) {
+    return content.replace(
+      sectionPattern,
+      '[sandbox_workspace_write]\nwritable_roots = [".a5c", ".codex"]',
+    );
+  }
+
+  return content.replace(rootsPattern, (_match, inner) => {
+    const values = inner
+      .split(',')
+      .map((part) => part.trim())
+      .filter(Boolean)
+      .map((part) => part.replace(/^"(.*)"$/, '$1'));
+    const merged = [...new Set([...values, ...requiredRoots])];
+    return `writable_roots = [${merged.map((value) => `"${value}"`).join(', ')}]`;
+  });
+}
+
+function mergeCodexConfig(existing) {
+  let content = existing.trim() ? existing : '';
+  content = insertRootKey(content, 'approval_policy', 'approval_policy = "on-request"');
+  content = insertRootKey(content, 'sandbox_mode', 'sandbox_mode = "workspace-write"');
+  content = insertRootKey(content, 'project_doc_max_bytes', 'project_doc_max_bytes = 65536');
+  content = ensureWritableRoots(content);
+  content = ensureSectionLine(content, 'features', 'codex_hooks', 'codex_hooks = true');
+  content = ensureSectionLine(content, 'features', 'multi_agent', 'multi_agent = true');
+  content = ensureSectionLine(content, 'agents', 'max_depth', 'max_depth = 3');
+  content = ensureSectionLine(content, 'agents', 'max_threads', 'max_threads = 4');
+  return `${content.trimEnd()}\n`;
+}
+
+function mergeCodexConfigFile(configPath) {
+  const current = fs.existsSync(configPath)
+    ? fs.readFileSync(configPath, 'utf8')
+    : renderCodexConfigToml();
+  writeFileIfChanged(configPath, mergeCodexConfig(current));
+}
+
+function resolveBabysitterCommand(packageRoot) {
+  if (process.env.BABYSITTER_SDK_CLI) {
+    return {
+      command: process.execPath,
+      argsPrefix: [path.resolve(process.env.BABYSITTER_SDK_CLI)],
+    };
+  }
+  try {
+    return {
+      command: process.execPath,
+      argsPrefix: [
+        require.resolve('@a5c-ai/babysitter-sdk/dist/cli/main.js', {
+          paths: [packageRoot],
+        }),
+      ],
+    };
+  } catch {
+    return {
+      command: 'babysitter',
+      argsPrefix: [],
+    };
+  }
+}
+
+function runBabysitterCli(packageRoot, cliArgs, options = {}) {
+  const resolved = resolveBabysitterCommand(packageRoot);
+  const result = spawnSync(resolved.command, [...resolved.argsPrefix, ...cliArgs], {
+    cwd: options.cwd || process.cwd(),
+    stdio: ['ignore', 'pipe', 'pipe'],
+    encoding: 'utf8',
+    env: {
+      ...process.env,
+      ...(options.env || {}),
+    },
+  });
+  if (result.status !== 0) {
+    const stderr = (result.stderr || '').trim();
+    const stdout = (result.stdout || '').trim();
+    throw new Error(
+      `babysitter ${cliArgs.join(' ')} failed` +
+      (stderr ? `: ${stderr}` : stdout ? `: ${stdout}` : ''),
+    );
+  }
+  return result.stdout;
+}
+
+function ensureGlobalProcessLibrary(packageRoot) {
+  return JSON.parse(
+    runBabysitterCli(
+      packageRoot,
+      ['process-library:active', '--state-dir', getGlobalStateDir(), '--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.
+  }
+}
+
+function normalizeMarketplaceSourcePath(marketplacePath, pluginSourcePath) {
+  let next = pluginSourcePath;
+  if (path.isAbsolute(next)) {
+    next = path.relative(path.dirname(marketplacePath), next);
+  }
+  next = String(next || '').replace(/\\/g, '/');
+  if (!next.startsWith('./') && !next.startsWith('../')) {
+    next = `./${next}`;
+  }
+  return next;
+}
+
+function ensureMarketplaceEntry(marketplacePath, pluginSourcePath) {
+  const marketplace = fs.existsSync(marketplacePath)
+    ? readJson(marketplacePath)
+    : { ...DEFAULT_MARKETPLACE, plugins: [] };
+  marketplace.name = marketplace.name || DEFAULT_MARKETPLACE.name;
+  marketplace.interface = marketplace.interface || {};
+  marketplace.interface.displayName =
+    marketplace.interface.displayName || DEFAULT_MARKETPLACE.interface.displayName;
+  const nextEntry = {
+    name: PLUGIN_NAME,
+    source: {
+      source: 'local',
+      path: normalizeMarketplaceSourcePath(marketplacePath, pluginSourcePath),
+    },
+    policy: {
+      installation: 'AVAILABLE',
+      authentication: 'ON_INSTALL',
+    },
+    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);
+  }
+  writeJson(marketplacePath, marketplace);
+  return nextEntry;
+}
+
+function removeMarketplaceEntry(marketplacePath) {
+  if (!fs.existsSync(marketplacePath)) {
+    return;
+  }
+  const marketplace = readJson(marketplacePath);
+  if (!Array.isArray(marketplace.plugins)) {
+    return;
+  }
+  marketplace.plugins = marketplace.plugins.filter((entry) => entry && entry.name !== PLUGIN_NAME);
+  writeJson(marketplacePath, marketplace);
+}
+
+function removeLegacyCodexSurface(codexHome) {
+  for (const skillName of LEGACY_SKILL_NAMES) {
+    fs.rmSync(path.join(codexHome, 'skills', skillName), { recursive: true, force: true });
+  }
+  for (const promptName of LEGACY_PROMPT_NAMES) {
+    fs.rmSync(path.join(codexHome, 'prompts', promptName), { force: true });
+  }
+  for (const hookName of LEGACY_HOOK_SCRIPT_NAMES) {
+    fs.rmSync(path.join(codexHome, 'hooks', hookName), { force: true });
+  }
+
+  const hooksConfigPath = path.join(codexHome, 'hooks.json');
+  if (!fs.existsSync(hooksConfigPath)) {
+    return;
+  }
+  let hooksConfig;
+  try {
+    hooksConfig = readJson(hooksConfigPath);
+  } catch {
+    return;
+  }
+  if (!hooksConfig.hooks || typeof hooksConfig.hooks !== 'object') {
+    return;
+  }
+  for (const eventName of ['SessionStart', 'UserPromptSubmit', 'Stop']) {
+    const eventHooks = Array.isArray(hooksConfig.hooks[eventName]) ? hooksConfig.hooks[eventName] : [];
+    const filteredMatchers = eventHooks
+      .map((matcher) => {
+        const hooks = Array.isArray(matcher.hooks) ? matcher.hooks : [];
+        const keptHooks = hooks.filter((hook) => {
+          const command = String(hook.command || '');
+          return !LEGACY_HOOK_SCRIPT_NAMES.some((name) => command.includes(name));
+        });
+        return keptHooks.length > 0 ? { ...matcher, hooks: keptHooks } : null;
+      })
+      .filter(Boolean);
+    if (filteredMatchers.length > 0) {
+      hooksConfig.hooks[eventName] = filteredMatchers;
+    } else {
+      delete hooksConfig.hooks[eventName];
+    }
+  }
+  if (Object.keys(hooksConfig.hooks).length === 0) {
+    fs.rmSync(hooksConfigPath, { force: true });
+  } else {
+    writeJson(hooksConfigPath, hooksConfig);
+  }
+}
+
+function installManagedSkills(packageRoot, codexHome) {
+  const sourceRoot = path.join(packageRoot, 'skills');
+  const targetRoot = path.join(codexHome, 'skills');
+  fs.mkdirSync(targetRoot, { recursive: true });
+
+  for (const entry of fs.readdirSync(sourceRoot, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    copyRecursive(
+      path.join(sourceRoot, entry.name),
+      path.join(targetRoot, entry.name),
+    );
+  }
+}
+
+function mergeManagedHooksConfig(packageRoot, codexHome) {
+  const managedHooks = readJson(path.join(packageRoot, 'hooks.json')).hooks || {};
+  const hooksConfigPath = path.join(codexHome, 'hooks.json');
+  const existing = fs.existsSync(hooksConfigPath)
+    ? readJson(hooksConfigPath)
+    : { hooks: {} };
+  if (!existing.hooks || typeof existing.hooks !== 'object') {
+    existing.hooks = {};
+  }
+
+  for (const [eventName, matchers] of Object.entries(managedHooks)) {
+    const existingMatchers = Array.isArray(existing.hooks[eventName]) ? existing.hooks[eventName] : [];
+    const filteredMatchers = existingMatchers
+      .map((matcher) => {
+        const hooks = Array.isArray(matcher.hooks) ? matcher.hooks : [];
+        const keptHooks = hooks.filter((hook) => {
+          const command = String(hook.command || '');
+          return !LEGACY_HOOK_SCRIPT_NAMES.some((name) => command.includes(name));
+        });
+        return keptHooks.length > 0 ? { ...matcher, hooks: keptHooks } : null;
+      })
+      .filter(Boolean);
+    existing.hooks[eventName] = [...filteredMatchers, ...matchers];
+  }
+
+  writeJson(hooksConfigPath, existing);
+}
+
+function installManagedHooks(packageRoot, codexHome) {
+  const sourceRoot = path.join(packageRoot, 'hooks');
+  const targetRoot = path.join(codexHome, 'hooks');
+  fs.mkdirSync(targetRoot, { recursive: true });
+
+  for (const scriptName of LEGACY_HOOK_SCRIPT_NAMES) {
+    const sourcePath = path.join(sourceRoot, scriptName);
+    const targetPath = path.join(targetRoot, scriptName);
+    copyRecursive(sourcePath, targetPath);
+    ensureExecutable(targetPath);
+  }
+
+  mergeManagedHooksConfig(packageRoot, codexHome);
+}
+
+function installCodexSurface(packageRoot, codexHome) {
+  removeLegacyCodexSurface(codexHome);
+  installManagedSkills(packageRoot, codexHome);
+  installManagedHooks(packageRoot, codexHome);
+}
+
+function warnWindowsHooks() {
+  if (process.platform !== 'win32') {
+    return;
+  }
+  console.warn('[babysitter-codex] Warning: Codex hooks are currently disabled on native Windows.');
+  console.warn('[babysitter-codex] The plugin will install correctly, but SessionStart/UserPromptSubmit/Stop hooks will not fire until Codex enables Windows hook execution.');
+}
+
+module.exports = {
+  copyPluginBundle,
+  ensureGlobalProcessLibrary,
+  ensureMarketplaceEntry,
+  getCodexHome,
+  getHomeMarketplacePath,
+  getHomePluginRoot,
+  installCodexSurface,
+  mergeCodexConfigFile,
+  removeLegacyCodexSurface,
+  removeMarketplaceEntry,
+  warnWindowsHooks,
+  writeJson,
+};

package/bin/install.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+'use strict';
+
+const path = require('path');
+const {
+  copyPluginBundle,
+  ensureGlobalProcessLibrary,
+  ensureMarketplaceEntry,
+  getCodexHome,
+  getHomeMarketplacePath,
+  getHomePluginRoot,
+  installCodexSurface,
+  mergeCodexConfigFile,
+  warnWindowsHooks,
+} = require('./install-shared');
+
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+
+function main() {
+  const codexHome = getCodexHome();
+  const pluginRoot = getHomePluginRoot();
+  const marketplacePath = getHomeMarketplacePath();
+
+  console.log(`[babysitter-codex] 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-codex]   marketplace: ${marketplacePath}`);
+    console.log(`[babysitter-codex]   process library: ${active.binding?.dir}`);
+    if (active.defaultSpec?.cloneDir) {
+      console.log(`[babysitter-codex]   process library clone: ${active.defaultSpec.cloneDir}`);
+    }
+    console.log(`[babysitter-codex]   process library state: ${active.stateFile}`);
+    warnWindowsHooks();
+    console.log('[babysitter-codex] Installation complete!');
+    console.log('[babysitter-codex] Restart Codex to pick up the installed plugin and config changes.');
+  } catch (err) {
+    console.error(`[babysitter-codex] Failed to install plugin: ${err.message}`);
+    process.exitCode = 1;
+  }
+}
+
+main();

package/bin/uninstall.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const {
+  getCodexHome,
+  getHomeMarketplacePath,
+  getHomePluginRoot,
+  removeLegacyCodexSurface,
+  removeMarketplaceEntry,
+} = require('./install-shared');
+
+function main() {
+  const codexHome = getCodexHome();
+  const pluginRoot = getHomePluginRoot();
+  const marketplacePath = getHomeMarketplacePath();
+  let removedPlugin = false;
+
+  if (fs.existsSync(pluginRoot)) {
+    try {
+      fs.rmSync(pluginRoot, { recursive: true, force: true });
+      console.log(`[babysitter-codex] Removed ${pluginRoot}`);
+      removedPlugin = true;
+    } catch (err) {
+      console.warn(`[babysitter-codex] Warning: Could not remove plugin directory ${pluginRoot}: ${err.message}`);
+    }
+  }
+
+  removeMarketplaceEntry(marketplacePath);
+  removeLegacyCodexSurface(codexHome);
+
+  if (!removedPlugin) {
+    console.log('[babysitter-codex] Plugin directory not found, legacy Codex surface cleaned if present.');
+    return;
+  }
+
+  console.log('[babysitter-codex] Restart Codex to complete uninstallation.');
+}
+
+main();

package/hooks/babysitter-session-start.sh

@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PLUGIN_ROOT="$(cd "${SCRIPT_DIR}/.." && pwd)"
+STATE_DIR="${BABYSITTER_STATE_DIR:-${PWD}/.a5c}"
+LOG_DIR="${BABYSITTER_LOG_DIR:-$PLUGIN_ROOT/.a5c/logs}"
+LOG_FILE="$LOG_DIR/babysitter-session-start-hook.log"
+
+export CODEX_PLUGIN_ROOT="${CODEX_PLUGIN_ROOT:-${PLUGIN_ROOT}}"
+export BABYSITTER_STATE_DIR="${STATE_DIR}"
+
+mkdir -p "$LOG_DIR" 2>/dev/null
+{
+  echo "[INFO] $(date -u +%Y-%m-%dT%H:%M:%SZ) Hook script invoked"
+  echo "[INFO] $(date -u +%Y-%m-%dT%H:%M:%SZ) PLUGIN_ROOT=$PLUGIN_ROOT"
+  echo "[INFO] $(date -u +%Y-%m-%dT%H:%M:%SZ) STATE_DIR=$STATE_DIR"
+} >> "$LOG_FILE" 2>/dev/null
+
+INPUT_FILE=$(mktemp 2>/dev/null || echo "/tmp/codex-session-start-hook-$$.json")
+cat > "$INPUT_FILE"
+
+echo "[INFO] $(date -u +%Y-%m-%dT%H:%M:%SZ) Hook input received ($(wc -c < "$INPUT_FILE") bytes)" >> "$LOG_FILE" 2>/dev/null
+
+RESULT=$(babysitter hook:run \
+  --hook-type session-start \
+  --harness codex \
+  --plugin-root "${CODEX_PLUGIN_ROOT}" \
+  --state-dir "${BABYSITTER_STATE_DIR}" \
+  < "$INPUT_FILE" 2>"$LOG_DIR/babysitter-session-start-hook-stderr.log")
+EXIT_CODE=$?
+
+echo "[INFO] $(date -u +%Y-%m-%dT%H:%M:%SZ) CLI exit code=$EXIT_CODE" >> "$LOG_FILE" 2>/dev/null
+
+rm -f "$INPUT_FILE" 2>/dev/null
+printf '%s\n' "$RESULT"
+exit $EXIT_CODE

package/hooks/babysitter-stop-hook.sh

@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PLUGIN_ROOT="$(cd "${SCRIPT_DIR}/.." && pwd)"
+STATE_DIR="${BABYSITTER_STATE_DIR:-${PWD}/.a5c}"
+LOG_DIR="${BABYSITTER_LOG_DIR:-$PLUGIN_ROOT/.a5c/logs}"
+LOG_FILE="$LOG_DIR/babysitter-stop-hook.log"
+
+export CODEX_PLUGIN_ROOT="${CODEX_PLUGIN_ROOT:-${PLUGIN_ROOT}}"
+export BABYSITTER_STATE_DIR="${STATE_DIR}"
+
+mkdir -p "$LOG_DIR" 2>/dev/null
+{
+  echo "[INFO] $(date -u +%Y-%m-%dT%H:%M:%SZ) Hook script invoked"
+  echo "[INFO] $(date -u +%Y-%m-%dT%H:%M:%SZ) PLUGIN_ROOT=$PLUGIN_ROOT"
+  echo "[INFO] $(date -u +%Y-%m-%dT%H:%M:%SZ) STATE_DIR=$STATE_DIR"
+} >> "$LOG_FILE" 2>/dev/null
+
+INPUT_FILE=$(mktemp 2>/dev/null || echo "/tmp/codex-stop-hook-$$.json")
+cat > "$INPUT_FILE"
+
+echo "[INFO] $(date -u +%Y-%m-%dT%H:%M:%SZ) Hook input received ($(wc -c < "$INPUT_FILE") bytes)" >> "$LOG_FILE" 2>/dev/null
+
+RESULT=$(babysitter hook:run \
+  --hook-type stop \
+  --harness codex \
+  --plugin-root "${CODEX_PLUGIN_ROOT}" \
+  --state-dir "${BABYSITTER_STATE_DIR}" \
+  < "$INPUT_FILE" 2>"$LOG_DIR/babysitter-stop-hook-stderr.log")
+EXIT_CODE=$?
+
+echo "[INFO] $(date -u +%Y-%m-%dT%H:%M:%SZ) CLI exit code=$EXIT_CODE" >> "$LOG_FILE" 2>/dev/null
+
+rm -f "$INPUT_FILE" 2>/dev/null
+printf '%s\n' "$RESULT"
+exit $EXIT_CODE