gitdone-agent 0.7.6 → 0.8.0

package/index.js

@@ -13,6 +13,7 @@ import { execSync, execFileSync, spawn } from 'node:child_process'
 import {
   existsSync, writeFileSync, readFileSync, unlinkSync, renameSync,
   mkdirSync, copyFileSync, appendFileSync, readdirSync, rmSync, statSync,
+  openSync, writeSync, fsyncSync, closeSync, readSync,
 } from 'node:fs'
 import { resolve, join } from 'node:path'
 import { homedir, hostname, tmpdir } from 'node:os'
@@ -27,10 +28,12 @@ import { randomUUID, createHash } from 'node:crypto'
 // Reported to the server on every sync so the web UI can flag outdated agents.
 // Keep in lockstep with packages/agent/package.json "version" AND
 // src/lib/agentVersion.ts LATEST_AGENT_VERSION.
-const AGENT_VERSION = '0.7.6'
+const AGENT_VERSION = '0.8.0'
 
 const AGENT_DIR = join(homedir(), '.gitdone-agent')
 const CONFIG_PATH = join(AGENT_DIR, 'config.json')
+// Last-known-good copy of config.json, refreshed once per successful start.
+const CONFIG_BAK_PATH = CONFIG_PATH + '.bak'
 const STABLE_AGENT = join(AGENT_DIR, 'agent.mjs')
 const LOG_PATH = join(AGENT_DIR, 'agent.log')
 
@@ -80,20 +83,98 @@ function survive(kind, err) {
 process.on('uncaughtException', (err) => survive('uncaught exception', err))
 process.on('unhandledRejection', (err) => survive('unhandled rejection', err))
 
-function readConfig() {
-  try { return JSON.parse(readFileSync(CONFIG_PATH, 'utf8')) } catch { return null }
+function parseConfigFile(path) {
+  try {
+    // Strip a UTF-8 BOM: we never write one, but a config repaired by hand in an
+    // editor that adds one would otherwise be unparsable — and "I fixed the file
+    // and it still says no config" is the worst possible dead end (gd-478).
+    const cfg = JSON.parse(readFileSync(path, 'utf8').replace(/^/, ''))
+    return cfg && typeof cfg === 'object' && cfg.key ? cfg : null
+  } catch { return null }
+}
+
+// Rebuild the bare minimum from ai-mcp-config.json — last resort when both
+// config.json and its backup are gone. It is written from cfg.key/cfg.machineId
+// on every AI session, so it carries the two values that cannot be regenerated
+// locally (a new machineId would show up as a SECOND machine on the server, and
+// there is no way to invent the API key). Roots are lost, but an agent that is
+// online with no roots can be fixed from the web UI; an offline one cannot.
+function recoverConfigFromAiMcp() {
+  try {
+    const mcp = JSON.parse(readFileSync(join(AGENT_DIR, 'ai-mcp-config.json'), 'utf8'))
+    const server = mcp?.mcpServers?.gitdone
+    const key = server?.headers?.Authorization?.replace(/^Bearer\s+/, '')
+    const machineId = server?.headers?.['X-Gitdone-Machine-Id']
+    if (!key || !machineId || !server.url) return null
+    return {
+      key,
+      url: server.url.replace(/\/api\/mcp\/?$/, ''),
+      interval: 30,
+      machineId,
+      hostname: hostname(),
+      roots: [],
+    }
+  } catch { return null }
 }
 
+// True when the running config had to be rebuilt — surfaced by --doctor.
+let configWasRecovered = null
+
+// An unclean shutdown (power loss, BSOD) can leave config.json committed by the
+// filesystem as a NUL-filled file of the right length: intact on disk, garbage
+// to JSON.parse. Before gd-478 that bricked the agent for good — every autostart
+// exited with "no config found" and the supervisor just respawned it every 10s,
+// so the machine stayed offline until somebody hand-edited the file. A user
+// without filesystem access had no way out at all. So never trust the primary
+// copy blindly: fall back to the last-known-good backup, then to the AI MCP
+// config, and put whichever survived back in place.
+function readConfig() {
+  const primary = parseConfigFile(CONFIG_PATH)
+  if (primary) return primary
+  // Nothing to recover from on a fresh machine (install path) — stay quiet.
+  if (!existsSync(CONFIG_PATH) && !existsSync(CONFIG_BAK_PATH)) return null
+
+  for (const [source, cfg] of [
+    ['config.json.bak', parseConfigFile(CONFIG_BAK_PATH)],
+    ['ai-mcp-config.json', recoverConfigFromAiMcp()],
+  ]) {
+    if (!cfg) continue
+    configWasRecovered = source
+    log(`✗ config.json е повреден (най-вероятно от неочаквано изключване) — възстановен от ${source}`)
+    try { writeConfig(cfg) } catch (err) { log(`✗ записът на възстановения config не успя: ${err.message}`) }
+    return cfg
+  }
+  log('✗ config.json е повреден и няма от какво да се възстанови — пусни gitdone-agent --key=... --root=... --install')
+  return null
+}
+
+// Atomic AND durable: write to a temp file, force it to the platter, and only
+// then rename over the real one. The fsync is the part that matters — without
+// it the rename can be committed while the data is still in the page cache, and
+// a power cut in that window is exactly what produced the NUL-filled config in
+// gd-478. Losing the rename is harmless (the old config survives); losing the
+// data is not.
 function writeConfig(cfg) {
   ensureAgentDir()
-  // Write-then-rename so a crash / reboot mid-write can never leave a truncated
-  // config.json — a corrupt config makes every subsequent autostart exit
-  // immediately, which reads as "агентът умря и рестартът не помага" (gd-403).
   const tmp = CONFIG_PATH + '.tmp'
-  writeFileSync(tmp, JSON.stringify(cfg, null, 2), 'utf8')
+  const fd = openSync(tmp, 'w')
+  try {
+    writeSync(fd, JSON.stringify(cfg, null, 2), null, 'utf8')
+    fsyncSync(fd)
+  } finally {
+    closeSync(fd)
+  }
   renameSync(tmp, CONFIG_PATH)
 }
 
+// Refresh the last-known-good copy. Called once per successful start, so the
+// backup is always a config that actually booted the agent — never a half-baked
+// one. Best-effort: a failed backup must not stop the agent from running.
+function backupConfig(cfg) {
+  try { writeFileSync(CONFIG_BAK_PATH, JSON.stringify(cfg, null, 2), 'utf8') }
+  catch (err) { log(`✗ backup на config.json не успя: ${err.message}`) }
+}
+
 // ─── Arg parsing ─────────────────────────────────────────────────────────────
 
 function parseArgs() {
@@ -148,42 +229,65 @@ function getNodePath() {
   return process.execPath
 }
 
-// Locate the Claude Code CLI. Prefer a real executable (claude.exe from the
-// native installer) so spawn works WITHOUT a shell — that lets us pass a
+// Locate an agentic CLI on this machine. Prefer a real executable (the native
+// installer's .exe) so spawn works WITHOUT a shell — that lets us pass a
 // multi-line, non-ASCII prompt as a single argv element with no escaping. An
-// npm shim (claude.cmd) needs shell:true, where we collapse the prompt to one
-// line to survive cmd.exe parsing. Returns `found:false` when nothing was
-// located, so callers can show a clear message instead of spawning bare
-// `claude` and letting cmd.exe emit "'claude' is not recognized…".
-function findClaude() {
+// npm shim (.cmd) needs shell:true, where we collapse the prompt to one line to
+// survive cmd.exe parsing. Returns `found:false` when nothing was located, so
+// callers can show a clear message instead of spawning the bare name and letting
+// cmd.exe emit "'…' is not recognized…".
+//
+// `wellKnown` lists install locations to probe directly: the agent is
+// auto-started at login, so its PATH is frozen at that moment — a CLI installed
+// (or a PATH entry added) afterwards is invisible to `where`/`which`. Probing
+// makes a freshly-installed CLI work without a Windows re-login.
+function findCli(bin, wellKnown) {
   const tryCmd = (c) => {
     try {
       const out = execSync(c, { encoding: 'utf8' }).trim()
       return out ? out.split(/\r?\n/).map((s) => s.trim()).filter(Boolean) : []
     } catch { return [] }
   }
-  const cands = [...tryCmd('where claude'), ...tryCmd('which claude')]
+  const cands = [...tryCmd(`where ${bin}`), ...tryCmd(`which ${bin}`)]
+  for (const p of wellKnown) {
+    if (existsSync(p) && !cands.includes(p)) cands.push(p)
+  }
 
-  // The agent is auto-started at login, so its PATH is frozen at that moment —
-  // a `claude` installed (or a PATH entry added) afterwards is invisible to
-  // `where`/`which` above. Probe the well-known install locations directly so a
-  // freshly-installed CLI works without a Windows re-login.
+  const exe = cands.find((p) => /\.exe$/i.test(p))
+  if (exe) return { path: exe, shell: false, found: true }
+  if (cands.length) return { path: cands[0], shell: true, found: true }
+  return { path: bin, shell: true, found: false }
+}
+
+// Locate the Claude Code CLI.
+function findClaude() {
   const home = homedir()
   const appData = process.env.APPDATA || join(home, 'AppData', 'Roaming')
-  for (const p of [
+  return findCli('claude', [
     join(home, '.local', 'bin', 'claude.exe'), // Windows native installer
     join(appData, 'npm', 'claude.cmd'),        // Windows npm global shim
     join(home, '.local', 'bin', 'claude'),     // macOS/Linux native installer
     '/usr/local/bin/claude',                   // Homebrew (Intel) / manual install
     '/opt/homebrew/bin/claude',                // Homebrew (Apple silicon)
-  ]) {
-    if (existsSync(p) && !cands.includes(p)) cands.push(p)
-  }
+  ])
+}
 
-  const exe = cands.find((p) => /\.exe$/i.test(p))
-  if (exe) return { path: exe, shell: false, found: true }
-  if (cands.length) return { path: cands[0], shell: true, found: true }
-  return { path: 'claude', shell: true, found: false }
+// Locate the OpenAI Codex CLI — the ChatGPT-side engine (gd-491). Same rules as
+// findClaude; the Codex binary ships as a Rust executable (native installer /
+// cargo / Homebrew) or as the `@openai/codex` npm global.
+function findCodex() {
+  const home = homedir()
+  const appData = process.env.APPDATA || join(home, 'AppData', 'Roaming')
+  return findCli('codex', [
+    join(home, '.codex', 'bin', 'codex.exe'),  // Windows native installer
+    join(home, '.local', 'bin', 'codex.exe'),
+    join(appData, 'npm', 'codex.cmd'),         // Windows npm global shim
+    join(home, '.codex', 'bin', 'codex'),      // macOS/Linux native installer
+    join(home, '.local', 'bin', 'codex'),
+    join(home, '.cargo', 'bin', 'codex'),      // cargo install
+    '/usr/local/bin/codex',                    // Homebrew (Intel) / manual install
+    '/opt/homebrew/bin/codex',                 // Homebrew (Apple silicon)
+  ])
 }
 
 // ─── Single instance (gd-407) ─────────────────────────────────────────────────
@@ -458,11 +562,18 @@ function runDoctor() {
   let hb = '(none yet)'
   try { hb = `(последен: преди ${Math.round((Date.now() - statSync(HEARTBEAT_PATH).mtimeMs) / 1000)}s)` } catch { /* no beat yet */ }
   console.log(`  heartbeat     : ${HEARTBEAT_PATH} ${hb}`)
-  console.log(`  config        : ${CONFIG_PATH} ${existsSync(CONFIG_PATH) ? '(ok)' : '(MISSING)'}`)
+  // cfg comes from readConfig() above, so a corrupt config.json has already been
+  // repaired by the time we print this — say so rather than a bare "(ok)".
+  const cfgState = configWasRecovered ? `(ВЪЗСТАНОВЕН от ${configWasRecovered} — беше повреден)`
+    : cfg ? '(ok)' : existsSync(CONFIG_PATH) ? '(ПОВРЕДЕН)' : '(MISSING)'
+  console.log(`  config        : ${CONFIG_PATH} ${cfgState}`)
+  console.log(`  config backup : ${CONFIG_BAK_PATH} ${parseConfigFile(CONFIG_BAK_PATH) ? '(ok)' : '(няма — прави се при първия успешен старт)'}`)
   console.log(`  log file      : ${LOG_PATH} ${existsSync(LOG_PATH) ? '(ok)' : '(none yet)'}`)
   console.log(`  crash log     : ${join(AGENT_DIR, 'agent-crash.log')} ${existsSync(join(AGENT_DIR, 'agent-crash.log')) ? '(има записи — виж го при проблеми)' : '(празен — няма крашове)'}`)
   const claude = findClaude()
   console.log(`  claude cli    : ${claude.found ? claude.path : 'NOT FOUND — инсталирай от claude.ai/code и рестартирай агента'}`)
+  const codex = findCodex()
+  console.log(`  codex cli     : ${codex.found ? codex.path : 'NOT FOUND — нужен само за проекти с АИ = ChatGPT (npm i -g @openai/codex + codex login)'}`)
   if (cfg) {
     console.log(`  machineId     : ${cfg.machineId}`)
     console.log(`  server        : ${cfg.url}`)
@@ -1058,6 +1169,162 @@ function parseStreamLine(line, push, onInit, onDelta, onMeta, onTurnEnd) {
   }
 }
 
+// ─── Codex (ChatGPT) event stream (gd-491) ───────────────────────────────────
+// `codex exec --json` emits JSON Lines with a different vocabulary than Claude's
+// stream-json, so it gets its own parser behind the SAME callback contract
+// (push / onInit / onDelta / onMeta / onTurnEnd) — everything downstream (the
+// console flushers, the run/session posters) then works unchanged.
+//
+// Events: thread.started (thread_id — the id we resume with), turn.started,
+// turn.completed (usage), turn.failed, item.started|updated|completed (the work
+// itself), error. Item types: agent_message, reasoning, command_execution,
+// file_change, mcp_tool_call, web_search, todo_list.
+//
+// Field access is deliberately forgiving (several spellings per field): the
+// Codex CLI is explicitly experimental and has renamed stream fields between
+// releases, and an unknown shape must degrade to "shows less in the console",
+// never to a crashed turn.
+
+// Compact one item into the console's TOOL_CALL one-liner.
+function codexItemText(item) {
+  const type = item?.type
+  if (type === 'command_execution') {
+    const cmd = item.command ?? item.cmd ?? ''
+    const arr = Array.isArray(cmd) ? cmd.join(' ') : String(cmd)
+    return arr ? `Bash ${arr.slice(0, 400)}` : 'Bash'
+  }
+  if (type === 'file_change') {
+    const changes = item.changes ?? item.files ?? []
+    const names = (Array.isArray(changes) ? changes : [])
+      .map((c) => (typeof c === 'string' ? c : c?.path ?? c?.file ?? ''))
+      .filter(Boolean)
+    return names.length ? `Edit ${names.slice(0, 8).join(', ').slice(0, 400)}` : 'Edit'
+  }
+  if (type === 'mcp_tool_call') {
+    const server = item.server ?? item.server_name ?? ''
+    const tool = item.tool ?? item.tool_name ?? item.name ?? ''
+    const args = item.arguments ?? item.args ?? item.input
+    const argStr = args ? ` ${(typeof args === 'string' ? args : JSON.stringify(args)).slice(0, 300)}` : ''
+    return `${[server, tool].filter(Boolean).join('__') || 'mcp'}${argStr}`
+  }
+  if (type === 'web_search') {
+    const q = item.query ?? item.q ?? ''
+    return `WebSearch${q ? ` ${String(q).slice(0, 300)}` : ''}`
+  }
+  if (type === 'todo_list') {
+    const items = item.items ?? item.todos ?? []
+    const names = (Array.isArray(items) ? items : [])
+      .map((t) => (typeof t === 'string' ? t : t?.text ?? t?.title ?? ''))
+      .filter(Boolean)
+    return names.length ? `TodoWrite\n${names.map((n) => `- ${n}`).join('\n').slice(0, 800)}` : 'TodoWrite'
+  }
+  return null
+}
+
+// Raw output of a finished tool item — the Codex counterpart of the PostToolUse
+// hook we register for Claude (Codex has no hook mechanism, but it puts the
+// output right in the item, which is better).
+function codexItemResult(item) {
+  if (item?.type === 'command_execution') {
+    const out = item.aggregated_output ?? item.output ?? item.stdout ?? ''
+    const code = item.exit_code ?? item.exitCode
+    const text = String(out || '').slice(0, 2000)
+    if (!text && code == null) return null
+    return `${text}${code != null ? `\n(exit ${code})` : ''}`.trim()
+  }
+  // A failed gitdone MCP call is worth seeing: it's how the AI drives the task,
+  // so silence here would leave the board unmoved with no visible reason.
+  if (item?.type === 'mcp_tool_call' && item.error) {
+    const msg = typeof item.error === 'string' ? item.error : item.error.message ?? JSON.stringify(item.error)
+    return `✗ ${String(msg).slice(0, 500)}`
+  }
+  return null
+}
+
+function parseCodexLine(line, push, onInit, onDelta, onMeta, onTurnEnd) {
+  let ev
+  try { ev = JSON.parse(line) } catch { return }
+  // Valid JSON that isn't an object (`null`, `[]`, a bare number) must not throw:
+  // this runs inside the child's stdout handler, where an exception is uncaught
+  // and would take down the whole agent process.
+  if (!ev || typeof ev !== 'object') return
+  const type = ev.type ?? ev.event ?? ''
+
+  if (type === 'thread.started') {
+    const id = ev.thread_id ?? ev.threadId ?? ev.id
+    push('SYSTEM', 'Сесия стартирана (Codex).')
+    // The thread id is what `codex exec resume <id>` continues — the Codex
+    // equivalent of claude's session id, stored in the same column.
+    if (id && typeof onInit === 'function') onInit(id)
+    return
+  }
+
+  if (type === 'item.started' || type === 'item.updated' || type === 'item.completed') {
+    const item = ev.item ?? ev
+    const itemType = item?.type
+
+    // The model's own prose. Only the completed item is final; the in-flight
+    // updates drive the live "being typed" preview, like Claude's text deltas.
+    if (itemType === 'agent_message') {
+      const text = item.text ?? item.message ?? item.content ?? ''
+      if (type === 'item.completed') {
+        if (String(text).trim()) push('TEXT', String(text).trim())
+      } else if (typeof onDelta === 'function' && text) {
+        // Codex sends the whole message so far (not a delta) — replace rather
+        // than append, or the preview would repeat itself as it grows.
+        onDelta(String(text), 'text-replace')
+      }
+      return
+    }
+
+    // Reasoning → the gray „какво прави АИ-то" line.
+    if (itemType === 'reasoning') {
+      const text = item.text ?? item.summary ?? item.content ?? ''
+      if (typeof onDelta === 'function' && text) {
+        onDelta('', 'thinking-start')
+        onDelta(String(text), 'thinking')
+      }
+      return
+    }
+
+    // Tools: announce on start, show raw output on completion.
+    if (type === 'item.started') {
+      const text = codexItemText(item)
+      if (text) push('TOOL_CALL', text)
+    } else if (type === 'item.completed') {
+      const result = codexItemResult(item)
+      if (result) push('TOOL_RESULT', result)
+    }
+    return
+  }
+
+  if (type === 'turn.completed') {
+    const u = ev.usage ?? ev.turn?.usage
+    if (u && typeof onMeta === 'function') {
+      onMeta({
+        usage: {
+          inputTokens: u.input_tokens ?? u.inputTokens ?? 0,
+          outputTokens: u.output_tokens ?? u.outputTokens ?? 0,
+          cacheReadTokens: u.cached_input_tokens ?? u.cachedInputTokens ?? 0,
+          cacheCreateTokens: 0,
+        },
+      })
+    }
+    if (typeof onTurnEnd === 'function') onTurnEnd('success')
+    return
+  }
+
+  if (type === 'turn.failed' || type === 'error') {
+    const err = ev.error ?? ev.message ?? ev
+    const text = typeof err === 'string' ? err : err?.message ?? JSON.stringify(err).slice(0, 500)
+    push('SYSTEM', `✗ ${text}`)
+    // Feed the failure text to the usage-limit detector, same as Claude's
+    // result text — a ChatGPT quota stop parks the task the same way.
+    if (typeof onMeta === 'function') onMeta({ subtype: 'error', resultText: text })
+    if (typeof onTurnEnd === 'function') onTurnEnd('error')
+  }
+}
+
 // Phase 2: write (once) a PostToolUse hook that forwards each tool's raw output
 // (Bash stdout, edit results, …) to the run's console, plus the settings file
 // that registers it. The hook reads GITDONE_* from its env (set per run on the
@@ -1196,64 +1463,155 @@ function aiModelArg(raw) {
   return /^[A-Za-z0-9._-]+$/.test(m) ? m : null
 }
 
-// Run a headless Claude Code session for an `ai_run` command and stream its
-// output back. Long-running and fire-and-forget: it wires up async handlers and
-// returns immediately so the agent's snapshot loop is never blocked.
+// Which CLI a command asks for (gd-491). Anything unknown — including the
+// missing field sent by a gitDone older than gd-491 — means Claude, which is
+// what every run was before this existed.
+function aiProviderArg(raw) {
+  return raw === 'codex' ? 'codex' : 'claude'
+}
+
+function cliNotFoundMessage(provider, hostname) {
+  return provider === 'codex'
+    ? `Codex CLI (ChatGPT) не е намерен на този компютър (${hostname}). Инсталирай го (npm i -g @openai/codex), влез с ChatGPT акаунт през „codex login", увери се, че „codex" е в PATH, после рестартирай агента.`
+    : `Claude Code CLI не е намерен на този компютър (${hostname}). Инсталирай го от claude.ai/code и се увери, че „claude" е в PATH, после рестартирай агента.`
+}
+
+// Argument list for one `codex exec` run (gd-491).
+//
+// Notes on the choices here:
+//  • `-` makes Codex read the prompt from STDIN — same reason as Claude's `-p`
+//    on stdin: a multi-line Cyrillic prompt survives the npm .cmd shim intact.
+//  • `--json` is the JSONL event stream parseCodexLine consumes.
+//  • `--sandbox workspace-write` matches Claude's `--permission-mode acceptEdits`:
+//    the AI may edit the repo it was pointed at, but not roam the machine.
+//  • `--skip-git-repo-check` — the repo IS a git repo, but a fresh clone/worktree
+//    without a commit would otherwise abort the run.
+//  • MCP: Codex has no `--mcp-config`; the documented route is config overrides,
+//    so we inject the gitdone HTTP MCP server with `-c` dotted keys. The bearer
+//    token is passed by ENV VAR NAME (bearer_token_env_var), so the agent's key
+//    never lands in the process command line where other users could read it.
+//
+// The commit policy is NOT here: Codex has no tool-level deny list to mirror
+// Claude's --disallowedTools, so it rides along in the prompt (codexPrompt).
+function codexExecArgs(cfg, opts) {
+  const { model, resumeId } = opts
+  const flags = [
+    '--json',
+    '--skip-git-repo-check',
+    // Why the alarming flag: in `codex exec` there is NO approval handler (stdin
+    // carries the prompt, not answers), so EVERY MCP tool call is auto-denied
+    // with "user cancelled MCP tool call" — verified here against codex 0.146,
+    // and tracked upstream as openai/codex#24135 and #16685. Neither
+    // `-a never`, `-c approval_policy="never"` nor a sandbox mode changes it;
+    // this flag is the only thing that lets an MCP call through. Without it the
+    // gitdone MCP is dead weight and a ChatGPT run cannot register its agents or
+    // move its own task — the entire point of dispatching it.
+    //
+    // It is not a step down from how this agent already runs Claude: that path
+    // uses `--permission-mode acceptEdits` with Bash allowed and no OS sandbox,
+    // so both engines have the same reach on the machine. Revisit once the
+    // upstream issue lands — the sandbox is worth having back.
+    //
+    // (`--sandbox` is deliberately NOT used: it exists only on plain `exec`, and
+    // `codex exec resume` — a subcommand with its own smaller flag set — rejects
+    // it, which killed every resumed turn with "unexpected argument".)
+    '--dangerously-bypass-approvals-and-sandbox',
+    ...(model ? ['--model', model] : []),
+    '-c', `mcp_servers.gitdone.url="${cfg.url}/api/mcp"`,
+    '-c', 'mcp_servers.gitdone.bearer_token_env_var="GITDONE_KEY"',
+    // Tags the AI agents this run registers with THIS computer (gd-308).
+    '-c', `mcp_servers.gitdone.http_headers.X-Gitdone-Machine-Id="${cfg.machineId}"`,
+  ]
+  // `-` = read the prompt from stdin, and it must be the LAST positional:
+  //   codex exec        [OPTIONS] [PROMPT]
+  //   codex exec resume [OPTIONS] [SESSION_ID] [PROMPT]
+  // Continuing a thread is how a console session keeps its context across turns,
+  // and how a token-limit park resumes (gd-466 semantics, Codex spelling).
+  return resumeId
+    ? ['exec', 'resume', ...flags, resumeId, '-']
+    : ['exec', ...flags, '-']
+}
+
+// Claude gets the repo's commit policy enforced by `--disallowedTools`; Codex
+// has no equivalent deny list, so the same policy is stated in the prompt. Weaker
+// (an instruction, not a hard block) — hence it's spelled out unmistakably.
+function codexPrompt(prompt, allowCommit) {
+  if (allowCommit) return prompt
+  return `${prompt}\n\n[ВАЖНО: в това repo НЕ ти е позволено да правиш git commit или git push. Остави промените некомитнати — човекът ги преглежда и комитва сам.]`
+}
+
+// Run a headless AI session for an `ai_run` command and stream its output back.
+// Long-running and fire-and-forget: it wires up async handlers and returns
+// immediately so the agent's snapshot loop is never blocked. The engine is
+// whichever CLI the task's project picked — Claude Code or Codex (gd-491); the
+// streaming/exit machinery below is shared, only the spawn + parser differ.
 function runAiCommand(cfg, cmd, repoPath) {
   const runId = cmd.payload?.runId
   const prompt = cmd.payload?.prompt ?? ''
   const allowCommit = cmd.payload?.allowCommit === true
   const model = aiModelArg(cmd.payload?.model)
-  // gd-466: a token-reset resume asks us to continue claude's own conversation.
+  const provider = aiProviderArg(cmd.payload?.provider)
+  const isCodex = provider === 'codex'
+  // gd-466: a token-reset resume asks us to continue the CLI's own conversation.
   const resumeId = cmd.payload?.resume || null
   if (!runId || !prompt) {
     reportCommandResult(cfg, cmd.id, 'error', 'invalid ai_run payload')
     return
   }
 
-  const { path: claudePath, shell, found } = findClaude()
+  const { path: cliPath, shell, found } = isCodex ? findCodex() : findClaude()
   if (!found) {
-    const msg = `Claude Code CLI не е намерен на този компютър (${cfg.hostname}). Инсталирай го от claude.ai/code и се увери, че „claude" е в PATH, после рестартирай агента.`
-    log(`✗ ai_run ${runId}: claude not found`)
-    postRunEvents(cfg, runId, [{ kind: 'SYSTEM', text: `✗ ${msg}` }], 'error', 'claude not found')
-    reportCommandResult(cfg, cmd.id, 'error', 'claude not found')
+    const msg = cliNotFoundMessage(provider, cfg.hostname)
+    log(`✗ ai_run ${runId}: ${provider} not found`)
+    postRunEvents(cfg, runId, [{ kind: 'SYSTEM', text: `✗ ${msg}` }], 'error', `${provider} not found`)
+    reportCommandResult(cfg, cmd.id, 'error', `${provider} not found`)
     return
   }
 
+  // Claude-only: the PostToolUse hook + MCP config files. Codex reports tool
+  // output inline in its own stream and takes MCP via `-c` overrides.
   let settingsPath
-  try { settingsPath = ensureAiHookFiles() } catch (e) { log(`✗ ai hook setup failed: ${e.message}`) }
   let mcpConfigPath
-  try { mcpConfigPath = ensureAiMcpConfig(cfg) } catch (e) { log(`✗ ai mcp config setup failed: ${e.message}`) }
+  if (!isCodex) {
+    try { settingsPath = ensureAiHookFiles() } catch (e) { log(`✗ ai hook setup failed: ${e.message}`) }
+    try { mcpConfigPath = ensureAiMcpConfig(cfg) } catch (e) { log(`✗ ai mcp config setup failed: ${e.message}`) }
+  }
 
   // The prompt is delivered on STDIN, not as a `-p <arg>` command-line value.
   // A multi-line, non-ASCII (Cyrillic) prompt passed as an argv element gets
   // mangled under the claude.cmd npm shim (shell:true → cmd.exe splits/strips
   // it), so Claude received no prompt and fell back to an empty stdin
   // ("no stdin data received…"), then ran blind off whatever was in the repo.
-  // Piping it to stdin is robust for both the native exe and the shim.
-  const args = [
-    '-p',
-    '--output-format', 'stream-json',
-    '--verbose',
-    // Stream text token-by-token + thinking deltas so the terminal shows the
-    // reply being written live, ред по ред, not in whole-block batches (gd-419).
-    '--include-partial-messages',
-    // gd-466: resume claude's own prior conversation for this task when we're
-    // continuing after a token reset — it keeps its context/todo. A stale/missing
-    // session errors out fast; the watchdog then re-dispatches fresh (no resume).
-    ...(resumeId ? ['--resume', resumeId] : []),
-    // Model chosen in gitDone (project default / task); omitted → machine default (gd-354).
-    ...(model ? ['--model', model] : []),
-    '--permission-mode', 'acceptEdits',
-    '--allowedTools', 'Read,Edit,Write,Bash,mcp__gitdone__*',
-    // Block git commit/push unless this repo opted in (per-repo aiAutoCommit).
-    ...(allowCommit ? [] : ['--disallowedTools', 'Bash(git commit *),Bash(git push *)']),
-    ...(settingsPath ? ['--settings', settingsPath] : []),
-    // Our own gitdone MCP, tagged with this machine (gd-308).
-    ...(mcpConfigPath ? ['--mcp-config', mcpConfigPath, '--strict-mcp-config'] : []),
-  ]
+  // Piping it to stdin is robust for both the native exe and the shim; `codex
+  // exec -` reads its prompt from stdin the same way.
+  const args = isCodex
+    ? codexExecArgs(cfg, { model, resumeId })
+    : [
+        '-p',
+        '--output-format', 'stream-json',
+        '--verbose',
+        // Stream text token-by-token + thinking deltas so the terminal shows the
+        // reply being written live, ред по ред, not in whole-block batches (gd-419).
+        '--include-partial-messages',
+        // gd-466: resume claude's own prior conversation for this task when we're
+        // continuing after a token reset — it keeps its context/todo. A stale/missing
+        // session errors out fast; the watchdog then re-dispatches fresh (no resume).
+        ...(resumeId ? ['--resume', resumeId] : []),
+        // Model chosen in gitDone (project default / task); omitted → machine default (gd-354).
+        ...(model ? ['--model', model] : []),
+        '--permission-mode', 'acceptEdits',
+        '--allowedTools', 'Read,Edit,Write,Bash,mcp__gitdone__*',
+        // Block git commit/push unless this repo opted in (per-repo aiAutoCommit).
+        ...(allowCommit ? [] : ['--disallowedTools', 'Bash(git commit *),Bash(git push *)']),
+        ...(settingsPath ? ['--settings', settingsPath] : []),
+        // Our own gitdone MCP, tagged with this machine (gd-308).
+        ...(mcpConfigPath ? ['--mcp-config', mcpConfigPath, '--strict-mcp-config'] : []),
+      ]
+
+  const parseLine = isCodex ? parseCodexLine : parseStreamLine
 
   // The PostToolUse hook reads these from its env to post raw tool output.
+  // GITDONE_KEY doubles as the bearer token for Codex's MCP client (gd-491).
   const childEnv = { ...process.env, GITDONE_URL: cfg.url, GITDONE_KEY: cfg.key, GITDONE_RUN_ID: runId }
 
   // Batch events on a timer so we don't hammer the server per token/line.
@@ -1293,6 +1651,8 @@ function runAiCommand(cfg, cmd, repoPath) {
     if (type === 'thinking-start') { liveActivity = ''; return }
     // Keep only the tail — the freshest thought is what the gray line shows.
     if (type === 'thinking') { liveActivity = (liveActivity + chunk).slice(-4000); return }
+    // Codex resends the whole message-so-far rather than a delta (gd-491).
+    if (type === 'text-replace') { liveText = chunk; return }
     liveText += chunk
   }
   const timer = setInterval(flush, 500)
@@ -1317,12 +1677,12 @@ function runAiCommand(cfg, cmd, repoPath) {
   const onInit = (sid) => { if (sid) capturedSession = sid }
   let stderrBuf = ''
 
-  log(`▶ ai_run ${runId} @ ${repoPath} via ${claudePath}`)
-  postRunEvents(cfg, runId, [{ kind: 'SYSTEM', text: `Стартиране на Claude Code в ${repoPath}…` }], 'running')
+  log(`▶ ai_run ${runId} @ ${repoPath} via ${cliPath} (${provider})`)
+  postRunEvents(cfg, runId, [{ kind: 'SYSTEM', text: `Стартиране на ${isCodex ? 'Codex (ChatGPT)' : 'Claude Code'} в ${repoPath}…` }], 'running')
 
   let child
   try {
-    child = spawn(claudePath, args, { cwd: repoPath, shell, windowsHide: true, env: childEnv })
+    child = spawn(cliPath, args, { cwd: repoPath, shell, windowsHide: true, env: childEnv })
   } catch (err) {
     clearInterval(timer)
     postRunEvents(cfg, runId, [{ kind: 'SYSTEM', text: `Грешка при стартиране: ${err.message}` }], 'error', err.message)
@@ -1334,7 +1694,7 @@ function runAiCommand(cfg, cmd, repoPath) {
   // Swallow EPIPE in case the process exits before we finish writing.
   if (child.stdin) {
     child.stdin.on('error', () => {})
-    try { child.stdin.write(prompt); child.stdin.end() }
+    try { child.stdin.write(isCodex ? codexPrompt(prompt, allowCommit) : prompt); child.stdin.end() }
     catch (e) { push('SYSTEM', `stdin write failed: ${e.message}`) }
   }
 
@@ -1345,14 +1705,14 @@ function runAiCommand(cfg, cmd, repoPath) {
     while ((nl = buf.indexOf('\n')) >= 0) {
       const line = buf.slice(0, nl).trim()
       buf = buf.slice(nl + 1)
-      if (line) parseStreamLine(line, push, onInit, onDelta, onMeta)
+      if (line) parseLine(line, push, onInit, onDelta, onMeta)
     }
   })
   child.stderr.on('data', (d) => { const s = d.toString().trim(); if (s) { stderrBuf = (stderrBuf + '\n' + s).slice(-8000); push('SYSTEM', s) } })
   child.on('error', (err) => push('SYSTEM', `Процесна грешка: ${err.message}`))
   child.on('close', async (code) => {
     clearInterval(timer)
-    if (buf.trim()) parseStreamLine(buf.trim(), push, onInit, onDelta, onMeta)
+    if (buf.trim()) parseLine(buf.trim(), push, onInit, onDelta, onMeta)
     liveText = '' // run is over — drop any lingering live preview / thought
     liveActivity = ''
     await flush()
@@ -1421,6 +1781,17 @@ async function downloadSessionImages(sessionId, urls) {
   return { dir, paths }
 }
 
+// Point the AI at the images the user attached: neither CLI renders an image URL
+// off stdin, so they're downloaded locally and referenced by path for its Read
+// tool. Returns the prompt unchanged when nothing was attached (or every
+// download failed), so an image-only turn still says something.
+function withImageNote(prompt, paths) {
+  if (!paths || paths.length === 0) return prompt
+  const list = paths.map((p) => `- ${p}`).join('\n')
+  const note = `Потребителят прикачи ${paths.length} изображени${paths.length === 1 ? 'е' : 'я'}. Прегледай ги с Read tool от следните локални пътища:\n${list}`
+  return prompt ? `${prompt}\n\n[${note}]` : `[${note}]`
+}
+
 // ─── Persistent chat processes (gd-421) ───────────────────────────────────────
 // One long-lived `claude` process per chat session, keyed by sessionId.
 // Spawning a fresh CLI per turn (`claude -p --resume`) cost 5–15s of process
@@ -1624,6 +1995,105 @@ function killTree(child) {
   }
 }
 
+// Run one turn of a Codex (ChatGPT) chat session (gd-491).
+//
+// Unlike Claude, `codex exec` has no persistent stdin protocol — it runs ONE
+// turn and exits — so the gd-421 process pool doesn't apply: every turn spawns
+// its own process, continuing the conversation with `codex exec resume <thread>`
+// (the thread id we captured from the first turn). It still registers in
+// chatProcs under the same entry shape, so ai_chat_stop and the stuck-turn
+// sweeper keep working untouched.
+function runCodexChatTurn(cfg, cmd, repoPath, opts) {
+  const { sessionId, prompt, resumeId, model, allowCommit } = opts
+
+  const { path: codexPath, shell, found } = findCodex()
+  if (!found) {
+    const msg = cliNotFoundMessage('codex', cfg.hostname)
+    log(`✗ ai_chat ${sessionId}: codex not found`)
+    postSessionEvents(cfg, sessionId, [{ role: 'SYSTEM', text: `✗ ${msg}` }], 'error')
+    reportCommandResult(cfg, cmd.id, 'error', 'codex not found')
+    return
+  }
+
+  const args = codexExecArgs(cfg, { model, resumeId })
+  const childEnv = { ...process.env, GITDONE_URL: cfg.url, GITDONE_KEY: cfg.key, GITDONE_SESSION_ID: sessionId }
+
+  let child
+  try {
+    child = spawn(codexPath, args, { cwd: repoPath, shell, windowsHide: true, env: childEnv })
+  } catch (err) {
+    postSessionEvents(cfg, sessionId, [{ role: 'SYSTEM', text: `Грешка при стартиране: ${err.message}` }], 'error')
+    reportCommandResult(cfg, cmd.id, 'error', err.message)
+    return
+  }
+
+  const entry = {
+    sessionId, child, busy: true, stopped: false, lastUsedAt: Date.now(),
+    allowCommit, capturedSession: resumeId || null, turn: null,
+  }
+  chatProcs.set(sessionId, entry)
+  ensureChatSweep()
+
+  const push = (kind, text) => {
+    const t = entry.turn
+    if (!t || text == null || String(text) === '') return
+    if (kind === 'TEXT') t.liveText = ''
+    t.liveActivity = ''
+    t.pending.push({ kind, text: String(text) })
+  }
+  const onInit = (sid) => { if (sid && !entry.capturedSession) entry.capturedSession = sid }
+  const onDelta = (chunk, type) => {
+    const t = entry.turn
+    if (!t) return
+    if (type === 'thinking-start') { t.liveActivity = ''; return }
+    if (type === 'thinking') { t.liveActivity = (t.liveActivity + chunk).slice(-4000); return }
+    // Codex resends the whole message-so-far, not a delta — replace, or the
+    // preview would repeat itself as it grows.
+    if (type === 'text-replace') { t.liveText = chunk; return }
+    t.liveText += chunk
+  }
+  const onTurnEnd = () => { finishChatTurn(cfg, entry, { ok: true }) }
+
+  // Open the turn BEFORE writing the prompt so the earliest output is captured.
+  entry.turn = {
+    cmdId: cmd.id, imgDir: opts.imgDir, startedAt: Date.now(), timer: null, flushing: false,
+    pending: [], liveText: '', sentLive: '', liveActivity: '', sentActivity: '', lastPostAt: 0,
+  }
+  entry.turn.timer = setInterval(() => flushChatTurn(cfg, entry), 250)
+
+  if (child.stdin) {
+    child.stdin.on('error', () => {})
+    try { child.stdin.write(codexPrompt(prompt, allowCommit)); child.stdin.end() }
+    catch (e) { push('SYSTEM', `stdin write failed: ${e.message}`) }
+  }
+
+  let buf = ''
+  child.stdout.on('data', (d) => {
+    buf += d.toString()
+    let nl
+    while ((nl = buf.indexOf('\n')) >= 0) {
+      const line = buf.slice(0, nl).trim()
+      buf = buf.slice(nl + 1)
+      if (line) parseCodexLine(line, push, onInit, onDelta, undefined, onTurnEnd)
+    }
+  })
+  child.stderr.on('data', (d) => { const s = d.toString().trim(); if (s) push('SYSTEM', s) })
+  child.on('error', (err) => push('SYSTEM', `Процесна грешка: ${err.message}`))
+  child.on('close', async (code) => {
+    if (chatProcs.get(sessionId) === entry) chatProcs.delete(sessionId)
+    if (buf.trim()) parseCodexLine(buf.trim(), push, onInit, onDelta, undefined, onTurnEnd)
+    // `turn.completed` normally ends the turn just before the process exits, in
+    // which case entry.turn is already null and finishChatTurn no-ops. This is
+    // the fallback for a process that died without one.
+    if (entry.turn) {
+      await finishChatTurn(cfg, entry, entry.stopped ? { stopped: true } : code === 0 ? { ok: true } : { ok: false, code })
+    }
+    log(`■ ai_chat codex ${sessionId} приключи (code ${code})`)
+  })
+
+  log(`▶ ai_chat codex ход ${sessionId} @ ${repoPath} (resume=${resumeId ? 'yes' : 'no'}) via ${codexPath}`)
+}
+
 // Run one turn of an interactive chat session (gd-421): reuse the session's
 // persistent claude process when it's alive — the message is one stream-json
 // line on its stdin and the reply starts within seconds. Only the FIRST turn
@@ -1636,6 +2106,7 @@ async function runAiChat(cfg, cmd, repoPath) {
   const claudeSessionId = cmd.payload?.claudeSessionId || null
   const allowCommit = cmd.payload?.allowCommit === true
   const model = aiModelArg(cmd.payload?.model)
+  const provider = aiProviderArg(cmd.payload?.provider)
   // A turn may be text-only, image-only, or both — but needs at least one.
   if (!sessionId || (!prompt && images.length === 0)) {
     reportCommandResult(cfg, cmd.id, 'error', 'invalid ai_chat payload')
@@ -1658,10 +2129,26 @@ async function runAiChat(cfg, cmd, repoPath) {
     return
   }
 
+  // Codex (gd-491): one process per turn, prompt on stdin at spawn — so the
+  // images have to be on disk BEFORE we start it, unlike the Claude path where
+  // the message is written into an already-running process.
+  if (provider === 'codex') {
+    const dl = images.length > 0 ? await downloadSessionImages(sessionId, images) : null
+    runCodexChatTurn(cfg, cmd, repoPath, {
+      sessionId,
+      prompt: withImageNote(prompt, dl?.paths ?? []),
+      imgDir: dl?.dir ?? null,
+      resumeId: claudeSessionId,
+      model,
+      allowCommit,
+    })
+    return
+  }
+
   if (!entry) {
     const { path: claudePath, shell, found } = findClaude()
     if (!found) {
-      const msg = `Claude Code CLI не е намерен на този компютър (${cfg.hostname}). Инсталирай го от claude.ai/code и се увери, че „claude" е в PATH, после рестартирай агента.`
+      const msg = cliNotFoundMessage('claude', cfg.hostname)
       log(`✗ ai_chat ${sessionId}: claude not found`)
       postSessionEvents(cfg, sessionId, [{ role: 'SYSTEM', text: `✗ ${msg}` }], 'error')
       reportCommandResult(cfg, cmd.id, 'error', 'claude not found')
@@ -1682,17 +2169,13 @@ async function runAiChat(cfg, cmd, repoPath) {
   }
 
   // Fetch any attached images locally and fold their paths into the prompt so
-  // Claude reads them with its Read tool (URLs on stdin don't render).
+  // the AI reads them with its Read tool (URLs on stdin don't render).
   let imgDir = null
   let fullPrompt = prompt
   if (images.length > 0) {
     const dl = await downloadSessionImages(sessionId, images)
     imgDir = dl.dir
-    if (dl.paths.length > 0) {
-      const list = dl.paths.map((p) => `- ${p}`).join('\n')
-      const note = `Потребителят прикачи ${dl.paths.length} изображени${dl.paths.length === 1 ? 'е' : 'я'}. Прегледай ги с Read tool от следните локални пътища:\n${list}`
-      fullPrompt = prompt ? `${prompt}\n\n[${note}]` : `[${note}]`
-    }
+    fullPrompt = withImageNote(prompt, dl.paths)
   }
 
   // Open the turn BEFORE writing the message, so even the earliest output
@@ -1904,6 +2387,117 @@ async function readClaudeUsage() {
   }
 }
 
+// ─── Codex (ChatGPT) plan usage (gd-492) ───────────────────────────────────
+// Codex knows its own rate limits but does NOT put them in the `codex exec
+// --json` stdout stream (upstream openai/codex#14728). It DOES write them to the
+// session rollout it keeps on disk:
+//   ~/.codex/sessions/<YYYY>/<MM>/<DD>/rollout-<ts>-<thread>.jsonl
+// where `token_count` lines carry:
+//   payload.rate_limits = { primary: { used_percent, window_minutes, resets_at },
+//                           secondary: …|null, plan_type, credits, … }
+// So we read the newest rollout and take its LAST rate_limits record.
+//
+// Unlike the Claude numbers — fetched live from Anthropic on every tick — these
+// are only as fresh as the user's last Codex run, which is why we report the
+// rollout line's OWN timestamp as observedAt instead of "now". The console can
+// then say how old they are rather than implying they're live.
+
+// Newest entry in a dir, by name (the sessions tree is zero-padded YYYY/MM/DD,
+// so the lexicographic max IS the newest) or by mtime for the files themselves.
+function newestChild(dir, { dirs }) {
+  let entries
+  try { entries = readdirSync(dir, { withFileTypes: true }) } catch { return [] }
+  const wanted = entries.filter((e) => (dirs ? e.isDirectory() : e.isFile() && e.name.endsWith('.jsonl')))
+  if (dirs) return wanted.map((e) => e.name).sort().reverse().map((n) => join(dir, n))
+  return wanted
+    .map((e) => {
+      const p = join(dir, e.name)
+      try { return { p, t: statSync(p).mtimeMs } } catch { return { p, t: 0 } }
+    })
+    .sort((a, b) => b.t - a.t)
+    .map((x) => x.p)
+}
+
+// Rollout files hold the whole transcript, so read only the tail — the newest
+// token_count is at the end, and a long session can be megabytes.
+const CODEX_TAIL_BYTES = 256 * 1024
+function readTail(file, bytes) {
+  const size = statSync(file).size
+  const start = Math.max(0, size - bytes)
+  const len = size - start
+  if (len <= 0) return ''
+  const buf = Buffer.alloc(len)
+  const fd = openSync(file, 'r')
+  try { readSync(fd, buf, 0, len, start) } finally { closeSync(fd) }
+  const text = buf.toString('utf8')
+  // A tail read almost certainly starts mid-line — drop that partial first line
+  // so JSON.parse below isn't fed a fragment.
+  return start > 0 ? text.slice(text.indexOf('\n') + 1) : text
+}
+
+// One window of a Codex rate limit → the shape the server stores.
+function codexWindow(w) {
+  if (!w || typeof w !== 'object') return null
+  const pct = Number(w.used_percent)
+  if (!Number.isFinite(pct)) return null
+  // resets_at is epoch SECONDS here (Claude's endpoint returns an ISO string).
+  const resets = Number(w.resets_at)
+  return {
+    pct: Math.round(pct),
+    windowMin: Number.isFinite(Number(w.window_minutes)) ? Math.round(Number(w.window_minutes)) : null,
+    resetsAt: Number.isFinite(resets) && resets > 0 ? new Date(resets * 1000).toISOString() : null,
+  }
+}
+
+let codexUsageCache = { at: 0, data: null }
+function readCodexUsage() {
+  const now = Date.now()
+  if (codexUsageCache.data && now - codexUsageCache.at < 60_000) return codexUsageCache.data
+  try {
+    const root = join(homedir(), '.codex', 'sessions')
+    if (!existsSync(root)) return null
+    // Descend newest year → month → day. Check a few of the newest day folders,
+    // since the very newest could be empty (a crashed/cleaned run).
+    let dayDirs = []
+    for (const y of newestChild(root, { dirs: true }).slice(0, 2)) {
+      for (const m of newestChild(y, { dirs: true }).slice(0, 2)) {
+        dayDirs.push(...newestChild(m, { dirs: true }).slice(0, 3))
+        if (dayDirs.length >= 3) break
+      }
+      if (dayDirs.length >= 3) break
+    }
+    for (const day of dayDirs.slice(0, 3)) {
+      for (const file of newestChild(day, { dirs: false }).slice(0, 3)) {
+        const lines = readTail(file, CODEX_TAIL_BYTES).split('\n')
+        // Walk backwards: the freshest rate_limits wins.
+        for (let i = lines.length - 1; i >= 0; i--) {
+          const line = lines[i].trim()
+          if (!line || !line.includes('rate_limits')) continue
+          let ev
+          try { ev = JSON.parse(line) } catch { continue }
+          const rl = ev?.payload?.rate_limits
+          if (!rl || typeof rl !== 'object') continue
+          const primary = codexWindow(rl.primary)
+          const secondary = codexWindow(rl.secondary)
+          if (!primary && !secondary) continue
+          const data = {
+            primary,
+            secondary,
+            planType: typeof rl.plan_type === 'string' ? rl.plan_type : null,
+            // When these numbers were actually true — the run that produced them.
+            observedAt: typeof ev.timestamp === 'string' ? ev.timestamp : new Date(statSync(file).mtimeMs).toISOString(),
+          }
+          codexUsageCache = { at: now, data }
+          return data
+        }
+      }
+    }
+    return null
+  } catch {
+    return null // no codex / unreadable rollout — stay quiet, same as Claude's
+  }
+}
+
 // The discovered repo list barely ever changes, but re-upserting every repo's
 // row on the server each tick is pure idle write load at scale. So we ship the
 // full `repos` list only when the discovered set actually changed, or every
@@ -1917,6 +2511,9 @@ let syncFullCountdown = 0
 
 async function sync(cfg, discovered) {
   const usage = await readClaudeUsage()
+  // gd-492: the ChatGPT side's own limits, so a Codex console shows ITS numbers
+  // instead of Claude's. Both ride along — one machine can run both engines.
+  const codexUsage = readCodexUsage()
   const sig = createHash('sha1').update(JSON.stringify(discovered)).digest('hex')
   const full = sig !== syncRepoSig || syncFullCountdown <= 0
   const data = await api(cfg, '/api/v1/agent/sync', {
@@ -1926,6 +2523,7 @@ async function sync(cfg, discovered) {
     roots: cfg.roots,
     repos: full ? discovered : [],
     ...(usage ? { usage } : {}),
+    ...(codexUsage ? { codexUsage } : {}),
   })
   if (full) { syncRepoSig = sig; syncFullCountdown = SYNC_FULL_TICKS }
   else syncFullCountdown--
@@ -2094,6 +2692,9 @@ async function runLoop(cfg) {
   // start so in-place-updated agents get the watchdog without a re-install.
   startHeartbeat()
   ensureWatchdog()
+  // This config just booted an agent, so it is known-good — snapshot it for
+  // readConfig() to fall back on (gd-478).
+  backupConfig(cfg)
   log(`gitdone-agent started — machine: ${cfg.hostname}, server: ${cfg.url}, interval: ${cfg.interval}s`)
   log(`  roots: ${cfg.roots.join(', ') || '(none — add one with --root)'}`)
 
@@ -2169,7 +2770,10 @@ async function main() {
   // No args → running mode (this is how autostart launches us): read config.
   const cfg = readConfig()
   if (!cfg || !cfg.key) {
-    console.error(`Error: no config found at ${CONFIG_PATH}. Run with --key=... --root=... --install first.`)
+    // Through agent.log, not just stderr — the autostart runs hidden, so the
+    // crash log is the only other place this would land and nobody reads it
+    // until someone already suspects the agent (gd-478).
+    log(`✗ няма използваем config в ${CONFIG_PATH} — пусни gitdone-agent --key=... --root=... --install`)
     process.exit(1)
   }
   await runLoop(cfg)

package/package.json

@@ -1,6 +1,6 @@
 {
     "name":  "gitdone-agent",
-    "version":  "0.7.6",
+    "version":  "0.8.0",
     "description":  "Local git agent for gitdone — watches a local repo and sends snapshots to gitdone.eu",
     "type":  "module",
     "bin":  {