autodev-cli 1.4.186 → 1.4.188

package/out/providers/grok/tui.js

@@ -70,12 +70,18 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.grokAgentStdioSupported = grokAgentStdioSupported;
+exports.grokAcpEnabled = grokAcpEnabled;
 exports.isGrokTuiBusy = isGrokTuiBusy;
 exports.getGrokTuiLastActivity = getGrokTuiLastActivity;
 exports.forceIdleGrokTui = forceIdleGrokTui;
 exports.tmuxAvailable = tmuxAvailable;
+exports.grokSessionArgsFor = grokSessionArgsFor;
 exports.sendGrokPrompt = sendGrokPrompt;
 exports.sendGrokCliPrompt = sendGrokCliPrompt;
+exports.sendGrokAcpPrompt = sendGrokAcpPrompt;
+exports.steerGrokAcp = steerGrokAcp;
+exports.isGrokAcpBusy = isGrokAcpBusy;
 exports.decideGrokRunMode = decideGrokRunMode;
 exports.decideHeadlessGrokMode = decideHeadlessGrokMode;
 exports.resumeProbeVerdict = resumeProbeVerdict;
@@ -101,6 +107,7 @@ const authClassify_1 = require("./authClassify");
 const grokEvents_1 = require("../../core/grokEvents");
 const sessions_1 = require("./sessions");
 const redactSecrets_1 = require("../../core/redactSecrets");
+const GrokAcpSession_1 = require("./GrokAcpSession");
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
@@ -155,6 +162,39 @@ const _resumeFailCount = (root) => _resumeFailures.get(root) ?? 0;
 const _noteResumeFailure = (root) => { _resumeFailures.set(root, _resumeFailCount(root) + 1); };
 const _noteResumeSuccess = (root) => { _resumeFailures.delete(root); };
 const _tmuxSessions = new Map();
+/**
+ * Live PERSISTENT `grok agent stdio` ACP sessions by root (the persistent-process
+ * model). ONE long-lived grok per workspace serves many turns without exiting;
+ * resume happens only at (re)start via session/load. See GrokAcpSession.
+ */
+const _acpSessions = new Map();
+/** Cached probe: does this grok build expose `agent stdio` (the ACP transport)? */
+let _grokAgentStdioSupported = null;
+function grokAgentStdioSupported() {
+    if (_grokAgentStdioSupported !== null) {
+        return _grokAgentStdioSupported;
+    }
+    try {
+        const out = child_process.execFileSync(GROK_BIN, ['agent', '--help'], { encoding: 'utf8', timeout: 8_000, stdio: ['ignore', 'pipe', 'ignore'] });
+        _grokAgentStdioSupported = /\bstdio\b/.test(out);
+    }
+    catch {
+        _grokAgentStdioSupported = false;
+    }
+    return _grokAgentStdioSupported;
+}
+/**
+ * Whether the persistent ACP path is active. Gated on grok supporting `agent
+ * stdio` AND the AUTODEV_GROK_PERSISTENT env override (default ON when supported;
+ * set to 'false'/'0'/'off' to force the legacy one-shot headless path).
+ */
+function grokAcpEnabled() {
+    const raw = String(process.env['AUTODEV_GROK_PERSISTENT'] ?? '').toLowerCase();
+    if (raw === 'false' || raw === '0' || raw === 'off' || raw === 'no') {
+        return false;
+    }
+    return grokAgentStdioSupported();
+}
 // 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;
@@ -1510,6 +1550,29 @@ function runGrokTmuxTurn(root, promptFilePath, resolvedSessionId, stdoutFile, ex
         }
     })();
 }
+/**
+ * Pure builder for the grok session CLI flags, extracted so the mutually-exclusive
+ * invariants are unit-testable without spawning grok:
+ *   - continueSession → `['--continue']` ONLY. NEVER with `--session-id` (grok rejects
+ *     that combo unless `--fork-session`, which we never pass) and never an explicit id.
+ *   - sessionId       → `['--resume', <id>]` (legacy explicit-id resume; not used by the
+ *     headless path anymore, kept for callers that pass a concrete id).
+ *   - newSessionId    → `['--session-id', <uuid>]` (bootstrap a brand-new named session).
+ *   - none            → `[]` (stateless: grok mints its own throwaway id).
+ * continueSession takes precedence, so `--continue` can never be emitted alongside an id.
+ */
+function grokSessionArgsFor(args) {
+    if (args.continueSession) {
+        return ['--continue'];
+    }
+    if (args.sessionId) {
+        return ['--resume', args.sessionId];
+    }
+    if (args.newSessionId) {
+        return ['--session-id', args.newSessionId];
+    }
+    return [];
+}
 function sendGrokPrompt(root, promptFilePath, stdoutFile, exitFile, log, opts = {}) {
     opts.showOutput?.();
     const modelArgs = opts.model ? ['-m', opts.model] : [];
@@ -1525,10 +1588,34 @@ function sendGrokPrompt(root, promptFilePath, stdoutFile, exitFile, log, opts =
     // read from the start = an instant false failure). This is the primary fix for
     // the 1.4.181 forced-resume regression.
     let _launchSid;
+    // For the `--continue` path the concrete id is not known up front — grok appends to
+    // the cwd's most-recent session dir — so we pin the tailer to that EXISTING newest
+    // dir (resolved at launch, before grok appends). Kept separate from _launchSid (which
+    // means "we minted/passed this exact id"), since --continue passes no id at all.
+    let _continueDir;
     if (opts.persist) {
         const providerId = opts.providerId ?? 'grok-tui';
-        if (opts.sessionId) {
-            sessionArgs.push('--resume', opts.sessionId);
+        if (opts.continueSession) {
+            // `grok --continue`: resume the folder's most-recent session. No id, and NO
+            // --session-id (grok rejects that combo unless --fork-session, which we never
+            // want). Robust to the stale-id / cwd-tracking-drift that made `--resume <id>`
+            // error in ~1s on Windows and forced every turn stateless.
+            sessionArgs.push(...grokSessionArgsFor({ continueSession: true }));
+            _continueDir = (0, sessions_1.newestGrokSessionDir)(path.resolve(root));
+            // Best-effort: stamp the resolved id into session-state.json so the sessions UI
+            // / resume-aware profile reminder can still name the session. The continue
+            // DECISION no longer depends on a stored id (it keys off folder-session presence).
+            try {
+                const resumedId = _continueDir ? path.basename(_continueDir) : undefined;
+                if (resumedId) {
+                    (0, sessionState_1.saveSessionId)(root, providerId, resumedId);
+                }
+            }
+            catch { /* best effort */ }
+            log(`Grok: continuing most-recent session for cwd (--continue) (model=${modelLabel})`);
+        }
+        else if (opts.sessionId) {
+            sessionArgs.push(...grokSessionArgsFor({ sessionId: opts.sessionId }));
             _launchSid = opts.sessionId;
             // Persist the id we're resuming so the NEXT turn reads it from
             // session-state.json directly — this also stamps a session that was only
@@ -1542,7 +1629,7 @@ function sendGrokPrompt(root, promptFilePath, stdoutFile, exitFile, log, opts =
         }
         else {
             const sid = (0, crypto_1.randomUUID)();
-            sessionArgs.push('--session-id', sid);
+            sessionArgs.push(...grokSessionArgsFor({ newSessionId: sid }));
             _launchSid = sid;
             try {
                 (0, sessionState_1.saveSessionId)(root, providerId, sid);
@@ -1666,6 +1753,22 @@ function sendGrokPrompt(root, promptFilePath, stdoutFile, exitFile, log, opts =
     let _endSeen = false;
     let _forcedExit = null; // set by a session-log turn_ended finish
     let _grokFilesActive = false; // once true, session logs own narration
+    // Best diagnostic grok gave us THIS turn, so a fast-failing resume/continue is no
+    // longer a blind guess (the user's Windows `--resume <id>` errors in ~1s but our log
+    // never showed grok's real reason). Populated from three channels: an authoritative
+    // streaming-json {type:"error"} record or an error turn_ended detail (_lastGrokErr),
+    // and, as a fallback, the most recent stderr line (_lastGrokStderr). Surfaced right
+    // before the stateless fallback in finishFromTurnEnd, redacted + truncated.
+    let _lastGrokErr = ''; // authoritative: json error record / error turn_ended detail
+    let _lastGrokStderr = ''; // fallback: latest non-empty stderr line
+    const grokFailDiag = () => {
+        const raw = _lastGrokErr || _lastGrokStderr;
+        if (!raw) {
+            return '';
+        }
+        const t = (0, redactSecrets_1.redactSecrets)(String(raw)).replace(/\s+/g, ' ').trim();
+        return t.length > 300 ? t.slice(0, 297) + '…' : t;
+    };
     // Headless resume hang-probe state (see resumeProbeMs / onResumeHang below). The
     // probe window is the caller-supplied value (sendGrokTuiPrompt reads the env);
     // 0 (all stateless / non-probed calls) leaves the probe disarmed.
@@ -1700,7 +1803,10 @@ function sendGrokPrompt(root, promptFilePath, stdoutFile, exitFile, log, opts =
     // the tailer pins THIS dir and never "newest-by-mtime" (which a newer unrelated
     // session dir could hijack). undefined only in the stateless mode, where grok
     // mints an unknown id and newest-by-mtime is the only way to find it.
-    const _fixedDir = _launchSid ? (0, sessions_1.grokSessionDirFor)(path.resolve(root), _launchSid) : undefined;
+    // --continue → the existing newest dir grok appends to (resolved above); resume /
+    // new-persistent → the fixed dir for the known id; stateless → undefined (unknown id).
+    const _fixedDir = _continueDir
+        ?? (_launchSid ? (0, sessions_1.grokSessionDirFor)(path.resolve(root), _launchSid) : undefined);
     // Snapshot the pre-turn session so the tailer forwards ONLY this turn's records:
     // a RESUMED session's dir already holds backlog → seed at its current end; a
     // FRESH session mints a NEW dir that appears later → read that dir from the start
@@ -1787,8 +1893,16 @@ function sendGrokPrompt(root, promptFilePath, stdoutFile, exitFile, log, opts =
         // re-attempts `--resume <storedId>` — continuity resumes as soon as the transient
         // condition clears. Only for a launched RESUME (opts.sessionId present, probe
         // armed); a new-persistent/stateless error falls through to the normal report.
-        if (!clean && !_sawFirstToken && opts.sessionId && opts.onResumeHang && !_resumeAbandoned) {
+        if (!clean && !_sawFirstToken && (opts.sessionId || opts.continueSession) && opts.onResumeHang && !_resumeAbandoned) {
             _resumeAbandoned = true; // close skips the exit file — the relaunch owns the turn
+            const how = opts.continueSession ? '--continue' : '--resume';
+            const diag = grokFailDiag();
+            if (diag) {
+                log(`Grok: ${how} failed fast — grok said: "${diag}"`);
+            }
+            else {
+                log(`Grok: ${how} failed fast — grok emitted no diagnostic (no stderr / error record captured this turn)`);
+            }
             log('Grok: resume errored before any output (no first_token) — marking session non-resumable this run, falling back to stateless for this turn');
             if (grokFilePoll) {
                 clearInterval(grokFilePoll);
@@ -1889,7 +2003,7 @@ function sendGrokPrompt(root, promptFilePath, stdoutFile, exitFile, log, opts =
         // prior transient hiccup stops biasing later turns.
         if (!_sawFirstToken && (0, grokEvents_1.scanGrokFirstToken)(ev.lines)) {
             _sawFirstToken = true;
-            if (opts.sessionId && opts.onResumeOk) {
+            if ((opts.sessionId || opts.continueSession) && opts.onResumeOk) {
                 try {
                     opts.onResumeOk();
                 }
@@ -1927,6 +2041,28 @@ function sendGrokPrompt(root, promptFilePath, stdoutFile, exitFile, log, opts =
         // instead of hanging to GROK_MAX_RUN_MS. An error/aborted outcome ends it too
         // (retryable), honoring scanGrokTurnEnd's classification.
         const te = (0, grokEvents_1.scanGrokTurnEnd)(ev.lines);
+        // Capture grok's own error detail from an error turn_ended so the fast-fail
+        // fallback can name WHY (session-not-found, in-use, cwd mismatch, auth, …). Only
+        // when we don't already have an authoritative streaming-json error record.
+        if (te === 'error' && !_lastGrokErr) {
+            for (const l of ev.lines) {
+                let o;
+                try {
+                    o = typeof l === 'string' ? JSON.parse(l) : l;
+                }
+                catch {
+                    continue;
+                }
+                if (!o || o.type !== 'turn_ended') {
+                    continue;
+                }
+                const d = o.error?.message ?? o.error ?? o.detail ?? o.message ?? o.reason ?? o.outcome_detail;
+                if (d) {
+                    _lastGrokErr = typeof d === 'string' ? d : JSON.stringify(d);
+                    break;
+                }
+            }
+        }
         // Safety net against any residual offset skew: only honor a turn_ended once
         // THIS turn has demonstrably started in the tailed window. A turn_ended with no
         // preceding current-turn start is backlog (a prior errored turn read from a
@@ -2004,7 +2140,12 @@ function sendGrokPrompt(root, promptFilePath, stdoutFile, exitFile, log, opts =
                 // counts a TRANSIENT failure (bounded counter); it does NOT permanently disable
                 // resume — the next turn re-attempts `--resume`.
                 _resumeAbandoned = true;
-                log(`Grok: headless --resume produced no output in ${Math.round(_probeWaitedMs / 1000)}s (${_probeRound} extension${_probeRound === 1 ? '' : 's'}) — stateless for this turn only (stored session id kept; resume retried next turn)`);
+                const how = opts.continueSession ? '--continue' : '--resume';
+                const diag = grokFailDiag();
+                if (diag) {
+                    log(`Grok: ${how} failed — grok said: "${diag}"`);
+                }
+                log(`Grok: headless ${how} produced no output in ${Math.round(_probeWaitedMs / 1000)}s (${_probeRound} extension${_probeRound === 1 ? '' : 's'}) — stateless for this turn only (stored session id kept; resume retried next turn)`);
                 if (grokFilePoll) {
                     clearInterval(grokFilePoll);
                 }
@@ -2060,6 +2201,7 @@ function sendGrokPrompt(root, promptFilePath, stdoutFile, exitFile, log, opts =
         }
         else if (type === 'error') {
             const errMsg = msg.message ?? JSON.stringify(msg);
+            _lastGrokErr = errMsg; // authoritative diagnostic for a fast resume/continue failure
             log(`Grok error: ${errMsg}`);
             try {
                 fs.appendFileSync(stdoutFile, `\n[Grok error: ${errMsg}]\n`, 'utf8');
@@ -2080,6 +2222,7 @@ function sendGrokPrompt(root, promptFilePath, stdoutFile, exitFile, log, opts =
         if (!text) {
             return;
         }
+        _lastGrokStderr = text; // fallback diagnostic for a fast resume/continue failure
         log(`Grok stderr: ${text}`);
         if (GROK_MAX_TOOL_ERRORS > 0 && text.includes('tool_output_error')) {
             toolErrorCount++;
@@ -2122,6 +2265,17 @@ function sendGrokPrompt(root, promptFilePath, stdoutFile, exitFile, log, opts =
         // A session-log turn_ended already reported the true outcome via _forcedExit;
         // don't let the SIGKILL exit code (1) override a clean finish.
         const exitCode = _forcedExit ?? code ?? 1;
+        // A resume/continue that FAILED FAST by exiting non-zero directly (grok printed to
+        // stderr and quit, e.g. "Session <id> not found locally … 404 Not Found") never
+        // wrote a session-log turn_ended, so it bypassed finishFromTurnEnd's diagnostic.
+        // Surface grok's captured reason here too so this failure shape is not a blind guess.
+        if (exitCode !== 0 && !_sawFirstToken && (opts.sessionId || opts.continueSession)) {
+            const how = opts.continueSession ? '--continue' : '--resume';
+            const diag = grokFailDiag();
+            if (diag) {
+                log(`Grok: ${how} failed fast (exit ${exitCode}) — grok said: "${diag}"`);
+            }
+        }
         log(`Grok: exited (code=${exitCode})`);
         if (!_endSeen) {
             _emitGrokHook(root, exitCode === 0 ? 'Stop' : 'StopFailure', { exit_code: exitCode });
@@ -2142,8 +2296,154 @@ function sendGrokPrompt(root, promptFilePath, stdoutFile, exitFile, log, opts =
  * to a stateless relaunch instead of hanging the loop.
  */
 function sendGrokCliPrompt(root, promptFilePath, resolvedSessionId, stdoutFile, exitFile, log, model, showOutput) {
+    if (grokAcpEnabled()) {
+        sendGrokAcpPrompt(root, promptFilePath, resolvedSessionId, stdoutFile, exitFile, log, 'grok-cli', model, showOutput);
+        return;
+    }
     sendGrokPersistentHeadless(root, promptFilePath, resolvedSessionId, stdoutFile, exitFile, log, 'grok-cli', model, showOutput);
 }
+// ---------------------------------------------------------------------------
+// PERSISTENT-PROCESS (ACP) path — one long-lived `grok agent stdio` per root.
+// ---------------------------------------------------------------------------
+/** Get (or lazily create) the persistent ACP session for a root. */
+function getOrCreateAcpSession(root, providerId, model, log, resolvedSessionId) {
+    let sess = _acpSessions.get(root);
+    if (sess) {
+        return sess;
+    }
+    // Resume-on-(re)start: seed the id to session/load from the persisted id, else
+    // the newest grok session on disk for this cwd (works whether that session was
+    // created by a prior ACP run or the legacy headless `--continue`).
+    const seedId = resolvedSessionId || (0, sessionState_1.getSessionId)(root, providerId) || (0, sessions_1.getGrokLatestSessionId)(root) || undefined;
+    const hooks = {
+        emitHook: (name, extra) => {
+            if (name === 'Notification' && typeof extra['message'] === 'string') {
+                const msg = (0, redactSecrets_1.redactSecrets)(String(extra['message'])).slice(0, 1200);
+                if (!msg.trim()) {
+                    return;
+                }
+                _emitGrokHook(root, 'Notification', { ...extra, message: msg });
+            }
+            else {
+                _emitGrokHook(root, name, (0, redactSecrets_1.redactDeep)(extra));
+            }
+        },
+        log,
+    };
+    sess = new GrokAcpSession_1.GrokAcpSession({ root, model, bin: GROK_BIN, hooks, initialSessionId: seedId });
+    _acpSessions.set(root, sess);
+    return sess;
+}
+/**
+ * Fire-and-forget: run ONE turn through the persistent ACP session. Streams
+ * assistant text to stdoutFile and writes the exit code to exitFile exactly once
+ * at turn end — preserving the taskLoop contract byte-for-byte. The grok process
+ * STAYS ALIVE between turns; a crash/exit is detected and the NEXT turn respawns
+ * + session/load restores context. If the ACP handshake can't be established
+ * (older grok, or a transient spawn failure) it transparently FALLS BACK to the
+ * legacy one-shot headless path so nothing regresses.
+ */
+function sendGrokAcpPrompt(root, promptFilePath, resolvedSessionId, stdoutFile, exitFile, log, providerId, model, showOutput) {
+    try {
+        fs.writeFileSync(stdoutFile, '', 'utf8');
+    }
+    catch { /* ignore */ }
+    try {
+        fs.writeFileSync(exitFile, '', 'utf8');
+    }
+    catch { /* ignore */ }
+    let promptText = '';
+    try {
+        promptText = fs.readFileSync(promptFilePath, 'utf8');
+    }
+    catch (err) {
+        try {
+            fs.appendFileSync(stdoutFile, `\n[Grok ACP: cannot read prompt file: ${err?.message ?? err}]\n`, 'utf8');
+        }
+        catch { /* ignore */ }
+        try {
+            fs.writeFileSync(exitFile, '1\n', 'utf8');
+        }
+        catch { /* ignore */ }
+        return;
+    }
+    const sess = getOrCreateAcpSession(root, providerId, model, log, resolvedSessionId);
+    _busyRoots.add(root);
+    if (showOutput) {
+        try {
+            showOutput();
+        }
+        catch { /* ignore */ }
+    }
+    const sink = (text) => { try {
+        fs.appendFileSync(stdoutFile, text, 'utf8');
+    }
+    catch { /* ignore */ } };
+    void (async () => {
+        try {
+            await sess.ensureReady();
+        }
+        catch (err) {
+            // ACP unavailable / handshake failed → clean fallback to the one-shot path
+            // (which writes its own stdout/exit + hooks). Nothing regresses.
+            log(`Grok ACP: startup failed (${err?.message ?? err}); stderr="${sess.stderrSnapshot.slice(0, 200)}" — falling back to headless one-shot`);
+            try {
+                sess.close();
+            }
+            catch { /* ignore */ }
+            _acpSessions.delete(root);
+            _busyRoots.delete(root);
+            sendGrokPersistentHeadless(root, promptFilePath, resolvedSessionId, stdoutFile, exitFile, log, providerId, model, showOutput);
+            return;
+        }
+        // Persist the session id so a restart can session/load it (resume-on-restart).
+        if (sess.sessionId) {
+            try {
+                (0, sessionState_1.saveSessionId)(root, providerId, sess.sessionId);
+            }
+            catch { /* ignore */ }
+        }
+        let res;
+        try {
+            res = await sess.runTurn(promptText, sink);
+        }
+        catch (err) {
+            res = { clean: false, stopReason: 'exception', error: err?.message ?? String(err) };
+        }
+        if (!res.clean && res.error) {
+            try {
+                fs.appendFileSync(stdoutFile, `\n[Grok ACP: turn ended ${res.stopReason} — ${res.error}]\n`, 'utf8');
+            }
+            catch { /* ignore */ }
+        }
+        try {
+            fs.writeFileSync(exitFile, `${res.clean ? 0 : 1}\n`, 'utf8');
+        }
+        catch { /* ignore */ }
+        _busyRoots.delete(root);
+    })();
+}
+/**
+ * Deliver a mid-run steer to the LIVE persistent grok process (a queued
+ * session/prompt). Returns true only when a live ACP session accepted it; false
+ * lets the caller fall back to the durable TODO buffer (at-least-once).
+ */
+function steerGrokAcp(root, text, log) {
+    const sess = _acpSessions.get(root);
+    if (!sess || !sess.isAlive()) {
+        return false;
+    }
+    const ok = sess.steer(text);
+    if (ok) {
+        log(`Grok ACP: steered live process (${text.length} chars) — queued to the running session`);
+    }
+    return ok;
+}
+/** True if a persistent ACP session for this root is mid-turn. */
+function isGrokAcpBusy(root) {
+    const sess = _acpSessions.get(root);
+    return !!sess && sess.isBusy();
+}
 /**
  * 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
@@ -2156,7 +2456,7 @@ function sendGrokCliPrompt(root, promptFilePath, resolvedSessionId, stdoutFile,
  *
  * - grok-tui + tmux    → useTmux: true  (persistent live pane; context accretes)
  * - grok-tui + no tmux → useTmux: false (HEADLESS path — persistence handled there
- *   via `grok --resume` behind the first_token hang-probe; see decideHeadlessGrokMode)
+ *   via `grok --continue` behind the first_token hang-probe; see decideHeadlessGrokMode)
  * - grok-cli           → useTmux: false always (never uses tmux)
  */
 function decideGrokRunMode(opts) {
@@ -2168,27 +2468,32 @@ function decideGrokRunMode(opts) {
  * unit-testable. The `maxConsecutiveFailures` guard REPLACES the old permanent
  * "resumeBroken" flag that doomed a whole run to statelessness after one hiccup.
  *
- * - no stored session id                                → 'new-persistent': there is
- *   no id to reuse, so bootstrap persistence with a fresh named session
- *   (`--session-id`, mints + persists a UUID; NOT `--resume`, so it can't hit a
- *   resume-hang), behind the probe as a safety net.
- * - a stored id, failures < max                         → 'resume': attempt persistent
- *   `grok --resume <id>` (the reliable, near-instant path on grok 1.0.13), gated by
- *   the first_token hang-probe. This is the STEADY STATE — every turn resumes.
- * - a stored id, failures >= max (sustained resume hang) → 'stateless' for exactly ONE
+ * - no folder session yet                                → 'new-session': there is no
+ *   session on disk for this cwd to continue, so bootstrap persistence with a fresh
+ *   named session (`--session-id`, mints + persists a UUID; NOT `--continue`, which
+ *   would have nothing to continue), behind the probe as a safety net.
+ * - a folder session exists, failures < max              → 'continue': resume the cwd's
+ *   most-recent session with `grok --continue` — robust to the stale-id / cwd-tracking
+ *   drift that made an explicit `--resume <id>` error in ~1s on Windows. Gated by the
+ *   first_token hang-probe. This is the STEADY STATE — every turn continues.
+ * - a folder session, failures >= max (sustained hang)   → 'stateless' for exactly ONE
  *   breather turn (skip the probe cost once); the caller resets the counter so the
- *   NEXT turn returns to 'resume'. The stored id is preserved throughout, so resume
- *   is NEVER permanently abandoned — persistence self-heals.
+ *   NEXT turn returns to 'continue'. The folder session is untouched, so continuity is
+ *   NEVER permanently abandoned — persistence self-heals.
+ *
+ * NOTE: the decision keys off FOLDER-SESSION PRESENCE (newestGrokSessionDir exists),
+ * NOT a stored id — because `--continue` needs no id, and keying off a stored id is
+ * exactly what let a stale/mismatched id drive a doomed `--resume`.
  */
 function decideHeadlessGrokMode(args) {
-    if (!args.hasSessionId) {
-        return 'new-persistent';
+    if (!args.hasFolderSession) {
+        return 'new-session';
     }
     const max = args.maxConsecutiveFailures ?? RESUME_MAX_CONSEC_FAILURES;
     if (args.consecutiveResumeFailures >= max) {
         return 'stateless';
     }
-    return 'resume';
+    return 'continue';
 }
 /**
  * Pure verdict for the headless resume hang-probe (multi-round exponential, 1.4.185).
@@ -2237,6 +2542,12 @@ function resumeProbeVerdict(args) {
     return 'wait';
 }
 function sendGrokTuiPrompt(root, promptFilePath, resolvedSessionId, stdoutFile, exitFile, log, model, showOutput) {
+    // Preferred persistent model: ONE long-lived `grok agent stdio` (ACP). Cleaner
+    // than the tmux PTY (no pane-scraping, real steering, unified with grok-cli).
+    if (grokAcpEnabled()) {
+        sendGrokAcpPrompt(root, promptFilePath, resolvedSessionId, stdoutFile, exitFile, log, 'grok-tui', model, showOutput);
+        return;
+    }
     const mode = decideGrokRunMode({ tmuxAvailable: tmuxAvailable(), providerId: 'grok-tui' });
     if (mode.useTmux) {
         runGrokTmuxTurn(root, promptFilePath, resolvedSessionId, stdoutFile, exitFile, log, model, showOutput);
@@ -2247,14 +2558,16 @@ function sendGrokTuiPrompt(root, promptFilePath, resolvedSessionId, stdoutFile,
 }
 /**
  * The persistent HEADLESS grok launch, shared by grok-cli and headless grok-tui.
- * We want PERSISTENCE across turns, so attempt grok's persistent session
- * (`--resume` when a session id exists). grok 1.0.41's headless `--resume` can hang
- * the resumed turn (loaded-but-never-answers) → the 10-min watchdog, so every
- * persistent launch is gated behind a FAST first_token hang-probe: if grok begins
- * answering within AUTODEV_GROK_RESUME_PROBE_MS the turn runs normally (persistent,
- * context intact); if not, sendGrokPrompt kills it and calls onResumeHang to relaunch
- * THIS turn stateless. A resume failure is COUNTED (bounded, NOT a permanent poison):
- * the STORED session id is preserved and the NEXT turn re-attempts `--resume`, so a
+ * We want PERSISTENCE across turns, so when the cwd already has a grok session on disk
+ * we resume the MOST RECENT one with `grok --continue` (robust to the stale-id /
+ * cwd-tracking drift that made an explicit `--resume <id>` error in ~1s on Windows and
+ * forced every turn stateless). grok's headless resume can also hang a resumed turn
+ * (loaded-but-never-answers) → the watchdog, so every persistent launch is gated behind
+ * a FAST first_token hang-probe: if grok begins answering within
+ * AUTODEV_GROK_RESUME_PROBE_MS the turn runs normally (persistent, context intact); if
+ * not, sendGrokPrompt kills it and calls onResumeHang to relaunch THIS turn stateless. A
+ * failure is COUNTED (bounded, NOT a permanent poison): the folder session is preserved
+ * and the NEXT turn re-attempts `--continue`, so a
  * transient hiccup can't strand the run in per-turn statelessness (the pre-1.4.184 bug).
  * Only after RESUME_MAX_CONSEC_FAILURES straight failures does a single breather turn
  * skip resume, after which resume is tried again. The stateless path stays intact as the
@@ -2264,6 +2577,11 @@ function sendGrokTuiPrompt(root, promptFilePath, resolvedSessionId, stdoutFile,
 function sendGrokPersistentHeadless(root, promptFilePath, resolvedSessionId, stdoutFile, exitFile, log, providerId, model, showOutput) {
     const label = providerId === 'grok-cli' ? 'Grok CLI' : 'Grok TUI';
     const PROBE_MS = envNum('AUTODEV_GROK_RESUME_PROBE_MS', 90_000);
+    // Continuity is decided by whether grok has a session on disk for THIS cwd — the same
+    // signal `grok --continue` itself uses — NOT a stored id (a stale/mismatched id was the
+    // root cause of the instant `--resume <id>` error). resolvedSessionId/getSessionId are
+    // kept only for logging + best-effort id display.
+    const hasFolderSession = !!(0, sessions_1.newestGrokSessionDir)(path.resolve(root));
     const persistedSid = resolvedSessionId || (0, sessionState_1.getSessionId)(root, providerId);
     // Stateless relaunch: grok mints a throwaway id for THIS turn. persist:false means
     // it never overwrites the STORED session id in session-state.json → the next turn
@@ -2285,27 +2603,28 @@ function sendGrokPersistentHeadless(root, promptFilePath, resolvedSessionId, std
     // Clear the failure counter the instant a resumed turn starts answering.
     const onResumeOk = () => { _noteResumeSuccess(root); };
     const decision = decideHeadlessGrokMode({
-        hasSessionId: !!persistedSid, consecutiveResumeFailures: _resumeFailCount(root),
+        hasFolderSession, consecutiveResumeFailures: _resumeFailCount(root),
     });
     if (decision === 'stateless') {
-        // Sustained resume failures → ONE breather turn (skip the probe cost), then the
-        // counter resets so the NEXT turn resumes again. Persistence is never abandoned.
-        log(`${label}: --resume failed ${_resumeFailCount(root)}× in a row — one stateless breather turn, will retry --resume next turn`);
-        _noteResumeSuccess(root); // reset so the next turn returns to 'resume'
+        // Sustained continue failures → ONE breather turn (skip the probe cost), then the
+        // counter resets so the NEXT turn continues again. Persistence is never abandoned.
+        log(`${label}: --continue failed ${_resumeFailCount(root)}× in a row — one stateless breather turn, will retry --continue next turn`);
+        _noteResumeSuccess(root); // reset so the next turn returns to 'continue'
         runStateless();
         return;
     }
-    if (decision === 'resume') {
-        log(`${label}: resuming session ${persistedSid.slice(0, 8)}… (headless)`);
+    if (decision === 'continue') {
+        const idNote = persistedSid ? ` (${persistedSid.slice(0, 8)}…)` : '';
+        log(`${label}: continuing most-recent session for cwd${idNote} (headless --continue)`);
         sendGrokPrompt(root, promptFilePath, stdoutFile, exitFile, log, {
-            model, showOutput, persist: true, sessionId: persistedSid, providerId,
+            model, showOutput, persist: true, continueSession: true, providerId,
             resumeProbeMs: PROBE_MS, onResumeHang, onResumeOk,
         });
         return;
     }
-    // new-persistent — no stored id yet: bootstrap a fresh named session so later turns
-    // have an id to resume. A fresh `--session-id` isn't a `--resume`, but keep the
-    // probe as a belt-and-braces safety net (and it can never exceed the watchdog).
+    // new-session — no folder session yet: bootstrap a fresh named session so later turns
+    // have one to `--continue`. A fresh `--session-id` isn't a resume, but keep the probe
+    // as a belt-and-braces safety net (and it can never exceed the watchdog).
     log(`${label}: starting a new persistent session (headless)`);
     sendGrokPrompt(root, promptFilePath, stdoutFile, exitFile, log, {
         model, showOutput, persist: true, providerId,
@@ -2363,6 +2682,22 @@ async function steerGrokTui(root, text, log) {
  * persisted session id so a later task relaunches with --resume (context intact).
  */
 function closeGrokTuiSession(root, _log) {
+    const acp = _acpSessions.get(root);
+    if (acp) {
+        // Reap grok's whole worker subtree (grok forks a per-turn worker child), then
+        // close — SIGKILL of just the parent would orphan the worker to init.
+        if (acp.pid) {
+            try {
+                (0, killProcessTree_1.killProcessTree)(acp.pid);
+            }
+            catch { /* ignore */ }
+        }
+        try {
+            acp.close();
+        }
+        catch { /* ignore */ }
+        _acpSessions.delete(root);
+    }
     const child = _activeChildren.get(root);
     if (child) {
         if (child.pid) {
@@ -2394,6 +2729,19 @@ function closeGrokTuiSession(root, _log) {
 }
 /** Kill all live grok sessions — called on SDK/extension shutdown. */
 function closeAllGrokTuiSessions() {
+    for (const acp of _acpSessions.values()) {
+        if (acp.pid) {
+            try {
+                (0, killProcessTree_1.killProcessTree)(acp.pid);
+            }
+            catch { /* ignore */ }
+        }
+        try {
+            acp.close();
+        }
+        catch { /* ignore */ }
+    }
+    _acpSessions.clear();
     for (const child of _activeChildren.values()) {
         if (child.pid) {
             (0, killProcessTree_1.killProcessTree)(child.pid);