ronds_ai 0.1.10 → 0.1.12

package/README.md

@@ -49,9 +49,29 @@ npx ronds_ai@latest check record
 - 当前 Node 版本
 - Node 是否满足 `>=16`
 - 当前目录下读取到的 `git user.email`
-- 当前 `worker_id` 配置来源和取值
+- 当前 `MCP_TRACKER_WORKER_ID` 的来源和取值
 - `~/.profile` 路径
 
+输出 JSON 后，命令还会继续在终端里显示当前 `MCP_TRACKER_WORKER_ID`，并询问是否要修改。
+如果选择修改：
+
+- Windows：写入用户级持久环境变量，新的终端可直接读取
+- Linux：写入 `~/.profile`，新的 shell 可读取
+
+如果不想进入交互流程，可加上：
+
+```bash
+ronds_ai check record --no-prompt
+```
+
+或：
+
+```bash
+npx ronds_ai@latest check record --no-prompt
+```
+
+交互式修改后，命令会再次显示更新后的 `MCP_TRACKER_WORKER_ID`。
+
 输出是一个 JSON，例如：
 
 ```json
@@ -201,6 +221,7 @@ npx ronds_ai@latest hooks deploy
 - 在 `.cursor/hooks.json` 中确保存在 `npx ronds_ai@latest record cursor`
 - 在 `.claude/settings.json` 中确保存在 `npx ronds_ai@latest record claude`
 - 在 `.codex/hooks.json` 中确保存在 `npx ronds_ai@latest record codex`（`UserPromptSubmit` + `Stop` 两个 hook）
+- 在 `.codex/config.toml` 中确保存在 `[features] codex_hooks = true`，启用 Codex hooks
 - 清理旧版 hook 脚本文件
 - 如果存在 `.claude/settings.local.json`，会移除其中由本工具管理的旧 hook，避免重复触发
 - 所有工具的失败事件统一写入 `~/.ronds_ai/failed-events`

package/bin/ronds_ai.js

@@ -1,9 +1,61 @@
 #!/usr/bin/env node
 
 const { runCodeRecord, saveCliError } = require('../lib/code_record');
-const { runCheckRecord } = require('../lib/check_record');
+const {
+  ENVIRONMENT_VARIABLE_NAME,
+  getRefreshNotice,
+  getPersistentWorkerHint,
+  isPersistentWorkerUpdateSupported,
+  runCheckRecord,
+  savePersistentWorkerId,
+} = require('../lib/check_record');
 const { runDoctor } = require('../lib/doctor');
 const { deployHooks } = require('../lib/hooks_deploy');
+const { promptForText, promptYesNo } = require('../lib/skills_prompt');
+
+function writeWorkerSummary(result) {
+  process.stderr.write(`${ENVIRONMENT_VARIABLE_NAME}: ${result.workerId.value || '（空）'}\n`);
+  process.stderr.write(`来源: ${result.workerId.source || '未设置'}\n`);
+}
+
+async function maybeUpdateWorkerId() {
+  const initialResult = runCheckRecord(process.cwd());
+  writeWorkerSummary(initialResult);
+  process.stderr.write(`${getPersistentWorkerHint()}\n`);
+
+  if (!isPersistentWorkerUpdateSupported()) {
+    return;
+  }
+
+  const shouldModify = await promptYesNo(`是否要修改 ${ENVIRONMENT_VARIABLE_NAME}？`);
+  if (!shouldModify) {
+    return;
+  }
+
+  const nextValue = await promptForText(`请输入新的 ${ENVIRONMENT_VARIABLE_NAME}：`, initialResult.workerId.value);
+  if (!nextValue) {
+    process.stderr.write(`输入为空，已跳过更新 ${ENVIRONMENT_VARIABLE_NAME}。\n`);
+    return;
+  }
+
+  const saveResult = savePersistentWorkerId(nextValue);
+  process.stderr.write(`${ENVIRONMENT_VARIABLE_NAME} 已保存到 ${saveResult.location}。\n`);
+
+  const refreshNotice = getRefreshNotice();
+  if (refreshNotice) {
+    process.stderr.write(`${refreshNotice}\n`);
+  }
+
+  writeWorkerSummary(runCheckRecord(process.cwd()));
+}
+
+function shouldPromptWorkerUpdate(args) {
+  return !args.includes('--no-prompt');
+}
+
+function stripCheckFlags(args) {
+  return args.filter((value) => value !== '--no-prompt');
+}
 
 const SUPPORTED_SOURCES = new Set(['claude', 'cursor', 'codex']);
 
@@ -47,7 +99,8 @@ async function runHooksCommand(args) {
 }
 
 async function runCheckCommand(args) {
-  const [target] = args;
+  const filteredArgs = stripCheckFlags(args);
+  const [target] = filteredArgs;
 
   if (target !== 'record') {
     throw new Error('Unsupported check command');
@@ -56,6 +109,10 @@ async function runCheckCommand(args) {
   const result = runCheckRecord(process.cwd());
   process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
 
+  if (shouldPromptWorkerUpdate(args)) {
+    await maybeUpdateWorkerId();
+  }
+
   if (!result.ok) {
     process.exitCode = 1;
   }

package/lib/check_record.js

@@ -1,106 +1,232 @@
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { execFileSync } = require('child_process');
-
-const ENVIRONMENT_VARIABLE_NAME = process.env.ENVIRONMENT_VARIABLE_NAME || 'MCP_TRACKER_WORKER_ID';
-const MINIMUM_NODE_MAJOR = 16;
-
-function readGitUserEmail(baseDir) {
-  try {
-    return execFileSync('git', ['config', 'user.email'], {
-      cwd: baseDir,
-      encoding: 'utf8',
-      stdio: ['ignore', 'pipe', 'pipe'],
-    })
-      .trim()
-      .replace(/^["'“”]+/, '')
-      .replace(/["'“”]+$/, '');
-  } catch {
-    return '';
-  }
-}
-
-function getProfileFilePath() {
-  return path.join(os.homedir(), '.profile');
-}
-
-function getCurrentWorkerId() {
-  const envValue = String(process.env[ENVIRONMENT_VARIABLE_NAME] || '').trim();
-  if (envValue) {
-    return {
-      name: ENVIRONMENT_VARIABLE_NAME,
-      value: envValue,
-      source: 'env',
-    };
-  }
-
-  const profileFile = getProfileFilePath();
-  if (!fs.existsSync(profileFile)) {
-    return {
-      name: ENVIRONMENT_VARIABLE_NAME,
-      value: '',
-      source: '',
-    };
-  }
-
-  const lines = fs.readFileSync(profileFile, 'utf8').split('\n');
-  const prefix = `export ${ENVIRONMENT_VARIABLE_NAME}=`;
-
-  for (let index = lines.length - 1; index >= 0; index -= 1) {
-    const line = lines[index].trim();
-    if (!line.startsWith(prefix)) {
-      continue;
-    }
-
-    const value = line
-      .slice(prefix.length)
-      .trim()
-      .replace(/^"/, '')
-      .replace(/"$/, '');
-
-    return {
-      name: ENVIRONMENT_VARIABLE_NAME,
-      value,
-      source: 'profile',
-    };
-  }
-
-  return {
-    name: ENVIRONMENT_VARIABLE_NAME,
-    value: '',
-    source: '',
-  };
-}
-
-function parseNodeMajor(version) {
-  const normalized = String(version || '').trim();
-  const match = normalized.match(/^v?(\d+)/);
-  return match ? Number(match[1]) : 0;
-}
-
-function runCheckRecord(targetDir = process.cwd()) {
-  const baseDir = path.resolve(targetDir);
-  const nodeVersion = process.version;
-  const nodeMajor = parseNodeMajor(nodeVersion);
-  const gitUserEmail = readGitUserEmail(baseDir);
-  const worker = getCurrentWorkerId();
-  const nodeSatisfied = nodeMajor >= MINIMUM_NODE_MAJOR;
-
-  return {
-    ok: nodeSatisfied,
-    targetDir: baseDir,
-    node: {
-      version: nodeVersion,
-      requirement: `>=${MINIMUM_NODE_MAJOR}`,
-      satisfied: nodeSatisfied,
-    },
-    gitUserEmail,
-    workerId: worker,
-    profileFile: getProfileFilePath(),
-  };
-}
-
-module.exports = {
-  runCheckRecord,
-};
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFileSync } = require('child_process');
+const { runGit } = require('./git');
+
+const ENVIRONMENT_VARIABLE_NAME = process.env.ENVIRONMENT_VARIABLE_NAME || 'MCP_TRACKER_WORKER_ID';
+const MINIMUM_NODE_MAJOR = 16;
+const SUPPORTED_PERSISTENT_PLATFORMS = new Set(['win32', 'linux']);
+
+function readGitUserEmail(baseDir) {
+  return runGit(baseDir, ['config', 'user.email'], false)
+    .replace(/^["'“”]+/, '')
+    .replace(/["'“”]+$/, '');
+}
+
+function getProfileFilePath() {
+  return path.join(os.homedir(), '.profile');
+}
+
+function stripShellQuotes(value) {
+  return String(value || '')
+    .trim()
+    .replace(/^['"]/, '')
+    .replace(/['"]$/, '');
+}
+
+function readWorkerIdFromProfile() {
+  const profileFile = getProfileFilePath();
+  if (!fs.existsSync(profileFile)) {
+    return '';
+  }
+
+  const lines = fs.readFileSync(profileFile, 'utf8').split('\n');
+  const prefix = `export ${ENVIRONMENT_VARIABLE_NAME}=`;
+
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    const line = lines[index].trim();
+    if (!line.startsWith(prefix)) {
+      continue;
+    }
+
+    return stripShellQuotes(line.slice(prefix.length));
+  }
+
+  return '';
+}
+
+function readWorkerIdFromWindowsUserEnv() {
+  try {
+    return execFileSync('powershell', ['-NoProfile', '-Command', `[Environment]::GetEnvironmentVariable('${ENVIRONMENT_VARIABLE_NAME}', 'User')`], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    }).trim();
+  } catch {
+    return '';
+  }
+}
+
+function getCurrentWorkerId() {
+  const envValue = String(process.env[ENVIRONMENT_VARIABLE_NAME] || '').trim();
+  if (envValue) {
+    return {
+      name: ENVIRONMENT_VARIABLE_NAME,
+      value: envValue,
+      source: 'env',
+    };
+  }
+
+  if (process.platform === 'win32') {
+    const userEnvValue = readWorkerIdFromWindowsUserEnv();
+    if (userEnvValue) {
+      return {
+        name: ENVIRONMENT_VARIABLE_NAME,
+        value: userEnvValue,
+        source: 'user_env',
+      };
+    }
+  }
+
+  const profileValue = readWorkerIdFromProfile();
+  if (profileValue) {
+    return {
+      name: ENVIRONMENT_VARIABLE_NAME,
+      value: profileValue,
+      source: 'profile',
+    };
+  }
+
+  return {
+    name: ENVIRONMENT_VARIABLE_NAME,
+    value: '',
+    source: '',
+  };
+}
+
+function escapeProfileValue(value) {
+  return String(value).replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+
+function upsertProfileWorkerId(value) {
+  const profileFile = getProfileFilePath();
+  const nextLine = `export ${ENVIRONMENT_VARIABLE_NAME}="${escapeProfileValue(value)}"`;
+  const currentContent = fs.existsSync(profileFile)
+    ? fs.readFileSync(profileFile, 'utf8')
+    : '';
+  const lines = currentContent ? currentContent.split('\n') : [];
+  const prefix = `export ${ENVIRONMENT_VARIABLE_NAME}=`;
+  let updated = false;
+
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    if (!lines[index].trim().startsWith(prefix)) {
+      continue;
+    }
+
+    lines[index] = nextLine;
+    updated = true;
+    break;
+  }
+
+  const nextLines = updated ? lines : lines.concat(nextLine);
+  const nextContent = `${nextLines.join('\n').replace(/\n*$/, '\n')}`;
+  if (nextContent !== currentContent) {
+    fs.writeFileSync(profileFile, nextContent, 'utf8');
+  }
+
+  return {
+    location: profileFile,
+    source: 'profile',
+  };
+}
+
+function setWindowsUserWorkerId(value) {
+  execFileSync('setx', [ENVIRONMENT_VARIABLE_NAME, String(value)], {
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+
+  return {
+    location: 'Windows user environment',
+    source: 'user_env',
+  };
+}
+
+function setPersistentWorkerId(value) {
+  const normalizedValue = String(value || '').trim();
+  if (!normalizedValue) {
+    throw new Error(`${ENVIRONMENT_VARIABLE_NAME} cannot be empty`);
+  }
+
+  if (!SUPPORTED_PERSISTENT_PLATFORMS.has(process.platform)) {
+    throw new Error(`Persistent ${ENVIRONMENT_VARIABLE_NAME} updates are not supported on ${process.platform}`);
+  }
+
+  if (process.platform === 'win32') {
+    return setWindowsUserWorkerId(normalizedValue);
+  }
+
+  return upsertProfileWorkerId(normalizedValue);
+}
+
+function savePersistentWorkerId(value) {
+  const normalizedValue = String(value || '').trim();
+  const result = setPersistentWorkerId(normalizedValue);
+  process.env[ENVIRONMENT_VARIABLE_NAME] = normalizedValue;
+  return result;
+}
+
+function isPersistentWorkerUpdateSupported() {
+  return SUPPORTED_PERSISTENT_PLATFORMS.has(process.platform);
+}
+
+function getPersistentWorkerHint() {
+  if (process.platform === 'win32') {
+    return '会写入 Windows 用户级环境变量，新开的终端可以读取到。';
+  }
+
+  if (process.platform === 'linux') {
+    return `会写入 ${getProfileFilePath()}，新开的 shell 可以读取到。`;
+  }
+
+  return `当前平台暂不支持持久化修改 ${ENVIRONMENT_VARIABLE_NAME}。`;
+}
+
+function getRefreshNotice() {
+  if (process.platform === 'win32') {
+    return '请打开新的终端，让 shell 继承更新后的用户环境变量。';
+  }
+
+  if (process.platform === 'linux') {
+    return `请打开新的 shell，或执行 source ${getProfileFilePath()} 以在当前 shell 中加载新变量。`;
+  }
+
+  return '';
+}
+
+function parseNodeMajor(version) {
+  const normalized = String(version || '').trim();
+  const match = normalized.match(/^v?(\d+)/);
+  return match ? Number(match[1]) : 0;
+}
+
+function runCheckRecord(targetDir = process.cwd()) {
+  const baseDir = path.resolve(targetDir);
+  const nodeVersion = process.version;
+  const nodeMajor = parseNodeMajor(nodeVersion);
+  const gitUserEmail = readGitUserEmail(baseDir);
+  const worker = getCurrentWorkerId();
+  const nodeSatisfied = nodeMajor >= MINIMUM_NODE_MAJOR;
+
+  return {
+    ok: nodeSatisfied,
+    targetDir: baseDir,
+    node: {
+      version: nodeVersion,
+      requirement: `>=${MINIMUM_NODE_MAJOR}`,
+      satisfied: nodeSatisfied,
+    },
+    gitUserEmail,
+    workerId: worker,
+    profileFile: getProfileFilePath(),
+  };
+}
+
+module.exports = {
+  ENVIRONMENT_VARIABLE_NAME,
+  getCurrentWorkerId,
+  getPersistentWorkerHint,
+  getRefreshNotice,
+  isPersistentWorkerUpdateSupported,
+  runCheckRecord,
+  savePersistentWorkerId,
+};

package/lib/code_record.js

@@ -4,6 +4,7 @@ const path = require('path');
 const http = require('http');
 const https = require('https');
 const { execFileSync } = require('child_process');
+const { runGit } = require('./git');
 const { createHash, randomUUID } = require('crypto');
 
 const DEFAULT_TIMEOUT_MS = 10000;
@@ -14,6 +15,7 @@ const CLAUDE_SUPPORTED_TOOLS = new Set(['Write', 'Edit', 'MultiEdit']);
 const CURSOR_SUPPORTED_HOOK_EVENT = 'afterFileEdit';
 const CODEX_SUPPORTED_HOOK_EVENTS = new Set(['UserPromptSubmit', 'Stop']);
 const CODEX_SNAPSHOT_DIR = path.join(os.homedir(), '.ronds_ai', 'codex-snapshots');
+const CODEX_SNAPSHOT_TTL_SEC = 86400;
 const GIT_STATUS_ARGS = ['status', '--porcelain=v1', '--untracked-files=all'];
 const CODEX_STOP_OUTPUT = {
   continue: false,
@@ -135,23 +137,6 @@ function findGitRepoRoot(startDir) {
   }
 }
 
-function runGit(repoRoot, args, required = true) {
-  try {
-    return execFileSync('git', args, {
-      cwd: repoRoot,
-      encoding: 'utf8',
-      stdio: ['ignore', 'pipe', 'pipe'],
-    }).trim();
-  } catch (error) {
-    if (!required) {
-      return '';
-    }
-
-    const stderr = error && error.stderr ? String(error.stderr).trim() : String(error);
-    throw new Error(`git ${args.join(' ')} failed: ${stderr}`);
-  }
-}
-
 function extractRepoNameFromRemoteUrl(remoteUrl) {
   const normalizedUrl = String(remoteUrl || '').trim().replace(/[\\/]+$/, '');
   if (!normalizedUrl) {
@@ -509,9 +494,9 @@ function readFileState(filePath) {
   }
 }
 
-function readHeadFileState(repoRoot, relativePath) {
+function readGitRefFileState(repoRoot, ref, relativePath) {
   try {
-    const buffer = execFileSync('git', ['show', `HEAD:${relativePath}`], {
+    const buffer = execFileSync('git', ['show', `${ref}:${relativePath}`], {
       cwd: repoRoot,
       encoding: null,
       stdio: ['ignore', 'pipe', 'pipe'],
@@ -539,6 +524,27 @@ function readHeadFileState(repoRoot, relativePath) {
   }
 }
 
+function readHeadFileState(repoRoot, relativePath) {
+  return readGitRefFileState(repoRoot, 'HEAD', relativePath);
+}
+
+function readCurrentHead(repoRoot) {
+  return runGit(repoRoot, ['rev-parse', 'HEAD'], false);
+}
+
+function parseGitDiffNameOnly(repoRoot, fromRef, toRef) {
+  const normalizedFromRef = String(fromRef || '').trim();
+  const normalizedToRef = String(toRef || '').trim();
+  if (!normalizedFromRef || !normalizedToRef || normalizedFromRef === normalizedToRef) {
+    return [];
+  }
+
+  const output = runGit(repoRoot, ['diff', '--name-only', `${normalizedFromRef}..${normalizedToRef}`], false);
+  return output.split('\n')
+    .map((line) => line.trim().replace(/\\/g, '/'))
+    .filter(Boolean);
+}
+
 function statesEqual(beforeState, afterState) {
   return beforeState.exists === afterState.exists
     && beforeState.isBinary === afterState.isBinary
@@ -569,6 +575,41 @@ function buildCodexChange(beforeState, afterState) {
   };
 }
 
+function cleanupStaleSnapshots() {
+  let entries;
+  try {
+    if (!fs.existsSync(CODEX_SNAPSHOT_DIR)) {
+      return;
+    }
+    entries = fs.readdirSync(CODEX_SNAPSHOT_DIR);
+  } catch {
+    return;
+  }
+
+  const nowSec = Date.now() / 1000;
+  for (const entry of entries) {
+    if (!entry.endsWith('.json')) {
+      continue;
+    }
+
+    const filePath = path.join(CODEX_SNAPSHOT_DIR, entry);
+    try {
+      const raw = fs.readFileSync(filePath, 'utf8');
+      const snapshot = JSON.parse(raw);
+      const createdAt = String(snapshot.created_at || '');
+      const createdSec = new Date(createdAt).getTime() / 1000;
+      if (isNaN(createdSec)) {
+        continue;
+      }
+      if (nowSec - createdSec > CODEX_SNAPSHOT_TTL_SEC) {
+        fs.rmSync(filePath, { force: true });
+      }
+    } catch {
+      continue;
+    }
+  }
+}
+
 function handleCodexUserPromptSubmit(payload) {
   const cwd = payload.cwd || process.cwd();
   const repoRoot = findGitRepoRoot(cwd);
@@ -577,6 +618,7 @@ function handleCodexUserPromptSubmit(payload) {
     return [];
   }
 
+  const head = readCurrentHead(repoRoot);
   const baseline = {};
   for (const entry of parseGitStatus(repoRoot)) {
     const absolutePath = path.join(repoRoot, entry.path);
@@ -585,12 +627,14 @@ function handleCodexUserPromptSubmit(payload) {
       : readFileState(absolutePath);
   }
 
+  cleanupStaleSnapshots();
   fs.mkdirSync(CODEX_SNAPSHOT_DIR, { recursive: true });
   fs.writeFileSync(snapshotPath, JSON.stringify({
     version: 1,
     session_id: payload.session_id || payload.sessionId || '',
     turn_id: payload.turn_id || payload.turnId || '',
     repo_root: repoRoot,
+    head,
     created_at: new Date().toISOString(),
     baseline,
   }), 'utf8');
@@ -620,9 +664,15 @@ function buildCodexStopEvents(payload, source) {
     : {};
   const currentEntries = parseGitStatus(repoRoot);
   const currentPaths = new Set(currentEntries.map((entry) => entry.path));
+  const baseRef = snapshot && typeof snapshot.head === 'string' && snapshot.head.trim()
+    ? snapshot.head.trim()
+    : 'HEAD';
+  const currentHead = readCurrentHead(repoRoot) || 'HEAD';
+  const committedPaths = new Set(parseGitDiffNameOnly(repoRoot, baseRef, currentHead));
   const allPaths = new Set([
     ...Object.keys(baseline),
     ...currentPaths,
+    ...committedPaths,
   ]);
   const workerId = resolveWorkerId(repoRoot);
   const git = resolveGitMetadata(repoRoot);
@@ -630,8 +680,11 @@ function buildCodexStopEvents(payload, source) {
 
   for (const repoRelativePath of allPaths) {
     const absolutePath = path.join(repoRoot, repoRelativePath);
-    const beforeState = baseline[repoRelativePath] || readHeadFileState(repoRoot, repoRelativePath);
-    const afterState = readFileState(absolutePath);
+    const beforeState = baseline[repoRelativePath] || readGitRefFileState(repoRoot, baseRef, repoRelativePath);
+    let afterState = readFileState(absolutePath);
+    if (!afterState.exists && committedPaths.has(repoRelativePath)) {
+      afterState = readGitRefFileState(repoRoot, currentHead, repoRelativePath);
+    }
 
     if (statesEqual(beforeState, afterState)) {
       continue;

package/lib/doctor.js

@@ -1,7 +1,7 @@
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
-const { execFileSync } = require('child_process');
+const { runGit } = require('./git');
 
 const SUPPORTED_TOOLS = new Set(['claude', 'codex', 'cursor']);
 
@@ -74,15 +74,11 @@ function getConfigChecks(tool, baseDir) {
 }
 
 function readGitUserEmail(baseDir) {
-  try {
-    return execFileSync('git', ['config', 'user.email'], {
-      cwd: baseDir,
-      encoding: 'utf8',
-      stdio: ['ignore', 'pipe', 'pipe'],
-    }).trim();
-  } catch {
-    return '';
-  }
+  return runGit(baseDir, ['config', 'user.email'], false);
+}
+
+function readGitRemoteUrl(baseDir) {
+  return runGit(baseDir, ['remote', 'get-url', 'origin'], false);
 }
 
 function runDoctor(tool, targetDir = process.cwd()) {
@@ -101,6 +97,7 @@ function runDoctor(tool, targetDir = process.cwd()) {
     tool: normalizedTool,
     targetDir: baseDir,
     gitUserEmail: readGitUserEmail(baseDir),
+    gitRemoteUrl: readGitRemoteUrl(baseDir),
     configChecks,
     recentLogs: readRecentLogs(normalizedTool),
   };

package/lib/git.js

@@ -0,0 +1,22 @@
+const { execFileSync } = require('child_process');
+
+function runGit(repoRoot, args, required = true) {
+  try {
+    return execFileSync('git', args, {
+      cwd: repoRoot,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    }).trim();
+  } catch (error) {
+    if (!required) {
+      return '';
+    }
+
+    const stderr = error && error.stderr ? String(error.stderr).trim() : String(error);
+    throw new Error(`git ${args.join(' ')} failed: ${stderr}`);
+  }
+}
+
+module.exports = {
+  runGit,
+};

package/lib/hooks_deploy.js

@@ -72,6 +72,19 @@ function writeJsonFile(filePath, data) {
   return true;
 }
 
+function writeTextFileIfChanged(filePath, nextContent) {
+  if (fs.existsSync(filePath)) {
+    const currentContent = fs.readFileSync(filePath, 'utf8');
+    if (currentContent === nextContent) {
+      return false;
+    }
+  }
+
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, nextContent, 'utf8');
+  return true;
+}
+
 function removeFileIfExists(filePath, removedFiles) {
   if (!fs.existsSync(filePath)) {
     return;
@@ -217,6 +230,57 @@ function cleanupCodexManagedHooks(hooks) {
   return removeCommandEntriesByMatcher(withoutManagedCommands, CODEX_OLD_COMMAND_MATCHERS);
 }
 
+function ensureCodexHooksFeatureFlag(toml) {
+  const newline = toml.includes('\r\n') ? '\r\n' : '\n';
+  const desiredLine = `codex_hooks = true${newline}`;
+  const desiredSection = `[features]${newline}${desiredLine}`;
+
+  if (!toml.trim()) {
+    return desiredSection;
+  }
+
+  const featuresHeaderPattern = /^[ \t]*\[features\][ \t]*(?:#.*)?$/m;
+  const featuresHeaderMatch = featuresHeaderPattern.exec(toml);
+  if (!featuresHeaderMatch) {
+    const trimmed = toml.replace(/[ \t\r\n]*$/, '');
+    return `${trimmed}${newline}${newline}${desiredSection}`;
+  }
+
+  const headerStart = featuresHeaderMatch.index;
+  const headerEnd = headerStart + featuresHeaderMatch[0].length;
+  const sectionAfterHeaderStart = toml.indexOf('\n', headerEnd) === -1
+    ? toml.length
+    : toml.indexOf('\n', headerEnd) + 1;
+  const afterHeader = toml.slice(sectionAfterHeaderStart);
+  const nextHeaderMatch = /^[ \t]*\[[^\]]+\][ \t]*(?:#.*)?$/m.exec(afterHeader);
+  const sectionEnd = nextHeaderMatch
+    ? sectionAfterHeaderStart + nextHeaderMatch.index
+    : toml.length;
+  const section = toml.slice(headerStart, sectionEnd);
+  const flagPattern = /^([ \t]*codex_hooks[ \t]*=[ \t]*)(true|false)([ \t]*(?:#.*)?$)/m;
+  const flagMatch = flagPattern.exec(section);
+
+  if (flagMatch) {
+    if (flagMatch[2] === 'true') {
+      return toml;
+    }
+
+    const nextSection = section.replace(flagPattern, '$1true$3');
+    return `${toml.slice(0, headerStart)}${nextSection}${toml.slice(sectionEnd)}`;
+  }
+
+  return `${toml.slice(0, sectionAfterHeaderStart)}${desiredLine}${toml.slice(sectionAfterHeaderStart)}`;
+}
+
+function ensureCodexConfigToml(configPath) {
+  const exists = fs.existsSync(configPath);
+  const currentContent = exists ? fs.readFileSync(configPath, 'utf8') : '';
+  const nextContent = ensureCodexHooksFeatureFlag(currentContent);
+  const changed = writeTextFileIfChanged(configPath, nextContent);
+
+  return { exists, changed };
+}
+
 function ensureCodexHook(config) {
   const next = isPlainObject(config) ? { ...config } : {};
   const hooks = isPlainObject(next.hooks) ? { ...next.hooks } : {};
@@ -289,13 +353,20 @@ function deployHooks(targetDir = process.cwd()) {
     (claudeSettingsResult.exists ? updatedFiles : createdFiles).push(claudeSettingsPath);
   }
 
-  const codexHooksPath = path.join(baseDir, '.codex', 'hooks.json');
+  const codexDir = path.join(baseDir, '.codex');
+  const codexHooksPath = path.join(codexDir, 'hooks.json');
   const codexHooksResult = readJsonFile(codexHooksPath, {});
   const nextCodexHooks = ensureCodexHook(codexHooksResult.data);
   if (writeJsonFile(codexHooksPath, nextCodexHooks)) {
     (codexHooksResult.exists ? updatedFiles : createdFiles).push(codexHooksPath);
   }
 
+  const codexConfigPath = path.join(codexDir, 'config.toml');
+  const codexConfigResult = ensureCodexConfigToml(codexConfigPath);
+  if (codexConfigResult.changed) {
+    (codexConfigResult.exists ? updatedFiles : createdFiles).push(codexConfigPath);
+  }
+
   const localCandidates = [
     path.join(baseDir, '.claude', 'settings.local.json'),
     path.join(baseDir, '.claude', 'setting.local.json'),

package/lib/skills_prompt.js

@@ -81,11 +81,50 @@ async function promptForScope() {
   }
 }
 
+async function promptYesNo(message) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  try {
+    process.stderr.write(`${message} [y/N]\n`);
+    const answer = String(await new Promise((resolve) => {
+      rl.question('> ', resolve);
+    })).trim().toLowerCase();
+    return answer === 'y' || answer === 'yes';
+  } finally {
+    rl.close();
+  }
+}
+
+async function promptForText(message, defaultValue = '') {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  try {
+    process.stderr.write(`${message}\n`);
+    if (defaultValue) {
+      process.stderr.write(`Current value: ${defaultValue}\n`);
+    }
+    const answer = await new Promise((resolve) => {
+      rl.question('> ', resolve);
+    });
+    return String(answer).trim();
+  } finally {
+    rl.close();
+  }
+}
+
 module.exports = {
   SCOPE_CHOICES,
   TOOL_CHOICES,
   normalizeChoiceInput,
   normalizeCsvInput,
   promptForScope,
+  promptForText,
   promptForTools,
+  promptYesNo,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ronds_ai",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "CLI for reporting AI code edit events.",
   "bin": {
     "ronds_ai": "bin/ronds_ai.js"