@indigoai-us/hq-cli 5.125.0 → 5.127.0

package/dist/lib/bot/runtime/grok.d.ts

@@ -1,16 +1,39 @@
 /**
  * Grok CLI headless adapter.
  *
- *   grok -p <prompt> --output-format streaming-messages-json --always-approve
+ *   grok -p <prompt> --output-format <streaming format> --always-approve
  *        --no-subagents --cwd <cwd> [-m m] [-r <sessionId>]
  *
- * stdout is NDJSON in the Anthropic Messages shape (see messages-stream.ts).
- * The plain `json` format glued every interim sentence into one reply; the
- * streaming format lets each message be posted as it is written.
- * Verified against grok (grok-4.6) on 2026-09-12 (fixtures/grok-stream.ndjson);
- * the older `{ text, sessionId }` envelope is still accepted.
+ * stdout is NDJSON. Older grok (before 0.2.56) wrote Anthropic Messages
+ * shapes under `--output-format streaming-messages-json` (see
+ * messages-stream.ts). grok 0.2.56 dropped that value and emits token
+ * events under `streaming-json`:
+ *
+ *   {"type":"thought","data":…}
+ *   {"type":"text","data":"Hi"}
+ *   {"type":"end","stopReason":"EndTurn","sessionId":…}
+ *
+ * The format is probed from `grok --help` once per process (and cached).
+ * If an older grok still lists `streaming-messages-json`, that is used.
+ * If the probe misses and grok rejects the old value, the turn retries
+ * with `streaming-json`. The older `{ text, sessionId }` envelope is
+ * still accepted.
  */
 import { type BotRuntime, type RuntimeTurnInput } from "./types.js";
+export declare const GROK_OUTPUT_FORMAT_LEGACY = "streaming-messages-json";
+export declare const GROK_OUTPUT_FORMAT_STREAMING_JSON = "streaming-json";
+export declare function resetGrokOutputFormatCache(): void;
+/** Pick the streaming `--output-format` grok's `--help` says it accepts. */
+export declare function grokOutputFormatFromHelp(helpText: string): string;
+/** Probe `grok --help` once and cache the streaming format. */
+export declare function probeGrokOutputFormat(readHelp?: () => string): string;
+/**
+ * When grok 0.2.56 rejects the pre-0.2.56 flag, rewrite argv to
+ * `streaming-json` and remember that for later turns.
+ */
+export declare function grokRetryArgsAfterInvalidOutputFormat(args: string[], stderr: string): string[] | undefined;
 export declare function grokPrompt(input: RuntimeTurnInput): string;
-export declare function createGrokRuntime(): BotRuntime;
+export declare function createGrokRuntime(opts?: {
+    grokHelp?: string;
+}): BotRuntime;
 //# sourceMappingURL=grok.d.ts.map

package/dist/lib/bot/runtime/grok.js

@@ -1,23 +1,101 @@
 /**
  * Grok CLI headless adapter.
  *
- *   grok -p <prompt> --output-format streaming-messages-json --always-approve
+ *   grok -p <prompt> --output-format <streaming format> --always-approve
  *        --no-subagents --cwd <cwd> [-m m] [-r <sessionId>]
  *
- * stdout is NDJSON in the Anthropic Messages shape (see messages-stream.ts).
- * The plain `json` format glued every interim sentence into one reply; the
- * streaming format lets each message be posted as it is written.
- * Verified against grok (grok-4.6) on 2026-09-12 (fixtures/grok-stream.ndjson);
- * the older `{ text, sessionId }` envelope is still accepted.
+ * stdout is NDJSON. Older grok (before 0.2.56) wrote Anthropic Messages
+ * shapes under `--output-format streaming-messages-json` (see
+ * messages-stream.ts). grok 0.2.56 dropped that value and emits token
+ * events under `streaming-json`:
+ *
+ *   {"type":"thought","data":…}
+ *   {"type":"text","data":"Hi"}
+ *   {"type":"end","stopReason":"EndTurn","sessionId":…}
+ *
+ * The format is probed from `grok --help` once per process (and cached).
+ * If an older grok still lists `streaming-messages-json`, that is used.
+ * If the probe misses and grok rejects the old value, the turn retries
+ * with `streaming-json`. The older `{ text, sessionId }` envelope is
+ * still accepted.
  */
+import { execFileSync } from "node:child_process";
 import { messagesStreamEvents, messagesStreamFailure, messagesStreamResult } from "./messages-stream.js";
 import { parseJsonLine, RuntimeError } from "./types.js";
+export const GROK_OUTPUT_FORMAT_LEGACY = "streaming-messages-json";
+export const GROK_OUTPUT_FORMAT_STREAMING_JSON = "streaming-json";
+let cachedOutputFormat;
+export function resetGrokOutputFormatCache() {
+    cachedOutputFormat = undefined;
+}
+/** Pick the streaming `--output-format` grok's `--help` says it accepts. */
+export function grokOutputFormatFromHelp(helpText) {
+    const section = /--output-format\s*<OUTPUT_FORMAT>[\s\S]*?\[possible values:\s*([^\]]+)\]/i.exec(helpText);
+    const values = (section?.[1] ?? "")
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean);
+    if (values.includes(GROK_OUTPUT_FORMAT_LEGACY))
+        return GROK_OUTPUT_FORMAT_LEGACY;
+    if (values.includes(GROK_OUTPUT_FORMAT_STREAMING_JSON))
+        return GROK_OUTPUT_FORMAT_STREAMING_JSON;
+    if (helpText.includes(GROK_OUTPUT_FORMAT_LEGACY))
+        return GROK_OUTPUT_FORMAT_LEGACY;
+    if (/\bstreaming-json\b/.test(helpText))
+        return GROK_OUTPUT_FORMAT_STREAMING_JSON;
+    return GROK_OUTPUT_FORMAT_LEGACY;
+}
+function defaultGrokHelp() {
+    try {
+        return execFileSync("grok", ["--help"], {
+            encoding: "utf8",
+            timeout: 5_000,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+    }
+    catch (err) {
+        const e = err;
+        return `${e.stdout ?? ""}\n${e.stderr ?? ""}`;
+    }
+}
+/** Probe `grok --help` once and cache the streaming format. */
+export function probeGrokOutputFormat(readHelp = defaultGrokHelp) {
+    if (cachedOutputFormat)
+        return cachedOutputFormat;
+    let help;
+    try {
+        help = readHelp();
+    }
+    catch {
+        help = "";
+    }
+    cachedOutputFormat = grokOutputFormatFromHelp(help);
+    return cachedOutputFormat;
+}
+/**
+ * When grok 0.2.56 rejects the pre-0.2.56 flag, rewrite argv to
+ * `streaming-json` and remember that for later turns.
+ */
+export function grokRetryArgsAfterInvalidOutputFormat(args, stderr) {
+    if (!/invalid value ['"]streaming-messages-json['"]/.test(stderr))
+        return undefined;
+    const i = args.indexOf("--output-format");
+    if (i < 0 || args[i + 1] === GROK_OUTPUT_FORMAT_STREAMING_JSON)
+        return undefined;
+    const next = args.slice();
+    next[i + 1] = GROK_OUTPUT_FORMAT_STREAMING_JSON;
+    cachedOutputFormat = GROK_OUTPUT_FORMAT_STREAMING_JSON;
+    return next;
+}
 export function grokPrompt(input) {
     if (input.sessionId)
         return input.prompt;
     return `${input.systemPrompt}\n\n---\n\nMessage from your owner:\n\n${input.prompt}`;
 }
-export function createGrokRuntime() {
+export function createGrokRuntime(opts = {}) {
+    const format = opts.grokHelp !== undefined
+        ? grokOutputFormatFromHelp(opts.grokHelp)
+        : (cachedOutputFormat ?? GROK_OUTPUT_FORMAT_LEGACY);
     return {
         id: "grok",
         binary: "grok",
@@ -26,7 +104,7 @@ export function createGrokRuntime() {
                 "-p",
                 grokPrompt(input),
                 "--output-format",
-                "streaming-messages-json",
+                format,
                 "--always-approve",
                 "--no-subagents",
                 "--cwd",

package/dist/lib/bot/runtime/index.js

@@ -5,7 +5,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { createClaudeRuntime } from "./claude.js";
 import { createCodexRuntime } from "./codex.js";
-import { createGrokRuntime } from "./grok.js";
+import { createGrokRuntime, grokRetryArgsAfterInvalidOutputFormat, probeGrokOutputFormat } from "./grok.js";
 import { parseJsonLine, RuntimeError, turnTimeoutMs, stderrExcerpt, } from "./types.js";
 export * from "./types.js";
 export { createClaudeRuntime, claudePermissionMode } from "./claude.js";
@@ -16,6 +16,7 @@ export function runtimeFor(id, env = process.env) {
         return createClaudeRuntime(env);
     if (id === "codex")
         return createCodexRuntime();
+    probeGrokOutputFormat();
     return createGrokRuntime();
 }
 /**
@@ -220,15 +221,21 @@ export async function runRuntimeTurn(runtime, input, deps = {}) {
         }
         : undefined;
     const timeoutMs = deps.timeoutMs ?? turnTimeoutMs(env);
+    const spawnOptions = {
+        cwd: input.cwd,
+        env,
+        ...(timeoutMs !== undefined ? { timeoutMs } : {}),
+        ...(onStdoutLine ? { onStdoutLine } : {}),
+        ...(input.signal ? { signal: input.signal } : {}),
+    };
     let result;
     try {
-        result = await spawnImpl(binary, args, {
-            cwd: input.cwd,
-            env,
-            ...(timeoutMs !== undefined ? { timeoutMs } : {}),
-            ...(onStdoutLine ? { onStdoutLine } : {}),
-            ...(input.signal ? { signal: input.signal } : {}),
-        });
+        result = await spawnImpl(binary, args, spawnOptions);
+        if (runtime.id === "grok" && result.code !== 0 && !input.signal?.aborted) {
+            const retryArgs = grokRetryArgsAfterInvalidOutputFormat(args, result.stderr);
+            if (retryArgs)
+                result = await spawnImpl(binary, retryArgs, spawnOptions);
+        }
     }
     catch (err) {
         const code = err.code;

package/dist/lib/bot/runtime/messages-stream.d.ts

@@ -1,6 +1,6 @@
 /**
  * The NDJSON stream Claude Code (`--output-format stream-json --verbose`) and
- * Grok (`--output-format streaming-messages-json`) both write: Anthropic
+ * older Grok (`--output-format streaming-messages-json`) both write: Anthropic
  * Messages wire shapes, one event per line.
  *
  *   {"type":"system","subtype":"init","session_id":…}
@@ -9,9 +9,18 @@
  *   {"type":"user","message":{"content":[{"type":"tool_result",…}]}}
  *   {"type":"result","subtype":"success","is_error":false,"result":"<last message>","session_id":…}
  *
- * Recorded from Claude Code 2.1.258 and grok (model grok-4.6) on 2026-09-12;
+ * grok 0.2.56 dropped `streaming-messages-json` for `streaming-json`, which
+ * is token deltas rather than whole messages:
+ *
+ *   {"type":"thought","data":…}
+ *   {"type":"text","data":"Hi"}
+ *   {"type":"end","stopReason":"EndTurn","sessionId":…}
+ *
+ * Text `data` chunks are concatenated for the final reply and never emitted
+ * as progress (they are token deltas). Recorded from Claude Code 2.1.258 and
+ * grok (model grok-4.6) on 2026-09-12, plus grok 0.2.56 on 2026-09-21;
  * fixtures in runtime/fixtures/. Claude sends one content block per assistant
- * event; Grok sends a whole message (thinking + text + tool_use) per event.
+ * event; older Grok sends a whole message (thinking + text + tool_use) per event.
  */
 import { type RuntimeStreamEvent, type RuntimeTurnResult } from "./types.js";
 /** Progress events in one stream line: top-level assistant text and tool starts only. */

package/dist/lib/bot/runtime/messages-stream.js

@@ -1,6 +1,6 @@
 /**
  * The NDJSON stream Claude Code (`--output-format stream-json --verbose`) and
- * Grok (`--output-format streaming-messages-json`) both write: Anthropic
+ * older Grok (`--output-format streaming-messages-json`) both write: Anthropic
  * Messages wire shapes, one event per line.
  *
  *   {"type":"system","subtype":"init","session_id":…}
@@ -9,9 +9,18 @@
  *   {"type":"user","message":{"content":[{"type":"tool_result",…}]}}
  *   {"type":"result","subtype":"success","is_error":false,"result":"<last message>","session_id":…}
  *
- * Recorded from Claude Code 2.1.258 and grok (model grok-4.6) on 2026-09-12;
+ * grok 0.2.56 dropped `streaming-messages-json` for `streaming-json`, which
+ * is token deltas rather than whole messages:
+ *
+ *   {"type":"thought","data":…}
+ *   {"type":"text","data":"Hi"}
+ *   {"type":"end","stopReason":"EndTurn","sessionId":…}
+ *
+ * Text `data` chunks are concatenated for the final reply and never emitted
+ * as progress (they are token deltas). Recorded from Claude Code 2.1.258 and
+ * grok (model grok-4.6) on 2026-09-12, plus grok 0.2.56 on 2026-09-21;
  * fixtures in runtime/fixtures/. Claude sends one content block per assistant
- * event; Grok sends a whole message (thinking + text + tool_use) per event.
+ * event; older Grok sends a whole message (thinking + text + tool_use) per event.
  */
 import { parseJsonLine, RuntimeError } from "./types.js";
 /** Progress events in one stream line: top-level assistant text and tool starts only. */
@@ -48,6 +57,9 @@ export function messagesStreamEvents(line) {
  * RuntimeError for an error result, or when there is nothing usable.
  */
 export function messagesStreamResult(stdout, runtimeName) {
+    const token = grokTokenStreamResult(stdout, runtimeName);
+    if (token)
+        return token;
     let result = null;
     let sessionId;
     let lastText;
@@ -78,6 +90,38 @@ export function messagesStreamResult(stdout, runtimeName) {
         sessionId = result.session_id;
     return { text, sessionId };
 }
+/**
+ * grok 0.2.56 `--output-format streaming-json`: concatenate text deltas and
+ * take sessionId from the terminal `end` event. Throws on `error`. Null when
+ * the stream is not this shape (so the Anthropic Messages parser can run).
+ */
+function grokTokenStreamResult(stdout, runtimeName) {
+    let text = "";
+    let sessionId;
+    let saw = false;
+    for (const line of stdout.split("\n")) {
+        const ev = parseJsonLine(line);
+        if (!ev)
+            continue;
+        if (ev.type === "text" && typeof ev.data === "string") {
+            saw = true;
+            text += ev.data;
+        }
+        else if (ev.type === "thought") {
+            saw = true;
+        }
+        else if (ev.type === "end") {
+            saw = true;
+            if (typeof ev.sessionId === "string")
+                sessionId = ev.sessionId;
+        }
+        else if (ev.type === "error" && typeof ev.message === "string") {
+            const detail = ev.message;
+            throw new RuntimeError(`${runtimeName} reported an error: ${detail.slice(0, 200)}`, detail.slice(0, 400), null);
+        }
+    }
+    return saw ? { text, sessionId } : null;
+}
 /** The error text of an `is_error` result event, if the stream has one. */
 export function messagesStreamFailure(stdout) {
     let reason;
@@ -85,6 +129,8 @@ export function messagesStreamFailure(stdout) {
         const ev = parseJsonLine(line);
         if (ev?.type === "result" && ev.is_error === true && typeof ev.result === "string" && ev.result.trim())
             reason = ev.result.trim();
+        if (ev?.type === "error" && typeof ev.message === "string" && ev.message.trim())
+            reason = ev.message.trim();
     }
     return reason;
 }

package/dist/lib/lanes/accounts.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Provider account resolution (spec §5.5).
+ *
+ * Naming an account and omitting one mean different things: an explicit
+ * disabled id is refused; omitting picks the least-loaded eligible account.
+ * Status reports `configured` and `logged_in` separately. logged_in is
+ * derived from whether a provider credential file EXISTS — this module
+ * never reads, prints, copies, or hashes that file.
+ */
+import { type LaneRecord, type LaneProvider } from "./types.js";
+import type { LanesConfig } from "./types.js";
+export declare const PROVIDER_HOME_ENV: Record<LaneProvider, string>;
+export declare const AUTH_JSON_NAME = "auth.json";
+export declare const CLAUDE_CREDENTIALS_NAME = ".credentials.json";
+/**
+ * Credential filenames are a property of the provider. Codex and Grok write
+ * auth.json. Claude Code writes .credentials.json (never auth.json) inside
+ * the config dir, and can also authenticate via the OS keychain with no
+ * file here at all.
+ */
+export declare const PROVIDER_CREDENTIAL_FILES: Record<LaneProvider, readonly string[]>;
+export type AuthState = "file" | "absent" | "unknown";
+export interface AccountDeps {
+    existsSync: (p: string) => boolean;
+}
+export interface AccountResolveContext {
+    hqRoot?: string;
+    existsSync?: (p: string) => boolean;
+    loadLanes?: (hqRoot: string) => LaneRecord[];
+    /** Already-resolved model for this lane. Beats cliModel and account defaults. */
+    model?: string;
+    /** `--model` from create, applied to every candidate account. */
+    cliModel?: string;
+    now?: Date;
+}
+export interface ResolvedAccount {
+    provider: LaneProvider;
+    id: string;
+    home: string;
+    enabled: true;
+    envVar: string;
+}
+export interface AccountStatus {
+    provider: LaneProvider;
+    id: string;
+    home: string;
+    enabled: boolean;
+    disabled_reason?: string;
+    /** Present in personal/lanes/config.json. */
+    configured: boolean;
+    /**
+     * True when a provider credential file exists. False only when every
+     * candidate is absent AND absence is conclusive for that provider
+     * (Codex, Grok). Null for Claude when no candidate exists: Claude can
+     * authenticate via keychain, so a missing file is not logged-out.
+     * Never inspects file contents.
+     */
+    logged_in: boolean | null;
+    auth_state: AuthState;
+    envVar: string;
+}
+export declare function credentialPaths(provider: LaneProvider, home: string): string[];
+/**
+ * Existence-only probe. Callers must not read the files this returns paths to.
+ */
+export declare function hasCredentialFile(provider: LaneProvider, home: string, existsSync: (p: string) => boolean): boolean;
+/**
+ * Claude with no file in the config dir is unknown, not logged out: the
+ * credential may live in the OS keychain or an API-key helper. Codex and
+ * Grok write auth.json when logged in, so absence is logged out.
+ */
+export declare function authStateFor(provider: LaneProvider, present: boolean): AuthState;
+export declare function loggedInFromAuthState(state: AuthState): boolean | null;
+/** Admission and listing share this: refuse only a conclusive logged-out. */
+export declare function isLoggedOut(status: Pick<AccountStatus, "logged_in">): boolean;
+/** Auto-select requires a proven credential file, not Claude-unknown. */
+export declare function isCredentialProven(status: Pick<AccountStatus, "logged_in">): boolean;
+/**
+ * Occupying states hold a slot: running / awaiting_input / blocked have a
+ * live (or paused-live) worker; queued holds a queue slot that will take a
+ * running slot. Terminal states do not count.
+ */
+export declare function isOccupyingLaneState(state: LaneRecord["state"]): boolean;
+export declare function occupyingLaneCount(lanes: readonly LaneRecord[], provider: LaneProvider, accountId: string): number;
+export declare function runningLaneCount(lanes: readonly LaneRecord[], provider: LaneProvider, accountId: string): number;
+/** Most recent created_at on this account+provider, any state. Null if none. */
+export declare function lastStartedAt(lanes: readonly LaneRecord[], provider: LaneProvider, accountId: string): string | null;
+/**
+ * Pick among enabled, credential-proven accounts by occupying count
+ * (lowest wins). Ties break to least-recently-started (oldest created_at),
+ * then account id ascending. Accounts at max_running are excluded from
+ * start-eligible; if every proven account is at cap the pick still returns
+ * one so admission can queue rather than overflow.
+ */
+export declare function selectBalancedAccount(provider: LaneProvider, config: LanesConfig, ctx?: AccountResolveContext): ResolvedAccount;
+export declare function resolveAccount(provider: LaneProvider, requestedId: string | undefined, config: LanesConfig, ctx?: AccountResolveContext): ResolvedAccount;
+/** Codex/Grok path. Kept for callers that still name auth.json. */
+export declare function authJsonPath(home: string): string;
+export declare function accountStatus(provider: LaneProvider, accountId: string, config: LanesConfig, deps?: AccountDeps): AccountStatus;
+export declare function listAccountStatuses(provider: LaneProvider, config: LanesConfig, deps?: AccountDeps): AccountStatus[];
+/** Environment assignment the worker process should receive. */
+export declare function accountEnv(resolved: ResolvedAccount): Record<string, string>;
+//# sourceMappingURL=accounts.d.ts.map