autodev-cli 1.4.131 → 1.4.133

package/out/providers/grokTuiProvider.js

@@ -1,41 +1,4 @@
 "use strict";
-// ---------------------------------------------------------------------------
-// grokProvider -- Grok tasks via the `grok` CLI. Backs BOTH provider variants:
-//
-//   grok-cli  (stateless):  fresh HEADLESS process each task (--prompt-file),
-//                           no context accumulation across tasks.
-//   grok-tui  (persistent): ONE long-lived interactive `grok` process kept alive
-//                           inside a per-workspace tmux session (a real PTY), so
-//                           grok's in-process context accumulates across tasks —
-//                           exactly like a human-driven interactive session.
-//
-// -------------------------------------------------------------------------
-// Why tmux for grok-tui?
-// -------------------------------------------------------------------------
-// grok is an interactive terminal UI. The OLD grok-tui ran it HEADLESS with
-// piped, non-TTY stdio (`--prompt-file --output-format streaming-json`, stdin
-// ignored). Under load it would finish producing output but never terminate the
-// process (no controlling TTY to close on, an internal render/input wait, or a
-// tool it retried forever). `close` never fired → the per-message exit file was
-// never written → the task loop blocked until its 30 s sentinel / the 10 min
-// watchdog, and the turn surfaced as a StopFailure. The wedge root-cause was the
-// no-TTY non-exit.
-//
-// The tmux reimplementation gives grok a real PTY. One detached tmux session per
-// workspace runs `grok --no-alt-screen --always-approve` interactively; each
-// task PASTES its prompt into the live pane and detects turn-end by output
-// quiescence (recipe below). Context lives in the one long-running grok process
-// — the live session IS the resumed context, so we no longer `--resume` per task.
-//
-// Contract preserved for taskLoop (unchanged): stream assistant/pane text to the
-// SAME per-message stdoutFile; write the exit code to the SAME per-message
-// exitFile exactly ONCE, only when the turn genuinely ends. Session id is still
-// minted-once and persisted under getSessionId/saveSessionId('grok-tui') so the
-// office/loop see continuity and a dead session can be relaunched with --resume.
-//
-// If tmux is not installed, grok-tui transparently FALLS BACK to the old
-// headless spawn so nothing regresses on boxes without tmux.
-// ---------------------------------------------------------------------------
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -47,1584 +10,9 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
 }));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isGrokTuiBusy = isGrokTuiBusy;
-exports.getGrokTuiLastActivity = getGrokTuiLastActivity;
-exports.forceIdleGrokTui = forceIdleGrokTui;
-exports.tmuxAvailable = tmuxAvailable;
-exports.sendGrokPrompt = sendGrokPrompt;
-exports.sendGrokCliPrompt = sendGrokCliPrompt;
-exports.sendGrokTuiPrompt = sendGrokTuiPrompt;
-exports.steerGrokTui = steerGrokTui;
-exports.closeGrokTuiSession = closeGrokTuiSession;
-exports.closeAllGrokTuiSessions = closeAllGrokTuiSessions;
-exports.detectGrokTuiRateLimit = detectGrokTuiRateLimit;
-const path = __importStar(require("path"));
-const fs = __importStar(require("fs"));
-const os = __importStar(require("os"));
-const crypto = __importStar(require("crypto"));
-const readline = __importStar(require("readline"));
-const child_process = __importStar(require("child_process"));
-const crypto_1 = require("crypto");
-const hookEventNormalizer_1 = require("../hookEventNormalizer");
-const rateLimit_1 = require("../rateLimit");
-const sessionState_1 = require("../sessionState");
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-/** Path to the grok binary — use env override for non-default installs. */
-const GROK_BIN = process.env['GROK_BIN'] ?? (() => {
-    // Prefer a grok on PATH; otherwise fall back to the default install location
-    // (~/.grok/bin/grok) so the provider works without PATH changes.
-    try {
-        const home = os.homedir();
-        const local = path.join(home, '.grok', 'bin', 'grok');
-        if (fs.existsSync(local)) {
-            return local;
-        }
-    }
-    catch { /* ignore */ }
-    return 'grok';
-})();
-/** tmux binary — overridable for non-standard installs. */
-const TMUX_BIN = process.env['TMUX_BIN'] ?? 'tmux';
-// Env-tunable knobs. `envNum` accepts any finite >= 0; 0 disables that guard.
-const envNum = (key, def) => {
-    const n = Number(process.env[key]);
-    return Number.isFinite(n) && n >= 0 ? n : def;
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
-// ---------------------------------------------------------------------------
-// Per-workspace state
-// ---------------------------------------------------------------------------
-/** Roots with an actively-running grok turn (headless OR tmux). */
-const _busyRoots = new Set();
-/** Active HEADLESS child processes by root — grok-cli + tmux-unavailable fallback. */
-const _activeChildren = new Map();
-const _tmuxSessions = new Map();
-// Per-root set of grok tool_call ids already emitted as PreToolUse, so a re-scan of
-// the transcript can't emit the SAME tool call twice → duplicate rows in the office
-// hook feed (observed ~2.4× per call). PostToolUse is already dedup'd by pending.delete;
-// PreToolUse had no guard. tool_call ids are unique per call, so this is exact. Bounded
-// so an overnight run can't grow it unboundedly; cleared when the session is closed.
-const _emittedToolIds = new Map();
-const EMITTED_TOOL_IDS_CAP = 8000;
-// Reap grok on process shutdown. grok runs in a DETACHED tmux session that outlives
-// the loop, so killing the loop (app Stop, `autodev stop`, SIGTERM) would otherwise
-// ORPHAN grok — it keeps running/burning tokens, its stale office presence makes the
-// agent look stuck ("Stopping…" forever), and orphans accumulate across restarts.
-// closeAllGrokTuiSessions() (defined below, hoisted) reaps every session this process
-// launched; it was previously only wired to SDK/extension shutdown, not the standalone
-// `autodev start` loop. A signal handler suppresses Node's default terminate, so we
-// re-exit after the sync cleanup; 'exit' is a backstop for other exit paths. No other
-// SIGTERM/SIGINT handler exists in the CLI, so taking the signal here is safe.
-let _grokShuttingDown = false;
-function _grokReapOnSignal(sig) {
-    if (_grokShuttingDown) {
-        return;
-    }
-    _grokShuttingDown = true;
-    try {
-        closeAllGrokTuiSessions();
-    }
-    catch { /* best effort */ }
-    process.exit(sig === 'SIGINT' ? 130 : 143);
-}
-try {
-    process.on('SIGTERM', () => _grokReapOnSignal('SIGTERM'));
-    process.on('SIGINT', () => _grokReapOnSignal('SIGINT'));
-    process.on('exit', () => { try {
-        closeAllGrokTuiSessions();
-    }
-    catch { /* best effort */ } });
-}
-catch { /* handlers restricted in this env */ }
-/** Epoch-ms of the last streamed pane growth per root (activity heartbeat). */
-const _lastActivityMs = new Map();
-/** True while a grok turn is running for the given workspace root. */
-function isGrokTuiBusy(root) {
-    return _busyRoots.has(root);
-}
-/** Epoch-ms of the most recent streamed pane activity, or 0 if none. */
-function getGrokTuiLastActivity(root) {
-    return _lastActivityMs.get(root) ?? 0;
-}
-/** Force-clear the busy flag for a root whose turn appears hung. */
-function forceIdleGrokTui(root) {
-    _busyRoots.delete(root);
-}
-/**
- * Append a REAL grok activity event to `.autodev/hooks-events.jsonl` in the
- * native Claude-Code hook schema (pixel-office reads `hook_event_name`).
- */
-function _emitGrokHook(root, hookEventName, extra = {}) {
-    try {
-        const dir = path.join(root, '.autodev');
-        if (!fs.existsSync(dir)) {
-            fs.mkdirSync(dir, { recursive: true });
-        }
-        const ev = { hook_event_name: hookEventName, event_type: (0, hookEventNormalizer_1.eventTypeFor)(hookEventName), provider: 'grok-tui', cwd: root, timestamp: new Date().toISOString(), ...extra };
-        fs.appendFileSync(path.join(dir, 'hooks-events.jsonl'), JSON.stringify(ev) + '\n', 'utf8');
-    }
-    catch { /* non-critical */ }
-}
-// ---------------------------------------------------------------------------
-// tmux helpers — all synchronous, best-effort (swallow + report).
-// ---------------------------------------------------------------------------
-let _tmuxAvailable = null;
-/** True if tmux is installed and runnable. Cached after first probe. */
-function tmuxAvailable() {
-    if (_tmuxAvailable !== null) {
-        return _tmuxAvailable;
-    }
-    try {
-        child_process.execFileSync(TMUX_BIN, ['-V'], { stdio: 'ignore', timeout: 5_000 });
-        _tmuxAvailable = true;
-    }
-    catch {
-        _tmuxAvailable = false;
-    }
-    return _tmuxAvailable;
-}
-/** Run a tmux subcommand; returns stdout string, or null on any failure. */
-function tmux(args, input) {
-    try {
-        const out = child_process.execFileSync(TMUX_BIN, args, {
-            encoding: 'utf8', timeout: 15_000, input, stdio: ['pipe', 'pipe', 'ignore'],
-        });
-        return out ?? '';
-    }
-    catch {
-        return null;
-    }
-}
-/** Deterministic, tmux-safe session name from the absolute workspace path. */
-function sessionName(root) {
-    const h = crypto.createHash('sha1').update(root).digest('hex').slice(0, 10);
-    return `grok-${h}`;
-}
-/** True if the tmux session exists (a dead grok collapses the session). */
-function hasSession(name) {
-    try {
-        child_process.execFileSync(TMUX_BIN, ['has-session', '-t', name], { stdio: 'ignore', timeout: 5_000 });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/** Kill a tmux session (best-effort). */
-function killSession(name) {
-    tmux(['kill-session', '-t', name]);
-}
-/** Escape-stripped visible grid + scrollback of a pane (for detection). */
-function capturePane(name, scrollback = 200) {
-    const out = tmux(['capture-pane', '-p', '-t', name, '-S', `-${scrollback}`]);
-    return out === null ? '' : stripAnsi(out);
-}
-/** Shell-quote a single argument for a `send-keys "exec …"` command string. */
-function shq(s) {
-    return `'${s.replace(/'/g, `'\\''`)}'`;
-}
-/**
- * Strip ANSI/OSC/DCS escapes and carriage returns from raw pane bytes.
- * `pipe-pane` captures the full TUI byte stream (SGR colour, mouse tracking,
- * bracketed-paste markers, OSC titles, `\r`), which must be removed before the
- * text is written to stdoutFile or scanned for banners.
- */
-function stripAnsi(s) {
-    return s
-        // CSI sequences: ESC [ ... final-byte
-        .replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, '')
-        // OSC sequences: ESC ] ... (BEL | ST)
-        .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, '')
-        // DCS/PM/APC: ESC (P|X|^|_) ... ST
-        .replace(/\x1b[PX^_][^\x1b]*\x1b\\/g, '')
-        // Any other single-char escape
-        .replace(/\x1b[@-Z\\-_]/g, '')
-        .replace(/\r/g, '');
-}
-// ---------------------------------------------------------------------------
-// Turn-end / auth detectors (calibrate against a live authed grok — see risks).
-// ---------------------------------------------------------------------------
-/**
- * Markers that mean grok hit the OAuth/expired-token gate instead of a prompt.
- * The loop must treat this as reauth, NOT a hung turn.
- */
-const REAUTH_MARKERS = /waiting for approval|approve in your browser|sign(?:ing)? in to grok|finish signing in|device code|please (?:log ?in|sign ?in)/i;
-/**
- * "grok finished this turn" affordance — CALIBRATED against grok 4.5 build 0.2.93:
- * a completed turn prints "Worked for 4.1s." (a summary line) and the footer drops
- * the cancel affordance. Used as a fast, positive turn-end confirmation.
- */
-const DONE_MARKER = /worked for\s+[\d.]+\s*s\b/i;
-/**
- * "grok is actively working" affordance. grok renders a live spinner + an
- * "esc to interrupt"-style footer while a turn runs. If present we never
- * declare idle. This is a SOFT guard: the primary idle signal is output
- * quiescence + a byte-identical pane snapshot across polls (a running spinner
- * animates, so the snapshot is never stable while grok works), which fires
- * cleanly even if this pattern never matches on a given grok build.
- */
-// CALIBRATED against real grok 4.5 (build 0.2.93): while a turn runs the footer
-// shows "Ctrl+c:cancel" and a "⠧ Waiting for response… 1.5s … [stop]" status line;
-// when idle the footer is only "Shift+Tab:mode │ Ctrl+x:shortcuts" (no Ctrl+c).
-// So the presence of Ctrl+c / "waiting for response" / "[stop]" / a braille spinner
-// = working. This is the primary running signal (backed by output-quiescence).
-const RUNNING_INDICATOR = /ctrl\+c\s*[: ]|waiting for response|\[stop\]|esc to (?:interrupt|cancel)|⠋|⠙|⠹|⠸|⠼|⠴|⠦|⠧|⠇|⠏/i;
-// ---------------------------------------------------------------------------
-// grok-tui: persistent interactive session driven through tmux.
-// ---------------------------------------------------------------------------
-/** Launch a fresh grok process in a new detached tmux session for this root. */
-/** Block the calling thread for `ms` — launchSession is synchronous, so the
- *  cross-process launch serialization below needs a synchronous wait. */
-function sleepSyncMs(ms) {
-    if (!(ms > 0))
-        return;
-    try {
-        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
-    }
-    catch {
-        const end = Date.now() + ms;
-        while (Date.now() < end) { /* spin fallback */ }
-    }
-}
-// ── Cross-process grok-tui launch serialization ─────────────────────────────
-// Every office agent runs in its OWN `autodev start` process, so an in-process
-// mutex can't help: when many agents fire a turn at the same instant they all
-// hit `tmux new-session` (and the shared ~/.grok config) simultaneously, the
-// tmux server races on startup, and grok dies during startup ("session died
-// during startup"). A lockfile + a minimum spacing between launches turns that
-// stampede into an orderly ~1-launch-per-second queue. Tunable/disable via
-// GROK_TMUX_LAUNCH_SPACING_MS (0 disables the spacing; the lock still serializes).
-const TMUX_LAUNCH_LOCK = path.join(os.homedir(), '.grok', '.autodev-tmux-launch.lock');
-const TMUX_LAUNCH_STAMP = path.join(os.homedir(), '.grok', '.autodev-tmux-launch.stamp');
-// 10s default: 1s only spaced the tmux new-session call, but grok's ~9s startup
-// (where it initializes its session + writes the shared session_search.sqlite
-// index) still overlapped across agents and raced. Holding the slot ~10s lets
-// each grok fully initialize its session before the next one launches.
-const TMUX_LAUNCH_SPACING_MS = envNum('GROK_TMUX_LAUNCH_SPACING_MS', 10000);
-const TMUX_LOCK_STALE_MS = 15000;
-/** Acquire the shared launch slot (atomic-create lockfile, steal if stale), then
- *  wait out the minimum spacing since the previous launch. Best-effort: never
- *  blocks a turn forever. */
-function acquireTmuxLaunchSlot(log) {
-    try {
-        fs.mkdirSync(path.dirname(TMUX_LAUNCH_LOCK), { recursive: true });
-    }
-    catch { /* ignore */ }
-    const deadline = Date.now() + 45000;
-    for (;;) {
-        try {
-            fs.closeSync(fs.openSync(TMUX_LAUNCH_LOCK, 'wx'));
-            break;
-        } // atomic exclusive create = acquired
-        catch {
-            try {
-                const st = fs.statSync(TMUX_LAUNCH_LOCK);
-                if (Date.now() - st.mtimeMs > TMUX_LOCK_STALE_MS) {
-                    try {
-                        fs.unlinkSync(TMUX_LAUNCH_LOCK);
-                    }
-                    catch { /* race */ }
-                    continue;
-                }
-            }
-            catch {
-                continue;
-            } // lock vanished mid-check → retry create
-            if (Date.now() > deadline) {
-                log('Grok TUI: tmux-launch lock wait timed out — launching anyway');
-                return;
-            }
-            sleepSyncMs(120);
-        }
-    }
-    try {
-        const last = Number(fs.readFileSync(TMUX_LAUNCH_STAMP, 'utf8')) || 0;
-        sleepSyncMs(TMUX_LAUNCH_SPACING_MS - (Date.now() - last));
-    }
-    catch { /* no prior stamp */ }
-}
-/** Stamp the launch time (for the next launcher's spacing) and release the lock. */
-function releaseTmuxLaunchSlot() {
-    try {
-        fs.writeFileSync(TMUX_LAUNCH_STAMP, String(Date.now()));
-    }
-    catch { /* ignore */ }
-    try {
-        fs.unlinkSync(TMUX_LAUNCH_LOCK);
-    }
-    catch { /* ignore */ }
-}
-// grok keeps a SHARED session index at ~/.grok/sessions/session_search.sqlite.
-// In the default rollback journal mode a writer takes an exclusive lock, so when
-// many agents initialize a session at once they block/fail on it and grok dies
-// during startup. Enabling WAL (persistent — stored in the db header, so once is
-// enough) lets concurrent readers/writers proceed without that exclusive-lock
-// stampede. Best-effort via node:sqlite (Node ≥22), falling back to the sqlite3
-// CLI; if neither is available the launch spacing still serializes access.
-let _grokWalEnsured = false;
-function ensureGrokSessionDbWal(log) {
-    if (_grokWalEnsured)
-        return;
-    const db = path.join(os.homedir(), '.grok', 'sessions', 'session_search.sqlite');
-    if (!fs.existsSync(db))
-        return; // grok hasn't created it yet — retry on a later launch
-    const PRAGMAS = 'PRAGMA journal_mode=WAL; PRAGMA busy_timeout=5000;';
-    try {
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
-        const { DatabaseSync } = require('node:sqlite');
-        const d = new DatabaseSync(db);
-        d.exec(PRAGMAS);
-        d.close();
-        _grokWalEnsured = true;
-        log('Grok TUI: enabled WAL on session_search.sqlite');
-        return;
-    }
-    catch { /* node:sqlite unavailable → try the CLI */ }
-    try {
-        child_process.execSync(`sqlite3 ${shq(db)} ${shq(PRAGMAS)}`, { stdio: 'ignore', timeout: 5000 });
-        _grokWalEnsured = true;
-        log('Grok TUI: enabled WAL on session_search.sqlite (sqlite3)');
-    }
-    catch { /* best effort — spacing still serializes */ }
-}
-function launchSession(root, sessionId, resume, model, log) {
-    const name = sessionName(root);
-    // A stale/dead session for this name must be cleared first.
-    if (hasSession(name)) {
-        killSession(name);
-    }
-    // Per-agent pane log (distinct file per root → no cross-agent race).
-    const dir = path.join(root, '.autodev', 'grok-tui');
-    try {
-        if (!fs.existsSync(dir)) {
-            fs.mkdirSync(dir, { recursive: true });
-        }
-    }
-    catch { /* ignore */ }
-    const rawLog = path.join(dir, 'pane.raw');
-    // Start each launch with a fresh raw log so readOffset math is simple.
-    try {
-        fs.writeFileSync(rawLog, '', 'utf8');
-    }
-    catch { /* ignore */ }
-    // Build the interactive grok command. `exec` replaces the shell so a dead grok
-    // collapses the pane/session → cheap liveness signal via has-session. (Pure
-    // string work — no shared state — so it stays outside the launch lock.)
-    // Launch grok via `env -u TMUX -u TMUX_PANE TERM=xterm-256color`: although grok
-    // physically runs inside our tmux pane (so we can capture it), inheriting the
-    // pane's TMUX/TMUX_PANE + TERM=screen makes grok take a NESTED-tmux terminal
-    // path — under load its /dev/tty window-size handshake times out after ~11s and
-    // grok exits CLEANLY (exit_group(0)), which we misread as "session died during
-    // startup". Hiding the nesting (proper TERM, no TMUX) makes grok use the normal
-    // terminal path and it stays alive. (strace-confirmed 2026-08-02.)
-    const parts = [
-        'exec', 'env', '-u', 'TMUX', '-u', 'TMUX_PANE', 'TERM=xterm-256color',
-        shq(GROK_BIN),
-        '--no-alt-screen', '--always-approve',
-        '--cwd', shq(root),
-    ];
-    if (model) {
-        parts.push('-m', shq(model));
-    }
-    if (resume) {
-        // Restore the accumulated conversation on relaunch.
-        parts.push('--resume', shq(sessionId));
-    }
-    else {
-        // Name a brand-new conversation with our UUID so it is addressable later.
-        parts.push('-s', shq(sessionId));
-    }
-    // Serialize the race-prone work — the shared ~/.grok config write and the tmux
-    // server interactions — across the per-agent loop processes, spaced ~1s apart,
-    // so a burst of simultaneous turns can't race the tmux server startup and kill
-    // grok ("session died during startup").
-    acquireTmuxLaunchSlot(log);
-    try {
-        // Put grok's shared session index into WAL so concurrent session inits don't
-        // block on an exclusive rollback-journal lock (a cause of startup crashes).
-        ensureGrokSessionDbWal(log);
-        // Kill the one-time project-directory picker before it can block the turn.
-        ensureGrokPickerDisabled(log);
-        // Trust the workspace dir so grok skips its "Do you trust this directory?"
-        // gate (a first-run-only prompt that otherwise kills the turn — see fn doc).
-        ensureGrokDirTrusted(root, log);
-        // Pre-create grok's per-session dir + an empty transcript for a NEW session so
-        // grok doesn't have to mkdir it (and register it in the shared
-        // ~/.grok/sessions/session_search.sqlite index) during startup — that
-        // filesystem/sqlite contention across a burst of concurrent launches is a
-        // suspected cause of the immediate "session died during startup". A resumed
-        // session already has its dir, so skip it there.
-        if (!resume) {
-            try {
-                const sPath = chatHistoryPath(root, sessionId);
-                fs.mkdirSync(path.dirname(sPath), { recursive: true });
-                if (!fs.existsSync(sPath)) {
-                    fs.writeFileSync(sPath, '', 'utf8');
-                }
-            }
-            catch { /* best effort */ }
-        }
-        // Kill any stale session with this name first. launchSession only runs when
-        // there's no live in-process session, so an existing tmux session by this name
-        // is an ORPHAN from a previous loop instance (the tmux session outlives a
-        // killed loop). Without this, `new-session` fails "duplicate session" on
-        // restart, and orphans accumulate. The shutdown handler (closeAllGrokTuiSessions)
-        // normally reaps them, but a SIGKILL'd loop can't run it — so reap here too.
-        try {
-            killSession(name);
-        }
-        catch { /* none to kill */ }
-        // Fixed geometry so wrapping/relayout never shifts detection rows; manual
-        // window-size so a human attaching can't reflow the pane mid-turn.
-        tmux(['new-session', '-d', '-s', name, '-x', '200', '-y', '50', '-c', root]);
-        tmux(['set-option', '-t', name, 'window-size', 'manual']);
-        // pipe-pane BEFORE launching grok — it only captures bytes emitted after it
-        // attaches (confirmed). Append mode.
-        tmux(['pipe-pane', '-o', '-t', name, `cat >> ${shq(rawLog)}`]);
-        tmux(['send-keys', '-t', name, parts.join(' '), 'Enter']);
-    }
-    finally {
-        releaseTmuxLaunchSlot();
-    }
-    const sess = { name, rawLog, sessionId, readOffset: 0 };
-    _tmuxSessions.set(root, sess);
-    log(`Grok TUI: launched tmux session ${name} (${resume ? 'resume' : 'new'} ${sessionId.slice(0, 8)}…, model=${model || 'account default'})`);
-    return sess;
-}
-/**
- * Ensure a live tmux grok session exists for this root. Returns the session and
- * whether it was just launched (caller applies a startup grace before pasting).
- */
-function ensureSession(root, resolvedSessionId, model, log) {
-    const name = sessionName(root);
-    const cached = _tmuxSessions.get(root);
-    if (cached && cached.name === name && hasSession(name)) {
-        return { sess: cached, justLaunched: false }; // reuse — context is live in-process
-    }
-    // No live session. If we have a stored session id, relaunch with --resume so
-    // grok restores the accumulated history; otherwise mint + persist a new UUID.
-    let sid = resolvedSessionId || (0, sessionState_1.getSessionId)(root, 'grok-tui');
-    let resume = false;
-    if (sid) {
-        resume = true; // a stored id means grok already has a persisted session
-    }
-    else {
-        sid = (0, crypto_1.randomUUID)();
-        try {
-            (0, sessionState_1.saveSessionId)(root, 'grok-tui', sid);
-        }
-        catch { /* best effort */ }
-    }
-    const sess = launchSession(root, sid, resume, model, log);
-    return { sess, justLaunched: true };
-}
-/** Read new bytes of rawLog past `offset`; returns decoded text + new offset. */
-function readFrom(file, offset) {
-    try {
-        const size = fs.statSync(file).size;
-        if (size <= offset) {
-            return { text: '', offset };
-        }
-        const len = size - offset;
-        const buf = Buffer.alloc(len);
-        const fd = fs.openSync(file, 'r');
-        try {
-            fs.readSync(fd, buf, 0, len, offset);
-        }
-        finally {
-            fs.closeSync(fd);
-        }
-        return { text: buf.toString('utf8'), offset: size };
-    }
-    catch {
-        return { text: '', offset };
-    }
-}
-/**
- * grok persists a CLEAN structured transcript per workspace session at
- *   ~/.grok/sessions/<encodeURIComponent(cwd)>/<sessionId>/chat_history.jsonl
- * one JSON object per line: {type:'system'|'user'|'reasoning'|'assistant'|
- * 'tool_result', content, tool_calls?}. The assistant `content` is the real
- * message text (markdown), with none of the TUI chrome — spinners, "Waiting for
- * response…", token counters, "Ctrl+x:shortcuts", load-bar glyphs — that scraping
- * the live tmux pane drags in. We read the agent's OUTPUT from here; the pane is
- * used only for turn-end/reauth detection.
- */
-function chatHistoryPath(root, sessionId) {
-    return path.join(os.homedir(), '.grok', 'sessions', encodeURIComponent(root), sessionId, 'chat_history.jsonl');
-}
-/**
- * A NEW grok session shows a one-time "Run Grok Build in a project directory?"
- * picker before the first turn's work, which blocks headless automation. grok
- * exposes a persistent opt-out — `hints = { project_picker_disabled = true }` in
- * ~/.grok/config.toml (what its "Don't ask me again" option writes). Ensure it is
- * present before launching so the session goes straight to the prompt. Idempotent;
- * the poll-loop picker backstop covers any grok build that ignores this.
- */
-function ensureGrokPickerDisabled(log) {
-    try {
-        const cfg = path.join(os.homedir(), '.grok', 'config.toml');
-        let text = '';
-        try {
-            text = fs.readFileSync(cfg, 'utf8');
-        }
-        catch { /* no config yet */ }
-        if (/project_picker_disabled\s*=\s*true/.test(text)) {
-            return;
-        }
-        if (/^hints\s*=\s*\{/m.test(text)) {
-            // Inject the key into the existing inline `hints` table.
-            text = text.replace(/^hints\s*=\s*\{/m, 'hints = { project_picker_disabled = true,');
-        }
-        else {
-            text = 'hints = { project_picker_disabled = true }\n' + text;
-        }
-        fs.mkdirSync(path.dirname(cfg), { recursive: true });
-        fs.writeFileSync(cfg, text, 'utf8');
-        log('Grok TUI: disabled grok project-directory picker in config.toml');
-    }
-    catch { /* best effort — the poll-loop dismissal is the backstop */ }
-}
-/**
- * Pre-trust the workspace directory in ~/.grok/trusted_folders.toml so grok skips
- * its "Do you trust the contents of this directory?" startup gate. That gate is
- * NOT the project picker (ensureGrokPickerDisabled) and is not covered by the
- * startup picker loop — if it shows, the loop mistakes the blank body for the
- * ready prompt, pastes the turn into the trust dialog, grok reads it as "not y"
- * and QUITS (observed as "session-exit" right after "sending turn"). Untrusted
- * dirs are the ones an agent has never run in before, so this is the durable fix
- * for the "some agents crash on first launch" class. Idempotent: skip if already
- * present.
- */
-function ensureGrokDirTrusted(root, log) {
-    try {
-        const tf = path.join(os.homedir(), '.grok', 'trusted_folders.toml');
-        const abs = path.resolve(root);
-        let text = '';
-        try {
-            text = fs.readFileSync(tf, 'utf8');
-        }
-        catch { /* no file yet */ }
-        // Match the exact folder header so a substring path can't yield a false skip.
-        const header = `[folders."${abs}"]`;
-        if (text.includes(header)) {
-            return;
-        }
-        const nowSec = Math.floor(Date.now() / 1000);
-        const entry = `${text.endsWith('\n') || text === '' ? '' : '\n'}\n${header}\ntrusted = true\ndecided_at = ${nowSec}\n`;
-        fs.mkdirSync(path.dirname(tf), { recursive: true });
-        fs.appendFileSync(tf, entry, 'utf8');
-        log(`Grok TUI: trusted workspace dir in trusted_folders.toml (skips grok's trust gate)`);
-    }
-    catch { /* best effort — the picker loop's trust-prompt handling is the backstop */ }
-}
-/** Cap a string field to `max` chars, appending an ellipsis when truncated. */
-function _truncStr(s, max) {
-    return s.length > max ? s.slice(0, max) + '…' : s;
-}
-/**
- * Parse a grok tool_call `arguments` JSON string into a plain OBJECT suitable
- * for the office `tool_input` field, which the pixel-office normalizer requires
- * to be an array/object (a raw string is dropped). Long string values are
- * truncated so a huge write/patch payload can't bloat the hook line. Non-JSON
- * arguments fall back to `{ _raw: <truncated> }` so tool_input is still an object.
- */
-function _parseToolInput(argsStr) {
-    const raw = (argsStr ?? '').trim();
-    if (!raw) {
-        return {};
-    }
-    try {
-        const parsed = JSON.parse(raw);
-        if (parsed && typeof parsed === 'object') {
-            const obj = parsed;
-            for (const k of Object.keys(obj)) {
-                if (typeof obj[k] === 'string') {
-                    obj[k] = _truncStr(obj[k], 2000);
-                }
-            }
-            return obj;
-        }
-        // JSON that isn't an object (number/array/string) — wrap it.
-        return { value: parsed };
-    }
-    catch {
-        return { _raw: _truncStr(raw, 2000) };
-    }
-}
-/**
- * Scan NEW chat_history.jsonl records past `offset` and emit ONE rich hook event
- * per grok tool call: `PreToolUse` when the assistant record's `tool_calls[]`
- * entry first appears (carrying tool_name + parsed tool_input), then `PostToolUse`
- * when its matching `tool_result` (by tool_call_id) lands (carrying tool_name +
- * tool_input + tool_output.text). `pending` (keyed by tool_call id) survives
- * across polls so a Pre/Post pair split over two reads is matched. Advances the
- * offset only past COMPLETE lines so a half-written trailing record is re-read.
- *
- * grok's OWN native tools (Read/Edit/Bash/Glob/…) are what surface here. Office
- * MCP tools (`mcp__…`) are skipped: the office already records those server-side
- * (OfficeMcpController → provider 'mcp-operator'), so emitting them again would
- * double-render the same call.
- */
-function scanGrokToolEvents(root, file, offset, pending) {
-    let size = 0;
-    try {
-        size = fs.statSync(file).size;
-    }
-    catch {
-        return offset;
-    }
-    if (size <= offset) {
-        return offset;
-    }
-    let raw = '';
-    try {
-        const len = size - offset;
-        const buf = Buffer.alloc(len);
-        const fd = fs.openSync(file, 'r');
-        try {
-            fs.readSync(fd, buf, 0, len, offset);
-        }
-        finally {
-            fs.closeSync(fd);
-        }
-        raw = buf.toString('utf8');
-    }
-    catch {
-        return offset;
-    }
-    const lastNl = raw.lastIndexOf('\n');
-    if (lastNl < 0) {
-        return offset;
-    } // no complete line yet
-    const complete = raw.slice(0, lastNl);
-    const newOffset = offset + Buffer.byteLength(complete, 'utf8') + 1; // +1 for the \n
-    for (const line of complete.split('\n')) {
-        const s = line.trim();
-        if (!s) {
-            continue;
-        }
-        let o;
-        try {
-            o = JSON.parse(s);
-        }
-        catch {
-            continue;
-        }
-        const kind = o.type || o.role;
-        if (kind === 'assistant' && Array.isArray(o.tool_calls)) {
-            const emitted = _emittedToolIds.get(root) ?? (() => { const s = new Set(); _emittedToolIds.set(root, s); return s; })();
-            for (const tc of o.tool_calls) {
-                const name = (tc?.name || '').trim();
-                if (!name) {
-                    continue;
-                }
-                if (name.startsWith('mcp__')) {
-                    continue;
-                } // office logs MCP tools server-side
-                // Dedup: a re-scan of the transcript would otherwise re-emit this tool call's
-                // PreToolUse → duplicate rows. tool_call ids are unique per call, so an id we
-                // already emitted is a re-scan, not a real second call — skip it.
-                const id = tc?.id;
-                if (id && emitted.has(id)) {
-                    continue;
-                }
-                const input = _parseToolInput(tc?.arguments);
-                // tool_use_id lets the office pair this PreToolUse with its PostToolUse
-                // into ONE step card (useToolPairing keys on rawPayload.tool_use_id).
-                // Without it, Pre and Post render as two separate cards = duplicates.
-                _emitGrokHook(root, 'PreToolUse', { tool_name: name, tool_input: input, tool_use_id: id });
-                if (id) {
-                    pending.set(id, { name, input });
-                    emitted.add(id);
-                    if (emitted.size > EMITTED_TOOL_IDS_CAP) {
-                        emitted.clear();
-                    } // bound memory; old ids won't re-scan
-                }
-            }
-            continue;
-        }
-        if (kind === 'tool_result') {
-            const id = o.tool_call_id;
-            if (!id) {
-                continue;
-            }
-            const p = pending.get(id);
-            if (!p) {
-                continue;
-            } // no matching Pre (e.g. resumed history / skipped mcp tool) — don't emit an empty event
-            pending.delete(id);
-            const outText = typeof o.content === 'string' ? o.content : (o.content == null ? '' : JSON.stringify(o.content));
-            _emitGrokHook(root, 'PostToolUse', {
-                tool_name: p.name,
-                tool_input: p.input,
-                tool_output: { text: _truncStr(outText, 2000) },
-                tool_use_id: id, // pair with the PreToolUse above (see note there)
-            });
-        }
-    }
-    return newOffset;
-}
-/**
- * Read new chat_history.jsonl records past `offset` and render only the
- * user-facing parts: assistant prose + compact tool-call markers. Skips
- * reasoning/user/system/tool_result. Advances the offset only past COMPLETE
- * lines so a half-written trailing record is re-read next poll.
- */
-function drainChatHistory(file, offset) {
-    let size = 0;
-    try {
-        size = fs.statSync(file).size;
-    }
-    catch {
-        return { text: '', offset };
-    }
-    if (size <= offset) {
-        return { text: '', offset };
-    }
-    let raw = '';
-    try {
-        const len = size - offset;
-        const buf = Buffer.alloc(len);
-        const fd = fs.openSync(file, 'r');
-        try {
-            fs.readSync(fd, buf, 0, len, offset);
-        }
-        finally {
-            fs.closeSync(fd);
-        }
-        raw = buf.toString('utf8');
-    }
-    catch {
-        return { text: '', offset };
-    }
-    const lastNl = raw.lastIndexOf('\n');
-    if (lastNl < 0) {
-        return { text: '', offset };
-    } // no complete line yet
-    const complete = raw.slice(0, lastNl);
-    const newOffset = offset + Buffer.byteLength(complete, 'utf8') + 1; // +1 for the \n
-    let out = '';
-    for (const line of complete.split('\n')) {
-        const s = line.trim();
-        if (!s) {
-            continue;
-        }
-        let o;
-        try {
-            o = JSON.parse(s);
-        }
-        catch {
-            continue;
-        }
-        if ((o.type || o.role) !== 'assistant') {
-            continue;
-        }
-        const c = (o.content || '').trim();
-        if (c) {
-            out += c + '\n';
-        }
-        // NOTE: tool calls are NOT appended as "» tool" text markers here — they are
-        // emitted as proper PreToolUse/PostToolUse hook events by scanGrokToolEvents,
-        // which the office renders as (richer, paired) step cards. Emitting them here
-        // too made every grok tool call appear TWICE (a card AND a text line).
-    }
-    return { text: out, offset: newOffset };
-}
-/** Type a prompt into the live pane and submit it. CALIBRATED against real grok:
- *  a tmux bracketed paste (paste-buffer) is misread by grok's TUI as a
- *  worktree/directory PICKER, not chat input — only literal keystrokes land in
- *  the input box. grok also has no reliable "newline without submit" key over
- *  send-keys (Enter submits), so flatten the prompt to one logical line. */
-function pastePrompt(sess, promptFilePath) {
-    // A full agent prompt is 10KB+ (system prompt + task + context). Typing that
-    // via send-keys -l is UNRELIABLE (tmux drops/garbles keys at that size —
-    // observed live), and a bracketed paste is misread by grok's TUI as a directory
-    // picker. So DON'T type the prompt: hand grok a SHORT literal instruction to
-    // READ the prompt file, and its file tool ingests the whole thing losslessly.
-    const instr = `Read the file ${promptFilePath} in full right now — it is your current task with all its context and instructions. Do exactly what it says: do the real work, then mark the task done in TODO.md. Do not ask questions; do not skip the file.`;
-    tmux(['send-keys', '-t', sess.name, '-l', instr]);
-    tmux(['send-keys', '-t', sess.name, 'Enter']);
-}
-// ---------------------------------------------------------------------------
-// runGrokTmuxTurn — one turn against the persistent tmux session.
-// Fire-and-forget: streams pane text to stdoutFile, writes exitFile at turn end.
-// ---------------------------------------------------------------------------
-function runGrokTmuxTurn(root, promptFilePath, resolvedSessionId, stdoutFile, exitFile, log, model, showOutput) {
-    showOutput?.();
-    try {
-        fs.writeFileSync(stdoutFile, '', 'utf8');
-    }
-    catch { /* ignore */ }
-    try {
-        fs.writeFileSync(exitFile, '', 'utf8');
-    }
-    catch { /* ignore */ }
-    _busyRoots.add(root);
-    const POLL_MS = envNum('AUTODEV_GROK_TUI_POLL_MS', 700);
-    const DEBOUNCE_MS = envNum('AUTODEV_GROK_TUI_DEBOUNCE_MS', 5_000);
-    // Quiescence-only fallback (no "Worked for" marker seen) needs a much longer
-    // quiet window so grok's early "Starting session…"/"Reading file…" pauses aren't
-    // misread as turn-end (observed a false ~4s finish). The "Worked for" marker is
-    // the fast, positive done-signal for the normal case.
-    const QUIET_FALLBACK_MS = envNum('AUTODEV_GROK_TUI_QUIET_FALLBACK_MS', 45_000);
-    // 18s default (was 8s): only paid on a fresh launch, never on a reused live
-    // session. Under a launch storm (many agents starting at once → dozens of MCP
-    // servers spinning up together) grok's startup can exceed 8s; the picker loop
-    // then sees a blank splash, assumes the ready prompt, and pastes the turn into a
-    // not-yet-ready grok, which dies ("session-exit" right after "sending turn").
-    // A longer grace lets grok reach its input prompt before we type. Override with
-    // AUTODEV_GROK_TUI_STARTUP_MS for faster single-agent launches. Default 30s: 18s
-    // was still too tight under a many-agents-at-once spawn (the "turn failed (provider
-    // stopped or timed out)" then recover-on-retry pattern), so give grok more headroom.
-    const STARTUP_MS = envNum('AUTODEV_GROK_TUI_STARTUP_MS', 30_000);
-    const NOOUTPUT_MS = envNum('AUTODEV_GROK_TUI_NOOUTPUT_MS', 25_000);
-    const MAX_RUN_MS = envNum('AUTODEV_GROK_MAX_RUN_MS', 10 * 60_000);
-    const STABLE_POLLS = Math.max(2, envNum('AUTODEV_GROK_TUI_STABLE_POLLS', 4));
-    const sleep = (ms) => new Promise(r => setTimeout(r, ms));
-    // Line-buffer for clean console logging (grok streams mid-word).
-    let lineBuf = '';
-    const emitLines = (text) => {
-        lineBuf += text;
-        let nl;
-        while ((nl = lineBuf.indexOf('\n')) >= 0) {
-            const line = lineBuf.slice(0, nl).replace(/\s+$/, '');
-            lineBuf = lineBuf.slice(nl + 1);
-            if (line.trim()) {
-                log(`  ${line}`);
-            }
-        }
-    };
-    const flushLine = () => {
-        const line = lineBuf.replace(/\s+$/, '');
-        lineBuf = '';
-        if (line.trim()) {
-            log(`  ${line}`);
-        }
-    };
-    // Coalesced office activity feed (grok exposes no per-tool events here).
-    let activityBuf = '';
-    let activityTimer = null;
-    const flushActivity = () => {
-        if (activityTimer) {
-            clearTimeout(activityTimer);
-            activityTimer = null;
-        }
-        const t = activityBuf.trim();
-        activityBuf = '';
-        if (!t) {
-            return;
-        }
-        const preview = t.length > 280 ? t.slice(0, 277) + '…' : t;
-        _emitGrokHook(root, 'Notification', { message: preview, title: 'grok', tool_name: 'grok' });
-    };
-    const scheduleActivity = () => {
-        if (activityBuf.length >= 400) {
-            flushActivity();
-            return;
-        }
-        if (!activityTimer) {
-            activityTimer = setTimeout(flushActivity, 1200);
-        }
-    };
-    const finish = (code, reason) => {
-        flushLine();
-        flushActivity();
-        _busyRoots.delete(root);
-        log(`Grok TUI: turn ${code === 0 ? 'complete' : `ended (code=${code}, ${reason})`}`);
-        _emitGrokHook(root, code === 0 ? 'Stop' : 'StopFailure', { exit_code: code });
-        _emitGrokHook(root, 'SessionEnd', { reason: code === 0 ? 'completed' : reason });
-        try {
-            fs.writeFileSync(exitFile, `${code}\n`, 'utf8');
-        }
-        catch { /* ignore */ }
-    };
-    void (async () => {
-        let sess;
-        let justLaunched = false;
-        let readOffset = 0;
-        // Poison-resume self-heal. grok-tui always resumes its stored session; if that
-        // resume dies on startup the session is poisoned and resuming it again fails
-        // forever. Rather than emit a hard-failure (which the desktop app flags as
-        // "Crashed" and STOPS the agent, forcing a manual Restart), clear the poisoned
-        // id and relaunch FRESH in place, retrying THIS turn. `sidForLaunch` goes
-        // undefined after a clear so ensureSession mints a new UUID instead of resuming
-        // the poison again. Only after MAX_STARTUP_TRIES do we surface startup-exit.
-        let sidForLaunch = resolvedSessionId;
-        const MAX_STARTUP_TRIES = 3;
-        let startupOk = false;
-        for (let attempt = 1; attempt <= MAX_STARTUP_TRIES; attempt++) {
-            try {
-                const r = ensureSession(root, sidForLaunch, model, log);
-                sess = r.sess;
-                justLaunched = r.justLaunched;
-            }
-            catch (err) {
-                const msg = err?.message ?? String(err);
-                log(`Grok TUI: session launch failed: ${msg}`);
-                try {
-                    fs.appendFileSync(stdoutFile, `\n[Grok TUI launch error: ${msg}]\n`, 'utf8');
-                }
-                catch { /* ignore */ }
-                finish(1, 'launch-failed');
-                return;
-            }
-            // Stream only THIS turn's output: start reading at the current rawLog size.
-            readOffset = (() => { try {
-                return fs.statSync(sess.rawLog).size;
-            }
-            catch {
-                return 0;
-            } })();
-            if (!justLaunched) {
-                startupOk = true;
-                break;
-            } // reused live session — no grace
-            _emitGrokHook(root, 'SessionStart', { source: 'startup' });
-            let died = false;
-            let reauth = false;
-            // Startup grace — grok's splash takes a few seconds before it accepts input.
-            const deadline = Date.now() + STARTUP_MS;
-            while (Date.now() < deadline) {
-                await sleep(500);
-                if (!hasSession(sess.name)) {
-                    died = true;
-                    break;
-                }
-                if (REAUTH_MARKERS.test(capturePane(sess.name))) {
-                    reauth = true;
-                    break;
-                }
-            }
-            if (!died && !reauth) {
-                // Past the grace with a live session — dismiss any welcome/project picker
-                // (Enter through it) or the directory-trust gate (accept with 'y'), until
-                // the ready "❯" prompt is clear. CALIBRATED: a NEW grok session opens on a
-                // picker over the input box; a single fixed Enter races grok's splash, so
-                // poll + press each pass. The trust gate ("Do you trust this directory?")
-                // is normally prevented by ensureGrokDirTrusted; this is the backstop.
-                const PICKER_MARKERS = /project directory|New worktree|Resume session|Changelog|\(current\)|Run Grok Build|[◯○◉●]|Select|↑\/↓/i;
-                const TRUST_MARKERS = /Do you trust|Yes, proceed|posing security risks/i;
-                for (let i = 0; i < 8; i++) {
-                    if (!hasSession(sess.name)) {
-                        died = true;
-                        break;
-                    }
-                    const snap = capturePane(sess.name);
-                    if (REAUTH_MARKERS.test(snap)) {
-                        reauth = true;
-                        break;
-                    }
-                    if (TRUST_MARKERS.test(snap)) {
-                        // Accept explicitly with 'y' (Enter alone is unreliable depending on
-                        // which option is highlighted), then keep polling.
-                        log('Grok TUI: accepting grok directory-trust gate (y)');
-                        tmux(['send-keys', '-t', sess.name, 'y']);
-                        await sleep(1200);
-                        continue;
-                    }
-                    if (!PICKER_MARKERS.test(snap)) {
-                        break;
-                    } // at the ready prompt
-                    tmux(['send-keys', '-t', sess.name, 'Enter']);
-                    await sleep(1500);
-                }
-            }
-            if (reauth) {
-                log('Grok TUI: reauth required (OAuth gate at startup)');
-                try {
-                    fs.appendFileSync(stdoutFile, `\n[Grok TUI: reauthentication required — please login]\n`, 'utf8');
-                }
-                catch { /* ignore */ }
-                finish(1, 'reauth_required');
-                return;
-            }
-            if (!died) {
-                // re-read the offset after startup so the splash/menu text isn't streamed
-                // as "turn output".
-                readOffset = (() => { try {
-                    return fs.statSync(sess.rawLog).size;
-                }
-                catch {
-                    return readOffset;
-                } })();
-                startupOk = true;
-                break;
-            }
-            // Session died during startup — a poisoned resume (or a storm-starved launch).
-            // Clear the stored id, tear down the dead pane, and relaunch FRESH next pass.
-            log(`Grok TUI: session died during startup — ${attempt < MAX_STARTUP_TRIES ? `relaunching fresh (attempt ${attempt + 1}/${MAX_STARTUP_TRIES})` : 'giving up this turn'} (poisoned-resume self-heal)`);
-            try {
-                (0, sessionState_1.clearSessionId)(root, 'grok-tui');
-            }
-            catch { /* best effort */ }
-            _tmuxSessions.delete(root);
-            try {
-                tmux(['kill-session', '-t', sess.name]);
-            }
-            catch { /* already gone */ }
-            sidForLaunch = undefined; // force a fresh mint on the retry
-        }
-        if (!startupOk) {
-            try {
-                fs.appendFileSync(stdoutFile, `\n[Grok TUI: session kept exiting during startup — a fresh session will be tried next turn]\n`, 'utf8');
-            }
-            catch { /* ignore */ }
-            finish(1, 'startup-exit');
-            return;
-        }
-        // NOTE: when the session is REUSED (not justLaunched) we deliberately emit NO
-        // SessionStart. The grok process is persistent across turns — one tmux launch
-        // serves many turns — so a per-turn "startup"/SessionStart is semantically
-        // false and made the office Events feed show a phantom "startup" every turn,
-        // reading as "the grok agent restarts each time" when it does not. A turn
-        // boundary is already conveyed by the prompt/task and the tool events.
-        // Clean-output source: grok's structured transcript. Seed the offset at the
-        // current size so we emit only THIS turn's assistant records, not the
-        // resumed history. (File may not exist yet on a fresh session → offset 0.)
-        const chatPath = chatHistoryPath(root, sess.sessionId);
-        let chatOffset = (() => { try {
-            return fs.statSync(chatPath).size;
-        }
-        catch {
-            return 0;
-        } })();
-        let chatEmitted = false;
-        // Rich tool-event stream: a SEPARATE offset over the same transcript so each
-        // grok tool call becomes one PreToolUse + one PostToolUse (payload-carrying)
-        // hook event in the office feed. `pendingTools` matches a Post to its Pre by
-        // tool_call id across polls. Seeded at the same size so only THIS turn's tools
-        // are emitted, not the resumed history.
-        let toolOffset = chatOffset;
-        const pendingTools = new Map();
-        // Submit the prompt.
-        log(`Grok TUI: sending turn (${(() => { try {
-            return fs.statSync(promptFilePath).size;
-        }
-        catch {
-            return 0;
-        } })()} bytes)`);
-        pastePrompt(sess, promptFilePath);
-        // -----------------------------------------------------------------------
-        // Poll: stream new pane bytes, detect turn-end by output quiescence + a
-        // byte-stable pane snapshot with the running-indicator absent.
-        // -----------------------------------------------------------------------
-        const turnStart = Date.now();
-        let lastGrowthMs = Date.now();
-        let sawOutput = false;
-        let lastSnap = '';
-        let stable = 0;
-        let sawDoneMarker = false;
-        for (;;) {
-            await sleep(POLL_MS);
-            // Session died mid-turn (grok crashed / was killed).
-            if (!hasSession(sess.name)) {
-                try {
-                    fs.appendFileSync(stdoutFile, `\n[Grok TUI: session exited]\n`, 'utf8');
-                }
-                catch { /* ignore */ }
-                _tmuxSessions.delete(root);
-                finish(1, 'session-exit');
-                return;
-            }
-            // 1a) Read the pane ONLY for activity/quiescence timing — its bytes are
-            //     TUI chrome (spinners, "Waiting for response…", token counters) and
-            //     must NOT be emitted as the agent's output.
-            const { text: paneText, offset: paneOff } = readFrom(sess.rawLog, readOffset);
-            if (paneText) {
-                readOffset = paneOff;
-                sess.readOffset = paneOff;
-                if (stripAnsi(paneText).trim()) {
-                    _lastActivityMs.set(root, Date.now());
-                    lastGrowthMs = Date.now();
-                    sawOutput = true;
-                }
-            }
-            // 1b) Emit CLEAN output from grok's structured transcript (assistant prose
-            //     + compact tool markers), never the pane scrape.
-            const ch = drainChatHistory(chatPath, chatOffset);
-            if (ch.text) {
-                chatOffset = ch.offset;
-                chatEmitted = true;
-                try {
-                    fs.appendFileSync(stdoutFile, ch.text, 'utf8');
-                }
-                catch { /* ignore */ }
-                emitLines(ch.text);
-                activityBuf += ch.text;
-                scheduleActivity();
-                _lastActivityMs.set(root, Date.now());
-            }
-            // 1c) Emit rich per-tool hook events (Pre/PostToolUse with payload) from the
-            //     SAME transcript, on an independent offset.
-            toolOffset = scanGrokToolEvents(root, chatPath, toolOffset, pendingTools);
-            // 2) Snapshot for detection (also catches a mid-turn reauth prompt).
-            const snap = capturePane(sess.name);
-            if (REAUTH_MARKERS.test(snap)) {
-                try {
-                    fs.appendFileSync(stdoutFile, `\n[Grok TUI: reauthentication required — please login]\n`, 'utf8');
-                }
-                catch { /* ignore */ }
-                finish(1, 'reauth_required');
-                return;
-            }
-            // Backstop: the project-directory picker appears AFTER the first prompt is
-            // submitted (grok's one-time confirm), so it lands mid-turn. The config
-            // opt-out normally prevents it; if a grok build ignores that, select the
-            // current dir (option "1", always present) to unblock the turn.
-            if (/Run Grok Build in a project directory|Don't ask me again|\(current\)/i.test(snap)) {
-                tmux(['send-keys', '-t', sess.name, '1']);
-                await sleep(800);
-                lastGrowthMs = Date.now();
-                continue;
-            }
-            // 3) Idle test. grok prints "Worked for N.Ns." when a turn genuinely ends —
-            //    that's the fast, positive done-signal. Absent it (an error turn, or an
-            //    unusual grok build), fall back to a MUCH longer quiescence so early
-            //    "Starting session…"/"Reading file…" pauses aren't misread as turn-end.
-            if (DONE_MARKER.test(snap)) {
-                sawDoneMarker = true;
-            }
-            if (snap === lastSnap) {
-                stable++;
-            }
-            else {
-                stable = 0;
-                lastSnap = snap;
-            }
-            const running = RUNNING_INDICATOR.test(snap);
-            const quietMs = Date.now() - lastGrowthMs;
-            const readyToJudge = sawOutput || (Date.now() - turnStart >= NOOUTPUT_MS);
-            const doneFast = sawDoneMarker && quietMs >= DEBOUNCE_MS;
-            const doneSlow = readyToJudge && quietMs >= QUIET_FALLBACK_MS && stable >= STABLE_POLLS;
-            if (!running && (doneFast || doneSlow)) {
-                // Final drain of the transcript to catch records written between the last
-                // poll and turn-end.
-                const tail = drainChatHistory(chatPath, chatOffset);
-                if (tail.text) {
-                    chatOffset = tail.offset;
-                    chatEmitted = true;
-                    try {
-                        fs.appendFileSync(stdoutFile, tail.text, 'utf8');
-                    }
-                    catch { /* ignore */ }
-                    emitLines(tail.text);
-                }
-                // Flush any tool events written between the last poll and turn-end.
-                toolOffset = scanGrokToolEvents(root, chatPath, toolOffset, pendingTools);
-                // Safety net: if the transcript path never resolved (grok layout change /
-                // encoding drift) yet the pane clearly produced output, fall back to a
-                // cleaned pane tail so the turn is never silently empty.
-                if (!chatEmitted && sawOutput) {
-                    const pane = stripAnsi(capturePane(sess.name, 400)).replace(/[ \t]+\n/g, '\n').trim();
-                    if (pane) {
-                        try {
-                            fs.appendFileSync(stdoutFile, pane + '\n', 'utf8');
-                        }
-                        catch { /* ignore */ }
-                    }
-                    log('Grok TUI: transcript yielded no output — fell back to pane capture (check chat_history path)');
-                }
-                finish(0, 'idle');
-                return;
-            }
-            // 4) Watchdog — a turn that overruns the hard budget. Interrupt with Esc
-            //    (grok's cancel) to preserve the session/context; if it won't settle,
-            //    kill the session so the NEXT turn relaunches with --resume.
-            if (MAX_RUN_MS > 0 && Date.now() - turnStart >= MAX_RUN_MS) {
-                log(`Grok TUI watchdog: exceeded ${Math.round(MAX_RUN_MS / 60_000)}min budget — interrupting`);
-                try {
-                    fs.appendFileSync(stdoutFile, `\n[Grok TUI watchdog: turn exceeded time budget — interrupted]\n`, 'utf8');
-                }
-                catch { /* ignore */ }
-                tmux(['send-keys', '-t', sess.name, 'Escape']);
-                // Give grok a moment to settle after the interrupt.
-                let settled = false;
-                for (let i = 0; i < 8; i++) {
-                    await sleep(500);
-                    if (!hasSession(sess.name)) {
-                        break;
-                    }
-                    const s2 = capturePane(sess.name);
-                    if (!RUNNING_INDICATOR.test(s2)) {
-                        settled = true;
-                        break;
-                    }
-                }
-                if (!settled && hasSession(sess.name)) {
-                    // Still wedged after Esc → kill so ensureSession relaunches next turn.
-                    killSession(sess.name);
-                    _tmuxSessions.delete(root);
-                }
-                finish(124, 'watchdog');
-                return;
-            }
-        }
-    })();
-}
-function sendGrokPrompt(root, promptFilePath, stdoutFile, exitFile, log, opts = {}) {
-    opts.showOutput?.();
-    const modelArgs = opts.model ? ['-m', opts.model] : [];
-    const modelLabel = opts.model || 'account default';
-    const sessionArgs = [];
-    if (opts.persist) {
-        const providerId = opts.providerId ?? 'grok-tui';
-        if (opts.sessionId) {
-            sessionArgs.push('--resume', opts.sessionId);
-            log(`Grok: resuming session ${opts.sessionId.slice(0, 8)}… (model=${modelLabel})`);
-        }
-        else {
-            const sid = (0, crypto_1.randomUUID)();
-            sessionArgs.push('--session-id', sid);
-            try {
-                (0, sessionState_1.saveSessionId)(root, providerId, sid);
-            }
-            catch { /* best effort */ }
-            log(`Grok: new persistent session ${sid.slice(0, 8)}… (model=${modelLabel})`);
-        }
-    }
-    else {
-        log(`Grok: spawning (model=${modelLabel})`);
-    }
-    try {
-        fs.writeFileSync(stdoutFile, '', 'utf8');
-    }
-    catch { /* ignore */ }
-    try {
-        fs.writeFileSync(exitFile, '', 'utf8');
-    }
-    catch { /* ignore */ }
-    const prior = _activeChildren.get(root);
-    if (prior) {
-        try {
-            prior.kill('SIGKILL');
-        }
-        catch { /* ignore */ }
-        _activeChildren.delete(root);
-    }
-    _busyRoots.add(root);
-    const failSpawn = (msg) => {
-        log(`Grok spawn error: ${msg}`);
-        try {
-            fs.appendFileSync(stdoutFile, `\n[Grok spawn error: ${msg}]\n`, 'utf8');
-        }
-        catch { /* ignore */ }
-        try {
-            fs.writeFileSync(exitFile, '1\n', 'utf8');
-        }
-        catch { /* ignore */ }
-        _activeChildren.delete(root);
-        _busyRoots.delete(root);
-    };
-    let child;
-    try {
-        child = child_process.spawn(GROK_BIN, [
-            ...modelArgs,
-            '--always-approve',
-            '--cwd', root,
-            ...sessionArgs,
-            '--prompt-file', promptFilePath,
-            '--output-format', 'streaming-json',
-        ], { cwd: root, stdio: ['ignore', 'pipe', 'pipe'], env: { ...process.env } });
-    }
-    catch (spawnErr) {
-        failSpawn(spawnErr?.message ?? String(spawnErr));
-        return;
-    }
-    child.on('error', (err) => {
-        const missing = err.code === 'ENOENT';
-        failSpawn(missing
-            ? `${GROK_BIN} is not installed or not on PATH (${err.message})`
-            : err.message);
-    });
-    _activeChildren.set(root, child);
-    child.once('spawn', () => { _emitGrokHook(root, 'SessionStart', { source: 'startup' }); });
-    const GROK_MAX_RUN_MS = envNum('AUTODEV_GROK_MAX_RUN_MS', 10 * 60_000);
-    const GROK_MAX_TOOL_ERRORS = envNum('AUTODEV_GROK_MAX_TOOL_ERRORS', 25);
-    let toolErrorCount = 0;
-    let killed = false;
-    const killGrok = (why) => {
-        if (killed) {
-            return;
-        }
-        killed = true;
-        log(`Grok watchdog: ${why} — killing run`);
-        try {
-            fs.appendFileSync(stdoutFile, `\n[Grok watchdog: ${why}]\n`, 'utf8');
-        }
-        catch { /* ignore */ }
-        try {
-            child.kill('SIGKILL');
-        }
-        catch { /* ignore */ }
-    };
-    const watchdog = GROK_MAX_RUN_MS > 0
-        ? setTimeout(() => killGrok(`exceeded ${Math.round(GROK_MAX_RUN_MS / 60_000)}min time budget`), GROK_MAX_RUN_MS)
-        : null;
-    const rl = readline.createInterface({ input: child.stdout });
-    let _endSeen = false;
-    let _activityBuf = '';
-    let _activityTimer = null;
-    const flushActivity = () => {
-        if (_activityTimer) {
-            clearTimeout(_activityTimer);
-            _activityTimer = null;
-        }
-        const t = _activityBuf.trim();
-        _activityBuf = '';
-        if (!t) {
-            return;
-        }
-        const preview = t.length > 280 ? t.slice(0, 277) + '…' : t;
-        _emitGrokHook(root, 'Notification', { message: preview, title: 'grok', tool_name: 'grok' });
-    };
-    const scheduleActivity = () => {
-        if (_activityBuf.length >= 400) {
-            flushActivity();
-            return;
-        }
-        if (!_activityTimer) {
-            _activityTimer = setTimeout(flushActivity, 1200);
-        }
-    };
-    let _lineBuf = '';
-    const emitOutputLines = (text) => {
-        _lineBuf += text;
-        let nl;
-        while ((nl = _lineBuf.indexOf('\n')) >= 0) {
-            const line = _lineBuf.slice(0, nl).replace(/\s+$/, '');
-            _lineBuf = _lineBuf.slice(nl + 1);
-            if (line.trim()) {
-                log(`  ${line}`);
-            }
-        }
-    };
-    const flushOutputLine = () => {
-        const line = _lineBuf.replace(/\s+$/, '');
-        _lineBuf = '';
-        if (line.trim()) {
-            log(`  ${line}`);
-        }
-    };
-    rl.on('line', (line) => {
-        if (!line.trim()) {
-            return;
-        }
-        let msg;
-        try {
-            msg = JSON.parse(line);
-        }
-        catch {
-            try {
-                fs.appendFileSync(stdoutFile, line + '\n', 'utf8');
-            }
-            catch { /* ignore */ }
-            return;
-        }
-        const type = msg.type ?? '';
-        if (type === 'assistant' || type === 'text') {
-            const text = msg.content ?? msg.data ?? msg.text ?? msg.message ?? '';
-            if (text) {
-                try {
-                    fs.appendFileSync(stdoutFile, text, 'utf8');
-                }
-                catch { /* ignore */ }
-                emitOutputLines(text);
-                _activityBuf += text;
-                scheduleActivity();
-            }
-        }
-        else if (type === 'error') {
-            const errMsg = msg.message ?? JSON.stringify(msg);
-            log(`Grok error: ${errMsg}`);
-            try {
-                fs.appendFileSync(stdoutFile, `\n[Grok error: ${errMsg}]\n`, 'utf8');
-            }
-            catch { /* ignore */ }
-        }
-        else if (type === 'end') {
-            _endSeen = true;
-            flushOutputLine();
-            flushActivity();
-            _emitGrokHook(root, 'Stop', {});
-            _emitGrokHook(root, 'SessionEnd', { reason: 'completed' });
-        }
-    });
-    const errRl = child.stderr ? readline.createInterface({ input: child.stderr }) : null;
-    errRl?.on('line', (line) => {
-        const text = line.trim();
-        if (!text) {
-            return;
-        }
-        log(`Grok stderr: ${text}`);
-        if (GROK_MAX_TOOL_ERRORS > 0 && text.includes('tool_output_error')) {
-            toolErrorCount++;
-            if (toolErrorCount >= GROK_MAX_TOOL_ERRORS) {
-                killGrok(`${toolErrorCount} tool-output errors (stuck retry loop)`);
-            }
-        }
-    });
-    child.on('close', (code) => {
-        if (watchdog) {
-            clearTimeout(watchdog);
-        }
-        flushOutputLine();
-        flushActivity();
-        errRl?.close();
-        rl.close();
-        _activeChildren.delete(root);
-        _busyRoots.delete(root);
-        const exitCode = code ?? 1;
-        log(`Grok: exited (code=${exitCode})`);
-        if (!_endSeen) {
-            _emitGrokHook(root, exitCode === 0 ? 'Stop' : 'StopFailure', { exit_code: exitCode });
-            _emitGrokHook(root, 'SessionEnd', { reason: exitCode === 0 ? 'completed' : 'error' });
-        }
-        try {
-            fs.writeFileSync(exitFile, `${exitCode}\n`, 'utf8');
-        }
-        catch { /* ignore */ }
-    });
-}
-/** grok-cli: stateless — a fresh HEADLESS grok process every task. */
-function sendGrokCliPrompt(root, promptFilePath, stdoutFile, exitFile, log, model, showOutput) {
-    sendGrokPrompt(root, promptFilePath, stdoutFile, exitFile, log, {
-        model, showOutput, persist: false, providerId: 'grok-cli',
-    });
-}
-/**
- * grok-tui: persistent — run the turn in the per-workspace tmux session so
- * grok's in-process context accumulates across tasks. Falls back to the old
- * headless spawn (with --resume) when tmux is unavailable so nothing regresses.
- */
-function sendGrokTuiPrompt(root, promptFilePath, resolvedSessionId, stdoutFile, exitFile, log, model, showOutput) {
-    if (tmuxAvailable()) {
-        runGrokTmuxTurn(root, promptFilePath, resolvedSessionId, stdoutFile, exitFile, log, model, showOutput);
-        return;
-    }
-    log('Grok TUI: tmux not available — falling back to headless spawn');
-    sendGrokPrompt(root, promptFilePath, stdoutFile, exitFile, log, {
-        model, showOutput, persist: true, sessionId: resolvedSessionId, providerId: 'grok-tui',
-    });
-}
-// ---------------------------------------------------------------------------
-// steerGrokTui — inject a message into the RUNNING grok turn via the live pane.
-//
-// Because the tmux session is a real TTY, keys sent to a mid-turn pane are
-// delivered to grok's input and folded into the current turn (confirmed with a
-// live REPL stand-in). Mirrors steerClaudeTui: only injects when a turn is
-// actually running; returns false when there is no live pane so the caller
-// keeps the durable TODO fallback (at-least-once delivery).
-// ---------------------------------------------------------------------------
-async function steerGrokTui(root, text, log) {
-    const sess = _tmuxSessions.get(root);
-    if (!sess) {
-        return false;
-    } // no live tmux session (headless / not started)
-    if (!_busyRoots.has(root)) {
-        return false;
-    } // only steer a turn in flight
-    if (!hasSession(sess.name)) {
-        _tmuxSessions.delete(root);
-        return false;
-    }
-    try {
-        // Literal keystrokes (send-keys -l), NOT a bracketed paste — grok's TUI
-        // misreads a paste as a directory picker. Flatten to one line (no reliable
-        // newline-without-submit key), then Enter to inject into the running turn.
-        const flat = text.replace(/\r?\n+/g, ' ').replace(/[ \t]+/g, ' ').trim();
-        for (let i = 0; i < flat.length; i += 3000) {
-            if (tmux(['send-keys', '-t', sess.name, '-l', flat.slice(i, i + 3000)]) === null) {
-                return false;
-            }
-        }
-        if (tmux(['send-keys', '-t', sess.name, 'Enter']) === null) {
-            return false;
-        }
-        log(`Grok TUI: steered live pane (${text.length} chars) — injected into current turn`);
-        return true;
-    }
-    catch (err) {
-        log(`Grok TUI: steer failed: ${err?.message ?? String(err)}`);
-        return false;
-    }
-}
-// ---------------------------------------------------------------------------
-// Teardown
-// ---------------------------------------------------------------------------
-/**
- * Called by taskLoop reset interval / provider close. Kills any live grok for
- * this root — the tmux session AND any headless child — while PRESERVING the
- * persisted session id so a later task relaunches with --resume (context intact).
- */
-function closeGrokTuiSession(root, _log) {
-    const child = _activeChildren.get(root);
-    if (child) {
-        try {
-            child.kill('SIGKILL');
-        }
-        catch { /* ignore */ }
-        _activeChildren.delete(root);
-    }
-    const sess = _tmuxSessions.get(root);
-    if (sess) {
-        killSession(sess.name);
-        _tmuxSessions.delete(root);
-    }
-    else {
-        // No cached handle but a session may still exist under the deterministic name.
-        const name = sessionName(root);
-        if (hasSession(name)) {
-            killSession(name);
-        }
-    }
-    _busyRoots.delete(root);
-    _emittedToolIds.delete(root);
-}
-/** Kill all live grok sessions — called on SDK/extension shutdown. */
-function closeAllGrokTuiSessions() {
-    for (const child of _activeChildren.values()) {
-        try {
-            child.kill('SIGKILL');
-        }
-        catch { /* ignore */ }
-    }
-    _activeChildren.clear();
-    for (const sess of _tmuxSessions.values()) {
-        killSession(sess.name);
-    }
-    _tmuxSessions.clear();
-    _busyRoots.clear();
-    _emittedToolIds.clear();
-}
-// ---------------------------------------------------------------------------
-// detectGrokTuiRateLimit
-// ---------------------------------------------------------------------------
-function detectGrokTuiRateLimit(stdoutContent) {
-    return rateLimit_1.RateLimitDetector.detect(stdoutContent);
-}
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./grok/tui"), exports);
 //# sourceMappingURL=grokTuiProvider.js.map