npm - gitdone-agent - Versions diffs - 0.6.17 → 0.7.1 - Mend

gitdone-agent 0.6.17 → 0.7.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/index.js +2011 -1787
package/package.json +1 -1

package/index.js CHANGED Viewed

@@ -1,1787 +1,2011 @@
-#!/usr/bin/env node
-// gitdone-agent — scans root folders for git repos and pushes snapshots of the
-// ones the server marks as "tracked" to gitdone.eu.
-//
-// Setup (once):
-//   npx gitdone-agent --key=gdo_xxx --root=C:\path\to\projects --install
-//
-// Then pick which discovered repos to track from gitdone.eu/github. Add more
-// roots anytime with --root (repeatable). The running agent reads its config
-// from ~/.gitdone-agent/config.json, so the autostart entry needs no args.
-import { execSync, execFileSync, spawn } from 'node:child_process'
-import {
-  existsSync, writeFileSync, readFileSync, unlinkSync, renameSync,
-  mkdirSync, copyFileSync, appendFileSync, readdirSync, rmSync, statSync,
-} from 'node:fs'
-import { resolve, join } from 'node:path'
-import { homedir, hostname, tmpdir } from 'node:os'
-import { randomUUID } from 'node:crypto'
-// ─── Stable agent dir, config + logging ────────────────────────────────────────
-// Everything persistent lives here: a stable copy of the agent script (so
-// autostart never points at a purged npx temp dir), the config file (source of
-// truth for the running agent), and a log file (so failures are visible even
-// when the agent runs in a hidden window).
-// 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.6.17'
-const AGENT_DIR = join(homedir(), '.gitdone-agent')
-const CONFIG_PATH = join(AGENT_DIR, 'config.json')
-const STABLE_AGENT = join(AGENT_DIR, 'agent.mjs')
-const LOG_PATH = join(AGENT_DIR, 'agent.log')
-function ensureAgentDir() {
-  if (!existsSync(AGENT_DIR)) mkdirSync(AGENT_DIR, { recursive: true })
-}
-// Keep agent.log from growing forever: past 5 MB it rolls to agent.log.old
-// (replacing the previous roll). Checked every 500 lines, not per line.
-const LOG_MAX_BYTES = 5 * 1024 * 1024
-let logLinesSinceCheck = 0
-function rotateLogIfNeeded() {
-  try {
-    if (statSync(LOG_PATH).size > LOG_MAX_BYTES) renameSync(LOG_PATH, LOG_PATH + '.old')
-  } catch { /* no log yet / roll failed — keep appending */ }
-}
-function log(msg) {
-  const line = `[${new Date().toISOString()}] ${msg}`
-  console.log(line)
-  try {
-    ensureAgentDir()
-    if (logLinesSinceCheck++ % 500 === 0) rotateLogIfNeeded()
-    appendFileSync(LOG_PATH, line + '\n')
-  } catch { /* best-effort */ }
-}
-// ─── Crash safety ─────────────────────────────────────────────────────────────
-// Node ≥15 KILLS the process on any unhandled promise rejection, and an uncaught
-// exception always did — and the autostart used to be one-shot, so a single
-// stray error left the machine offline until the next Windows login (gd-403).
-// Log and keep running instead; the loops here are stateless enough that
-// surviving is strictly better than dying. If errors come in a storm (>20/min —
-// something is genuinely broken), exit(1) and let the supervisor loop restart
-// us with a clean slate.
-let crashBurst = { count: 0, since: Date.now() }
-function survive(kind, err) {
-  const now = Date.now()
-  if (now - crashBurst.since > 60_000) crashBurst = { count: 0, since: now }
-  crashBurst.count++
-  log(`✗ ${kind}: ${err?.stack || err?.message || err}`)
-  if (crashBurst.count > 20) {
-    log('✗ over 20 crashes in 60s — exiting so the supervisor restarts us clean')
-    process.exit(1)
-  }
-}
-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 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')
-  renameSync(tmp, CONFIG_PATH)
-}
-// ─── Arg parsing ─────────────────────────────────────────────────────────────
-function parseArgs() {
-  const argv = process.argv.slice(2)
-  const flags = {}
-  const roots = []
-  for (const a of argv) {
-    if (!a.startsWith('--')) continue
-    const [k, ...rest] = a.slice(2).split('=')
-    const v = rest.join('=')
-    if (k === 'root') { if (v) roots.push(resolve(v)) }
-    else flags[k] = v
-  }
-  return {
-    key: flags.key,
-    roots,
-    interval: flags.interval ? Number(flags.interval) : undefined,
-    url: flags.url ? flags.url.replace(/\/$/, '') : undefined,
-    install: 'install' in flags,
-    uninstall: 'uninstall' in flags,
-    doctor: 'doctor' in flags,
-  }
-}
-// Merge CLI args into the persisted config, generating a machineId on first use.
-function buildConfig(args) {
-  const existing = readConfig() ?? {}
-  const mergedRoots = Array.from(new Set([...(existing.roots ?? []), ...args.roots]))
-  return {
-    key: args.key ?? existing.key,
-    url: args.url ?? existing.url ?? 'https://gitdone.eu',
-    interval: args.interval ?? existing.interval ?? 30,
-    machineId: existing.machineId ?? randomUUID(),
-    hostname: existing.hostname ?? hostname(),
-    roots: mergedRoots,
-  }
-}
-// ─── Windows auto-start ───────────────────────────────────────────────────────
-function getStartupDir() {
-  return join(homedir(), 'AppData', 'Roaming', 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'Startup')
-}
-function getVbsPath() {
-  return join(getStartupDir(), 'gitdone-agent.vbs')
-}
-function getNodePath() {
-  try { return execSync('where node', { encoding: 'utf8' }).trim().split('\n')[0].trim() } catch {}
-  try { return execSync('which node', { encoding: 'utf8' }).trim() } catch {}
-  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
-// 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() {
-  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')]
-  // 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 home = homedir()
-  const appData = process.env.APPDATA || join(home, 'AppData', 'Roaming')
-  for (const p of [
-    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 }
-}
-// ─── Single instance (gd-407) ─────────────────────────────────────────────────
-// Two agents on one machine (an old one surviving an update, or a manual
-// `npx gitdone-agent` next to the autostarted one) flap the machine's online
-// state and race dispatches. The running agent claims the machine via a pid
-// file; a newcomer that finds a LIVE agent behind it exits with EXIT_DUPLICATE,
-// which the supervisor treats as "do not restart me". First one wins.
-// 86 is outside node's own exit-code range (1-13) — keep in lockstep with the
-// run-agent.cmd template in installStartup().
-const EXIT_DUPLICATE = 86
-const PID_PATH = join(AGENT_DIR, 'agent.pid')
-// Command line of a live process, '' when unreadable (dead process, no rights).
-function processCmdline(pid) {
-  try {
-    if (process.platform === 'win32') {
-      return execSync(
-        `powershell -NoProfile -NonInteractive -Command "(Get-CimInstance Win32_Process -Filter 'ProcessId=${pid}').CommandLine"`,
-        { encoding: 'utf8' },
-      ).trim()
-    }
-    return execSync(`ps -p ${pid} -o command=`, { encoding: 'utf8' }).trim()
-  } catch { return '' }
-}
-function ensureSingleInstance() {
-  try {
-    const pid = parseInt(readFileSync(PID_PATH, 'utf8'), 10)
-    if (pid && pid !== process.pid) {
-      process.kill(pid, 0) // throws when that pid is no longer alive
-      // PID reuse guard: only defer to a process that really looks like an
-      // agent (stable copy agent.mjs, or any gitdone-agent npx/global run).
-      if (/gitdone-agent|agent\.mjs/i.test(processCmdline(pid))) {
-        log(`✗ друг gitdone-agent вече върви (PID ${pid}) — този процес излиза, за да няма два агента на машината`)
-        process.exit(EXIT_DUPLICATE)
-      }
-    }
-  } catch { /* no/stale pid file → the machine is free, we take over */ }
-  try { ensureAgentDir(); writeFileSync(PID_PATH, String(process.pid)) } catch { /* best-effort */ }
-}
-// Kill any previously-running agent processes so an update applies WITHOUT a
-// Windows re-login. Targets node processes that look like a gitdone agent —
-// both the stable copy in ~/.gitdone-agent AND one running straight from the
-// npx cache / global install (its command line contains "gitdone-agent") —
-// excluding ourselves and our parent (the npx wrapper that launched us).
-// Best-effort; failures are non-fatal.
-function stopRunningAgents() {
-  // Kill the supervisor loops (cmd.exe running run-agent.cmd) FIRST, then the
-  // agents — the other order lets a still-alive supervisor immediately respawn
-  // the agent we just killed, leaving two agents reporting after an update.
-  const ps = [
-    "$ErrorActionPreference='SilentlyContinue'",
-    "Get-CimInstance Win32_Process -Filter \"Name='cmd.exe'\" |",
-    "  Where-Object { $_.CommandLine -like '*run-agent.cmd*' } |",
-    '  ForEach-Object { Stop-Process -Id $_.ProcessId -Force }',
-    "Get-CimInstance Win32_Process -Filter \"Name='node.exe'\" |",
-    `  Where-Object { ($_.CommandLine -like '*gitdone-agent*' -or $_.CommandLine -like '*agent.mjs*') -and $_.ProcessId -ne ${process.pid} -and $_.ProcessId -ne ${process.ppid || 0} } |`,
-    '  ForEach-Object { Stop-Process -Id $_.ProcessId -Force }',
-  ].join('\n')
-  try {
-    ensureAgentDir()
-    const scriptPath = join(AGENT_DIR, 'stop-agents.ps1')
-    writeFileSync(scriptPath, ps, 'utf8')
-    execSync(`powershell -NoProfile -NonInteractive -ExecutionPolicy Bypass -File "${scriptPath}"`, { stdio: 'ignore' })
-  } catch { /* best-effort — at worst the old agent lingers until next login */ }
-}
-function installStartup() {
-  ensureAgentDir()
-  const nodePath = getNodePath()
-  // Stop the previously-running agent(s) first so we don't end up with the old
-  // build still reporting alongside the new one until the next Windows login.
-  stopRunningAgents()
-  // Copy this script to a stable location. process.argv[1] may point inside an
-  // npx cache dir that gets purged later — referencing it from autostart would
-  // silently break on the next login. A stable copy survives.
-  try {
-    copyFileSync(resolve(process.argv[1]), STABLE_AGENT)
-  } catch (err) {
-    console.error(`Warning: could not copy agent to ${STABLE_AGENT}: ${err.message}`)
-  }
-  const agentPath = existsSync(STABLE_AGENT) ? STABLE_AGENT : resolve(process.argv[1])
-  // The autostart used to launch the agent DIRECTLY — one crash and the machine
-  // stayed offline until the next Windows login (gd-403). Now the VBS launches a
-  // tiny supervisor loop instead: run the agent, and if it ever exits, note it
-  // in agent-crash.log and start it again after 10s. stderr is captured too, so
-  // node-level failures (corrupt file, bad path) finally leave a trace. If the
-  // node path recorded at install time vanished (node upgraded/moved), fall
-  // back to whatever `node` is on PATH.
-  //
-  // Restart forever on normal crashes, but STOP on process-START failures
-  // (0xc0000142 STATUS_DLL_INIT_FAILED, 0xc0000135 missing DLL): those mean the
-  // login session itself is broken (e.g. after a hardware crash), every attempt
-  // pops a blocking "Application Error" dialog, and a retry can never succeed —
-  // the loop turned into an endless dialog storm (gd-405). Same for the
-  // ping-as-sleep: if even ping can't start, bail instead of spinning with no
-  // delay at all. A Windows re-login restarts the supervisor cleanly.
-  const crashLog = join(AGENT_DIR, 'agent-crash.log')
-  const cmd = [
-    '@echo off',
-    'rem gitdone-agent supervisor — restarts the agent if it ever dies (gd-403)',
-    `set "NODE=${nodePath}"`,
-    'if not exist "%NODE%" set "NODE=node"',
-    ':loop',
-    `"%NODE%" "${agentPath}" 2>> "${crashLog}"`,
-    'set CODE=%errorlevel%',
-    `echo [%date% %time%] agent exited (code %CODE%) - restart in 10s >> "${crashLog}"`,
-    'if "%CODE%"=="86" goto duplicate',
-    'if "%CODE%"=="-1073741502" goto dead',
-    'if "%CODE%"=="-1073741515" goto dead',
-    'ping -n 11 127.0.0.1 >nul 2>nul || goto dead',
-    'goto loop',
-    ':dead',
-    `echo [%date% %time%] node cannot start (code %CODE%) - supervisor giving up until next login >> "${crashLog}"`,
-    'exit /b',
-    ':duplicate',
-    `echo [%date% %time%] another agent already runs this machine (code 86) - this supervisor exits >> "${crashLog}"`,
-  ].join('\r\n')
-  const cmdPath = join(AGENT_DIR, 'run-agent.cmd')
-  writeFileSync(cmdPath, cmd, 'utf8')
-  // VBScript runs the supervisor with window style 0 so nothing pops up on login.
-  const vbs = [
-    'Set WshShell = CreateObject("WScript.Shell")',
-    `WshShell.Run """${cmdPath}""", 0, False`,
-  ].join('\r\n')
-  writeFileSync(getVbsPath(), vbs, 'utf8')
-}
-function uninstallStartup() {
-  const vbsPath = getVbsPath()
-  if (existsSync(vbsPath)) {
-    unlinkSync(vbsPath)
-    console.log(`✓ Премахнат автостарт за gitdone-agent`)
-  } else {
-    console.log(`Не е намерен автостарт (${vbsPath})`)
-  }
-  const cmdPath = join(AGENT_DIR, 'run-agent.cmd')
-  if (existsSync(cmdPath)) unlinkSync(cmdPath)
-  // Also stop the live supervisor + agent — otherwise they keep running (and
-  // the supervisor keeps resurrecting the agent) until the next reboot.
-  stopRunningAgents()
-}
-// ─── Doctor ────────────────────────────────────────────────────────────────────
-function runDoctor() {
-  const cfg = readConfig()
-  console.log('gitdone-agent doctor')
-  console.log(`  node          : ${getNodePath()}`)
-  console.log(`  agent dir     : ${AGENT_DIR} ${existsSync(AGENT_DIR) ? '(ok)' : '(MISSING)'}`)
-  console.log(`  stable agent  : ${STABLE_AGENT} ${existsSync(STABLE_AGENT) ? '(ok)' : '(not installed)'}`)
-  console.log(`  autostart vbs : ${getVbsPath()} ${existsSync(getVbsPath()) ? '(ok)' : '(not installed)'}`)
-  console.log(`  supervisor    : ${join(AGENT_DIR, 'run-agent.cmd')} ${existsSync(join(AGENT_DIR, 'run-agent.cmd')) ? '(ok)' : '(not installed — пусни --install за авторестарт при crash)'}`)
-  console.log(`  config        : ${CONFIG_PATH} ${existsSync(CONFIG_PATH) ? '(ok)' : '(MISSING)'}`)
-  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 и рестартирай агента'}`)
-  if (cfg) {
-    console.log(`  machineId     : ${cfg.machineId}`)
-    console.log(`  server        : ${cfg.url}`)
-    console.log(`  interval      : ${cfg.interval}s`)
-    console.log(`  roots         :`)
-    for (const r of cfg.roots ?? []) console.log(`     - ${r} ${existsSync(r) ? '' : '(MISSING)'}`)
-    if (cfg.roots?.length) {
-      const found = scanRepos(cfg.roots)
-      console.log(`  found repos   : ${found.length}`)
-      for (const r of found) console.log(`     - ${r.name}  (${r.path})`)
-    }
-  }
-}
-// ─── Git helpers ─────────────────────────────────────────────────────────────
-// Room for large command output. `git status --porcelain -uall` (gd-369) lists
-// every untracked file individually, so a repo with a big new/untracked tree can
-// blow past execSync's default 1 MB buffer — which would throw and silently
-// return '' (an EMPTY snapshot, worse than the collapsed view). 64 MB is plenty.
-const GIT_MAX_BUFFER = 64 * 1024 * 1024
-// Cap for synthesising an untracked file's full-content diff (gd-370) — above
-// this the file keeps the "no diff" placeholder so a huge/binary blob can't
-// bloat the snapshot payload.
-const UNTRACKED_DIFF_MAX_BYTES = 1024 * 1024
-// Synthesising a per-file diff spawns a synchronous `git diff --no-index` per
-// untracked file. Individually cheap, but a repo with a huge untracked/scratch
-// tree (e.g. extracted game assets — thousands of files) would spawn thousands
-// of blocking git processes and freeze the single-threaded agent for MINUTES on
-// every snapshot, starving the 30s sync heartbeat so the machine flips offline.
-// Bound the synthesis two ways — a file-count cap and a wall-clock budget — so
-// no single repo can ever monopolise the event loop. Anything past either keeps
-// the "no diff" placeholder, identical to the size-cap path above.
-const UNTRACKED_DIFF_MAX_FILES = 200
-const UNTRACKED_DIFF_TIME_BUDGET_MS = 3000
-// Every git call here is execSync — synchronous, on the ONLY thread. A git that
-// stops to ask for credentials (a repo whose remote lost its token → Git
-// Credential Manager pops an invisible dialog) blocks the whole agent forever:
-// no ticks, no heartbeat, machine flips offline until someone restarts it
-// (gd-403). Two guards: never allow interactive prompts, and hard-timeout every
-// call so the worst case is one failed command, not a dead agent. Local
-// commands get 2 min; push/pull (network) get 5.
-const GIT_ENV = { ...process.env, GIT_TERMINAL_PROMPT: '0', GCM_INTERACTIVE: 'never' }
-const GIT_TIMEOUT_MS = 2 * 60 * 1000
-const GIT_NET_TIMEOUT_MS = 5 * 60 * 1000
-function git(cmd, cwd) {
-  try {
-    return execSync(cmd, { cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], maxBuffer: GIT_MAX_BUFFER, timeout: GIT_TIMEOUT_MS, env: GIT_ENV }).trim()
-  } catch {
-    return ''
-  }
-}
-// Like git(), but returns the RAW bytes instead of a UTF-8 string. Needed for
-// `git diff`, whose payload can be Windows-1251 (CP1251) Cyrillic — decoding
-// those bytes as UTF-8 up front would corrupt them to „�"/„?" irreversibly
-// (gd-276). Callers decode per-file via decodeDiffText().
-function gitRaw(cmd, cwd) {
-  try {
-    return execSync(cmd, { cwd, encoding: 'buffer', stdio: ['pipe', 'pipe', 'pipe'], maxBuffer: GIT_MAX_BUFFER, timeout: GIT_TIMEOUT_MS, env: GIT_ENV })
-  } catch {
-    return Buffer.alloc(0)
-  }
-}
-// Full-content diff of a single UNTRACKED file (against /dev/null), so the
-// console can show a new file's whole content as an all-added diff — like
-// GitHub Desktop (gd-370). Uses execFileSync (argv, no shell) so paths with
-// spaces / Cyrillic reach git intact, unlike a shell command string. `--no-index`
-// exits 1 when the file differs from empty (i.e. always) — that's expected, and
-// its stdout still holds the diff. Returns raw bytes for parseDiffByFile.
-function gitDiffUntracked(file, cwd) {
-  try {
-    return execFileSync('git', ['diff', '--no-index', '--', '/dev/null', file], {
-      cwd, encoding: 'buffer', stdio: ['pipe', 'pipe', 'pipe'], maxBuffer: GIT_MAX_BUFFER, timeout: GIT_TIMEOUT_MS, env: GIT_ENV,
-    })
-  } catch (err) {
-    return err && err.stdout && err.stdout.length ? err.stdout : Buffer.alloc(0)
-  }
-}
-// Like git(), but surfaces failures (with stderr) instead of swallowing them —
-// used for push/pull where we need to detect auth rejection.
-function gitTry(cmd, cwd) {
-  try {
-    const out = execSync(cmd, { cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], timeout: GIT_NET_TIMEOUT_MS, env: GIT_ENV }).trim()
-    return { ok: true, out }
-  } catch (err) {
-    const timedOut = err.signal === 'SIGTERM' && err.code == null
-    const out = (err.stderr || err.stdout || (timedOut ? `git не отговори ${GIT_NET_TIMEOUT_MS / 60000} мин и беше прекратен` : err.message) || '').toString().trim()
-    return { ok: false, out }
-  }
-}
-// Never let a token reach the log file or the server's command-result.
-function redact(text, token) {
-  if (!text || !token) return text
-  return text.split(token).join('***')
-}
-// https://x-access-token:<token>@github.com/<owner>/<repo>.git — an ad-hoc URL
-// passed straight to push/pull, so it never gets written into .git/config.
-function authUrl(auth) {
-  const repo = auth.repo.replace(/\.git$/i, '')
-  return `https://x-access-token:${auth.token}@github.com/${repo}.git`
-}
-// A push rejected because the remote branch moved ahead of us (someone else
-// pushed in the meantime). Git prints "non-fast-forward" / "fetch first" /
-// "tip of your current branch is behind". We recover by pulling+rebasing.
-const NON_FAST_FORWARD = /non-fast-forward|fetch first|tip of your current branch is behind|failed to push some refs/i
-// Point the local remote-tracking ref (e.g. refs/remotes/origin/master) at the
-// commit we just synced. We push/pull through the ad-hoc token URL, and — unlike
-// `git push origin` — pushing/pulling by URL leaves refs/remotes/origin/* UNTOUCHED.
-// getSnapshot() then measures "ahead"/"behind" against that stale tracking ref
-// (git rev-list @{u}..HEAD), so already-pushed commits keep showing as pending
-// forever: the ahead badge never clears, GitHub Desktop shows the same "N↑", and
-// the user pushes again and again while local commits pile up (gd-273). Fast-
-// forwarding the tracking ref to the true remote tip resets ahead/behind to reality.
-// Best-effort: git() swallows failures so this never breaks the push/pull itself.
-function updateTrackingRef(repoPath, branch, commitish) {
-  // Prefer the branch's configured upstream (usually origin/<branch>); fall back
-  // to origin/<branch> when no upstream is set.
-  const upstream = git('git rev-parse --abbrev-ref --symbolic-full-name @{u}', repoPath)
-  const ref = upstream ? `refs/remotes/${upstream}` : `refs/remotes/origin/${branch}`
-  git(`git update-ref "${ref}" ${commitish}`, repoPath)
-}
-// Push/pull using the server-issued token when we have one; otherwise fall back
-// to the machine's own git credentials (old behaviour). Throws on failure.
-function pushOrPull(type, repoPath, auth) {
-  const branch = git('git branch --show-current', repoPath) || 'HEAD'
-  const url = auth ? authUrl(auth) : null
-  const pushCmd = url ? `git push "${url}" HEAD:${branch}` : 'git push'
-  if (type === 'pull') {
-    const r = gitTry(url ? `git pull "${url}" ${branch}` : 'git pull', repoPath)
-    if (!r.ok) throw new Error(r.out || 'pull failed')
-    // Pulling by URL never advanced origin/<branch>; point it at the fetched tip
-    // (FETCH_HEAD) so a later push isn't seen as being "ahead" of a stale ref.
-    if (url) updateTrackingRef(repoPath, branch, 'FETCH_HEAD')
-    return r.out || 'pulled'
-  }
-  let r = gitTry(pushCmd, repoPath)
-  if (r.ok) {
-    // We just pushed HEAD to the remote branch, so the remote tip == HEAD. Sync
-    // the local tracking ref to clear the "ahead" count (gd-273).
-    if (url) updateTrackingRef(repoPath, branch, 'HEAD')
-    return r.out || 'pushed'
-  }
-  // Push rejected because the remote is ahead (gd-272): commit succeeded but the
-  // push bounced with non-fast-forward, so the files looked "pushed" while the
-  // UI showed a scary git error. Pull with --rebase to replay our commits on top
-  // of the remote ones, then push again — what the user means by "push my files".
-  if (NON_FAST_FORWARD.test(r.out)) {
-    const pull = gitTry(url ? `git pull --rebase "${url}" ${branch}` : 'git pull --rebase', repoPath)
-    if (!pull.ok) {
-      // Rebase couldn't apply cleanly (conflicts) — abort so the repo isn't left
-      // mid-rebase, and surface an actionable message instead of guessing.
-      gitTry('git rebase --abort', repoPath)
-      throw new Error(`отдалеченият клон е напред и има конфликт при обединяване — дръпни (Sync) и слей ръчно, после пусни пак.\n${pull.out}`)
-    }
-    r = gitTry(pushCmd, repoPath)
-    if (!r.ok) throw new Error(r.out || 'push failed')
-    if (url) updateTrackingRef(repoPath, branch, 'HEAD')
-    return `дръпнах новите промени от сървъра и пушнах наново.\n${r.out}`.trim()
-  }
-  throw new Error(r.out || 'push failed')
-}
-const AUTH_FAIL = /authentication|authorization|403|401|denied|could not read Username|invalid username or password|terminal prompts disabled/i
-// Discard all local changes to a SINGLE file, so it disappears from the repo's
-// "changes". Mirrors GitHub Desktop's "Discard changes": unstage first, then
-// either restore the file from HEAD (tracked) or delete it (new/untracked).
-function discardFile(repoPath, file) {
-  if (!file) throw new Error('no file')
-  // Unstage so index + worktree get reverted together (no-op if not staged).
-  gitTry(`git reset -q HEAD -- "${file}"`, repoPath)
-  // Does the file exist in the last commit? If so we restore its content; if
-  // not, it's a newly-added/untracked file and discarding means removing it.
-  const inHead = gitTry(`git cat-file -e "HEAD:${file}"`, repoPath).ok
-  if (inHead) {
-    const r = gitTry(`git checkout HEAD -- "${file}"`, repoPath)
-    if (!r.ok) throw new Error(r.out || 'checkout failed')
-    return 'discarded'
-  }
-  // New/untracked file (now unstaged) — drop it from the working tree.
-  const r = gitTry(`git clean -fdq -- "${file}"`, repoPath)
-  if (!r.ok) throw new Error(r.out || 'clean failed')
-  return 'discarded (new file removed)'
-}
-// ─── Windows-1251 (CP1251) aware diff decoding (gd-276) ───────────────────────
-// Legacy Cyrillic sources are often saved in CP1251. Their high bytes (0x80–0xFF,
-// single-byte) are invalid UTF-8, so reading the diff as UTF-8 shows „?"/„�"
-// instead of кирилица. We keep the raw bytes and decode each file's diff section
-// on its own: valid UTF-8 stays UTF-8; the rest goes through the CP1251 table
-// below — so a UTF-8 repo is untouched while CP1251 files finally read correctly.
-// CP1251 high range 0x80–0xFF → Unicode code points (0x00–0x7F is plain ASCII).
-// 0x98 is unassigned in CP1251 → U+FFFD.
-const CP1251_HIGH = [
-  0x0402, 0x0403, 0x201A, 0x0453, 0x201E, 0x2026, 0x2020, 0x2021, 0x20AC, 0x2030, 0x0409, 0x2039, 0x040A, 0x040C, 0x040B, 0x040F,
-  0x0452, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014, 0xFFFD, 0x2122, 0x0459, 0x203A, 0x045A, 0x045C, 0x045B, 0x045F,
-  0x00A0, 0x040E, 0x045E, 0x0408, 0x00A4, 0x0490, 0x00A6, 0x00A7, 0x0401, 0x00A9, 0x0404, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x0407,
-  0x00B0, 0x00B1, 0x0406, 0x0456, 0x0491, 0x00B5, 0x00B6, 0x00B7, 0x0451, 0x2116, 0x0454, 0x00BB, 0x0458, 0x0405, 0x0455, 0x0457,
-  0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417, 0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F,
-  0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427, 0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, 0x042F,
-  0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437, 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F,
-  0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447, 0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F,
-]
-function decodeCp1251(buf) {
-  let out = ''
-  for (const b of buf) out += String.fromCharCode(b < 0x80 ? b : CP1251_HIGH[b - 0x80])
-  return out
-}
-// A strict UTF-8 decoder (always available even on small-ICU builds) — throws on
-// any invalid sequence, which is exactly how we tell UTF-8 apart from CP1251.
-const UTF8_STRICT = new TextDecoder('utf-8', { fatal: true })
-function decodeDiffText(buf) {
-  try {
-    return UTF8_STRICT.decode(buf)
-  } catch {
-    return decodeCp1251(buf)
-  }
-}
-// Git C-quotes paths with spaces / special chars / non-ASCII bytes, wrapping them
-// in double quotes with backslash escapes (`"export coca_cola/x.cs"`, octal `\NNN`
-// for raw bytes). Both `git status --porcelain` and the `diff --git` header do it.
-// Left unhandled, files with spaces (or Cyrillic) got mis-keyed and their diff was
-// dropped (gd-321). This reverses it back to a plain path so the diff key matches
-// the file name shown in the list.
-function unquoteGitPath(s) {
-  if (typeof s !== 'string' || s.length < 2 || s[0] !== '"' || s[s.length - 1] !== '"') return s
-  const body = s.slice(1, -1)
-  const bytes = []
-  for (let i = 0; i < body.length; i++) {
-    if (body[i] === '\\' && i + 1 < body.length) {
-      const n = body[i + 1]
-      if (n === 'n') { bytes.push(10); i++ }
-      else if (n === 't') { bytes.push(9); i++ }
-      else if (n === 'r') { bytes.push(13); i++ }
-      else if (n === '"') { bytes.push(34); i++ }
-      else if (n === '\\') { bytes.push(92); i++ }
-      else if (n >= '0' && n <= '7') { bytes.push(parseInt(body.substr(i + 1, 3), 8) & 0xff); i += 3 }
-      else { bytes.push(body.charCodeAt(i)) }
-    } else {
-      bytes.push(body.charCodeAt(i) & 0xff)
-    }
-  }
-  return Buffer.from(bytes).toString('utf8')
-}
-// Read the b-side path from a `diff --git` header line, handling git's quoting
-// of paths with spaces / special chars (gd-321).
-function diffHeaderPath(hdr) {
-  const q = hdr.match(/ ("b\/.*")$/) // quoted:  "a/x" "b/x"
-  if (q) return unquoteGitPath(q[1]).replace(/^b\//, '')
-  const u = hdr.match(/ b\/(.*)$/) //  plain:   a/x b/x
-  return u ? u[1] : null
-}
-function parseDiffByFile(diffBuf) {
-  const files = {}
-  if (!diffBuf || diffBuf.length === 0) return files
-  // Latin1 is a lossless 1-byte⇢1-char mapping, so the ASCII "diff --git" split
-  // markers match while every original byte survives for the per-section decode.
-  const raw = Buffer.isBuffer(diffBuf) ? diffBuf.toString('latin1') : String(diffBuf)
-  const sections = raw.split(/(?=^diff --git )/m)
-  for (const section of sections) {
-    if (!section.trim()) continue
-    // Decode THIS file's bytes on their own (UTF-8 or CP1251), then read the
-    // filename from the decoded header (quoted or not).
-    const text = decodeDiffText(Buffer.from(section, 'latin1'))
-    const hdr = text.match(/^diff --git (.+)$/m)
-    const name = hdr ? diffHeaderPath(hdr[1]) : null
-    if (name) files[name] = text
-  }
-  return files
-}
-function getSnapshot(repoPath) {
-  const branch = git('git branch --show-current', repoPath) || 'HEAD'
-  // -uall lists every untracked file individually instead of collapsing a new
-  // directory into a single `dir/` entry — so the change list matches what
-  // GitHub Desktop shows, file-for-file (gd-369).
-  const statusLines = git('git status --porcelain -uall', repoPath).split('\n').filter(Boolean)
-  const modified = []
-  const staged = []
-  const statuses = {}
-  for (const line of statusLines) {
-    const xy = line.slice(0, 2)
-    const file = unquoteGitPath(line.slice(3))
-    statuses[file] = xy
-    if (xy[0] !== ' ' && xy[0] !== '?') staged.push(file)
-    if (xy[1] !== ' ') modified.push(file)
-  }
-  const aheadBy = parseInt(git('git rev-list --count @{u}..HEAD', repoPath), 10) || 0
-  const behindBy = parseInt(git('git rev-list --count HEAD..@{u}', repoPath), 10) || 0
-  const logLine = git('git log -1 --pretty=format:%H|%s|%an|%aI', repoPath)
-  let lastCommit = null
-  if (logLine) {
-    const [sha, message, author, date] = logLine.split('|')
-    lastCommit = { sha, message, author, date }
-  }
-  const diffs = parseDiffByFile(gitRaw('git diff HEAD', repoPath))
-  // Untracked files (`??`) aren't in `git diff HEAD`, so they had no content to
-  // show ("Нов или untracked файл — няма diff"). Synthesise an all-added diff for
-  // each from /dev/null so the console shows the whole new file — like GitHub
-  // Desktop (gd-370). Skip anything over the size cap so a stray big/binary blob
-  // can't bloat the snapshot; those keep the "no diff" placeholder.
-  const untracked = Object.keys(statuses).filter((f) => statuses[f] === '??' && !diffs[f])
-  const diffDeadline = Date.now() + UNTRACKED_DIFF_TIME_BUDGET_MS
-  let synthesised = 0
-  for (const file of untracked) {
-    // Stop before either bound so a scratch tree can't starve the heartbeat; the
-    // rest keep the "no diff" placeholder. Log once so it's visible why.
-    if (synthesised >= UNTRACKED_DIFF_MAX_FILES || Date.now() > diffDeadline) {
-      log(`⚠ untracked diff cap reached @ ${repoPath} (${synthesised}/${untracked.length} synthesised) — rest shown without preview`)
-      break
-    }
-    let st
-    try { st = statSync(join(repoPath, file)) } catch { continue }
-    if (!st.isFile() || st.size > UNTRACKED_DIFF_MAX_BYTES) continue
-    synthesised++
-    const parsed = parseDiffByFile(gitDiffUntracked(file, repoPath))
-    const val = parsed[file] ?? Object.values(parsed)[0]
-    if (val) diffs[file] = val
-  }
-  // Origin remote → lets the server auto-detect the GitHub repo for the History tab.
-  const remoteUrl = git('git config --get remote.origin.url', repoPath) || null
-  return { branch, modified, staged, aheadBy, behindBy, lastCommit, statuses, diffs, remoteUrl }
-}
-// ─── Repo discovery ─────────────────────────────────────────────────────────────
-// Walk each root looking for directories that contain a `.git` entry. Stop
-// descending once a repo is found (don't recurse into submodules/nested repos),
-// skip noisy dirs, and cap depth so a huge tree can't hang a tick.
-const SKIP_DIRS = new Set(['node_modules', '.next', 'dist', 'build', '.cache', 'vendor', '.venv', '__pycache__'])
-function scanRepos(roots, maxDepth = 5) {
-  const found = []
-  const seen = new Set()
-  function walk(dir, depth) {
-    if (depth > maxDepth) return
-    let entries
-    try { entries = readdirSync(dir, { withFileTypes: true }) } catch { return }
-    if (entries.some((e) => e.name === '.git')) {
-      const path = resolve(dir)
-      if (!seen.has(path)) {
-        seen.add(path)
-        found.push({ name: path.split(/[\\/]/).pop() ?? path, path })
-      }
-      return // a repo — don't descend further
-    }
-    for (const e of entries) {
-      if (!e.isDirectory()) continue
-      if (e.name.startsWith('.') || SKIP_DIRS.has(e.name)) continue
-      walk(join(dir, e.name), depth + 1)
-    }
-  }
-  for (const root of roots) walk(resolve(root), 0)
-  return found
-}
-// ─── Server sync + commands ─────────────────────────────────────────────────────
-async function api(cfg, path, body) {
-  const res = await fetch(`${cfg.url}${path}`, {
-    method: 'POST',
-    headers: { Authorization: `Bearer ${cfg.key}`, 'Content-Type': 'application/json' },
-    body: JSON.stringify(body),
-  })
-  if (!res.ok) {
-    const text = await res.text().catch(() => '')
-    throw new Error(`HTTP ${res.status} ${path}: ${text}`)
-  }
-  return res.json().catch(() => ({}))
-}
-async function reportCommandResult(cfg, id, status, result) {
-  await api(cfg, '/api/v1/agent/command-result', { id, status, result }).catch(() => {})
-}
-// Post a batch of console events (and optional lifecycle status) for an AiRun.
-// `usage` is sent once on the final (done/error) post so the server can record
-// how many tokens the run cost. `streamingText` / `activityText` (gd-419) carry
-// the live "being typed" preview and the latest thinking snippet — explicit ''
-// clears them; `undefined` leaves them untouched.
-async function postRunEvents(cfg, runId, events, status, result, usage, streamingText, activityText) {
-  await api(cfg, '/api/v1/agent/ai-run/events', {
-    runId,
-    events,
-    ...(status ? { status } : {}),
-    ...(result !== undefined ? { result } : {}),
-    ...(usage ? { usage } : {}),
-    ...(streamingText !== undefined ? { streamingText } : {}),
-    ...(activityText !== undefined ? { activityText } : {}),
-  }).catch((e) => log(`✗ ai-run events post failed: ${e.message}`))
-}
-// Post transcript lines (and optional turn status / Claude session id) for an
-// interactive AiSession chat turn.
-async function postSessionEvents(cfg, sessionId, events, status, claudeSessionId, streamingText, activityText) {
-  await api(cfg, '/api/v1/agent/ai-session/events', {
-    sessionId,
-    events,
-    ...(status ? { status } : {}),
-    ...(claudeSessionId ? { claudeSessionId } : {}),
-    // Explicit '' clears the live preview; `undefined` leaves it untouched.
-    ...(streamingText !== undefined ? { streamingText } : {}),
-    // Same semantics for the live thinking snippet (gd-419).
-    ...(activityText !== undefined ? { activityText } : {}),
-  }).catch((e) => log(`✗ ai-session events post failed: ${e.message}`))
-}
-// Turn one stream-json line from `claude -p` into console events. Phase 1 shows
-// what the model writes (TEXT) and which tools it calls (TOOL_CALL); raw tool
-// results (Bash stdout etc.) come in Phase 2 via a PostToolUse hook.
-// With `--include-partial-messages`, Claude also emits `stream_event` lines
-// carrying incremental text deltas — onDelta gets those so chat sessions can
-// show the reply being written live (gd-302).
-// "12.3k" / "1.2M" compaction for the console token summary line.
-function fmtTokens(n) {
-  n = Number(n) || 0
-  if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`
-  if (n >= 1_000) return `${(n / 1_000).toFixed(1)}k`
-  return String(n)
-}
-function parseStreamLine(line, push, onInit, onDelta, onMeta) {
-  let ev
-  try { ev = JSON.parse(line) } catch { return }
-  if (ev.type === 'system') {
-    if (ev.subtype === 'init') {
-      push('SYSTEM', `Сесия стартирана${ev.model ? ` (${ev.model})` : ''}.`)
-      // Surface Claude's own session id so chat sessions can --resume it.
-      if (ev.session_id && typeof onInit === 'function') onInit(ev.session_id)
-      // Remember which model ran, for the token/cost record (gd-334).
-      if (ev.model && typeof onMeta === 'function') onMeta({ model: ev.model })
-    }
-    return
-  }
-  // Partial-message stream: the model's visible text deltas feed the live
-  // preview, its thinking deltas feed the gray "какво прави АИ-то" snippet
-  // (gd-419). Tool-input JSON deltas stay ignored — the full block still
-  // arrives as a normal `assistant` event below.
-  if (ev.type === 'stream_event' && typeof onDelta === 'function') {
-    const e = ev.event
-    if (e?.type === 'content_block_delta') {
-      if (e.delta?.type === 'text_delta' && e.delta.text) onDelta(e.delta.text, 'text')
-      else if (e.delta?.type === 'thinking_delta' && e.delta.thinking) onDelta(e.delta.thinking, 'thinking')
-    } else if (e?.type === 'content_block_start' && e.content_block?.type === 'thinking') {
-      // A fresh thought begins — reset the snippet so old and new don't blend.
-      onDelta('', 'thinking-start')
-    }
-    return
-  }
-  if (ev.type === 'assistant' && ev.message?.content) {
-    for (const block of ev.message.content) {
-      if (block.type === 'text' && block.text?.trim()) {
-        push('TEXT', block.text.trim())
-      } else if (block.type === 'tool_use') {
-        const input = block.input ? JSON.stringify(block.input) : ''
-        push('TOOL_CALL', `${block.name}${input ? ` ${input.slice(0, 400)}` : ''}`)
-      }
-    }
-    return
-  }
-  if (ev.type === 'result') {
-    if (ev.subtype && ev.subtype !== 'success') push('SYSTEM', `Резултат: ${ev.subtype}`)
-    // claude's final result carries cumulative token usage + its own cost.
-    // Prefer `modelUsage` (summed over every model/subagent turn) which is the
-    // true cumulative; top-level `usage` is often just the last turn. Fall back
-    // to `usage` when modelUsage is absent (older CLI).
-    if (typeof onMeta === 'function' && (ev.modelUsage || ev.usage || typeof ev.total_cost_usd === 'number')) {
-      let usage
-      let model
-      if (ev.modelUsage && typeof ev.modelUsage === 'object') {
-        const acc = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreateTokens: 0 }
-        for (const [name, mu] of Object.entries(ev.modelUsage)) {
-          if (!model) model = name
-          acc.inputTokens += mu.inputTokens ?? mu.input_tokens ?? 0
-          acc.outputTokens += mu.outputTokens ?? mu.output_tokens ?? 0
-          acc.cacheReadTokens += mu.cacheReadInputTokens ?? mu.cache_read_input_tokens ?? 0
-          acc.cacheCreateTokens += mu.cacheCreationInputTokens ?? mu.cache_creation_input_tokens ?? 0
-        }
-        usage = acc
-      } else if (ev.usage) {
-        const u = ev.usage
-        usage = {
-          inputTokens: u.input_tokens ?? 0,
-          outputTokens: u.output_tokens ?? 0,
-          cacheReadTokens: u.cache_read_input_tokens ?? 0,
-          cacheCreateTokens: u.cache_creation_input_tokens ?? 0,
-        }
-      }
-      onMeta({
-        ...(usage ? { usage } : {}),
-        ...(model ? { model } : {}),
-        costUsd: typeof ev.total_cost_usd === 'number' ? ev.total_cost_usd : undefined,
-      })
-    }
-  }
-}
-// 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
-// claude process). Returns the settings path to pass via --settings.
-const AI_HOOK_SCRIPT = join(AGENT_DIR, 'ai-run-hook.mjs')
-const AI_SETTINGS_PATH = join(AGENT_DIR, 'ai-run-settings.json')
-function ensureAiHookFiles() {
-  ensureAgentDir()
-  const hookSrc = [
-    "import process from 'node:process'",
-    "let data = ''",
-    "process.stdin.setEncoding('utf8')",
-    "process.stdin.on('data', (c) => { data += c })",
-    'process.stdin.on(\'end\', async () => {',
-    '  try {',
-    "    const ev = JSON.parse(data || '{}')",
-    '    const url = process.env.GITDONE_URL, key = process.env.GITDONE_KEY, runId = process.env.GITDONE_RUN_ID',
-    '    if (url && key && runId) {',
-    "      const name = ev.tool_name || 'tool'",
-    '      const o = ev.tool_output',
-    "      let out = ''",
-    "      if (typeof o === 'string') out = o",
-    "      else if (o && typeof o === 'object') out = o.text || o.stdout || o.content || JSON.stringify(o)",
-    "      out = String(out || '').slice(0, 2000)",
-    "      const inp = ev.tool_input ? JSON.stringify(ev.tool_input).slice(0, 300) : ''",
-    "      const text = name + (inp ? ' ' + inp : '') + (out ? '\\n' + out : ' ✓')",
-    "      await fetch(url + '/api/v1/agent/ai-run/events', {",
-    "        method: 'POST',",
-    "        headers: { Authorization: 'Bearer ' + key, 'Content-Type': 'application/json' },",
-    "        body: JSON.stringify({ runId, events: [{ kind: 'TOOL_RESULT', text }] }),",
-    '      }).catch(() => {})',
-    '    }',
-    '  } catch {}',
-    '  process.exit(0)',
-    '})',
-  ].join('\n')
-  writeFileSync(AI_HOOK_SCRIPT, hookSrc, 'utf8')
-  const nodePath = getNodePath()
-  const settings = {
-    hooks: {
-      PostToolUse: [
-        { matcher: '', hooks: [{ type: 'command', command: `"${nodePath}" "${AI_HOOK_SCRIPT}"` }] },
-      ],
-    },
-  }
-  writeFileSync(AI_SETTINGS_PATH, JSON.stringify(settings, null, 2), 'utf8')
-  return AI_SETTINGS_PATH
-}
-// Same PostToolUse hook, for interactive chat sessions: posts raw tool output to
-// the session endpoint, reading GITDONE_SESSION_ID from the per-turn env.
-const AI_SESSION_HOOK_SCRIPT = join(AGENT_DIR, 'ai-session-hook.mjs')
-const AI_SESSION_SETTINGS_PATH = join(AGENT_DIR, 'ai-session-settings.json')
-function ensureAiSessionHookFiles() {
-  ensureAgentDir()
-  const hookSrc = [
-    "import process from 'node:process'",
-    "let data = ''",
-    "process.stdin.setEncoding('utf8')",
-    "process.stdin.on('data', (c) => { data += c })",
-    'process.stdin.on(\'end\', async () => {',
-    '  try {',
-    "    const ev = JSON.parse(data || '{}')",
-    '    const url = process.env.GITDONE_URL, key = process.env.GITDONE_KEY, sessionId = process.env.GITDONE_SESSION_ID',
-    '    if (url && key && sessionId) {',
-    "      const name = ev.tool_name || 'tool'",
-    '      const o = ev.tool_output',
-    "      let out = ''",
-    "      if (typeof o === 'string') out = o",
-    "      else if (o && typeof o === 'object') out = o.text || o.stdout || o.content || JSON.stringify(o)",
-    "      out = String(out || '').slice(0, 2000)",
-    "      const inp = ev.tool_input ? JSON.stringify(ev.tool_input).slice(0, 300) : ''",
-    "      const text = name + (inp ? ' ' + inp : '') + (out ? '\\n' + out : ' ✓')",
-    "      await fetch(url + '/api/v1/agent/ai-session/events', {",
-    "        method: 'POST',",
-    "        headers: { Authorization: 'Bearer ' + key, 'Content-Type': 'application/json' },",
-    "        body: JSON.stringify({ sessionId, events: [{ role: 'TOOL_RESULT', text }] }),",
-    '      }).catch(() => {})',
-    '    }',
-    '  } catch {}',
-    '  process.exit(0)',
-    '})',
-  ].join('\n')
-  writeFileSync(AI_SESSION_HOOK_SCRIPT, hookSrc, 'utf8')
-  const nodePath = getNodePath()
-  const settings = {
-    hooks: {
-      PostToolUse: [
-        { matcher: '', hooks: [{ type: 'command', command: `"${nodePath}" "${AI_SESSION_HOOK_SCRIPT}"` }] },
-      ],
-    },
-  }
-  writeFileSync(AI_SESSION_SETTINGS_PATH, JSON.stringify(settings, null, 2), 'utf8')
-  return AI_SESSION_SETTINGS_PATH
-}
-// gitdone MCP config for headless sessions (gd-308). We provide it ourselves —
-// with an X-Gitdone-Machine-Id header — so the server can attribute the AI agents
-// this session registers (ai_agent_start) to THIS computer, and the „АИ Агенти"
-// panel shows one sub-panel per machine instead of a single „Локален агент".
-// Used with --strict-mcp-config so the session uses exactly this server. The
-// agent's own key (a gdo_ key) authenticates the MCP endpoint.
-const AI_MCP_CONFIG_PATH = join(AGENT_DIR, 'ai-mcp-config.json')
-function ensureAiMcpConfig(cfg) {
-  ensureAgentDir()
-  const config = {
-    mcpServers: {
-      gitdone: {
-        type: 'http',
-        url: `${cfg.url}/api/mcp`,
-        headers: {
-          Authorization: `Bearer ${cfg.key}`,
-          'X-Gitdone-Machine-Id': cfg.machineId,
-        },
-      },
-    },
-  }
-  writeFileSync(AI_MCP_CONFIG_PATH, JSON.stringify(config, null, 2), 'utf8')
-  return AI_MCP_CONFIG_PATH
-}
-// Sanitise the model value from a command payload into a safe `--model`
-// argument. gitDone sends a stable CLI alias ("opus"/"sonnet"/"haiku"), but we
-// also allow a full model id (letters, digits, dot, dash). Anything else — or a
-// missing value — yields null, so the agent falls back to the machine's own
-// default model. Bounds the length as a belt-and-braces guard (gd-354).
-function aiModelArg(raw) {
-  if (typeof raw !== 'string') return null
-  const m = raw.trim()
-  if (!m || m.length > 100) return null
-  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.
-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)
-  if (!runId || !prompt) {
-    reportCommandResult(cfg, cmd.id, 'error', 'invalid ai_run payload')
-    return
-  }
-  const { path: claudePath, shell, found } = 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')
-    return
-  }
-  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}`) }
-  // 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',
-    // 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'] : []),
-  ]
-  // The PostToolUse hook reads these from its env to post raw tool output.
-  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.
-  let pending = []
-  let flushing = false
-  let liveText = '' // in-progress text of the current assistant block (live preview)
-  let sentLive = '' // last streamingText we posted — only push on change
-  let liveActivity = '' // latest thinking snippet — "какво прави АИ-то" (gd-419)
-  let sentActivity = ''
-  const flush = async () => {
-    if (flushing) return
-    const liveChanged = liveText !== sentLive
-    const activityChanged = liveActivity !== sentActivity
-    if (pending.length === 0 && !liveChanged && !activityChanged) return
-    flushing = true
-    const batch = pending; pending = []
-    const streamingText = liveChanged ? liveText : undefined
-    const activityText = activityChanged ? liveActivity : undefined
-    sentLive = liveText
-    sentActivity = liveActivity
-    await postRunEvents(cfg, runId, batch, undefined, undefined, undefined, streamingText, activityText)
-    flushing = false
-  }
-  const push = (kind, text) => {
-    if (text == null || String(text) === '') return
-    // A completed text block becomes a real event — drop its live preview; any
-    // new event also supersedes the last thinking snippet.
-    if (kind === 'TEXT') liveText = ''
-    liveActivity = ''
-    pending.push({ kind, text: String(text) })
-  }
-  const onDelta = (chunk, type) => {
-    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 }
-    liveText += chunk
-  }
-  const timer = setInterval(flush, 500)
-  // Accumulate model + token usage across the stream (model from init, usage
-  // from the final result event) to report once on exit (gd-334).
-  const meta = { model: undefined, usage: undefined, costUsd: undefined }
-  const onMeta = (m) => {
-    if (m.model) meta.model = m.model
-    if (m.usage) meta.usage = m.usage
-    if (typeof m.costUsd === 'number') meta.costUsd = m.costUsd
-  }
-  log(`▶ ai_run ${runId} @ ${repoPath} via ${claudePath}`)
-  postRunEvents(cfg, runId, [{ kind: 'SYSTEM', text: `Стартиране на Claude Code в ${repoPath}…` }], 'running')
-  let child
-  try {
-    child = spawn(claudePath, args, { cwd: repoPath, shell, windowsHide: true, env: childEnv })
-  } catch (err) {
-    clearInterval(timer)
-    postRunEvents(cfg, runId, [{ kind: 'SYSTEM', text: `Грешка при стартиране: ${err.message}` }], 'error', err.message)
-    reportCommandResult(cfg, cmd.id, 'error', err.message)
-    return
-  }
-  // Write the prompt to stdin and close it so Claude reads it as the task.
-  // 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() }
-    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) parseStreamLine(line, push, undefined, onDelta, onMeta)
-    }
-  })
-  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) => {
-    clearInterval(timer)
-    if (buf.trim()) parseStreamLine(buf.trim(), push, undefined, onDelta, onMeta)
-    liveText = '' // run is over — drop any lingering live preview / thought
-    liveActivity = ''
-    await flush()
-    const ok = code === 0
-    // Build the usage payload + a console summary line from what we saw.
-    const usage = meta.usage
-      ? { model: meta.model, ...meta.usage, ...(typeof meta.costUsd === 'number' ? { costUsd: meta.costUsd } : {}) }
-      : undefined
-    const events = [{ kind: 'SYSTEM', text: ok ? '✓ Готово.' : `✗ Процесът приключи с код ${code}.` }]
-    if (usage) events.push({ kind: 'SYSTEM', text: `📊 Токени: ${fmtTokens(usage.inputTokens)} вход · ${fmtTokens(usage.outputTokens)} изход${usage.cacheReadTokens ? ` · ${fmtTokens(usage.cacheReadTokens)} кеш` : ''}${typeof usage.costUsd === 'number' ? ` · $${usage.costUsd.toFixed(4)}` : ''}` })
-    await postRunEvents(
-      cfg, runId,
-      events,
-      ok ? 'done' : 'error',
-      ok ? 'ok' : `exit ${code}`,
-      usage,
-    )
-    reportCommandResult(cfg, cmd.id, ok ? 'done' : 'error', `exit ${code}`)
-    log(`■ ai_run ${runId} приключи (code ${code})`)
-  })
-}
-// Download the images attached to a chat turn to a per-session temp dir and
-// return their local paths. `claude -p` can't take image URLs on stdin, so we
-// fetch them locally and point Claude at the files (its Read tool renders
-// images). Best-effort: a failed download is skipped, not fatal.
-async function downloadSessionImages(sessionId, urls) {
-  const dir = join(tmpdir(), `gitdone-ai-${sessionId}`)
-  mkdirSync(dir, { recursive: true })
-  const paths = []
-  for (let i = 0; i < urls.length; i++) {
-    try {
-      const res = await fetch(urls[i])
-      if (!res.ok) { log(`✗ image download HTTP ${res.status}: ${urls[i]}`); continue }
-      const buf = Buffer.from(await res.arrayBuffer())
-      const m = /\.(png|jpe?g|gif|webp|bmp)(?:\?|$)/i.exec(urls[i])
-      const ext = m ? m[1].toLowerCase() : 'png'
-      const file = join(dir, `image-${i + 1}.${ext}`)
-      writeFileSync(file, buf)
-      paths.push(file)
-    } catch (e) {
-      log(`✗ image download failed (${urls[i]}): ${e.message}`)
-    }
-  }
-  return { dir, paths }
-}
-// Live chat turns, keyed by sessionId → their spawned `claude` child. Lets an
-// `ai_chat_stop` command find and kill the turn a user asked to interrupt
-// (gd-303). A turn registers itself on spawn and removes itself on close.
-const chatChildren = new Map()
-// Kill a process AND its descendants. `claude` spawns its own children (bash,
-// node hooks), so killing just the top pid would orphan them. Windows needs
-// `taskkill /T`; POSIX kills the process group, falling back to a hard kill.
-function killTree(child) {
-  const pid = child?.pid
-  if (!pid) return
-  if (process.platform === 'win32') {
-    try { spawn('taskkill', ['/PID', String(pid), '/T', '/F'], { windowsHide: true }) } catch { /* best-effort */ }
-  } else {
-    try { process.kill(-pid, 'SIGKILL') } catch { try { child.kill('SIGKILL') } catch { /* gone */ } }
-  }
-}
-// Run one turn of an interactive chat session: `claude -p` (resuming the prior
-// Claude session when known) with the user's message on stdin, streaming the
-// reply back to the session console. Long-running + fire-and-forget like ai_run.
-async function runAiChat(cfg, cmd, repoPath) {
-  const sessionId = cmd.payload?.sessionId
-  const prompt = cmd.payload?.prompt ?? ''
-  const images = Array.isArray(cmd.payload?.images) ? cmd.payload.images.filter((u) => typeof u === 'string' && u) : []
-  const claudeSessionId = cmd.payload?.claudeSessionId || null
-  const allowCommit = cmd.payload?.allowCommit === true
-  const model = aiModelArg(cmd.payload?.model)
-  // 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')
-    return
-  }
-  const { path: claudePath, shell, found } = findClaude()
-  if (!found) {
-    const msg = `Claude Code CLI не е намерен на този компютър (${cfg.hostname}). Инсталирай го от claude.ai/code и се увери, че „claude" е в PATH, после рестартирай агента.`
-    log(`✗ ai_chat ${sessionId}: claude not found`)
-    postSessionEvents(cfg, sessionId, [{ role: 'SYSTEM', text: `✗ ${msg}` }], 'error')
-    reportCommandResult(cfg, cmd.id, 'error', 'claude not found')
-    return
-  }
-  let settingsPath
-  try { settingsPath = ensureAiSessionHookFiles() } catch (e) { log(`✗ ai session hook setup failed: ${e.message}`) }
-  let mcpConfigPath
-  try { mcpConfigPath = ensureAiMcpConfig(cfg) } catch (e) { log(`✗ ai mcp config setup failed: ${e.message}`) }
-  const args = [
-    '-p',
-    '--output-format', 'stream-json',
-    '--verbose',
-    // Stream the reply token-by-token so the console can show it being written
-    // live, not only once each block is complete (gd-302).
-    '--include-partial-messages',
-    // Model resolved for this session (picker / project default); omitted →
-    // machine default (gd-354). Kept consistent across the session's turns.
-    ...(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 *)']),
-    ...(claudeSessionId ? ['--resume', claudeSessionId] : []),
-    ...(settingsPath ? ['--settings', settingsPath] : []),
-    // Our own gitdone MCP, tagged with this machine so ai_agent_start attributes
-    // the agents to this computer (gd-308). --strict = use exactly this server.
-    ...(mcpConfigPath ? ['--mcp-config', mcpConfigPath, '--strict-mcp-config'] : []),
-  ]
-  const childEnv = { ...process.env, GITDONE_URL: cfg.url, GITDONE_KEY: cfg.key, GITDONE_SESSION_ID: sessionId }
-  // Map console kinds → session transcript roles (model text → ASSISTANT).
-  const roleFor = (kind) => (kind === 'TEXT' ? 'ASSISTANT' : kind)
-  let pending = []
-  let capturedSession = null // Claude's session id, sent (idempotently) for --resume
-  let flushing = false
-  let liveText = '' // in-progress text of the current assistant block (live preview)
-  let sentLive = '' // last streamingText we posted — so we only push on change
-  let liveActivity = '' // latest thinking snippet — "какво прави АИ-то" (gd-419)
-  let sentActivity = ''
-  let lastPostAt = 0 // Date.now() of the last post, for the keep-alive heartbeat
-  const flush = async () => {
-    if (flushing) return
-    const hasEvents = pending.length > 0
-    const liveChanged = liveText !== sentLive
-    const activityChanged = liveActivity !== sentActivity
-    // Heartbeat: with nothing new for a while, still post (bumps lastActivityAt)
-    // so the console shows honest "still working" and can spot a real stall.
-    const heartbeat = !hasEvents && !liveChanged && !activityChanged && Date.now() - lastPostAt > 2500
-    if (!hasEvents && !liveChanged && !activityChanged && !heartbeat) return
-    flushing = true
-    const batch = pending.map((e) => ({ role: roleFor(e.kind), text: e.text })); pending = []
-    const streamingText = liveChanged ? liveText : undefined
-    const activityText = activityChanged ? liveActivity : undefined
-    sentLive = liveText
-    sentActivity = liveActivity
-    await postSessionEvents(cfg, sessionId, batch, 'running', capturedSession || undefined, streamingText, activityText)
-    lastPostAt = Date.now()
-    flushing = false
-  }
-  const push = (kind, text) => {
-    if (text == null || String(text) === '') return
-    // A completed text block becomes a real event — drop its live preview so the
-    // finalised bubble and the cleared preview swap in on the same flush. Any
-    // new event also supersedes the last thinking snippet (gd-419).
-    if (kind === 'TEXT') liveText = ''
-    liveActivity = ''
-    pending.push({ kind, text: String(text) })
-  }
-  const onInit = (sid) => { if (sid && !claudeSessionId) capturedSession = sid }
-  const onDelta = (chunk, type) => {
-    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 }
-    liveText += chunk
-  }
-  const timer = setInterval(flush, 500)
-  // 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).
-  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}]`
-    }
-  }
-  log(`▶ ai_chat ${sessionId} @ ${repoPath} (resume=${claudeSessionId ? 'yes' : 'no'}, images=${images.length}) via ${claudePath}`)
-  let child
-  try {
-    child = spawn(claudePath, args, { cwd: repoPath, shell, windowsHide: true, env: childEnv })
-  } catch (err) {
-    clearInterval(timer)
-    if (imgDir) { try { rmSync(imgDir, { recursive: true, force: true }) } catch { /* best-effort */ } }
-    postSessionEvents(cfg, sessionId, [{ role: 'SYSTEM', text: `Грешка при стартиране: ${err.message}` }], 'error')
-    reportCommandResult(cfg, cmd.id, 'error', err.message)
-    return
-  }
-  // Track this turn so an `ai_chat_stop` command can find and kill it (gd-303).
-  chatChildren.set(sessionId, child)
-  if (child.stdin) {
-    child.stdin.on('error', () => {})
-    try { child.stdin.write(fullPrompt); 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) parseStreamLine(line, push, onInit, onDelta)
-    }
-  })
-  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) => {
-    clearInterval(timer)
-    chatChildren.delete(sessionId)
-    if (imgDir) { try { rmSync(imgDir, { recursive: true, force: true }) } catch { /* best-effort */ } }
-    if (buf.trim()) parseStreamLine(buf.trim(), push, onInit, onDelta)
-    liveText = '' // turn is over — drop any lingering live preview / thought
-    liveActivity = ''
-    await flush()
-    // User-initiated stop (gd-303): land on idle with a friendly note, not an
-    // "exited with code N" error — the kill's non-zero code is expected here.
-    if (child.__stopped) {
-      await postSessionEvents(
-        cfg, sessionId,
-        [{ role: 'SYSTEM', text: '⏹ Спряно. Напиши още нещо, за да продължим разговора.' }],
-        'idle', capturedSession || undefined, '', '',
-      )
-      reportCommandResult(cfg, cmd.id, 'done', 'stopped by user')
-      log(`⏹ ai_chat ${sessionId} спряно от потребителя`)
-      return
-    }
-    const ok = code === 0
-    await postSessionEvents(
-      cfg, sessionId,
-      ok ? [] : [{ role: 'SYSTEM', text: `✗ Ходът приключи с код ${code}.` }],
-      ok ? 'idle' : 'error',
-      capturedSession || undefined,
-      '', // clear the live preview on the terminal post
-      '', // …and the thinking snippet (gd-419)
-    )
-    reportCommandResult(cfg, cmd.id, ok ? 'done' : 'error', `exit ${code}`)
-    log(`■ ai_chat ${sessionId} приключи (code ${code})`)
-  })
-}
-// ai_chat_stop — interrupt a running chat turn the user asked to stop (gd-303).
-// Kills the tracked child (its `close` handler then posts the "⏹ Спряно" note and
-// flips the session to idle). If nothing is running, just idles the session so
-// the console unlocks.
-function stopAiChat(cfg, cmd) {
-  const sessionId = cmd.payload?.sessionId
-  const child = sessionId ? chatChildren.get(sessionId) : null
-  if (!child) {
-    if (sessionId) postSessionEvents(cfg, sessionId, [], 'idle', undefined, '', '')
-    reportCommandResult(cfg, cmd.id, 'done', 'no active turn')
-    return
-  }
-  child.__stopped = true
-  killTree(child)
-  log(`⏹ ai_chat_stop ${sessionId} — kill signalled`)
-  reportCommandResult(cfg, cmd.id, 'done', 'stop signalled')
-}
-// deploy — run the project's deploy script (scripts/deploy.sh) in the repo.
-// Long-running (git pull + npm build + service restart), so we spawn it detached
-// from the poll loop and report the result on exit. The agent is its OWN process
-// (not part of any gitdone systemd service), so a `systemctl restart` inside the
-// script doesn't kill the deploy mid-flight — which a server-side spawn would.
-function runDeployCommand(cfg, cmd, repoPath) {
-  const script = 'scripts/deploy.sh'
-  if (!existsSync(join(repoPath, script))) {
-    reportCommandResult(cfg, cmd.id, 'error', `няма ${script} в repo-то — няма какво да деплойна`)
-    log(`✗ deploy @ ${repoPath}: липсва ${script}`)
-    return
-  }
-  log(`▸ deploy стартиран @ ${repoPath}`)
-  const child = spawn('bash', [script], { cwd: repoPath, stdio: ['ignore', 'pipe', 'pipe'] })
-  // Keep only the tail of the output — enough to explain a failure without
-  // shipping a whole build log back.
-  let tail = ''
-  const capture = (d) => { tail = (tail + d.toString()).slice(-2000) }
-  child.stdout.on('data', capture)
-  child.stderr.on('data', capture)
-  child.on('error', (err) => {
-    reportCommandResult(cfg, cmd.id, 'error', `процесна грешка: ${err.message}`)
-    log(`✗ deploy failed @ ${repoPath}: ${err.message}`)
-  })
-  child.on('close', (code) => {
-    const ok = code === 0
-    const detail = tail.trim() ? `\n${tail.trim()}` : ''
-    reportCommandResult(cfg, cmd.id, ok ? 'done' : 'error', `exit ${code}${detail}`.slice(0, 4000))
-    log(`${ok ? '✓' : '✗'} deploy @ ${repoPath} приключи (code ${code})`)
-  })
-}
-async function executeCommand(cfg, cmd, repoPath) {
-  // ai_run is long-running + streaming — launch it in the background and return
-  // so the snapshot loop keeps going. It reports its own result on exit.
-  if (cmd.type === 'ai_run') {
-    runAiCommand(cfg, cmd, repoPath)
-    return
-  }
-  // ai_chat — one interactive turn, same fire-and-forget model.
-  if (cmd.type === 'ai_chat') {
-    runAiChat(cfg, cmd, repoPath)
-    return
-  }
-  // ai_chat_stop — interrupt the running turn for a session (gd-303). Handled
-  // inline (it just signals a kill) and reports its own result.
-  if (cmd.type === 'ai_chat_stop') {
-    stopAiChat(cfg, cmd)
-    return
-  }
-  // deploy — run the repo's deploy script. Long-running (pull + build + service
-  // restart), so it's launched in the background and reports its own result on
-  // exit, same as ai_run.
-  if (cmd.type === 'deploy') {
-    runDeployCommand(cfg, cmd, repoPath)
-    return
-  }
-  let result = 'ok'
-  let status = 'done'
-  const auth = cfg.auth?.[repoPath] ?? null
-  try {
-    if (cmd.type === 'commit') {
-      const msg = (cmd.payload?.message ?? 'commit').replace(/"/g, '\\"')
-      // When the UI sends a list of selected files, stage ONLY those so the
-      // resulting commit (and the push that follows) contains just the checked
-      // files. No list → stage everything (old behaviour / older UIs).
-      const files = Array.isArray(cmd.payload?.files)
-        ? cmd.payload.files.filter((f) => typeof f === 'string' && f.trim())
-        : []
-      if (files.length) {
-        const quoted = files.map((f) => `"${f.replace(/"/g, '\\"')}"`).join(' ')
-        git(`git add -- ${quoted}`, repoPath)
-      } else {
-        git('git add -A', repoPath)
-      }
-      result = git(`git commit -m "${msg}"`, repoPath) || 'committed'
-    } else if (cmd.type === 'push' || cmd.type === 'pull') {
-      result = pushOrPull(cmd.type, repoPath, auth)
-    } else if (cmd.type === 'discard') {
-      result = discardFile(repoPath, cmd.payload?.file)
-    } else {
-      // Unknown command type — almost always a newer server feature (e.g. the
-      // gd-255 `deploy` command) reaching an agent too old to handle it. Do NOT
-      // silently mark it done: an older agent used to fall through here and
-      // report status=done/result=ok, so a queued deploy looked "completed" while
-      // nothing ran. Surface it as an error so the failure is visible and the
-      // user knows to update the agent.
-      throw new Error(`непозната команда „${cmd.type}" — обнови gitdone-agent (npm i -g gitdone-agent@latest)`)
-    }
-    log(`✓ ${cmd.type} @ ${repoPath}: ${redact(result, auth?.token)}`)
-  } catch (err) {
-    status = 'error'
-    result = redact(err.message, auth?.token)
-    // Cached token rejected (e.g. rotated/expired on the server) → drop it so
-    // the next snapshot reports hasGithubAuth:false and the server reissues one.
-    if (auth && AUTH_FAIL.test(err.message)) {
-      delete cfg.auth[repoPath]
-      writeConfig(cfg)
-      result += ' — токенът е изчистен, пробвай командата пак'
-    }
-    log(`✗ ${cmd.type} failed @ ${repoPath}: ${result}`)
-  }
-  await reportCommandResult(cfg, cmd.id, status, result)
-}
-// Report discovered repos + machine info, get back which repos to track.
-// ─── Claude plan usage (gd-355) ────────────────────────────────────────────
-// Claude Code persists an OAuth token at ~/.claude/.credentials.json and keeps
-// it fresh. We reuse it to ask Anthropic for the SAME plan-usage numbers the
-// /usage command shows (account-level: a 5-hour "session" window + a weekly
-// limit). The АИ Конзола then renders these live. Best-effort: on a missing or
-// expired token, being offline, or any error we return null and the console
-// simply keeps the last snapshot. Cached ~60s so the 30s sync loop doesn't hit
-// the endpoint twice as often as it changes.
-let usageCache = { at: 0, data: null }
-async function readClaudeUsage() {
-  const now = Date.now()
-  if (usageCache.data && now - usageCache.at < 60_000) return usageCache.data
-  try {
-    const creds = JSON.parse(readFileSync(join(homedir(), '.claude', '.credentials.json'), 'utf8'))
-    const token = creds?.claudeAiOauth?.accessToken
-    if (!token) return null
-    const ctrl = new AbortController()
-    const to = setTimeout(() => ctrl.abort(), 8000)
-    let res
-    try {
-      res = await fetch('https://api.anthropic.com/api/oauth/usage', {
-        headers: {
-          Authorization: `Bearer ${token}`,
-          'Content-Type': 'application/json',
-          'anthropic-beta': 'oauth-2025-04-20',
-          'User-Agent': 'claude-cli',
-        },
-        signal: ctrl.signal,
-      })
-    } finally { clearTimeout(to) }
-    if (!res.ok) return null // 401 = token expired; Claude Code refreshes it — skip this tick
-    const j = await res.json()
-    const data = {
-      sessionPct: Math.round(j?.five_hour?.utilization ?? 0),
-      sessionResetsAt: j?.five_hour?.resets_at ?? null,
-      weeklyPct: Math.round(j?.seven_day?.utilization ?? 0),
-      weeklyResetsAt: j?.seven_day?.resets_at ?? null,
-    }
-    usageCache = { at: now, data }
-    return data
-  } catch {
-    return null // no creds file / malformed / offline — stay quiet
-  }
-}
-async function sync(cfg, discovered) {
-  const usage = await readClaudeUsage()
-  const data = await api(cfg, '/api/v1/agent/sync', {
-    machineId: cfg.machineId,
-    hostname: cfg.hostname,
-    agentVersion: AGENT_VERSION,
-    roots: cfg.roots,
-    repos: discovered,
-    ...(usage ? { usage } : {}),
-  })
-  return data.tracked ?? []
-}
-// Push one tracked repo's snapshot and run any pending commands for it.
-async function pushSnapshot(cfg, repo) {
-  const snapshot = getSnapshot(repo.path)
-  const data = await api(cfg, '/api/v1/agent/snapshot', {
-    machineId: cfg.machineId,
-    path: repo.path,
-    repoName: repo.name,
-    // Tells the server whether we already hold a push token for this repo.
-    // Always a boolean → marks us as a token-capable agent.
-    hasGithubAuth: !!cfg.auth?.[repo.path],
-    ...snapshot,
-  })
-  // Server issued a (fresh) push token — cache it on disk so we ask only once.
-  if (data.githubAuth?.token && data.githubAuth?.repo) {
-    cfg.auth = cfg.auth ?? {}
-    cfg.auth[repo.path] = { token: data.githubAuth.token, repo: data.githubAuth.repo }
-    writeConfig(cfg)
-  }
-  for (const cmd of data.commands ?? []) {
-    await executeCommand(cfg, cmd, repo.path)
-  }
-  return snapshot
-}
-// ─── Low-latency command channel (gd-274) ───────────────────────────────────────
-// The 30s snapshot poll is fine for reflecting git state, but makes user actions
-// (Push/Pull/Commit/АИ) feel sluggish: a queued command waits up to a full tick
-// before the agent even asks for it. So we ALSO hold a persistent SSE connection
-// to the server and drain+run commands the instant it says "wake". The snapshot
-// poll stays as the reliable fallback (and cron heartbeat) if the stream drops.
-const GIT_STATE_CMDS = new Set(['commit', 'push', 'pull', 'discard'])
-// Pull this machine's pending commands in one shot (no git/snapshot work server-
-// side) and run them. Serialised via a tiny mutex so overlapping wakes don't
-// double-drain; a wake arriving mid-drain sets a flag to run once more after.
-let draining = false
-let drainAgain = false
-async function drainCommands(cfg) {
-  if (draining) { drainAgain = true; return }
-  draining = true
-  try {
-    do {
-      drainAgain = false
-      let data
-      try {
-        data = await api(cfg, '/api/v1/agent/commands', { machineId: cfg.machineId })
-      } catch (err) {
-        log(`✗ command drain failed: ${err.message}`)
-        return
-      }
-      const commands = data.commands ?? []
-      if (commands.length === 0) continue
-      // Cache any push tokens the server issued for these commands' repos.
-      if (data.githubAuth && typeof data.githubAuth === 'object') {
-        cfg.auth = cfg.auth ?? {}
-        for (const [path, a] of Object.entries(data.githubAuth)) {
-          if (a && a.token && a.repo) cfg.auth[path] = a
-        }
-        writeConfig(cfg)
-      }
-      // Run each command against its own repo path, and remember which repos had
-      // their git state changed so we can push a fresh snapshot right after —
-      // that's what makes the UI update instantly instead of on the next tick.
-      const touched = new Map()
-      for (const cmd of commands) {
-        const repoPath = cmd.path
-        if (!repoPath) { log(`✗ command ${cmd.id} has no path — skipped`); continue }
-        await executeCommand(cfg, cmd, repoPath)
-        if (GIT_STATE_CMDS.has(cmd.type)) touched.set(repoPath, cmd.repoName || repoPath)
-      }
-      for (const [path, name] of touched) {
-        try { await pushSnapshot(cfg, { path, name }) }
-        catch (err) { log(`✗ post-command snapshot failed @ ${path}: ${err.message}`) }
-      }
-    } while (drainAgain)
-  } finally {
-    draining = false
-  }
-}
-// Hold a persistent SSE connection open and drain the moment the server pushes a
-// `wake`. Reconnects forever with a short backoff; the server also recycles the
-// connection every few minutes (each reconnect re-sends an initial wake, so
-// anything queued while we were away is picked up). Never throws.
-const STREAM_RECONNECT_MS = 3000
-async function streamCommands(cfg) {
-  const url = `${cfg.url}/api/v1/agent/commands/stream?machineId=${encodeURIComponent(cfg.machineId)}`
-  for (;;) {
-    try {
-      const res = await fetch(url, { headers: { Authorization: `Bearer ${cfg.key}` } })
-      if (!res.ok || !res.body) throw new Error(`HTTP ${res.status}`)
-      log('▶ command stream connected')
-      const reader = res.body.getReader()
-      const decoder = new TextDecoder()
-      let buf = ''
-      for (;;) {
-        const { value, done } = await reader.read()
-        if (done) break
-        buf += decoder.decode(value, { stream: true })
-        // SSE events are separated by a blank line; a `wake` means "drain now".
-        let idx
-        while ((idx = buf.indexOf('\n\n')) >= 0) {
-          const frame = buf.slice(0, idx)
-          buf = buf.slice(idx + 2)
-          if (/(^|\n)event:\s*wake/.test(frame)) drainCommands(cfg)
-        }
-      }
-    } catch (err) {
-      log(`… command stream disconnected (${err.message}); reconnecting`)
-    }
-    await new Promise((r) => setTimeout(r, STREAM_RECONNECT_MS))
-  }
-}
-// ─── Main ────────────────────────────────────────────────────────────────────
-async function runLoop(cfg) {
-  ensureSingleInstance()
-  log(`gitdone-agent started — machine: ${cfg.hostname}, server: ${cfg.url}, interval: ${cfg.interval}s`)
-  log(`  roots: ${cfg.roots.join(', ') || '(none — add one with --root)'}`)
-  async function tick() {
-    try {
-      const discovered = scanRepos(cfg.roots)
-      const tracked = await sync(cfg, discovered)
-      let pushed = 0
-      for (const repo of tracked) {
-        try { await pushSnapshot(cfg, repo); pushed++ }
-        catch (err) { log(`✗ snapshot failed @ ${repo.path}: ${err.message}`) }
-      }
-      log(`✓ tick — discovered: ${discovered.length}, tracked: ${tracked.length}, pushed: ${pushed}`)
-    } catch (err) {
-      log(`✗ sync error: ${err.message}`)
-    }
-  }
-  // Fast command path runs alongside the snapshot poll. Fire-and-forget: it owns
-  // its own reconnect loop and never rejects.
-  streamCommands(cfg)
-  await tick()
-  setInterval(tick, cfg.interval * 1000)
-}
-async function main() {
-  const args = parseArgs()
-  if (args.doctor) {
-    runDoctor()
-    process.exit(0)
-  }
-  if (args.uninstall) {
-    uninstallStartup()
-    process.exit(0)
-  }
-  // Setup / install path: merge CLI args into config, optionally (re)install.
-  if (args.install || args.key || args.roots.length || args.url || args.interval) {
-    const cfg = buildConfig(args)
-    if (!cfg.key) {
-      console.error('Error: --key is required on first setup (e.g. --key=gdo_xxx)')
-      process.exit(1)
-    }
-    writeConfig(cfg)
-    if (args.install) {
-      installStartup()
-      console.log(`✓ Инсталиран! При следващото влизане в Windows агентът ще стартира автоматично.`)
-      console.log(`  Агент  : ${STABLE_AGENT}`)
-      console.log(`  Config : ${CONFIG_PATH}`)
-      console.log(`  Лог    : ${LOG_PATH}`)
-      console.log(`  Roots  :`)
-      for (const r of cfg.roots) console.log(`     - ${r}`)
-      console.log()
-      // Launch silently in the background right now.
-      const child = spawn('wscript.exe', [getVbsPath()], { detached: true, stdio: 'ignore' })
-      child.unref()
-      console.log('✓ Агентът е стартиран в заден план — можеш да затвориш прозореца.')
-      console.log('  Сега избери кои репота да следи от gitdone.eu/github.')
-      process.exit(0)
-    }
-    // --key/--root without --install: just run the loop in the foreground.
-    await runLoop(cfg)
-    return
-  }
-  // 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.`)
-    process.exit(1)
-  }
-  await runLoop(cfg)
-}
-main()
+#!/usr/bin/env node
+// gitdone-agent — scans root folders for git repos and pushes snapshots of the
+// ones the server marks as "tracked" to gitdone.eu.
+//
+// Setup (once):
+//   npx gitdone-agent --key=gdo_xxx --root=C:\path\to\projects --install
+//
+// Then pick which discovered repos to track from gitdone.eu/github. Add more
+// roots anytime with --root (repeatable). The running agent reads its config
+// from ~/.gitdone-agent/config.json, so the autostart entry needs no args.
+import { execSync, execFileSync, spawn } from 'node:child_process'
+import {
+  existsSync, writeFileSync, readFileSync, unlinkSync, renameSync,
+  mkdirSync, copyFileSync, appendFileSync, readdirSync, rmSync, statSync,
+} from 'node:fs'
+import { resolve, join } from 'node:path'
+import { homedir, hostname, tmpdir } from 'node:os'
+import { randomUUID } from 'node:crypto'
+// ─── Stable agent dir, config + logging ────────────────────────────────────────
+// Everything persistent lives here: a stable copy of the agent script (so
+// autostart never points at a purged npx temp dir), the config file (source of
+// truth for the running agent), and a log file (so failures are visible even
+// when the agent runs in a hidden window).
+// 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.1'
+const AGENT_DIR = join(homedir(), '.gitdone-agent')
+const CONFIG_PATH = join(AGENT_DIR, 'config.json')
+const STABLE_AGENT = join(AGENT_DIR, 'agent.mjs')
+const LOG_PATH = join(AGENT_DIR, 'agent.log')
+function ensureAgentDir() {
+  if (!existsSync(AGENT_DIR)) mkdirSync(AGENT_DIR, { recursive: true })
+}
+// Keep agent.log from growing forever: past 5 MB it rolls to agent.log.old
+// (replacing the previous roll). Checked every 500 lines, not per line.
+const LOG_MAX_BYTES = 5 * 1024 * 1024
+let logLinesSinceCheck = 0
+function rotateLogIfNeeded() {
+  try {
+    if (statSync(LOG_PATH).size > LOG_MAX_BYTES) renameSync(LOG_PATH, LOG_PATH + '.old')
+  } catch { /* no log yet / roll failed — keep appending */ }
+}
+function log(msg) {
+  const line = `[${new Date().toISOString()}] ${msg}`
+  console.log(line)
+  try {
+    ensureAgentDir()
+    if (logLinesSinceCheck++ % 500 === 0) rotateLogIfNeeded()
+    appendFileSync(LOG_PATH, line + '\n')
+  } catch { /* best-effort */ }
+}
+// ─── Crash safety ─────────────────────────────────────────────────────────────
+// Node ≥15 KILLS the process on any unhandled promise rejection, and an uncaught
+// exception always did — and the autostart used to be one-shot, so a single
+// stray error left the machine offline until the next Windows login (gd-403).
+// Log and keep running instead; the loops here are stateless enough that
+// surviving is strictly better than dying. If errors come in a storm (>20/min —
+// something is genuinely broken), exit(1) and let the supervisor loop restart
+// us with a clean slate.
+let crashBurst = { count: 0, since: Date.now() }
+function survive(kind, err) {
+  const now = Date.now()
+  if (now - crashBurst.since > 60_000) crashBurst = { count: 0, since: now }
+  crashBurst.count++
+  log(`✗ ${kind}: ${err?.stack || err?.message || err}`)
+  if (crashBurst.count > 20) {
+    log('✗ over 20 crashes in 60s — exiting so the supervisor restarts us clean')
+    process.exit(1)
+  }
+}
+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 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')
+  renameSync(tmp, CONFIG_PATH)
+}
+// ─── Arg parsing ─────────────────────────────────────────────────────────────
+function parseArgs() {
+  const argv = process.argv.slice(2)
+  const flags = {}
+  const roots = []
+  for (const a of argv) {
+    if (!a.startsWith('--')) continue
+    const [k, ...rest] = a.slice(2).split('=')
+    const v = rest.join('=')
+    if (k === 'root') { if (v) roots.push(resolve(v)) }
+    else flags[k] = v
+  }
+  return {
+    key: flags.key,
+    roots,
+    interval: flags.interval ? Number(flags.interval) : undefined,
+    url: flags.url ? flags.url.replace(/\/$/, '') : undefined,
+    install: 'install' in flags,
+    uninstall: 'uninstall' in flags,
+    doctor: 'doctor' in flags,
+  }
+}
+// Merge CLI args into the persisted config, generating a machineId on first use.
+function buildConfig(args) {
+  const existing = readConfig() ?? {}
+  const mergedRoots = Array.from(new Set([...(existing.roots ?? []), ...args.roots]))
+  return {
+    key: args.key ?? existing.key,
+    url: args.url ?? existing.url ?? 'https://gitdone.eu',
+    interval: args.interval ?? existing.interval ?? 30,
+    machineId: existing.machineId ?? randomUUID(),
+    hostname: existing.hostname ?? hostname(),
+    roots: mergedRoots,
+  }
+}
+// ─── Windows auto-start ───────────────────────────────────────────────────────
+function getStartupDir() {
+  return join(homedir(), 'AppData', 'Roaming', 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'Startup')
+}
+function getVbsPath() {
+  return join(getStartupDir(), 'gitdone-agent.vbs')
+}
+function getNodePath() {
+  try { return execSync('where node', { encoding: 'utf8' }).trim().split('\n')[0].trim() } catch {}
+  try { return execSync('which node', { encoding: 'utf8' }).trim() } catch {}
+  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
+// 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() {
+  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')]
+  // 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 home = homedir()
+  const appData = process.env.APPDATA || join(home, 'AppData', 'Roaming')
+  for (const p of [
+    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 }
+}
+// ─── Single instance (gd-407) ─────────────────────────────────────────────────
+// Two agents on one machine (an old one surviving an update, or a manual
+// `npx gitdone-agent` next to the autostarted one) flap the machine's online
+// state and race dispatches. The running agent claims the machine via a pid
+// file; a newcomer that finds a LIVE agent behind it exits with EXIT_DUPLICATE,
+// which the supervisor treats as "do not restart me". First one wins.
+// 86 is outside node's own exit-code range (1-13) — keep in lockstep with the
+// run-agent.cmd template in installStartup().
+const EXIT_DUPLICATE = 86
+const PID_PATH = join(AGENT_DIR, 'agent.pid')
+// Command line of a live process, '' when unreadable (dead process, no rights).
+function processCmdline(pid) {
+  try {
+    if (process.platform === 'win32') {
+      return execSync(
+        `powershell -NoProfile -NonInteractive -Command "(Get-CimInstance Win32_Process -Filter 'ProcessId=${pid}').CommandLine"`,
+        { encoding: 'utf8' },
+      ).trim()
+    }
+    return execSync(`ps -p ${pid} -o command=`, { encoding: 'utf8' }).trim()
+  } catch { return '' }
+}
+function ensureSingleInstance() {
+  try {
+    const pid = parseInt(readFileSync(PID_PATH, 'utf8'), 10)
+    if (pid && pid !== process.pid) {
+      process.kill(pid, 0) // throws when that pid is no longer alive
+      // PID reuse guard: only defer to a process that really looks like an
+      // agent (stable copy agent.mjs, or any gitdone-agent npx/global run).
+      if (/gitdone-agent|agent\.mjs/i.test(processCmdline(pid))) {
+        log(`✗ друг gitdone-agent вече върви (PID ${pid}) — този процес излиза, за да няма два агента на машината`)
+        process.exit(EXIT_DUPLICATE)
+      }
+    }
+  } catch { /* no/stale pid file → the machine is free, we take over */ }
+  try { ensureAgentDir(); writeFileSync(PID_PATH, String(process.pid)) } catch { /* best-effort */ }
+}
+// Kill any previously-running agent processes so an update applies WITHOUT a
+// Windows re-login. Targets node processes that look like a gitdone agent —
+// both the stable copy in ~/.gitdone-agent AND one running straight from the
+// npx cache / global install (its command line contains "gitdone-agent") —
+// excluding ourselves and our parent (the npx wrapper that launched us).
+// Best-effort; failures are non-fatal.
+function stopRunningAgents() {
+  // Kill the supervisor loops (cmd.exe running run-agent.cmd) FIRST, then the
+  // agents — the other order lets a still-alive supervisor immediately respawn
+  // the agent we just killed, leaving two agents reporting after an update.
+  const ps = [
+    "$ErrorActionPreference='SilentlyContinue'",
+    "Get-CimInstance Win32_Process -Filter \"Name='cmd.exe'\" |",
+    "  Where-Object { $_.CommandLine -like '*run-agent.cmd*' } |",
+    '  ForEach-Object { Stop-Process -Id $_.ProcessId -Force }',
+    "Get-CimInstance Win32_Process -Filter \"Name='node.exe'\" |",
+    `  Where-Object { ($_.CommandLine -like '*gitdone-agent*' -or $_.CommandLine -like '*agent.mjs*') -and $_.ProcessId -ne ${process.pid} -and $_.ProcessId -ne ${process.ppid || 0} } |`,
+    '  ForEach-Object { Stop-Process -Id $_.ProcessId -Force }',
+  ].join('\n')
+  try {
+    ensureAgentDir()
+    const scriptPath = join(AGENT_DIR, 'stop-agents.ps1')
+    writeFileSync(scriptPath, ps, 'utf8')
+    execSync(`powershell -NoProfile -NonInteractive -ExecutionPolicy Bypass -File "${scriptPath}"`, { stdio: 'ignore' })
+  } catch { /* best-effort — at worst the old agent lingers until next login */ }
+}
+// ─── Watchdog (gd-431) ────────────────────────────────────────────────────────
+// Third, OUTER layer of crash safety. Layers 1-2 (survive() in-process, the
+// run-agent.cmd supervisor loop) still leave two ways for a machine to stay
+// offline: the supervisor cmd.exe itself dying (nothing restarts IT), and the
+// agent HANGING without exiting (process alive → supervisor waits forever).
+// So: the agent touches a heartbeat file every 30s, and a Windows scheduled
+// task runs watchdog.ps1 every 5 minutes (hidden via watchdog.vbs). A stale
+// heartbeat (>10 min) means dead OR hung → the watchdog kills any leftover
+// agent/supervisor processes and relaunches run-agent.cmd. The relaunch goes
+// through WMI Win32_Process.Create so the agent does NOT live inside the task's
+// job object — otherwise Task Scheduler would consider the task "still running"
+// forever and never fire it again (and stopping the task would kill the agent).
+//
+// Broken-session guard (gd-405): if a restart attempt does NOT revive the
+// heartbeat (0xc0000142 storms after a hardware crash — every start pops a
+// blocking error dialog), the watchdog backs off to one attempt per 30 min via
+// a stamp file instead of retrying every 5 — and a fresh heartbeat clears it.
+const WATCHDOG_TASK = 'GitdoneAgentWatchdog'
+const WATCHDOG_PS1 = join(AGENT_DIR, 'watchdog.ps1')
+const WATCHDOG_VBS = join(AGENT_DIR, 'watchdog.vbs')
+const HEARTBEAT_PATH = join(AGENT_DIR, 'heartbeat.txt')
+function startHeartbeat() {
+  const beat = () => {
+    try { ensureAgentDir(); writeFileSync(HEARTBEAT_PATH, new Date().toISOString()) } catch { /* best-effort */ }
+  }
+  beat()
+  setInterval(beat, 30_000)
+}
+// Idempotent: (re)writes the watchdog scripts and (re)creates the scheduled
+// task. Called on EVERY agent start — not just --install — so an in-place
+// update (gd-420) gains the watchdog too, and a deleted task self-heals.
+// The ps1 stays ASCII-only: PowerShell 5.1 misreads UTF-8-without-BOM files.
+function ensureWatchdog() {
+  if (process.platform !== 'win32') return
+  try {
+    ensureAgentDir()
+    const runCmd = join(AGENT_DIR, 'run-agent.cmd')
+    const ps1 = [
+      "$ErrorActionPreference = 'SilentlyContinue'",
+      `$dir = '${AGENT_DIR.replace(/'/g, "''")}'`,
+      "$hb = Join-Path $dir 'heartbeat.txt'",
+      "$stamp = Join-Path $dir 'watchdog-restart.stamp'",
+      "$wlog = Join-Path $dir 'watchdog.log'",
+      "$runCmd = Join-Path $dir 'run-agent.cmd'",
+      'function WLog([string]$m) { Add-Content -Path $wlog -Value ("[{0}] {1}" -f (Get-Date -Format \'yyyy-MM-dd HH:mm:ss\'), $m) }',
+      'if ((Test-Path $wlog) -and ((Get-Item $wlog).Length -gt 1048576)) { Move-Item -Path $wlog -Destination ($wlog + \'.old\') -Force }',
+      '# Fresh heartbeat (<10 min) = agent alive and ticking - nothing to do.',
+      'if ((Test-Path $hb) -and (((Get-Date) - (Get-Item $hb).LastWriteTime).TotalSeconds -lt 600)) {',
+      '  if (Test-Path $stamp) { Remove-Item -Path $stamp -Force }',
+      '  exit 0',
+      '}',
+      '# Last restart attempt did not revive the heartbeat - broken login session',
+      '# (e.g. 0xc0000142 after a hardware crash). Back off to one try per 30 min',
+      '# so retries cannot turn into a blocking-dialog storm (gd-405).',
+      'if ((Test-Path $stamp) -and (((Get-Date) - (Get-Item $stamp).LastWriteTime).TotalMinutes -lt 30)) { exit 0 }',
+      'New-Item -ItemType File -Path $stamp -Force | Out-Null',
+      "if (-not (Test-Path $runCmd)) { WLog 'run-agent.cmd missing - cannot restart; run gitdone-agent --install'; exit 0 }",
+      "WLog 'heartbeat stale - killing leftover agent processes and restarting'",
+      '# Same sweep as stopRunningAgents(): supervisors first, then agents, so a',
+      '# surviving supervisor cannot respawn a second agent mid-cleanup.',
+      'Get-CimInstance Win32_Process -Filter "Name=\'cmd.exe\'" | Where-Object { $_.CommandLine -like \'*run-agent.cmd*\' } | ForEach-Object { Stop-Process -Id $_.ProcessId -Force }',
+      'Get-CimInstance Win32_Process -Filter "Name=\'node.exe\'" | Where-Object { $_.CommandLine -like \'*gitdone-agent*\' -or $_.CommandLine -like \'*agent.mjs*\' } | ForEach-Object { Stop-Process -Id $_.ProcessId -Force }',
+      'Start-Sleep -Seconds 2',
+      '# WMI Create = the new process tree lives OUTSIDE the scheduled task job.',
+      '# (wmiclass accelerator, not Invoke-CimMethod - CIM cannot marshal the',
+      '# embedded Win32_ProcessStartup instance and dies with "Type mismatch".)',
+      "$sup = ([wmiclass]'Win32_ProcessStartup').CreateInstance()",
+      '$sup.ShowWindow = 0',
+      "$r = ([wmiclass]'Win32_Process').Create(('\"' + $env:ComSpec + '\" /c \"\"' + $runCmd + '\"\"'), $null, $sup)",
+      'WLog ("restart issued (ReturnValue={0}, Pid={1})" -f $r.ReturnValue, $r.ProcessId)',
+    ].join('\r\n')
+    writeFileSync(WATCHDOG_PS1, ps1, 'utf8')
+    // VBS wrapper so the 5-minute task never flashes a window.
+    const vbs = [
+      'Set WshShell = CreateObject("WScript.Shell")',
+      `WshShell.Run "powershell -NoProfile -NonInteractive -ExecutionPolicy Bypass -File ""${WATCHDOG_PS1}""", 0, True`,
+    ].join('\r\n')
+    writeFileSync(WATCHDOG_VBS, vbs, 'utf8')
+    execFileSync('schtasks', [
+      '/Create', '/F', '/SC', 'MINUTE', '/MO', '5',
+      '/TN', WATCHDOG_TASK,
+      '/TR', `wscript.exe "${WATCHDOG_VBS}"`,
+    ], { stdio: 'ignore', timeout: 30_000 })
+    log(`✓ watchdog: планирана задача „${WATCHDOG_TASK}" проверява агента на всеки 5 мин`)
+  } catch (err) {
+    log(`✗ watchdog setup failed: ${err?.message || err}`)
+  }
+}
+function installStartup() {
+  ensureAgentDir()
+  const nodePath = getNodePath()
+  // Stop the previously-running agent(s) first so we don't end up with the old
+  // build still reporting alongside the new one until the next Windows login.
+  stopRunningAgents()
+  // Copy this script to a stable location. process.argv[1] may point inside an
+  // npx cache dir that gets purged later — referencing it from autostart would
+  // silently break on the next login. A stable copy survives.
+  try {
+    copyFileSync(resolve(process.argv[1]), STABLE_AGENT)
+  } catch (err) {
+    console.error(`Warning: could not copy agent to ${STABLE_AGENT}: ${err.message}`)
+  }
+  const agentPath = existsSync(STABLE_AGENT) ? STABLE_AGENT : resolve(process.argv[1])
+  // The autostart used to launch the agent DIRECTLY — one crash and the machine
+  // stayed offline until the next Windows login (gd-403). Now the VBS launches a
+  // tiny supervisor loop instead: run the agent, and if it ever exits, note it
+  // in agent-crash.log and start it again after 10s. stderr is captured too, so
+  // node-level failures (corrupt file, bad path) finally leave a trace. If the
+  // node path recorded at install time vanished (node upgraded/moved), fall
+  // back to whatever `node` is on PATH.
+  //
+  // Restart forever on normal crashes, but STOP on process-START failures
+  // (0xc0000142 STATUS_DLL_INIT_FAILED, 0xc0000135 missing DLL): those mean the
+  // login session itself is broken (e.g. after a hardware crash), every attempt
+  // pops a blocking "Application Error" dialog, and a retry can never succeed —
+  // the loop turned into an endless dialog storm (gd-405). Same for the
+  // ping-as-sleep: if even ping can't start, bail instead of spinning with no
+  // delay at all. A Windows re-login restarts the supervisor cleanly.
+  const crashLog = join(AGENT_DIR, 'agent-crash.log')
+  const cmd = [
+    '@echo off',
+    'rem gitdone-agent supervisor — restarts the agent if it ever dies (gd-403)',
+    `set "NODE=${nodePath}"`,
+    'if not exist "%NODE%" set "NODE=node"',
+    ':loop',
+    `"%NODE%" "${agentPath}" 2>> "${crashLog}"`,
+    'set CODE=%errorlevel%',
+    `echo [%date% %time%] agent exited (code %CODE%) - restart in 10s >> "${crashLog}"`,
+    'if "%CODE%"=="86" goto duplicate',
+    'if "%CODE%"=="-1073741502" goto dead',
+    'if "%CODE%"=="-1073741515" goto dead',
+    'ping -n 11 127.0.0.1 >nul 2>nul || goto dead',
+    'goto loop',
+    ':dead',
+    `echo [%date% %time%] node cannot start (code %CODE%) - supervisor giving up until next login >> "${crashLog}"`,
+    'exit /b',
+    ':duplicate',
+    `echo [%date% %time%] another agent already runs this machine (code 86) - this supervisor exits >> "${crashLog}"`,
+  ].join('\r\n')
+  const cmdPath = join(AGENT_DIR, 'run-agent.cmd')
+  writeFileSync(cmdPath, cmd, 'utf8')
+  // VBScript runs the supervisor with window style 0 so nothing pops up on login.
+  const vbs = [
+    'Set WshShell = CreateObject("WScript.Shell")',
+    `WshShell.Run """${cmdPath}""", 0, False`,
+  ].join('\r\n')
+  writeFileSync(getVbsPath(), vbs, 'utf8')
+  // Outer safety layer: the 5-minute watchdog task (gd-431).
+  ensureWatchdog()
+}
+function uninstallStartup() {
+  const vbsPath = getVbsPath()
+  if (existsSync(vbsPath)) {
+    unlinkSync(vbsPath)
+    console.log(`✓ Премахнат автостарт за gitdone-agent`)
+  } else {
+    console.log(`Не е намерен автостарт (${vbsPath})`)
+  }
+  const cmdPath = join(AGENT_DIR, 'run-agent.cmd')
+  if (existsSync(cmdPath)) unlinkSync(cmdPath)
+  // Drop the watchdog task too — otherwise it resurrects the agent in ≤5 min.
+  if (process.platform === 'win32') {
+    try {
+      execFileSync('schtasks', ['/Delete', '/F', '/TN', WATCHDOG_TASK], { stdio: 'ignore', timeout: 30_000 })
+      console.log('✓ Премахнат watchdog (планирана задача)')
+    } catch { /* not installed */ }
+  }
+  for (const f of [WATCHDOG_PS1, WATCHDOG_VBS, HEARTBEAT_PATH]) {
+    if (existsSync(f)) unlinkSync(f)
+  }
+  // Also stop the live supervisor + agent — otherwise they keep running (and
+  // the supervisor keeps resurrecting the agent) until the next reboot.
+  stopRunningAgents()
+}
+// ─── Doctor ────────────────────────────────────────────────────────────────────
+function runDoctor() {
+  const cfg = readConfig()
+  console.log('gitdone-agent doctor')
+  console.log(`  node          : ${getNodePath()}`)
+  console.log(`  agent dir     : ${AGENT_DIR} ${existsSync(AGENT_DIR) ? '(ok)' : '(MISSING)'}`)
+  console.log(`  stable agent  : ${STABLE_AGENT} ${existsSync(STABLE_AGENT) ? '(ok)' : '(not installed)'}`)
+  console.log(`  autostart vbs : ${getVbsPath()} ${existsSync(getVbsPath()) ? '(ok)' : '(not installed)'}`)
+  console.log(`  supervisor    : ${join(AGENT_DIR, 'run-agent.cmd')} ${existsSync(join(AGENT_DIR, 'run-agent.cmd')) ? '(ok)' : '(not installed — пусни --install за авторестарт при crash)'}`)
+  if (process.platform === 'win32') {
+    let wd = '(not installed — пусни --install или рестартирай агента)'
+    try { execFileSync('schtasks', ['/Query', '/TN', WATCHDOG_TASK], { stdio: 'ignore', timeout: 30_000 }); wd = '(ok — на всеки 5 мин)' } catch { /* missing */ }
+    console.log(`  watchdog      : ${WATCHDOG_TASK} ${wd}`)
+  }
+  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)'}`)
+  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 и рестартирай агента'}`)
+  if (cfg) {
+    console.log(`  machineId     : ${cfg.machineId}`)
+    console.log(`  server        : ${cfg.url}`)
+    console.log(`  interval      : ${cfg.interval}s`)
+    console.log(`  roots         :`)
+    for (const r of cfg.roots ?? []) console.log(`     - ${r} ${existsSync(r) ? '' : '(MISSING)'}`)
+    if (cfg.roots?.length) {
+      const found = scanRepos(cfg.roots)
+      console.log(`  found repos   : ${found.length}`)
+      for (const r of found) console.log(`     - ${r.name}  (${r.path})`)
+    }
+  }
+}
+// ─── Git helpers ─────────────────────────────────────────────────────────────
+// Room for large command output. `git status --porcelain -uall` (gd-369) lists
+// every untracked file individually, so a repo with a big new/untracked tree can
+// blow past execSync's default 1 MB buffer — which would throw and silently
+// return '' (an EMPTY snapshot, worse than the collapsed view). 64 MB is plenty.
+const GIT_MAX_BUFFER = 64 * 1024 * 1024
+// Cap for synthesising an untracked file's full-content diff (gd-370) — above
+// this the file keeps the "no diff" placeholder so a huge/binary blob can't
+// bloat the snapshot payload.
+const UNTRACKED_DIFF_MAX_BYTES = 1024 * 1024
+// Synthesising a per-file diff spawns a synchronous `git diff --no-index` per
+// untracked file. Individually cheap, but a repo with a huge untracked/scratch
+// tree (e.g. extracted game assets — thousands of files) would spawn thousands
+// of blocking git processes and freeze the single-threaded agent for MINUTES on
+// every snapshot, starving the 30s sync heartbeat so the machine flips offline.
+// Bound the synthesis two ways — a file-count cap and a wall-clock budget — so
+// no single repo can ever monopolise the event loop. Anything past either keeps
+// the "no diff" placeholder, identical to the size-cap path above.
+const UNTRACKED_DIFF_MAX_FILES = 200
+const UNTRACKED_DIFF_TIME_BUDGET_MS = 3000
+// Every git call here is execSync — synchronous, on the ONLY thread. A git that
+// stops to ask for credentials (a repo whose remote lost its token → Git
+// Credential Manager pops an invisible dialog) blocks the whole agent forever:
+// no ticks, no heartbeat, machine flips offline until someone restarts it
+// (gd-403). Two guards: never allow interactive prompts, and hard-timeout every
+// call so the worst case is one failed command, not a dead agent. Local
+// commands get 2 min; push/pull (network) get 5.
+const GIT_ENV = { ...process.env, GIT_TERMINAL_PROMPT: '0', GCM_INTERACTIVE: 'never' }
+const GIT_TIMEOUT_MS = 2 * 60 * 1000
+const GIT_NET_TIMEOUT_MS = 5 * 60 * 1000
+function git(cmd, cwd) {
+  try {
+    return execSync(cmd, { cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], maxBuffer: GIT_MAX_BUFFER, timeout: GIT_TIMEOUT_MS, env: GIT_ENV }).trim()
+  } catch {
+    return ''
+  }
+}
+// Like git(), but returns the RAW bytes instead of a UTF-8 string. Needed for
+// `git diff`, whose payload can be Windows-1251 (CP1251) Cyrillic — decoding
+// those bytes as UTF-8 up front would corrupt them to „�"/„?" irreversibly
+// (gd-276). Callers decode per-file via decodeDiffText().
+function gitRaw(cmd, cwd) {
+  try {
+    return execSync(cmd, { cwd, encoding: 'buffer', stdio: ['pipe', 'pipe', 'pipe'], maxBuffer: GIT_MAX_BUFFER, timeout: GIT_TIMEOUT_MS, env: GIT_ENV })
+  } catch {
+    return Buffer.alloc(0)
+  }
+}
+// Full-content diff of a single UNTRACKED file (against /dev/null), so the
+// console can show a new file's whole content as an all-added diff — like
+// GitHub Desktop (gd-370). Uses execFileSync (argv, no shell) so paths with
+// spaces / Cyrillic reach git intact, unlike a shell command string. `--no-index`
+// exits 1 when the file differs from empty (i.e. always) — that's expected, and
+// its stdout still holds the diff. Returns raw bytes for parseDiffByFile.
+function gitDiffUntracked(file, cwd) {
+  try {
+    return execFileSync('git', ['diff', '--no-index', '--', '/dev/null', file], {
+      cwd, encoding: 'buffer', stdio: ['pipe', 'pipe', 'pipe'], maxBuffer: GIT_MAX_BUFFER, timeout: GIT_TIMEOUT_MS, env: GIT_ENV,
+    })
+  } catch (err) {
+    return err && err.stdout && err.stdout.length ? err.stdout : Buffer.alloc(0)
+  }
+}
+// Like git(), but surfaces failures (with stderr) instead of swallowing them —
+// used for push/pull where we need to detect auth rejection.
+function gitTry(cmd, cwd) {
+  try {
+    const out = execSync(cmd, { cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], timeout: GIT_NET_TIMEOUT_MS, env: GIT_ENV }).trim()
+    return { ok: true, out }
+  } catch (err) {
+    const timedOut = err.signal === 'SIGTERM' && err.code == null
+    const out = (err.stderr || err.stdout || (timedOut ? `git не отговори ${GIT_NET_TIMEOUT_MS / 60000} мин и беше прекратен` : err.message) || '').toString().trim()
+    return { ok: false, out }
+  }
+}
+// Never let a token reach the log file or the server's command-result.
+function redact(text, token) {
+  if (!text || !token) return text
+  return text.split(token).join('***')
+}
+// https://x-access-token:<token>@github.com/<owner>/<repo>.git — an ad-hoc URL
+// passed straight to push/pull, so it never gets written into .git/config.
+function authUrl(auth) {
+  const repo = auth.repo.replace(/\.git$/i, '')
+  return `https://x-access-token:${auth.token}@github.com/${repo}.git`
+}
+// A push rejected because the remote branch moved ahead of us (someone else
+// pushed in the meantime). Git prints "non-fast-forward" / "fetch first" /
+// "tip of your current branch is behind". We recover by pulling+rebasing.
+const NON_FAST_FORWARD = /non-fast-forward|fetch first|tip of your current branch is behind|failed to push some refs/i
+// Point the local remote-tracking ref (e.g. refs/remotes/origin/master) at the
+// commit we just synced. We push/pull through the ad-hoc token URL, and — unlike
+// `git push origin` — pushing/pulling by URL leaves refs/remotes/origin/* UNTOUCHED.
+// getSnapshot() then measures "ahead"/"behind" against that stale tracking ref
+// (git rev-list @{u}..HEAD), so already-pushed commits keep showing as pending
+// forever: the ahead badge never clears, GitHub Desktop shows the same "N↑", and
+// the user pushes again and again while local commits pile up (gd-273). Fast-
+// forwarding the tracking ref to the true remote tip resets ahead/behind to reality.
+// Best-effort: git() swallows failures so this never breaks the push/pull itself.
+function updateTrackingRef(repoPath, branch, commitish) {
+  // Prefer the branch's configured upstream (usually origin/<branch>); fall back
+  // to origin/<branch> when no upstream is set.
+  const upstream = git('git rev-parse --abbrev-ref --symbolic-full-name @{u}', repoPath)
+  const ref = upstream ? `refs/remotes/${upstream}` : `refs/remotes/origin/${branch}`
+  git(`git update-ref "${ref}" ${commitish}`, repoPath)
+}
+// Push/pull using the server-issued token when we have one; otherwise fall back
+// to the machine's own git credentials (old behaviour). Throws on failure.
+function pushOrPull(type, repoPath, auth) {
+  const branch = git('git branch --show-current', repoPath) || 'HEAD'
+  const url = auth ? authUrl(auth) : null
+  const pushCmd = url ? `git push "${url}" HEAD:${branch}` : 'git push'
+  if (type === 'pull') {
+    const r = gitTry(url ? `git pull "${url}" ${branch}` : 'git pull', repoPath)
+    if (!r.ok) throw new Error(r.out || 'pull failed')
+    // Pulling by URL never advanced origin/<branch>; point it at the fetched tip
+    // (FETCH_HEAD) so a later push isn't seen as being "ahead" of a stale ref.
+    if (url) updateTrackingRef(repoPath, branch, 'FETCH_HEAD')
+    return r.out || 'pulled'
+  }
+  let r = gitTry(pushCmd, repoPath)
+  if (r.ok) {
+    // We just pushed HEAD to the remote branch, so the remote tip == HEAD. Sync
+    // the local tracking ref to clear the "ahead" count (gd-273).
+    if (url) updateTrackingRef(repoPath, branch, 'HEAD')
+    return r.out || 'pushed'
+  }
+  // Push rejected because the remote is ahead (gd-272): commit succeeded but the
+  // push bounced with non-fast-forward, so the files looked "pushed" while the
+  // UI showed a scary git error. Pull with --rebase to replay our commits on top
+  // of the remote ones, then push again — what the user means by "push my files".
+  if (NON_FAST_FORWARD.test(r.out)) {
+    const pull = gitTry(url ? `git pull --rebase "${url}" ${branch}` : 'git pull --rebase', repoPath)
+    if (!pull.ok) {
+      // Rebase couldn't apply cleanly (conflicts) — abort so the repo isn't left
+      // mid-rebase, and surface an actionable message instead of guessing.
+      gitTry('git rebase --abort', repoPath)
+      throw new Error(`отдалеченият клон е напред и има конфликт при обединяване — дръпни (Sync) и слей ръчно, после пусни пак.\n${pull.out}`)
+    }
+    r = gitTry(pushCmd, repoPath)
+    if (!r.ok) throw new Error(r.out || 'push failed')
+    if (url) updateTrackingRef(repoPath, branch, 'HEAD')
+    return `дръпнах новите промени от сървъра и пушнах наново.\n${r.out}`.trim()
+  }
+  throw new Error(r.out || 'push failed')
+}
+const AUTH_FAIL = /authentication|authorization|403|401|denied|could not read Username|invalid username or password|terminal prompts disabled/i
+// Discard all local changes to a SINGLE file, so it disappears from the repo's
+// "changes". Mirrors GitHub Desktop's "Discard changes": unstage first, then
+// either restore the file from HEAD (tracked) or delete it (new/untracked).
+function discardFile(repoPath, file) {
+  if (!file) throw new Error('no file')
+  // Unstage so index + worktree get reverted together (no-op if not staged).
+  gitTry(`git reset -q HEAD -- "${file}"`, repoPath)
+  // Does the file exist in the last commit? If so we restore its content; if
+  // not, it's a newly-added/untracked file and discarding means removing it.
+  const inHead = gitTry(`git cat-file -e "HEAD:${file}"`, repoPath).ok
+  if (inHead) {
+    const r = gitTry(`git checkout HEAD -- "${file}"`, repoPath)
+    if (!r.ok) throw new Error(r.out || 'checkout failed')
+    return 'discarded'
+  }
+  // New/untracked file (now unstaged) — drop it from the working tree.
+  const r = gitTry(`git clean -fdq -- "${file}"`, repoPath)
+  if (!r.ok) throw new Error(r.out || 'clean failed')
+  return 'discarded (new file removed)'
+}
+// ─── Windows-1251 (CP1251) aware diff decoding (gd-276) ───────────────────────
+// Legacy Cyrillic sources are often saved in CP1251. Their high bytes (0x80–0xFF,
+// single-byte) are invalid UTF-8, so reading the diff as UTF-8 shows „?"/„�"
+// instead of кирилица. We keep the raw bytes and decode each file's diff section
+// on its own: valid UTF-8 stays UTF-8; the rest goes through the CP1251 table
+// below — so a UTF-8 repo is untouched while CP1251 files finally read correctly.
+// CP1251 high range 0x80–0xFF → Unicode code points (0x00–0x7F is plain ASCII).
+// 0x98 is unassigned in CP1251 → U+FFFD.
+const CP1251_HIGH = [
+  0x0402, 0x0403, 0x201A, 0x0453, 0x201E, 0x2026, 0x2020, 0x2021, 0x20AC, 0x2030, 0x0409, 0x2039, 0x040A, 0x040C, 0x040B, 0x040F,
+  0x0452, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014, 0xFFFD, 0x2122, 0x0459, 0x203A, 0x045A, 0x045C, 0x045B, 0x045F,
+  0x00A0, 0x040E, 0x045E, 0x0408, 0x00A4, 0x0490, 0x00A6, 0x00A7, 0x0401, 0x00A9, 0x0404, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x0407,
+  0x00B0, 0x00B1, 0x0406, 0x0456, 0x0491, 0x00B5, 0x00B6, 0x00B7, 0x0451, 0x2116, 0x0454, 0x00BB, 0x0458, 0x0405, 0x0455, 0x0457,
+  0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417, 0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F,
+  0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427, 0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, 0x042F,
+  0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437, 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F,
+  0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447, 0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F,
+]
+function decodeCp1251(buf) {
+  let out = ''
+  for (const b of buf) out += String.fromCharCode(b < 0x80 ? b : CP1251_HIGH[b - 0x80])
+  return out
+}
+// A strict UTF-8 decoder (always available even on small-ICU builds) — throws on
+// any invalid sequence, which is exactly how we tell UTF-8 apart from CP1251.
+const UTF8_STRICT = new TextDecoder('utf-8', { fatal: true })
+function decodeDiffText(buf) {
+  try {
+    return UTF8_STRICT.decode(buf)
+  } catch {
+    return decodeCp1251(buf)
+  }
+}
+// Git C-quotes paths with spaces / special chars / non-ASCII bytes, wrapping them
+// in double quotes with backslash escapes (`"export coca_cola/x.cs"`, octal `\NNN`
+// for raw bytes). Both `git status --porcelain` and the `diff --git` header do it.
+// Left unhandled, files with spaces (or Cyrillic) got mis-keyed and their diff was
+// dropped (gd-321). This reverses it back to a plain path so the diff key matches
+// the file name shown in the list.
+function unquoteGitPath(s) {
+  if (typeof s !== 'string' || s.length < 2 || s[0] !== '"' || s[s.length - 1] !== '"') return s
+  const body = s.slice(1, -1)
+  const bytes = []
+  for (let i = 0; i < body.length; i++) {
+    if (body[i] === '\\' && i + 1 < body.length) {
+      const n = body[i + 1]
+      if (n === 'n') { bytes.push(10); i++ }
+      else if (n === 't') { bytes.push(9); i++ }
+      else if (n === 'r') { bytes.push(13); i++ }
+      else if (n === '"') { bytes.push(34); i++ }
+      else if (n === '\\') { bytes.push(92); i++ }
+      else if (n >= '0' && n <= '7') { bytes.push(parseInt(body.substr(i + 1, 3), 8) & 0xff); i += 3 }
+      else { bytes.push(body.charCodeAt(i)) }
+    } else {
+      bytes.push(body.charCodeAt(i) & 0xff)
+    }
+  }
+  return Buffer.from(bytes).toString('utf8')
+}
+// Read the b-side path from a `diff --git` header line, handling git's quoting
+// of paths with spaces / special chars (gd-321).
+function diffHeaderPath(hdr) {
+  const q = hdr.match(/ ("b\/.*")$/) // quoted:  "a/x" "b/x"
+  if (q) return unquoteGitPath(q[1]).replace(/^b\//, '')
+  const u = hdr.match(/ b\/(.*)$/) //  plain:   a/x b/x
+  return u ? u[1] : null
+}
+function parseDiffByFile(diffBuf) {
+  const files = {}
+  if (!diffBuf || diffBuf.length === 0) return files
+  // Latin1 is a lossless 1-byte⇢1-char mapping, so the ASCII "diff --git" split
+  // markers match while every original byte survives for the per-section decode.
+  const raw = Buffer.isBuffer(diffBuf) ? diffBuf.toString('latin1') : String(diffBuf)
+  const sections = raw.split(/(?=^diff --git )/m)
+  for (const section of sections) {
+    if (!section.trim()) continue
+    // Decode THIS file's bytes on their own (UTF-8 or CP1251), then read the
+    // filename from the decoded header (quoted or not).
+    const text = decodeDiffText(Buffer.from(section, 'latin1'))
+    const hdr = text.match(/^diff --git (.+)$/m)
+    const name = hdr ? diffHeaderPath(hdr[1]) : null
+    if (name) files[name] = text
+  }
+  return files
+}
+function getSnapshot(repoPath) {
+  const branch = git('git branch --show-current', repoPath) || 'HEAD'
+  // -uall lists every untracked file individually instead of collapsing a new
+  // directory into a single `dir/` entry — so the change list matches what
+  // GitHub Desktop shows, file-for-file (gd-369).
+  const statusLines = git('git status --porcelain -uall', repoPath).split('\n').filter(Boolean)
+  const modified = []
+  const staged = []
+  const statuses = {}
+  for (const line of statusLines) {
+    const xy = line.slice(0, 2)
+    const file = unquoteGitPath(line.slice(3))
+    statuses[file] = xy
+    if (xy[0] !== ' ' && xy[0] !== '?') staged.push(file)
+    if (xy[1] !== ' ') modified.push(file)
+  }
+  const aheadBy = parseInt(git('git rev-list --count @{u}..HEAD', repoPath), 10) || 0
+  const behindBy = parseInt(git('git rev-list --count HEAD..@{u}', repoPath), 10) || 0
+  const logLine = git('git log -1 --pretty=format:%H|%s|%an|%aI', repoPath)
+  let lastCommit = null
+  if (logLine) {
+    const [sha, message, author, date] = logLine.split('|')
+    lastCommit = { sha, message, author, date }
+  }
+  const diffs = parseDiffByFile(gitRaw('git diff HEAD', repoPath))
+  // Untracked files (`??`) aren't in `git diff HEAD`, so they had no content to
+  // show ("Нов или untracked файл — няма diff"). Synthesise an all-added diff for
+  // each from /dev/null so the console shows the whole new file — like GitHub
+  // Desktop (gd-370). Skip anything over the size cap so a stray big/binary blob
+  // can't bloat the snapshot; those keep the "no diff" placeholder.
+  const untracked = Object.keys(statuses).filter((f) => statuses[f] === '??' && !diffs[f])
+  const diffDeadline = Date.now() + UNTRACKED_DIFF_TIME_BUDGET_MS
+  let synthesised = 0
+  for (const file of untracked) {
+    // Stop before either bound so a scratch tree can't starve the heartbeat; the
+    // rest keep the "no diff" placeholder. Log once so it's visible why.
+    if (synthesised >= UNTRACKED_DIFF_MAX_FILES || Date.now() > diffDeadline) {
+      log(`⚠ untracked diff cap reached @ ${repoPath} (${synthesised}/${untracked.length} synthesised) — rest shown without preview`)
+      break
+    }
+    let st
+    try { st = statSync(join(repoPath, file)) } catch { continue }
+    if (!st.isFile() || st.size > UNTRACKED_DIFF_MAX_BYTES) continue
+    synthesised++
+    const parsed = parseDiffByFile(gitDiffUntracked(file, repoPath))
+    const val = parsed[file] ?? Object.values(parsed)[0]
+    if (val) diffs[file] = val
+  }
+  // Origin remote → lets the server auto-detect the GitHub repo for the History tab.
+  const remoteUrl = git('git config --get remote.origin.url', repoPath) || null
+  return { branch, modified, staged, aheadBy, behindBy, lastCommit, statuses, diffs, remoteUrl }
+}
+// ─── Repo discovery ─────────────────────────────────────────────────────────────
+// Walk each root looking for directories that contain a `.git` entry. Stop
+// descending once a repo is found (don't recurse into submodules/nested repos),
+// skip noisy dirs, and cap depth so a huge tree can't hang a tick.
+const SKIP_DIRS = new Set(['node_modules', '.next', 'dist', 'build', '.cache', 'vendor', '.venv', '__pycache__'])
+function scanRepos(roots, maxDepth = 5) {
+  const found = []
+  const seen = new Set()
+  function walk(dir, depth) {
+    if (depth > maxDepth) return
+    let entries
+    try { entries = readdirSync(dir, { withFileTypes: true }) } catch { return }
+    if (entries.some((e) => e.name === '.git')) {
+      const path = resolve(dir)
+      if (!seen.has(path)) {
+        seen.add(path)
+        found.push({ name: path.split(/[\\/]/).pop() ?? path, path })
+      }
+      return // a repo — don't descend further
+    }
+    for (const e of entries) {
+      if (!e.isDirectory()) continue
+      if (e.name.startsWith('.') || SKIP_DIRS.has(e.name)) continue
+      walk(join(dir, e.name), depth + 1)
+    }
+  }
+  for (const root of roots) walk(resolve(root), 0)
+  return found
+}
+// ─── Server sync + commands ─────────────────────────────────────────────────────
+async function api(cfg, path, body) {
+  const res = await fetch(`${cfg.url}${path}`, {
+    method: 'POST',
+    headers: { Authorization: `Bearer ${cfg.key}`, 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  })
+  if (!res.ok) {
+    const text = await res.text().catch(() => '')
+    throw new Error(`HTTP ${res.status} ${path}: ${text}`)
+  }
+  return res.json().catch(() => ({}))
+}
+async function reportCommandResult(cfg, id, status, result) {
+  await api(cfg, '/api/v1/agent/command-result', { id, status, result }).catch(() => {})
+}
+// Post a batch of console events (and optional lifecycle status) for an AiRun.
+// `usage` is sent once on the final (done/error) post so the server can record
+// how many tokens the run cost. `streamingText` / `activityText` (gd-419) carry
+// the live "being typed" preview and the latest thinking snippet — explicit ''
+// clears them; `undefined` leaves them untouched.
+async function postRunEvents(cfg, runId, events, status, result, usage, streamingText, activityText) {
+  await api(cfg, '/api/v1/agent/ai-run/events', {
+    runId,
+    events,
+    ...(status ? { status } : {}),
+    ...(result !== undefined ? { result } : {}),
+    ...(usage ? { usage } : {}),
+    ...(streamingText !== undefined ? { streamingText } : {}),
+    ...(activityText !== undefined ? { activityText } : {}),
+  }).catch((e) => log(`✗ ai-run events post failed: ${e.message}`))
+}
+// Post transcript lines (and optional turn status / Claude session id) for an
+// interactive AiSession chat turn.
+async function postSessionEvents(cfg, sessionId, events, status, claudeSessionId, streamingText, activityText) {
+  await api(cfg, '/api/v1/agent/ai-session/events', {
+    sessionId,
+    events,
+    ...(status ? { status } : {}),
+    ...(claudeSessionId ? { claudeSessionId } : {}),
+    // Explicit '' clears the live preview; `undefined` leaves it untouched.
+    ...(streamingText !== undefined ? { streamingText } : {}),
+    // Same semantics for the live thinking snippet (gd-419).
+    ...(activityText !== undefined ? { activityText } : {}),
+  }).catch((e) => log(`✗ ai-session events post failed: ${e.message}`))
+}
+// Turn one stream-json line from `claude -p` into console events. Phase 1 shows
+// what the model writes (TEXT) and which tools it calls (TOOL_CALL); raw tool
+// results (Bash stdout etc.) come in Phase 2 via a PostToolUse hook.
+// With `--include-partial-messages`, Claude also emits `stream_event` lines
+// carrying incremental text deltas — onDelta gets those so chat sessions can
+// show the reply being written live (gd-302).
+// "12.3k" / "1.2M" compaction for the console token summary line.
+function fmtTokens(n) {
+  n = Number(n) || 0
+  if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`
+  if (n >= 1_000) return `${(n / 1_000).toFixed(1)}k`
+  return String(n)
+}
+function parseStreamLine(line, push, onInit, onDelta, onMeta, onTurnEnd) {
+  let ev
+  try { ev = JSON.parse(line) } catch { return }
+  if (ev.type === 'system') {
+    if (ev.subtype === 'init') {
+      push('SYSTEM', `Сесия стартирана${ev.model ? ` (${ev.model})` : ''}.`)
+      // Surface Claude's own session id so chat sessions can --resume it.
+      if (ev.session_id && typeof onInit === 'function') onInit(ev.session_id)
+      // Remember which model ran, for the token/cost record (gd-334).
+      if (ev.model && typeof onMeta === 'function') onMeta({ model: ev.model })
+    }
+    return
+  }
+  // Partial-message stream: the model's visible text deltas feed the live
+  // preview, its thinking deltas feed the gray "какво прави АИ-то" snippet
+  // (gd-419). Tool-input JSON deltas stay ignored — the full block still
+  // arrives as a normal `assistant` event below.
+  if (ev.type === 'stream_event' && typeof onDelta === 'function') {
+    const e = ev.event
+    if (e?.type === 'content_block_delta') {
+      if (e.delta?.type === 'text_delta' && e.delta.text) onDelta(e.delta.text, 'text')
+      else if (e.delta?.type === 'thinking_delta' && e.delta.thinking) onDelta(e.delta.thinking, 'thinking')
+    } else if (e?.type === 'content_block_start' && e.content_block?.type === 'thinking') {
+      // A fresh thought begins — reset the snippet so old and new don't blend.
+      onDelta('', 'thinking-start')
+    }
+    return
+  }
+  if (ev.type === 'assistant' && ev.message?.content) {
+    for (const block of ev.message.content) {
+      if (block.type === 'text' && block.text?.trim()) {
+        push('TEXT', block.text.trim())
+      } else if (block.type === 'tool_use') {
+        const input = block.input ? JSON.stringify(block.input) : ''
+        push('TOOL_CALL', `${block.name}${input ? ` ${input.slice(0, 400)}` : ''}`)
+      }
+    }
+    return
+  }
+  if (ev.type === 'result') {
+    if (ev.subtype && ev.subtype !== 'success') push('SYSTEM', `Резултат: ${ev.subtype}`)
+    // claude's final result carries cumulative token usage + its own cost.
+    // Prefer `modelUsage` (summed over every model/subagent turn) which is the
+    // true cumulative; top-level `usage` is often just the last turn. Fall back
+    // to `usage` when modelUsage is absent (older CLI).
+    if (typeof onMeta === 'function' && (ev.modelUsage || ev.usage || typeof ev.total_cost_usd === 'number')) {
+      let usage
+      let model
+      if (ev.modelUsage && typeof ev.modelUsage === 'object') {
+        const acc = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheCreateTokens: 0 }
+        for (const [name, mu] of Object.entries(ev.modelUsage)) {
+          if (!model) model = name
+          acc.inputTokens += mu.inputTokens ?? mu.input_tokens ?? 0
+          acc.outputTokens += mu.outputTokens ?? mu.output_tokens ?? 0
+          acc.cacheReadTokens += mu.cacheReadInputTokens ?? mu.cache_read_input_tokens ?? 0
+          acc.cacheCreateTokens += mu.cacheCreationInputTokens ?? mu.cache_creation_input_tokens ?? 0
+        }
+        usage = acc
+      } else if (ev.usage) {
+        const u = ev.usage
+        usage = {
+          inputTokens: u.input_tokens ?? 0,
+          outputTokens: u.output_tokens ?? 0,
+          cacheReadTokens: u.cache_read_input_tokens ?? 0,
+          cacheCreateTokens: u.cache_creation_input_tokens ?? 0,
+        }
+      }
+      onMeta({
+        ...(usage ? { usage } : {}),
+        ...(model ? { model } : {}),
+        costUsd: typeof ev.total_cost_usd === 'number' ? ev.total_cost_usd : undefined,
+      })
+    }
+    // Turn boundary (gd-421): in the persistent stream-json chat mode every
+    // completed reply ends with a `result` event while the process stays alive
+    // waiting for the next stdin message — this is what ends the chat turn.
+    if (typeof onTurnEnd === 'function') onTurnEnd(ev.subtype)
+  }
+}
+// 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
+// claude process). Returns the settings path to pass via --settings.
+const AI_HOOK_SCRIPT = join(AGENT_DIR, 'ai-run-hook.mjs')
+const AI_SETTINGS_PATH = join(AGENT_DIR, 'ai-run-settings.json')
+function ensureAiHookFiles() {
+  ensureAgentDir()
+  const hookSrc = [
+    "import process from 'node:process'",
+    "let data = ''",
+    "process.stdin.setEncoding('utf8')",
+    "process.stdin.on('data', (c) => { data += c })",
+    'process.stdin.on(\'end\', async () => {',
+    '  try {',
+    "    const ev = JSON.parse(data || '{}')",
+    '    const url = process.env.GITDONE_URL, key = process.env.GITDONE_KEY, runId = process.env.GITDONE_RUN_ID',
+    '    if (url && key && runId) {',
+    "      const name = ev.tool_name || 'tool'",
+    '      const o = ev.tool_output',
+    "      let out = ''",
+    "      if (typeof o === 'string') out = o",
+    "      else if (o && typeof o === 'object') out = o.text || o.stdout || o.content || JSON.stringify(o)",
+    "      out = String(out || '').slice(0, 2000)",
+    "      const inp = ev.tool_input ? JSON.stringify(ev.tool_input).slice(0, 300) : ''",
+    "      const text = name + (inp ? ' ' + inp : '') + (out ? '\\n' + out : ' ✓')",
+    "      await fetch(url + '/api/v1/agent/ai-run/events', {",
+    "        method: 'POST',",
+    "        headers: { Authorization: 'Bearer ' + key, 'Content-Type': 'application/json' },",
+    "        body: JSON.stringify({ runId, events: [{ kind: 'TOOL_RESULT', text }] }),",
+    '      }).catch(() => {})',
+    '    }',
+    '  } catch {}',
+    '  process.exit(0)',
+    '})',
+  ].join('\n')
+  writeFileSync(AI_HOOK_SCRIPT, hookSrc, 'utf8')
+  const nodePath = getNodePath()
+  const settings = {
+    hooks: {
+      PostToolUse: [
+        { matcher: '', hooks: [{ type: 'command', command: `"${nodePath}" "${AI_HOOK_SCRIPT}"` }] },
+      ],
+    },
+  }
+  writeFileSync(AI_SETTINGS_PATH, JSON.stringify(settings, null, 2), 'utf8')
+  return AI_SETTINGS_PATH
+}
+// Same PostToolUse hook, for interactive chat sessions: posts raw tool output to
+// the session endpoint, reading GITDONE_SESSION_ID from the per-turn env.
+const AI_SESSION_HOOK_SCRIPT = join(AGENT_DIR, 'ai-session-hook.mjs')
+const AI_SESSION_SETTINGS_PATH = join(AGENT_DIR, 'ai-session-settings.json')
+function ensureAiSessionHookFiles() {
+  ensureAgentDir()
+  const hookSrc = [
+    "import process from 'node:process'",
+    "let data = ''",
+    "process.stdin.setEncoding('utf8')",
+    "process.stdin.on('data', (c) => { data += c })",
+    'process.stdin.on(\'end\', async () => {',
+    '  try {',
+    "    const ev = JSON.parse(data || '{}')",
+    '    const url = process.env.GITDONE_URL, key = process.env.GITDONE_KEY, sessionId = process.env.GITDONE_SESSION_ID',
+    '    if (url && key && sessionId) {',
+    "      const name = ev.tool_name || 'tool'",
+    '      const o = ev.tool_output',
+    "      let out = ''",
+    "      if (typeof o === 'string') out = o",
+    "      else if (o && typeof o === 'object') out = o.text || o.stdout || o.content || JSON.stringify(o)",
+    "      out = String(out || '').slice(0, 2000)",
+    "      const inp = ev.tool_input ? JSON.stringify(ev.tool_input).slice(0, 300) : ''",
+    "      const text = name + (inp ? ' ' + inp : '') + (out ? '\\n' + out : ' ✓')",
+    "      await fetch(url + '/api/v1/agent/ai-session/events', {",
+    "        method: 'POST',",
+    "        headers: { Authorization: 'Bearer ' + key, 'Content-Type': 'application/json' },",
+    "        body: JSON.stringify({ sessionId, events: [{ role: 'TOOL_RESULT', text }] }),",
+    '      }).catch(() => {})',
+    '    }',
+    '  } catch {}',
+    '  process.exit(0)',
+    '})',
+  ].join('\n')
+  writeFileSync(AI_SESSION_HOOK_SCRIPT, hookSrc, 'utf8')
+  const nodePath = getNodePath()
+  const settings = {
+    hooks: {
+      PostToolUse: [
+        { matcher: '', hooks: [{ type: 'command', command: `"${nodePath}" "${AI_SESSION_HOOK_SCRIPT}"` }] },
+      ],
+    },
+  }
+  writeFileSync(AI_SESSION_SETTINGS_PATH, JSON.stringify(settings, null, 2), 'utf8')
+  return AI_SESSION_SETTINGS_PATH
+}
+// gitdone MCP config for headless sessions (gd-308). We provide it ourselves —
+// with an X-Gitdone-Machine-Id header — so the server can attribute the AI agents
+// this session registers (ai_agent_start) to THIS computer, and the „АИ Агенти"
+// panel shows one sub-panel per machine instead of a single „Локален агент".
+// Used with --strict-mcp-config so the session uses exactly this server. The
+// agent's own key (a gdo_ key) authenticates the MCP endpoint.
+const AI_MCP_CONFIG_PATH = join(AGENT_DIR, 'ai-mcp-config.json')
+function ensureAiMcpConfig(cfg) {
+  ensureAgentDir()
+  const config = {
+    mcpServers: {
+      gitdone: {
+        type: 'http',
+        url: `${cfg.url}/api/mcp`,
+        headers: {
+          Authorization: `Bearer ${cfg.key}`,
+          'X-Gitdone-Machine-Id': cfg.machineId,
+        },
+      },
+    },
+  }
+  writeFileSync(AI_MCP_CONFIG_PATH, JSON.stringify(config, null, 2), 'utf8')
+  return AI_MCP_CONFIG_PATH
+}
+// Sanitise the model value from a command payload into a safe `--model`
+// argument. gitDone sends a stable CLI alias ("opus"/"sonnet"/"haiku"), but we
+// also allow a full model id (letters, digits, dot, dash). Anything else — or a
+// missing value — yields null, so the agent falls back to the machine's own
+// default model. Bounds the length as a belt-and-braces guard (gd-354).
+function aiModelArg(raw) {
+  if (typeof raw !== 'string') return null
+  const m = raw.trim()
+  if (!m || m.length > 100) return null
+  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.
+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)
+  if (!runId || !prompt) {
+    reportCommandResult(cfg, cmd.id, 'error', 'invalid ai_run payload')
+    return
+  }
+  const { path: claudePath, shell, found } = 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')
+    return
+  }
+  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}`) }
+  // 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',
+    // 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'] : []),
+  ]
+  // The PostToolUse hook reads these from its env to post raw tool output.
+  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.
+  let pending = []
+  let flushing = false
+  let liveText = '' // in-progress text of the current assistant block (live preview)
+  let sentLive = '' // last streamingText we posted — only push on change
+  let liveActivity = '' // latest thinking snippet — "какво прави АИ-то" (gd-419)
+  let sentActivity = ''
+  const flush = async () => {
+    if (flushing) return
+    const liveChanged = liveText !== sentLive
+    const activityChanged = liveActivity !== sentActivity
+    if (pending.length === 0 && !liveChanged && !activityChanged) return
+    flushing = true
+    const batch = pending; pending = []
+    const streamingText = liveChanged ? liveText : undefined
+    const activityText = activityChanged ? liveActivity : undefined
+    sentLive = liveText
+    sentActivity = liveActivity
+    await postRunEvents(cfg, runId, batch, undefined, undefined, undefined, streamingText, activityText)
+    flushing = false
+  }
+  const push = (kind, text) => {
+    if (text == null || String(text) === '') return
+    // A completed text block becomes a real event — drop its live preview; any
+    // new event also supersedes the last thinking snippet.
+    if (kind === 'TEXT') liveText = ''
+    liveActivity = ''
+    pending.push({ kind, text: String(text) })
+  }
+  const onDelta = (chunk, type) => {
+    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 }
+    liveText += chunk
+  }
+  const timer = setInterval(flush, 500)
+  // Accumulate model + token usage across the stream (model from init, usage
+  // from the final result event) to report once on exit (gd-334).
+  const meta = { model: undefined, usage: undefined, costUsd: undefined }
+  const onMeta = (m) => {
+    if (m.model) meta.model = m.model
+    if (m.usage) meta.usage = m.usage
+    if (typeof m.costUsd === 'number') meta.costUsd = m.costUsd
+  }
+  log(`▶ ai_run ${runId} @ ${repoPath} via ${claudePath}`)
+  postRunEvents(cfg, runId, [{ kind: 'SYSTEM', text: `Стартиране на Claude Code в ${repoPath}…` }], 'running')
+  let child
+  try {
+    child = spawn(claudePath, args, { cwd: repoPath, shell, windowsHide: true, env: childEnv })
+  } catch (err) {
+    clearInterval(timer)
+    postRunEvents(cfg, runId, [{ kind: 'SYSTEM', text: `Грешка при стартиране: ${err.message}` }], 'error', err.message)
+    reportCommandResult(cfg, cmd.id, 'error', err.message)
+    return
+  }
+  // Write the prompt to stdin and close it so Claude reads it as the task.
+  // 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() }
+    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) parseStreamLine(line, push, undefined, onDelta, onMeta)
+    }
+  })
+  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) => {
+    clearInterval(timer)
+    if (buf.trim()) parseStreamLine(buf.trim(), push, undefined, onDelta, onMeta)
+    liveText = '' // run is over — drop any lingering live preview / thought
+    liveActivity = ''
+    await flush()
+    const ok = code === 0
+    // Build the usage payload + a console summary line from what we saw.
+    const usage = meta.usage
+      ? { model: meta.model, ...meta.usage, ...(typeof meta.costUsd === 'number' ? { costUsd: meta.costUsd } : {}) }
+      : undefined
+    const events = [{ kind: 'SYSTEM', text: ok ? '✓ Готово.' : `✗ Процесът приключи с код ${code}.` }]
+    if (usage) events.push({ kind: 'SYSTEM', text: `📊 Токени: ${fmtTokens(usage.inputTokens)} вход · ${fmtTokens(usage.outputTokens)} изход${usage.cacheReadTokens ? ` · ${fmtTokens(usage.cacheReadTokens)} кеш` : ''}${typeof usage.costUsd === 'number' ? ` · $${usage.costUsd.toFixed(4)}` : ''}` })
+    await postRunEvents(
+      cfg, runId,
+      events,
+      ok ? 'done' : 'error',
+      ok ? 'ok' : `exit ${code}`,
+      usage,
+    )
+    reportCommandResult(cfg, cmd.id, ok ? 'done' : 'error', `exit ${code}`)
+    log(`■ ai_run ${runId} приключи (code ${code})`)
+  })
+}
+// Download the images attached to a chat turn to a per-session temp dir and
+// return their local paths. `claude -p` can't take image URLs on stdin, so we
+// fetch them locally and point Claude at the files (its Read tool renders
+// images). Best-effort: a failed download is skipped, not fatal.
+async function downloadSessionImages(sessionId, urls) {
+  const dir = join(tmpdir(), `gitdone-ai-${sessionId}`)
+  mkdirSync(dir, { recursive: true })
+  const paths = []
+  for (let i = 0; i < urls.length; i++) {
+    try {
+      const res = await fetch(urls[i])
+      if (!res.ok) { log(`✗ image download HTTP ${res.status}: ${urls[i]}`); continue }
+      const buf = Buffer.from(await res.arrayBuffer())
+      const m = /\.(png|jpe?g|gif|webp|bmp)(?:\?|$)/i.exec(urls[i])
+      const ext = m ? m[1].toLowerCase() : 'png'
+      const file = join(dir, `image-${i + 1}.${ext}`)
+      writeFileSync(file, buf)
+      paths.push(file)
+    } catch (e) {
+      log(`✗ image download failed (${urls[i]}): ${e.message}`)
+    }
+  }
+  return { dir, paths }
+}
+// ─── 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
+// start + transcript reload + MCP handshake on EVERY message, which read as
+// „конзолата е бавна". Now the first message of a session spawns claude with
+// --input-format stream-json and KEEPS STDIN OPEN; each following message is a
+// single JSON line, so the reply starts within seconds — like a local cmd. Each
+// completed reply emits a `result` event (the turn boundary); the process waits
+// for the next message. A pool entry:
+//   { sessionId, child, busy, stopped, lastUsedAt, allowCommit,
+//     capturedSession, turn }
+// where `turn` (non-null only while a reply is streaming) holds the per-turn
+// stream state: { cmdId, imgDir, startedAt, timer, flushing, pending,
+//                 liveText, sentLive, liveActivity, sentActivity, lastPostAt }.
+const chatProcs = new Map()
+const CHAT_PROC_MAX = 3 // each live claude holds real RAM — LRU-evict past this
+const CHAT_PROC_IDLE_MS = 30 * 60 * 1000 // idle processes die after 30 min
+const CHAT_TURN_MAX_MS = 60 * 60 * 1000 // a turn stuck past 1h → kill (watchdog)
+// Map console kinds → session transcript roles (model text → ASSISTANT).
+const chatRoleFor = (kind) => (kind === 'TEXT' ? 'ASSISTANT' : kind)
+// Reap idle/stuck session processes. Killing between turns is silent (the
+// session is already idle server-side); the next message respawns with
+// --resume. Started lazily with the first spawn so setup CLI paths never tick.
+let chatSweepTimer = null
+function ensureChatSweep() {
+  if (chatSweepTimer) return
+  chatSweepTimer = setInterval(() => {
+    const now = Date.now()
+    for (const entry of chatProcs.values()) {
+      if (!entry.busy && now - entry.lastUsedAt > CHAT_PROC_IDLE_MS) {
+        log(`… ai_chat proc ${entry.sessionId} бездейства ${Math.round(CHAT_PROC_IDLE_MS / 60000)} мин — спирам го (следващият ход ще го върне с --resume)`)
+        killTree(entry.child)
+      } else if (entry.busy && entry.turn && now - entry.turn.startedAt > CHAT_TURN_MAX_MS) {
+        log(`✗ ai_chat ход в ${entry.sessionId} върви над ${Math.round(CHAT_TURN_MAX_MS / 60000)} мин — убивам процеса`)
+        killTree(entry.child)
+      }
+    }
+  }, 60_000)
+}
+// Periodic flush of one running turn's stream state to the server (250ms —
+// what makes the console feel live). Includes the 2.5s keep-alive heartbeat.
+async function flushChatTurn(cfg, entry) {
+  const t = entry.turn
+  if (!t || t.flushing) return
+  const hasEvents = t.pending.length > 0
+  const liveChanged = t.liveText !== t.sentLive
+  const activityChanged = t.liveActivity !== t.sentActivity
+  const heartbeat = !hasEvents && !liveChanged && !activityChanged && Date.now() - t.lastPostAt > 2500
+  if (!hasEvents && !liveChanged && !activityChanged && !heartbeat) return
+  t.flushing = true
+  const batch = t.pending.map((e) => ({ role: chatRoleFor(e.kind), text: e.text })); t.pending = []
+  const streamingText = liveChanged ? t.liveText : undefined
+  const activityText = activityChanged ? t.liveActivity : undefined
+  t.sentLive = t.liveText
+  t.sentActivity = t.liveActivity
+  await postSessionEvents(cfg, entry.sessionId, batch, 'running', entry.capturedSession || undefined, streamingText, activityText)
+  t.lastPostAt = Date.now()
+  t.flushing = false
+}
+// End the running turn of a session process: post the tail events + terminal
+// status, report the command, and put the entry back to idle (process alive).
+// outcome: { ok: true } | { ok: false, code } | { stopped: true }.
+async function finishChatTurn(cfg, entry, outcome) {
+  const t = entry.turn
+  if (!t) return
+  entry.turn = null
+  entry.busy = false
+  entry.lastUsedAt = Date.now()
+  clearInterval(t.timer)
+  if (t.imgDir) { try { rmSync(t.imgDir, { recursive: true, force: true }) } catch { /* best-effort */ } }
+  // Let an in-flight periodic flush land first, so its 'running' post can't
+  // race past the terminal 'idle' post and re-lock the console.
+  for (let i = 0; i < 20 && t.flushing; i++) await new Promise((r) => setTimeout(r, 100))
+  const batch = t.pending.map((e) => ({ role: chatRoleFor(e.kind), text: e.text }))
+  t.pending = []
+  if (outcome.stopped) {
+    batch.push({ role: 'SYSTEM', text: '⏹ Спряно. Напиши още нещо, за да продължим разговора.' })
+    await postSessionEvents(cfg, entry.sessionId, batch, 'idle', entry.capturedSession || undefined, '', '')
+    reportCommandResult(cfg, t.cmdId, 'done', 'stopped by user')
+    log(`⏹ ai_chat ${entry.sessionId} спряно от потребителя`)
+    return
+  }
+  if (!outcome.ok) {
+    batch.push({ role: 'SYSTEM', text: `✗ Ходът приключи с код ${outcome.code}.` })
+    await postSessionEvents(cfg, entry.sessionId, batch, 'error', entry.capturedSession || undefined, '', '')
+    reportCommandResult(cfg, t.cmdId, 'error', `exit ${outcome.code}`)
+    log(`✗ ai_chat ход в ${entry.sessionId} падна (code ${outcome.code})`)
+    return
+  }
+  await postSessionEvents(cfg, entry.sessionId, batch, 'idle', entry.capturedSession || undefined, '', '')
+  reportCommandResult(cfg, t.cmdId, 'done', 'ok')
+  log(`✓ ai_chat ход в ${entry.sessionId} приключи (процесът остава жив)`)
+}
+// Spawn the persistent claude process for one session and wire its stream
+// handlers once. Turns come and go via entry.turn; the process stays.
+function spawnChatProc(cfg, opts) {
+  const { sessionId, repoPath, model, allowCommit, resumeId, claudePath, shell, settingsPath, mcpConfigPath } = opts
+  // Room in the pool: evict the least-recently-used idle process first.
+  if (chatProcs.size >= CHAT_PROC_MAX) {
+    const idle = [...chatProcs.values()].filter((e) => !e.busy).sort((a, b) => a.lastUsedAt - b.lastUsedAt)[0]
+    if (idle) { log(`… ai_chat pool пълен — спирам най-стария процес (${idle.sessionId})`); killTree(idle.child) }
+  }
+  const args = [
+    '-p',
+    // The whole point (gd-421): messages arrive as JSON lines on an OPEN stdin,
+    // so one process serves every turn of the session — no cold start per turn.
+    '--input-format', 'stream-json',
+    '--output-format', 'stream-json',
+    '--verbose',
+    // Stream the reply token-by-token + thinking deltas (gd-302, gd-419).
+    '--include-partial-messages',
+    // Model resolved for this session (picker / project default); omitted →
+    // machine default (gd-354). Kept consistent across the session's turns.
+    ...(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 *)']),
+    ...(resumeId ? ['--resume', resumeId] : []),
+    ...(settingsPath ? ['--settings', settingsPath] : []),
+    // Our own gitdone MCP, tagged with this machine so ai_agent_start attributes
+    // the agents to this computer (gd-308). --strict = use exactly this server.
+    ...(mcpConfigPath ? ['--mcp-config', mcpConfigPath, '--strict-mcp-config'] : []),
+  ]
+  const childEnv = { ...process.env, GITDONE_URL: cfg.url, GITDONE_KEY: cfg.key, GITDONE_SESSION_ID: sessionId }
+  const child = spawn(claudePath, args, { cwd: repoPath, shell, windowsHide: true, env: childEnv })
+  const entry = {
+    sessionId, child, busy: false, stopped: false, lastUsedAt: Date.now(),
+    allowCommit, capturedSession: resumeId || null, turn: null,
+  }
+  if (child.stdin) child.stdin.on('error', () => {})
+  const push = (kind, text) => {
+    const t = entry.turn
+    if (!t || text == null || String(text) === '') return
+    // A completed text block becomes a real event — drop its live preview so the
+    // finalised bubble and the cleared preview swap in on the same flush. Any
+    // new event also supersedes the last thinking snippet (gd-419).
+    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 }
+    // Keep only the tail — the freshest thought is what the gray line shows.
+    if (type === 'thinking') { t.liveActivity = (t.liveActivity + chunk).slice(-4000); return }
+    t.liveText += chunk
+  }
+  const onTurnEnd = () => { finishChatTurn(cfg, entry, { ok: true }) }
+  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) parseStreamLine(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()) parseStreamLine(buf.trim(), push, onInit, onDelta)
+    // A turn was in flight when the process died: user stop → idle with the
+    // friendly note; a crash → error. No turn → quiet cleanup (idle reap).
+    if (entry.turn) {
+      await finishChatTurn(cfg, entry, entry.stopped ? { stopped: true } : { ok: false, code })
+    }
+    log(`■ ai_chat proc ${sessionId} приключи (code ${code})`)
+  })
+  chatProcs.set(sessionId, entry)
+  ensureChatSweep()
+  return entry
+}
+// Kill a process AND its descendants. `claude` spawns its own children (bash,
+// node hooks), so killing just the top pid would orphan them. Windows needs
+// `taskkill /T`; POSIX kills the process group, falling back to a hard kill.
+function killTree(child) {
+  const pid = child?.pid
+  if (!pid) return
+  if (process.platform === 'win32') {
+    try { spawn('taskkill', ['/PID', String(pid), '/T', '/F'], { windowsHide: true }) } catch { /* best-effort */ }
+  } else {
+    try { process.kill(-pid, 'SIGKILL') } catch { try { child.kill('SIGKILL') } catch { /* gone */ } }
+  }
+}
+// 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
+// (or a turn after a kill / policy change) pays the spawn + --resume cost.
+// Long-running + fire-and-forget like ai_run.
+async function runAiChat(cfg, cmd, repoPath) {
+  const sessionId = cmd.payload?.sessionId
+  const prompt = cmd.payload?.prompt ?? ''
+  const images = Array.isArray(cmd.payload?.images) ? cmd.payload.images.filter((u) => typeof u === 'string' && u) : []
+  const claudeSessionId = cmd.payload?.claudeSessionId || null
+  const allowCommit = cmd.payload?.allowCommit === true
+  const model = aiModelArg(cmd.payload?.model)
+  // 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')
+    return
+  }
+  let entry = chatProcs.get(sessionId)
+  // The pooled process can't serve this turn: it already exited, or the repo's
+  // commit policy flipped since spawn (the flags are frozen on the command
+  // line). Kill it and respawn with --resume — context carries over.
+  if (entry && (entry.child.exitCode !== null || entry.allowCommit !== allowCommit)) {
+    killTree(entry.child)
+    chatProcs.delete(sessionId)
+    entry = null
+  }
+  // The server refuses a message while a turn RUNs, so this is belt-and-braces
+  // against a duplicate command delivery.
+  if (entry && entry.busy) {
+    reportCommandResult(cfg, cmd.id, 'error', 'turn already running')
+    return
+  }
+  if (!entry) {
+    const { path: claudePath, shell, found } = findClaude()
+    if (!found) {
+      const msg = `Claude Code CLI не е намерен на този компютър (${cfg.hostname}). Инсталирай го от claude.ai/code и се увери, че „claude" е в PATH, после рестартирай агента.`
+      log(`✗ ai_chat ${sessionId}: claude not found`)
+      postSessionEvents(cfg, sessionId, [{ role: 'SYSTEM', text: `✗ ${msg}` }], 'error')
+      reportCommandResult(cfg, cmd.id, 'error', 'claude not found')
+      return
+    }
+    let settingsPath
+    try { settingsPath = ensureAiSessionHookFiles() } catch (e) { log(`✗ ai session hook setup failed: ${e.message}`) }
+    let mcpConfigPath
+    try { mcpConfigPath = ensureAiMcpConfig(cfg) } catch (e) { log(`✗ ai mcp config setup failed: ${e.message}`) }
+    try {
+      entry = spawnChatProc(cfg, { sessionId, repoPath, model, allowCommit, resumeId: claudeSessionId, claudePath, shell, settingsPath, mcpConfigPath })
+    } catch (err) {
+      postSessionEvents(cfg, sessionId, [{ role: 'SYSTEM', text: `Грешка при стартиране: ${err.message}` }], 'error')
+      reportCommandResult(cfg, cmd.id, 'error', err.message)
+      return
+    }
+    log(`▶ ai_chat proc за ${sessionId} @ ${repoPath} (resume=${claudeSessionId ? 'yes' : 'no'}) via ${claudePath}`)
+  }
+  // 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).
+  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}]`
+    }
+  }
+  // Open the turn BEFORE writing the message, so even the earliest output
+  // (the init line of a fresh spawn) lands in the turn's stream state.
+  entry.busy = true
+  entry.stopped = false
+  entry.lastUsedAt = Date.now()
+  entry.turn = {
+    cmdId: cmd.id, imgDir, startedAt: Date.now(), timer: null, flushing: false,
+    pending: [], liveText: '', sentLive: '', liveActivity: '', sentActivity: '', lastPostAt: 0,
+  }
+  entry.turn.timer = setInterval(() => flushChatTurn(cfg, entry), 250)
+  // The message itself: one JSON line; stdin STAYS OPEN for the next turn.
+  try {
+    entry.child.stdin.write(JSON.stringify({
+      type: 'user',
+      message: { role: 'user', content: [{ type: 'text', text: fullPrompt }] },
+    }) + '\n')
+  } catch (err) {
+    // Pipe already broken (process died as we wrote) — fail the turn; the next
+    // message respawns cleanly with --resume.
+    killTree(entry.child)
+    await finishChatTurn(cfg, entry, { ok: false, code: `stdin: ${err.message}` })
+    return
+  }
+  log(`▶ ai_chat ход ${sessionId} (images=${images.length})`)
+}
+// ai_chat_stop — interrupt a running chat turn the user asked to stop (gd-303).
+// Kills the session's process (its `close` handler posts the "⏹ Спряно" note
+// and flips the session to idle); the next message respawns it with --resume.
+// If nothing is running, just idles the session so the console unlocks.
+function stopAiChat(cfg, cmd) {
+  const sessionId = cmd.payload?.sessionId
+  const entry = sessionId ? chatProcs.get(sessionId) : null
+  if (!entry || !entry.busy) {
+    if (sessionId) postSessionEvents(cfg, sessionId, [], 'idle', undefined, '', '')
+    reportCommandResult(cfg, cmd.id, 'done', 'no active turn')
+    return
+  }
+  entry.stopped = true
+  killTree(entry.child)
+  log(`⏹ ai_chat_stop ${sessionId} — kill signalled`)
+  reportCommandResult(cfg, cmd.id, 'done', 'stop signalled')
+}
+// deploy — run the project's deploy script (scripts/deploy.sh) in the repo.
+// Long-running (git pull + npm build + service restart), so we spawn it detached
+// from the poll loop and report the result on exit. The agent is its OWN process
+// (not part of any gitdone systemd service), so a `systemctl restart` inside the
+// script doesn't kill the deploy mid-flight — which a server-side spawn would.
+function runDeployCommand(cfg, cmd, repoPath) {
+  const script = 'scripts/deploy.sh'
+  if (!existsSync(join(repoPath, script))) {
+    reportCommandResult(cfg, cmd.id, 'error', `няма ${script} в repo-то — няма какво да деплойна`)
+    log(`✗ deploy @ ${repoPath}: липсва ${script}`)
+    return
+  }
+  log(`▸ deploy стартиран @ ${repoPath}`)
+  const child = spawn('bash', [script], { cwd: repoPath, stdio: ['ignore', 'pipe', 'pipe'] })
+  // Keep only the tail of the output — enough to explain a failure without
+  // shipping a whole build log back.
+  let tail = ''
+  const capture = (d) => { tail = (tail + d.toString()).slice(-2000) }
+  child.stdout.on('data', capture)
+  child.stderr.on('data', capture)
+  child.on('error', (err) => {
+    reportCommandResult(cfg, cmd.id, 'error', `процесна грешка: ${err.message}`)
+    log(`✗ deploy failed @ ${repoPath}: ${err.message}`)
+  })
+  child.on('close', (code) => {
+    const ok = code === 0
+    const detail = tail.trim() ? `\n${tail.trim()}` : ''
+    reportCommandResult(cfg, cmd.id, ok ? 'done' : 'error', `exit ${code}${detail}`.slice(0, 4000))
+    log(`${ok ? '✓' : '✗'} deploy @ ${repoPath} приключи (code ${code})`)
+  })
+}
+async function executeCommand(cfg, cmd, repoPath) {
+  // ai_run is long-running + streaming — launch it in the background and return
+  // so the snapshot loop keeps going. It reports its own result on exit.
+  if (cmd.type === 'ai_run') {
+    runAiCommand(cfg, cmd, repoPath)
+    return
+  }
+  // ai_chat — one interactive turn, same fire-and-forget model.
+  if (cmd.type === 'ai_chat') {
+    runAiChat(cfg, cmd, repoPath)
+    return
+  }
+  // ai_chat_stop — interrupt the running turn for a session (gd-303). Handled
+  // inline (it just signals a kill) and reports its own result.
+  if (cmd.type === 'ai_chat_stop') {
+    stopAiChat(cfg, cmd)
+    return
+  }
+  // deploy — run the repo's deploy script. Long-running (pull + build + service
+  // restart), so it's launched in the background and reports its own result on
+  // exit, same as ai_run.
+  if (cmd.type === 'deploy') {
+    runDeployCommand(cfg, cmd, repoPath)
+    return
+  }
+  let result = 'ok'
+  let status = 'done'
+  const auth = cfg.auth?.[repoPath] ?? null
+  try {
+    if (cmd.type === 'commit') {
+      const msg = (cmd.payload?.message ?? 'commit').replace(/"/g, '\\"')
+      // When the UI sends a list of selected files, stage ONLY those so the
+      // resulting commit (and the push that follows) contains just the checked
+      // files. No list → stage everything (old behaviour / older UIs).
+      const files = Array.isArray(cmd.payload?.files)
+        ? cmd.payload.files.filter((f) => typeof f === 'string' && f.trim())
+        : []
+      if (files.length) {
+        const quoted = files.map((f) => `"${f.replace(/"/g, '\\"')}"`).join(' ')
+        git(`git add -- ${quoted}`, repoPath)
+      } else {
+        git('git add -A', repoPath)
+      }
+      result = git(`git commit -m "${msg}"`, repoPath) || 'committed'
+    } else if (cmd.type === 'push' || cmd.type === 'pull') {
+      result = pushOrPull(cmd.type, repoPath, auth)
+    } else if (cmd.type === 'discard') {
+      result = discardFile(repoPath, cmd.payload?.file)
+    } else {
+      // Unknown command type — almost always a newer server feature (e.g. the
+      // gd-255 `deploy` command) reaching an agent too old to handle it. Do NOT
+      // silently mark it done: an older agent used to fall through here and
+      // report status=done/result=ok, so a queued deploy looked "completed" while
+      // nothing ran. Surface it as an error so the failure is visible and the
+      // user knows to update the agent.
+      throw new Error(`непозната команда „${cmd.type}" — обнови gitdone-agent (npm i -g gitdone-agent@latest)`)
+    }
+    log(`✓ ${cmd.type} @ ${repoPath}: ${redact(result, auth?.token)}`)
+  } catch (err) {
+    status = 'error'
+    result = redact(err.message, auth?.token)
+    // Cached token rejected (e.g. rotated/expired on the server) → drop it so
+    // the next snapshot reports hasGithubAuth:false and the server reissues one.
+    if (auth && AUTH_FAIL.test(err.message)) {
+      delete cfg.auth[repoPath]
+      writeConfig(cfg)
+      result += ' — токенът е изчистен, пробвай командата пак'
+    }
+    log(`✗ ${cmd.type} failed @ ${repoPath}: ${result}`)
+  }
+  await reportCommandResult(cfg, cmd.id, status, result)
+}
+// Report discovered repos + machine info, get back which repos to track.
+// ─── Claude plan usage (gd-355) ────────────────────────────────────────────
+// Claude Code persists an OAuth token at ~/.claude/.credentials.json and keeps
+// it fresh. We reuse it to ask Anthropic for the SAME plan-usage numbers the
+// /usage command shows (account-level: a 5-hour "session" window + a weekly
+// limit). The АИ Конзола then renders these live. Best-effort: on a missing or
+// expired token, being offline, or any error we return null and the console
+// simply keeps the last snapshot. Cached ~60s so the 30s sync loop doesn't hit
+// the endpoint twice as often as it changes.
+let usageCache = { at: 0, data: null }
+async function readClaudeUsage() {
+  const now = Date.now()
+  if (usageCache.data && now - usageCache.at < 60_000) return usageCache.data
+  try {
+    const creds = JSON.parse(readFileSync(join(homedir(), '.claude', '.credentials.json'), 'utf8'))
+    const token = creds?.claudeAiOauth?.accessToken
+    if (!token) return null
+    const ctrl = new AbortController()
+    const to = setTimeout(() => ctrl.abort(), 8000)
+    let res
+    try {
+      res = await fetch('https://api.anthropic.com/api/oauth/usage', {
+        headers: {
+          Authorization: `Bearer ${token}`,
+          'Content-Type': 'application/json',
+          'anthropic-beta': 'oauth-2025-04-20',
+          'User-Agent': 'claude-cli',
+        },
+        signal: ctrl.signal,
+      })
+    } finally { clearTimeout(to) }
+    if (!res.ok) return null // 401 = token expired; Claude Code refreshes it — skip this tick
+    const j = await res.json()
+    const data = {
+      sessionPct: Math.round(j?.five_hour?.utilization ?? 0),
+      sessionResetsAt: j?.five_hour?.resets_at ?? null,
+      weeklyPct: Math.round(j?.seven_day?.utilization ?? 0),
+      weeklyResetsAt: j?.seven_day?.resets_at ?? null,
+    }
+    usageCache = { at: now, data }
+    return data
+  } catch {
+    return null // no creds file / malformed / offline — stay quiet
+  }
+}
+async function sync(cfg, discovered) {
+  const usage = await readClaudeUsage()
+  const data = await api(cfg, '/api/v1/agent/sync', {
+    machineId: cfg.machineId,
+    hostname: cfg.hostname,
+    agentVersion: AGENT_VERSION,
+    roots: cfg.roots,
+    repos: discovered,
+    ...(usage ? { usage } : {}),
+  })
+  return data.tracked ?? []
+}
+// Push one tracked repo's snapshot and run any pending commands for it.
+async function pushSnapshot(cfg, repo) {
+  const snapshot = getSnapshot(repo.path)
+  const data = await api(cfg, '/api/v1/agent/snapshot', {
+    machineId: cfg.machineId,
+    path: repo.path,
+    repoName: repo.name,
+    // Tells the server whether we already hold a push token for this repo.
+    // Always a boolean → marks us as a token-capable agent.
+    hasGithubAuth: !!cfg.auth?.[repo.path],
+    ...snapshot,
+  })
+  // Server issued a (fresh) push token — cache it on disk so we ask only once.
+  if (data.githubAuth?.token && data.githubAuth?.repo) {
+    cfg.auth = cfg.auth ?? {}
+    cfg.auth[repo.path] = { token: data.githubAuth.token, repo: data.githubAuth.repo }
+    writeConfig(cfg)
+  }
+  for (const cmd of data.commands ?? []) {
+    await executeCommand(cfg, cmd, repo.path)
+  }
+  return snapshot
+}
+// ─── Low-latency command channel (gd-274) ───────────────────────────────────────
+// The 30s snapshot poll is fine for reflecting git state, but makes user actions
+// (Push/Pull/Commit/АИ) feel sluggish: a queued command waits up to a full tick
+// before the agent even asks for it. So we ALSO hold a persistent SSE connection
+// to the server and drain+run commands the instant it says "wake". The snapshot
+// poll stays as the reliable fallback (and cron heartbeat) if the stream drops.
+const GIT_STATE_CMDS = new Set(['commit', 'push', 'pull', 'discard'])
+// Pull this machine's pending commands in one shot (no git/snapshot work server-
+// side) and run them. Serialised via a tiny mutex so overlapping wakes don't
+// double-drain; a wake arriving mid-drain sets a flag to run once more after.
+let draining = false
+let drainAgain = false
+async function drainCommands(cfg) {
+  if (draining) { drainAgain = true; return }
+  draining = true
+  try {
+    do {
+      drainAgain = false
+      let data
+      try {
+        data = await api(cfg, '/api/v1/agent/commands', { machineId: cfg.machineId })
+      } catch (err) {
+        log(`✗ command drain failed: ${err.message}`)
+        return
+      }
+      const commands = data.commands ?? []
+      if (commands.length === 0) continue
+      // Cache any push tokens the server issued for these commands' repos.
+      if (data.githubAuth && typeof data.githubAuth === 'object') {
+        cfg.auth = cfg.auth ?? {}
+        for (const [path, a] of Object.entries(data.githubAuth)) {
+          if (a && a.token && a.repo) cfg.auth[path] = a
+        }
+        writeConfig(cfg)
+      }
+      // Run each command against its own repo path, and remember which repos had
+      // their git state changed so we can push a fresh snapshot right after —
+      // that's what makes the UI update instantly instead of on the next tick.
+      const touched = new Map()
+      for (const cmd of commands) {
+        const repoPath = cmd.path
+        if (!repoPath) { log(`✗ command ${cmd.id} has no path — skipped`); continue }
+        await executeCommand(cfg, cmd, repoPath)
+        if (GIT_STATE_CMDS.has(cmd.type)) touched.set(repoPath, cmd.repoName || repoPath)
+      }
+      for (const [path, name] of touched) {
+        try { await pushSnapshot(cfg, { path, name }) }
+        catch (err) { log(`✗ post-command snapshot failed @ ${path}: ${err.message}`) }
+      }
+    } while (drainAgain)
+  } finally {
+    draining = false
+  }
+}
+// Hold a persistent SSE connection open and drain the moment the server pushes a
+// `wake`. Reconnects forever with a short backoff; the server also recycles the
+// connection every few minutes (each reconnect re-sends an initial wake, so
+// anything queued while we were away is picked up). Never throws.
+const STREAM_RECONNECT_MS = 3000
+async function streamCommands(cfg) {
+  const url = `${cfg.url}/api/v1/agent/commands/stream?machineId=${encodeURIComponent(cfg.machineId)}`
+  for (;;) {
+    try {
+      const res = await fetch(url, { headers: { Authorization: `Bearer ${cfg.key}` } })
+      if (!res.ok || !res.body) throw new Error(`HTTP ${res.status}`)
+      log('▶ command stream connected')
+      const reader = res.body.getReader()
+      const decoder = new TextDecoder()
+      let buf = ''
+      for (;;) {
+        const { value, done } = await reader.read()
+        if (done) break
+        buf += decoder.decode(value, { stream: true })
+        // SSE events are separated by a blank line; a `wake` means "drain now".
+        let idx
+        while ((idx = buf.indexOf('\n\n')) >= 0) {
+          const frame = buf.slice(0, idx)
+          buf = buf.slice(idx + 2)
+          if (/(^|\n)event:\s*wake/.test(frame)) drainCommands(cfg)
+        }
+      }
+    } catch (err) {
+      log(`… command stream disconnected (${err.message}); reconnecting`)
+    }
+    await new Promise((r) => setTimeout(r, STREAM_RECONNECT_MS))
+  }
+}
+// ─── Main ────────────────────────────────────────────────────────────────────
+async function runLoop(cfg) {
+  ensureSingleInstance()
+  // Watchdog food: a heartbeat file every 30s. Stale >10 min (dead OR hung
+  // event loop) → the scheduled task restarts us (gd-431). Registered on every
+  // start so in-place-updated agents get the watchdog without a re-install.
+  startHeartbeat()
+  ensureWatchdog()
+  log(`gitdone-agent started — machine: ${cfg.hostname}, server: ${cfg.url}, interval: ${cfg.interval}s`)
+  log(`  roots: ${cfg.roots.join(', ') || '(none — add one with --root)'}`)
+  async function tick() {
+    try {
+      const discovered = scanRepos(cfg.roots)
+      const tracked = await sync(cfg, discovered)
+      let pushed = 0
+      for (const repo of tracked) {
+        try { await pushSnapshot(cfg, repo); pushed++ }
+        catch (err) { log(`✗ snapshot failed @ ${repo.path}: ${err.message}`) }
+      }
+      log(`✓ tick — discovered: ${discovered.length}, tracked: ${tracked.length}, pushed: ${pushed}`)
+    } catch (err) {
+      log(`✗ sync error: ${err.message}`)
+    }
+  }
+  // Fast command path runs alongside the snapshot poll. Fire-and-forget: it owns
+  // its own reconnect loop and never rejects.
+  streamCommands(cfg)
+  await tick()
+  setInterval(tick, cfg.interval * 1000)
+}
+async function main() {
+  const args = parseArgs()
+  if (args.doctor) {
+    runDoctor()
+    process.exit(0)
+  }
+  if (args.uninstall) {
+    uninstallStartup()
+    process.exit(0)
+  }
+  // Setup / install path: merge CLI args into config, optionally (re)install.
+  if (args.install || args.key || args.roots.length || args.url || args.interval) {
+    const cfg = buildConfig(args)
+    if (!cfg.key) {
+      console.error('Error: --key is required on first setup (e.g. --key=gdo_xxx)')
+      process.exit(1)
+    }
+    writeConfig(cfg)
+    if (args.install) {
+      installStartup()
+      console.log(`✓ Инсталиран! При следващото влизане в Windows агентът ще стартира автоматично.`)
+      console.log(`  Агент  : ${STABLE_AGENT}`)
+      console.log(`  Config : ${CONFIG_PATH}`)
+      console.log(`  Лог    : ${LOG_PATH}`)
+      console.log(`  Roots  :`)
+      for (const r of cfg.roots) console.log(`     - ${r}`)
+      console.log()
+      // Launch silently in the background right now.
+      const child = spawn('wscript.exe', [getVbsPath()], { detached: true, stdio: 'ignore' })
+      child.unref()
+      console.log('✓ Агентът е стартиран в заден план — можеш да затвориш прозореца.')
+      console.log('  Сега избери кои репота да следи от gitdone.eu/github.')
+      process.exit(0)
+    }
+    // --key/--root without --install: just run the loop in the foreground.
+    await runLoop(cfg)
+    return
+  }
+  // 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.`)
+    process.exit(1)
+  }
+  await runLoop(cfg)
+}
+main()