autodev-cli 1.4.191 → 1.4.193

package/out/providers/grok/tui.js

@@ -82,6 +82,9 @@ exports.sendGrokCliPrompt = sendGrokCliPrompt;
 exports.sendGrokAcpPrompt = sendGrokAcpPrompt;
 exports.steerGrokAcp = steerGrokAcp;
 exports.isGrokAcpBusy = isGrokAcpBusy;
+exports.hasGrokAcpSession = hasGrokAcpSession;
+exports.steerGrokAcpTracked = steerGrokAcpTracked;
+exports.ensureGrokAcpSteer = ensureGrokAcpSteer;
 exports.decideGrokRunMode = decideGrokRunMode;
 exports.decideHeadlessGrokMode = decideHeadlessGrokMode;
 exports.resumeProbeVerdict = resumeProbeVerdict;
@@ -108,6 +111,8 @@ const grokEvents_1 = require("../../core/grokEvents");
 const sessions_1 = require("./sessions");
 const redactSecrets_1 = require("../../core/redactSecrets");
 const GrokAcpSession_1 = require("./GrokAcpSession");
+const AcpSession_1 = require("../acp/AcpSession");
+const leader_1 = require("./leader");
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
@@ -2375,20 +2380,10 @@ function sendGrokCliPrompt(root, promptFilePath, resolvedSessionId, stdoutFile,
 // ---------------------------------------------------------------------------
 // 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`).
-    // Layer A.2: PREFER the persisted id (session-state.json) over the disk-latest
-    // fallback — disk-latest can resume the WRONG session (a stray/newer dir). Use
-    // disk-latest ONLY when there is no persisted id.
-    const seedId = (0, sessionState_1.getSessionId)(root, providerId) || resolvedSessionId || (0, sessions_1.getGrokLatestSessionId)(root) || undefined;
-    const hooks = {
+/** Redaction-aware AcpHostHooks that append to this root's hook feed. Shared by
+ *  the non-leader and leader ACP paths so hook emission stays in one place. */
+function makeAcpHooks(root, log) {
+    return {
         emitHook: (name, extra) => {
             if (name === 'Notification' && typeof extra['message'] === 'string') {
                 const msg = (0, redactSecrets_1.redactSecrets)(String(extra['message'])).slice(0, 1200);
@@ -2403,10 +2398,88 @@ function getOrCreateAcpSession(root, providerId, model, log, resolvedSessionId)
         },
         log,
     };
-    sess = new GrokAcpSession_1.GrokAcpSession({ root, model, bin: GROK_BIN, hooks, initialSessionId: seedId });
+}
+/** Get (or lazily create) the NON-LEADER 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`).
+    // Layer A.2: PREFER the persisted id (session-state.json) over the disk-latest
+    // fallback — disk-latest can resume the WRONG session (a stray/newer dir). Use
+    // disk-latest ONLY when there is no persisted id.
+    const seedId = (0, sessionState_1.getSessionId)(root, providerId) || resolvedSessionId || (0, sessions_1.getGrokLatestSessionId)(root) || undefined;
+    sess = new GrokAcpSession_1.GrokAcpSession({ root, model, bin: GROK_BIN, hooks: makeAcpHooks(root, log), initialSessionId: seedId });
     _acpSessions.set(root, sess);
     return sess;
 }
+/**
+ * LEADER-AWARE ensure (Layer B, 1.4.193). When AUTODEV_GROK_LEADER is ON, ensure a
+ * per-agent leader + keepalive backend (orphan-sweeping/adopting/spawning as
+ * needed) and return a LEADER-CLIENT ACP session that ATTACHES to the warm session
+ * WITHOUT session/load. When the flag is OFF — or the leader backend can't be
+ * established — this returns the existing non-leader session UNCHANGED. Async
+ * because ensuring the leader spawns detached processes on a cold start.
+ */
+async function ensureAcpSession(root, providerId, model, log, resolvedSessionId) {
+    if ((0, leader_1.leaderModeEnabled)()) {
+        const cached = _acpSessions.get(root);
+        if (cached && cached.isAlive()) {
+            return cached;
+        }
+        if (cached) {
+            try {
+                cached.close();
+            }
+            catch { /* ignore */ }
+            _acpSessions.delete(root);
+        }
+        const info = await (0, leader_1.ensureLeader)({ root, bin: GROK_BIN, providerId, model, log });
+        if (info) {
+            const sess = new GrokAcpSession_1.GrokAcpSession({
+                root, model, bin: GROK_BIN, hooks: makeAcpHooks(root, log),
+                initialSessionId: info.sessionId, leaderSocket: info.socket, attachWithoutLoad: true,
+            });
+            _acpSessions.set(root, sess);
+            return sess;
+        }
+        log('grok leader: backend unavailable — falling back to the non-leader ACP path');
+    }
+    return getOrCreateAcpSession(root, providerId, model, log, resolvedSessionId);
+}
+/**
+ * Leader POISON-ESCAPE: the attached session id was rejected by the leader
+ * ("unknown session id" — the keepalive died / a wrong id). Reap the leader
+ * backend, clear the persisted id, drop the thin client — the caller then
+ * re-ensures a FRESH leader with session/new.
+ */
+function recoverLeaderPoison(root, providerId, log) {
+    try {
+        (0, leader_1.stopLeader)(root, log);
+    }
+    catch { /* ignore */ }
+    try {
+        (0, sessionState_1.clearSessionId)(root, providerId);
+    }
+    catch { /* ignore */ }
+    const s = _acpSessions.get(root);
+    if (s) {
+        if (s.pid) {
+            try {
+                (0, killProcessTree_1.killProcessTree)(s.pid);
+            }
+            catch { /* ignore */ }
+        }
+        try {
+            s.close();
+        }
+        catch { /* ignore */ }
+        _acpSessions.delete(root);
+    }
+}
 /**
  * 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
@@ -2440,7 +2513,6 @@ function sendGrokAcpPrompt(root, promptFilePath, resolvedSessionId, stdoutFile,
         catch { /* ignore */ }
         return;
     }
-    const sess = getOrCreateAcpSession(root, providerId, model, log, resolvedSessionId);
     _busyRoots.add(root);
     if (showOutput) {
         try {
@@ -2453,23 +2525,29 @@ function sendGrokAcpPrompt(root, promptFilePath, resolvedSessionId, stdoutFile,
     }
     catch { /* ignore */ } };
     void (async () => {
+        let sess;
         try {
+            sess = await ensureAcpSession(root, providerId, model, log, resolvedSessionId);
             await sess.ensureReady();
         }
         catch (err) {
-            const startupErr = `${err?.message ?? err} ${sess.stderrSnapshot}`;
-            log(`Grok ACP: startup failed (${err?.message ?? err}); stderr="${sess.stderrSnapshot.slice(0, 200)}" — falling back to headless one-shot`);
-            try {
-                sess.close();
+            const cur = _acpSessions.get(root);
+            const stderr = cur?.stderrSnapshot ?? '';
+            const startupErr = `${err?.message ?? err} ${stderr}`;
+            log(`Grok ACP: startup failed (${err?.message ?? err}); stderr="${stderr.slice(0, 200)}" — falling back to headless one-shot`);
+            if (cur) {
+                try {
+                    cur.close();
+                }
+                catch { /* ignore */ }
             }
-            catch { /* ignore */ }
             _acpSessions.delete(root);
             _busyRoots.delete(root);
             // AUTH failure at ACP startup (grok not signed in): the headless fallback
             // would just re-hit the same logged-out gate, so short-circuit to
             // reauth_required (non-retryable) instead of falling through.
             if ((0, authClassify_1.isGrokAuthFailure)(startupErr)) {
-                _emitGrokReauthHook(root, stdoutFile, log, 'ACP startup (not signed in)', providerId, sess.stderrSnapshot.slice(0, 160));
+                _emitGrokReauthHook(root, stdoutFile, log, 'ACP startup (not signed in)', providerId, stderr.slice(0, 160));
                 try {
                     fs.writeFileSync(exitFile, '1\n', 'utf8');
                 }
@@ -2488,12 +2566,34 @@ function sendGrokAcpPrompt(root, promptFilePath, resolvedSessionId, stdoutFile,
             }
             catch { /* ignore */ }
         }
-        let res;
-        try {
-            res = await sess.runTurn(promptText, sink);
-        }
-        catch (err) {
-            res = { clean: false, stopReason: 'exception', error: err?.message ?? String(err) };
+        const runTurnSafe = async (s) => {
+            try {
+                return await s.runTurn(promptText, sink);
+            }
+            catch (err) {
+                return { clean: false, stopReason: 'exception', error: err?.message ?? String(err) };
+            }
+        };
+        let res = await runTurnSafe(sess);
+        // Leader POISON-ESCAPE: the warm session was rejected (keepalive died / stale
+        // id). Reap the leader + session/new on a FRESH leader, then retry ONCE.
+        if ((0, leader_1.leaderModeEnabled)() && sess.attachMode && !res.clean && AcpSession_1.AcpSession.isUnknownSessionError(res.error)) {
+            log('Grok leader: attach rejected (poison) — reaping leader, starting a fresh session, retrying once');
+            recoverLeaderPoison(root, providerId, log);
+            try {
+                sess = await ensureAcpSession(root, providerId, model, log, undefined);
+                await sess.ensureReady();
+                if (sess.sessionId) {
+                    try {
+                        (0, sessionState_1.saveSessionId)(root, providerId, sess.sessionId);
+                    }
+                    catch { /* ignore */ }
+                }
+                res = await runTurnSafe(sess);
+            }
+            catch (err) {
+                res = { clean: false, stopReason: 'poison-recover-failed', error: err?.message ?? String(err) };
+            }
         }
         if (!res.clean && res.error) {
             try {
@@ -2535,6 +2635,61 @@ function isGrokAcpBusy(root) {
     const sess = _acpSessions.get(root);
     return !!sess && sess.isBusy();
 }
+/** True when a LIVE (alive) persistent grok ACP session is held for this root. */
+function hasGrokAcpSession(root) {
+    const sess = _acpSessions.get(root);
+    return !!sess && sess.isAlive();
+}
+/**
+ * Durable-steer delivery to an EXISTING live grok ACP session. Returns a promise
+ * that resolves when the steered turn COMPLETES (so the caller can ack + de-queue
+ * only then), or null when no live session exists (the caller keeps it queued and
+ * retries via {@link ensureGrokAcpSteer} at the next boundary).
+ */
+function steerGrokAcpTracked(root, text, log) {
+    const sess = _acpSessions.get(root);
+    if (!sess || !sess.isAlive()) {
+        return null;
+    }
+    const p = sess.steerTracked(text);
+    if (p) {
+        log(`Grok ACP: durable steer delivered to live session (${text.length} chars) — awaiting completion`);
+    }
+    return p;
+}
+/**
+ * Restart-drain delivery: ENSURE a live grok ACP session (spawn + session/load if
+ * none is held — e.g. right after a loop restart with an empty TODO), then deliver
+ * the steer and await its completion. Returns the turn result, or null when the
+ * session could not be brought up (caller keeps the steer queued for a later
+ * boundary). Grok stays ALIVE between turns, so the common case just reuses the
+ * live session.
+ */
+async function ensureGrokAcpSteer(root, providerId, model, text, log) {
+    if (!grokAcpEnabled()) {
+        return null;
+    }
+    const sess = await ensureAcpSession(root, providerId, model, log, undefined);
+    try {
+        await sess.ensureReady();
+    }
+    catch (err) {
+        log(`Grok ACP: durable-steer ensureReady failed (${err?.message ?? err})`);
+        return null;
+    }
+    if (sess.sessionId) {
+        try {
+            (0, sessionState_1.saveSessionId)(root, providerId, sess.sessionId);
+        }
+        catch { /* ignore */ }
+    }
+    const p = sess.steerTracked(text);
+    if (!p) {
+        return null;
+    }
+    log(`Grok ACP: durable steer (re)delivered on restart-drain (${text.length} chars) — awaiting completion`);
+    return p;
+}
 /**
  * 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
@@ -2777,6 +2932,10 @@ function closeGrokTuiSession(root, _log) {
     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.
+        // LEADER-AWARE (Layer B): acp.pid here is the THIN CLIENT. The leader + keepalive
+        // are DETACHED (their own process groups, not in the client's tree), so this
+        // reaps ONLY the client — the leader survives the loop restart, exactly as
+        // intended. The app reaps the leader itself via `autodev leader-stop <root>`.
         if (acp.pid) {
             try {
                 (0, killProcessTree_1.killProcessTree)(acp.pid);