@indigoai-us/hq-cli 5.124.0 → 5.126.0

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/doctor/checks/work-context.js

@@ -6,7 +6,7 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { readDeviceConfig, getDefaultCompany, } from "../../work-context/config.js";
+import { readDeviceConfig, } from "../../work-context/config.js";
 import { outboxStats, listOutboxOperations } from "../../work-context/outbox.js";
 import { workContextRoot, workContextSessionsDir } from "../../work-context/paths.js";
 import { countJsonlLines, deadLetterNonEmpty, } from "../../mesh/live/spool.js";
@@ -96,7 +96,9 @@ function runChecks(deps) {
     // Default-company mode + migration capability (US-017B)
     try {
         const cfg = readDeviceConfig({ root });
-        const def = getDefaultCompany({ root });
+        const def = cfg.defaultCompany?.enabled && cfg.defaultCompany.slug
+            ? cfg.defaultCompany
+            : null;
         const mode = def?.enabled
             ? `enabled slug=${def.slug}`
             : "disabled (dark / unset)";

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

@@ -0,0 +1,43 @@
+/**
+ * Provider account resolution (spec §5.5).
+ *
+ * Naming an account and omitting one mean different things: an explicit
+ * disabled id is refused; omitting rotates past a disabled default.
+ * Status reports `configured` and `logged_in` separately. logged_in is
+ * derived from whether <home>/auth.json EXISTS — this module never reads,
+ * prints, copies, or hashes that file.
+ */
+import type { LaneProvider, LanesConfig } from "./types.js";
+export declare const PROVIDER_HOME_ENV: Record<LaneProvider, string>;
+export declare const AUTH_JSON_NAME = "auth.json";
+export interface AccountDeps {
+    existsSync: (p: string) => boolean;
+}
+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 iff `<home>/auth.json` exists. Never inspects the file contents.
+     */
+    logged_in: boolean;
+    envVar: string;
+}
+export declare function resolveAccount(provider: LaneProvider, requestedId: string | undefined, config: LanesConfig): ResolvedAccount;
+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

package/dist/lib/lanes/accounts.js

@@ -0,0 +1,128 @@
+/**
+ * Provider account resolution (spec §5.5).
+ *
+ * Naming an account and omitting one mean different things: an explicit
+ * disabled id is refused; omitting rotates past a disabled default.
+ * Status reports `configured` and `logged_in` separately. logged_in is
+ * derived from whether <home>/auth.json EXISTS — this module never reads,
+ * prints, copies, or hashes that file.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { AccountResolutionError } from "./errors.js";
+export const PROVIDER_HOME_ENV = {
+    claude: "CLAUDE_CONFIG_DIR",
+    codex: "CODEX_HOME",
+    grok: "GROK_HOME",
+};
+export const AUTH_JSON_NAME = "auth.json";
+function defaultAccountDeps() {
+    return { existsSync: (p) => fs.existsSync(p) };
+}
+function enabledIds(provider) {
+    return Object.entries(provider.accounts)
+        .filter(([, account]) => account.enabled)
+        .map(([id]) => id);
+}
+function rotateEnabled(providerCfg, skipId) {
+    for (const [id, account] of Object.entries(providerCfg.accounts)) {
+        if (!account.enabled)
+            continue;
+        if (skipId !== undefined && id === skipId)
+            continue;
+        return id;
+    }
+    return undefined;
+}
+export function resolveAccount(provider, requestedId, config) {
+    const providerCfg = config.providers[provider];
+    const envVar = PROVIDER_HOME_ENV[provider];
+    const enabled = enabledIds(providerCfg);
+    if (requestedId !== undefined && requestedId.length > 0) {
+        const account = providerCfg.accounts[requestedId];
+        if (account === undefined) {
+            throw new AccountResolutionError("unknown_account", `Unknown account ${JSON.stringify(requestedId)} for ${provider}. Enabled: ${enabled.join(", ") || "(none)"}`, {
+                provider,
+                account: requestedId,
+                enabled,
+            });
+        }
+        if (!account.enabled) {
+            throw new AccountResolutionError("account_disabled", `Account ${JSON.stringify(requestedId)} is disabled${account.disabled_reason ? `: ${account.disabled_reason}` : ""}`, {
+                account: requestedId,
+                reason: account.disabled_reason ?? "",
+            });
+        }
+        return {
+            provider,
+            id: requestedId,
+            home: account.home,
+            enabled: true,
+            envVar,
+        };
+    }
+    const defaultId = providerCfg.default_account;
+    const defaultAccount = providerCfg.accounts[defaultId];
+    if (defaultAccount?.enabled) {
+        return {
+            provider,
+            id: defaultId,
+            home: defaultAccount.home,
+            enabled: true,
+            envVar,
+        };
+    }
+    const rotated = rotateEnabled(providerCfg, defaultAccount ? defaultId : undefined);
+    if (rotated === undefined) {
+        throw new AccountResolutionError("no_enabled_account", `No enabled account for provider ${provider}`, { provider });
+    }
+    const rotatedAccount = providerCfg.accounts[rotated];
+    return {
+        provider,
+        id: rotated,
+        home: rotatedAccount.home,
+        enabled: true,
+        envVar,
+    };
+}
+export function authJsonPath(home) {
+    return path.join(home, AUTH_JSON_NAME);
+}
+export function accountStatus(provider, accountId, config, deps = defaultAccountDeps()) {
+    const envVar = PROVIDER_HOME_ENV[provider];
+    const account = config.providers[provider].accounts[accountId];
+    if (account === undefined) {
+        return {
+            provider,
+            id: accountId,
+            home: "",
+            enabled: false,
+            configured: false,
+            logged_in: false,
+            envVar,
+        };
+    }
+    const authPath = authJsonPath(account.home);
+    const logged_in = deps.existsSync(authPath);
+    const status = {
+        provider,
+        id: accountId,
+        home: account.home,
+        enabled: account.enabled,
+        configured: true,
+        logged_in,
+        envVar,
+    };
+    if (account.disabled_reason !== undefined) {
+        status.disabled_reason = account.disabled_reason;
+    }
+    return status;
+}
+export function listAccountStatuses(provider, config, deps = defaultAccountDeps()) {
+    return Object.keys(config.providers[provider].accounts).map((id) => accountStatus(provider, id, config, deps));
+}
+/** Environment assignment the worker process should receive. */
+export function accountEnv(resolved) {
+    return { [resolved.envVar]: resolved.home };
+}
+//# sourceMappingURL=accounts.js.map

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

@@ -0,0 +1,56 @@
+/**
+ * Load and validate personal/lanes/config.json (spec §5.5).
+ *
+ * A missing file is the documented defaults, not an error. A `providers` key
+ * outside {claude, codex, grok} is rejected with the accepted list. Account
+ * homes are canonicalised with realpath; two account ids for one provider
+ * that resolve to the same home are refused (identity-keyed-cap rule).
+ */
+import * as fs from "node:fs";
+import { type LaneProvider, type LanesConfig, type LivenessWindows, type ProviderConfig } from "./types.js";
+export declare const LANES_CONFIG_REL: string;
+export declare const DEFAULT_MAX_QUEUED = 3;
+export declare const DEFAULT_CPU_BUSY_PAUSE = 0.85;
+export declare const DEFAULT_CPU_BUSY_RESUME = 0.7;
+export declare const DEFAULT_MIN_AVAILABLE_MEM_MB = 1024;
+/** Spec §9: last event within 10 minutes → live. */
+export declare const DEFAULT_LIVE_WITHIN_MS: number;
+/** Spec §9: turn_start with no turn_end after 2 hours → lost. */
+export declare const DEFAULT_TURN_START_LOST_MS: number;
+/** Spec §9: no event for 12 hours (and no session_end) → lost. */
+export declare const DEFAULT_SILENT_LOST_MS: number;
+export declare const DEFAULT_LIVENESS_WINDOWS: LivenessWindows;
+export declare const DEFAULT_PROVIDER_MAX_RUNNING: Record<LaneProvider, number>;
+export declare const DEFAULT_ACCOUNT_HOMES: Record<LaneProvider, string>;
+export interface ConfigLoadDeps {
+    homedir: () => string;
+    realpathSync: (p: string) => string;
+    existsSync: (p: string) => boolean;
+    readFileSync: (p: string, encoding: "utf8") => string;
+}
+export declare function expandHome(home: string, homedir: string): string;
+/**
+ * Canonical principal for an account home: realpath when the path exists,
+ * otherwise resolve existing ancestors and rejoin the missing tail so two
+ * not-yet-created spellings of the same directory still collide.
+ */
+export declare function canonicalizeHome(home: string, deps?: Pick<ConfigLoadDeps, "homedir" | "realpathSync" | "existsSync">): string;
+export declare function documentedDefaultConfig(deps?: ConfigLoadDeps): LanesConfig;
+export declare function parseLanesConfig(raw: unknown, deps?: ConfigLoadDeps): LanesConfig;
+export declare function lanesConfigPath(hqRoot: string): string;
+/**
+ * Load operator config. Missing file → documented defaults. Unreadable or
+ * invalid JSON is an error (never a silent default).
+ */
+export declare function loadLanesConfig(hqRoot: string, deps?: ConfigLoadDeps): LanesConfig;
+export interface ConfigWriteDeps {
+    mkdirSync: typeof fs.mkdirSync;
+    writeFileSync: typeof fs.writeFileSync;
+    renameSync: typeof fs.renameSync;
+    unlinkSync: typeof fs.unlinkSync;
+}
+/** Persist operator config. Homes are stored as already-canonicalised paths. */
+export declare function writeLanesConfig(hqRoot: string, config: LanesConfig, deps?: ConfigWriteDeps): void;
+/** Account running cap, defaulting to the provider ceiling when unset. */
+export declare function accountMaxRunning(provider: ProviderConfig, accountId: string): number;
+//# sourceMappingURL=config.d.ts.map