autodev-cli 1.4.186 → 1.4.188

package/out/providers/grok/tui.d.ts

@@ -1,5 +1,12 @@
 import { RateLimitDetector } from '../../rateLimit';
 import type { ProviderId } from '../../providers';
+export declare function grokAgentStdioSupported(): boolean;
+/**
+ * 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).
+ */
+export declare function grokAcpEnabled(): boolean;
 /** True while a grok turn is running for the given workspace root. */
 export declare function isGrokTuiBusy(root: string): boolean;
 /** Epoch-ms of the most recent streamed pane activity, or 0 if none. */
@@ -14,6 +21,17 @@ interface GrokRunOptions {
     /** grok-tui: resume/continue a session so context accumulates across tasks. */
     persist?: boolean;
     sessionId?: string;
+    /**
+     * Resume the MOST RECENT grok session for this cwd via `grok --continue` (grok's
+     * "-c, --continue" = continue the most recent session for the current working
+     * directory). This is ROBUST to id/tracking drift: an explicit `--resume <id>`
+     * errors instantly on the user's Windows grok when the stored id can't be matched
+     * for the cwd (a stale id, or a cwd-encoding mismatch), so every turn fell back to
+     * stateless. `--continue` lets grok pick the folder's newest session itself.
+     * MUST NOT be combined with `--session-id` (grok rejects that unless --fork-session,
+     * which we do NOT want) or with `sessionId`.
+     */
+    continueSession?: boolean;
     providerId?: ProviderId;
     /**
      * Headless grok-tui resume hang-probe. When > 0 (with `onResumeHang`), watch
@@ -32,6 +50,22 @@ interface GrokRunOptions {
      */
     onResumeOk?: () => void;
 }
+/**
+ * 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.
+ */
+export declare function grokSessionArgsFor(args: {
+    continueSession?: boolean;
+    sessionId?: string;
+    newSessionId?: string;
+}): string[];
 export declare function sendGrokPrompt(root: string, promptFilePath: string, stdoutFile: string, exitFile: string, log: (msg: string) => void, opts?: GrokRunOptions): void;
 /**
  * grok-cli: PERSISTENT — a fresh HEADLESS grok process every turn, but launched
@@ -42,6 +76,24 @@ export declare function sendGrokPrompt(root: string, promptFilePath: string, std
  * to a stateless relaunch instead of hanging the loop.
  */
 export declare function sendGrokCliPrompt(root: string, promptFilePath: string, resolvedSessionId: string | undefined, stdoutFile: string, exitFile: string, log: (msg: string) => void, model?: string, showOutput?: () => void): void;
+/**
+ * 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.
+ */
+export declare function sendGrokAcpPrompt(root: string, promptFilePath: string, resolvedSessionId: string | undefined, stdoutFile: string, exitFile: string, log: (msg: string) => void, providerId: 'grok-cli' | 'grok-tui', model?: string, showOutput?: () => void): void;
+/**
+ * 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).
+ */
+export declare function steerGrokAcp(root: string, text: string, log: (msg: string) => void): boolean;
+/** True if a persistent ACP session for this root is mid-turn. */
+export declare function isGrokAcpBusy(root: string): boolean;
 /**
  * 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
@@ -54,7 +106,7 @@ export declare function sendGrokCliPrompt(root: string, promptFilePath: string,
  *
  * - 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)
  */
 export declare function decideGrokRunMode(opts: {
@@ -69,23 +121,28 @@ export declare 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`.
  */
 export declare function decideHeadlessGrokMode(args: {
-    hasSessionId: boolean;
+    hasFolderSession: boolean;
     consecutiveResumeFailures: number;
     maxConsecutiveFailures?: number;
-}): 'resume' | 'new-persistent' | 'stateless';
+}): 'continue' | 'new-session' | 'stateless';
 /**
  * Pure verdict for the headless resume hang-probe (multi-round exponential, 1.4.185).
  *   'ok'       — grok emitted first_token → the resumed prompt is being answered;