gitdone-agent 0.6.16 → 0.7.0

package/index.js

@@ -1,1733 +1,1892 @@
-#!/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.16'
-
-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.
-async function postRunEvents(cfg, runId, events, status, result, usage) {
-  await api(cfg, '/api/v1/agent/ai-run/events', {
-    runId,
-    events,
-    ...(status ? { status } : {}),
-    ...(result !== undefined ? { result } : {}),
-    ...(usage ? { usage } : {}),
-  }).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) {
-  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 } : {}),
-  }).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: only the model's visible text deltas feed the live
-  // preview. Tool-input JSON deltas and thinking deltas are ignored here — 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' && e.delta?.type === 'text_delta' && e.delta.text) {
-      onDelta(e.delta.text)
-    }
-    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',
-    // 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
-  const flush = async () => {
-    if (flushing || pending.length === 0) return
-    flushing = true
-    const batch = pending; pending = []
-    await postRunEvents(cfg, runId, batch)
-    flushing = false
-  }
-  const push = (kind, text) => { if (text != null && String(text) !== '') pending.push({ kind, text: String(text) }) }
-  const timer = setInterval(flush, 800)
-
-  // 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, undefined, 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, undefined, onMeta)
-    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 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
-    // 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 && Date.now() - lastPostAt > 2500
-    if (!hasEvents && !liveChanged && !heartbeat) return
-    flushing = true
-    const batch = pending.map((e) => ({ role: roleFor(e.kind), text: e.text })); pending = []
-    const streamingText = liveChanged ? liveText : undefined
-    sentLive = liveText
-    await postSessionEvents(cfg, sessionId, batch, 'running', capturedSession || undefined, streamingText)
-    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.
-    if (kind === 'TEXT') liveText = ''
-    pending.push({ kind, text: String(text) })
-  }
-  const onInit = (sid) => { if (sid && !claudeSessionId) capturedSession = sid }
-  const onDelta = (chunk) => { 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
-    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
-    )
-    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.0'
+
+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, 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()
+  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()