@indigoai-us/hq-cli 5.125.0 → 5.126.0

package/dist/commands/mesh.js

@@ -10,7 +10,7 @@ import { findHqRoot } from "../utils/manifest.js";
 import chalk from "chalk";
 import { loadCachedTokens, isMachineIdentity } from "../utils/cognito-session.js";
 import * as readline from "node:readline/promises";
-import { STORY_STATUSES, appendThreadEvent, callerLabelFromToken, ensureProjectThread, eventPayload, listActiveMembershipCompanies, listActiveThreads, patchStoryStatus, resolveActiveMembershipCompany, resolveMeshPrincipalUid, warmMeshConversationCache, } from "../lib/mesh/api.js";
+import { STORY_STATUSES, appendThreadEvent, ensureProjectThread, eventPayload, listActiveMembershipCompanies, listActiveThreads, patchStoryStatus, resolveActiveMembershipCompany, resolveMeshPrincipalUid, warmMeshConversationCache, } from "../lib/mesh/api.js";
 import { createCandidatesFetcher, createMigratePoster, createOrganizePoster, createWorkSessionDeliverer, fetchCompanyLive, formatCompanyLiveTable, openMeshTransport, probeMigrationCapabilityForMemberships, requireToken, } from "../lib/mesh/client.js";
 import { clearDefaultCompany, isDefaultCompanyDisabled, readDeviceConfig, recordMigrationCapabilitySnapshot, setRepairHeldWithDefault, setDefaultCompany, } from "../lib/work-context/config.js";
 import { ensureDefaultCompany } from "../lib/work-context/default-company.js";
@@ -29,7 +29,7 @@ import { generateUlid } from "../lib/mesh/live/ulid.js";
 import { readLegacyBacklog } from "../lib/mesh/live/emit-replay.js";
 import { resolveMeshEmitMode, writeMeshConfigMode, } from "../lib/mesh/live/daemon/mode.js";
 import { workMeshRoot } from "../lib/mesh/live/paths.js";
-import { buildInstallPaths, collectDaemonDoctor, daemonServiceStatus, detectPlatform, formatDaemonDoctor, installDaemonService, readDaemonState, runMeshDaemon, uninstallDaemonService, daemonDir, } from "../lib/mesh/live/daemon/index.js";
+import { buildInstallPaths, collectDaemonDoctor, daemonServiceStatus, findAncestorHqRoot, resolveInstallHqRoot, detectPlatform, formatDaemonDoctor, installDaemonService, readDaemonState, runMeshDaemon, uninstallDaemonService, daemonDir, } from "../lib/mesh/live/daemon/index.js";
 import { workContextRoot } from "../lib/work-context/paths.js";
 import { formatMigrateConfirmation, submitSessionMigration, } from "../lib/work-context/migrate.js";
 import { formatOrganizeList, prepareOrganizeDecision, settleOrganizeAskWithoutBind, submitOrganizeDecision, } from "../lib/work-context/organize.js";
@@ -93,7 +93,10 @@ async function runEvent(verb, opts) {
         summary: opts.summary,
     });
     const eventKind = verb === "start" ? "claim" : verb;
-    const event = await appendThreadEvent(token, company.companyUid, ensured.threadId, eventKind, eventPayload(eventKind, opts, callerLabelFromToken(token)));
+    const claimant = eventKind === "claim"
+        ? await resolveMeshPrincipalUid(token, loadCachedTokens())
+        : "";
+    const event = await appendThreadEvent(token, company.companyUid, ensured.threadId, eventKind, eventPayload(eventKind, opts, claimant));
     if (opts.json) {
         console.log(JSON.stringify({
             ok: true,
@@ -1227,11 +1230,13 @@ export function registerMeshCommand(program) {
     daemon
         .command("run")
         .description("Start the single-instance daemon (pid lock, spool watch, presence)")
-        .action(() => wrap(() => runDaemonRun())());
+        .option("--hq-root <path>", "HQ tree root (else HQ_ROOT / persisted trusted roots); the Windows task passes this explicitly")
+        .action((opts) => wrap(() => runDaemonRun(opts))());
     daemon
         .command("install")
-        .description("Install LaunchAgent (macOS) or systemd user unit (Linux)")
+        .description("Install LaunchAgent (macOS), systemd user unit (Linux), or Scheduled Task (Windows)")
         .option("--system-user <user>", "Write a root-owned unit template for agent boxes (e.g. ec2-user)")
+        .option("--hq-root <path>", "HQ root to record for the service (else HQ_ROOT, else the nearest HQ root above cwd)")
         .option("--json", "Print machine-readable JSON")
         .action((opts) => wrap(() => runDaemonInstall(opts))());
     daemon
@@ -1250,19 +1255,24 @@ export function registerMeshCommand(program) {
         .option("--json", "Print machine-readable JSON")
         .action((opts) => wrap(() => runDaemonDoctorCmd(opts))());
 }
-async function runDaemonRun() {
-    const handle = await runMeshDaemon();
+async function runDaemonRun(opts = {}) {
+    const hqRoot = opts.hqRoot?.trim() || undefined;
+    const handle = await runMeshDaemon(hqRoot ? { hqRoot } : {});
     // Stay alive until signal handlers call stop + exit.
     await new Promise(() => {
         void handle;
     });
 }
 async function runDaemonInstall(opts) {
+    // Verified root only: a repo's own .claude/ must never become the daemon's
+    // HQ root (that path is persisted as trusted and used for attribution).
+    const hqRoot = resolveInstallHqRoot({ explicit: opts.hqRoot });
     const result = installDaemonService({
         platform: detectPlatform(),
         paths: buildInstallPaths({
             systemUser: opts.systemUser,
-            hqRoot: process.env.HQ_ROOT?.trim() || findHqRoot(),
+            hqRoot: hqRoot.root,
+            hqRootSource: hqRoot.source,
         }),
         systemUser: opts.systemUser,
     });
@@ -1273,10 +1283,15 @@ async function runDaemonInstall(opts) {
             platform: result.platform,
             dest: result.dest,
             message: result.message,
+            hqRoot: hqRoot.root,
+            hqRootSource: hqRoot.source,
+            ...(result.notice ? { notice: result.notice } : {}),
         }, null, 2));
         return;
     }
     console.log(result.message);
+    if (result.notice)
+        console.log(result.notice);
 }
 async function runDaemonUninstall(opts) {
     const result = uninstallDaemonService({
@@ -1310,12 +1325,21 @@ async function runDaemonStatus(opts) {
             running: result.running ?? false,
             dest: result.dest,
             message: result.message,
+            ...(result.lastResult !== undefined ? { lastResult: result.lastResult } : {}),
+            ...(result.lastRunFailed !== undefined ? { lastRunFailed: result.lastRunFailed } : {}),
+            ...(result.recordedHqRoot !== undefined ? { hqRoot: result.recordedHqRoot } : {}),
+            ...(result.rootValid !== undefined ? { rootValid: result.rootValid } : {}),
+            ...(result.notice ? { notice: result.notice } : {}),
             mqttState: state?.mqttState,
             presenceRefusal,
         }, null, 2));
         return;
     }
     console.log(result.message);
+    if (result.recordedHqRoot)
+        console.log(`hq root: ${result.recordedHqRoot}`);
+    if (result.notice)
+        console.log(result.notice);
     if (presenceRefusal) {
         console.log(`presence refusal: ${presenceRefusal.code} (HTTP ${presenceRefusal.status}); next retry at ${presenceRefusal.nextRetryAt}`);
     }
@@ -1324,7 +1348,11 @@ async function runDaemonStatus(opts) {
     }
 }
 async function runDaemonDoctorCmd(opts) {
-    const report = collectDaemonDoctor({ hqRoot: process.env.HQ_ROOT?.trim() || findHqRoot() });
+    // Same predicate as install: a repo's .claude/ is not an HQ root. Doctor
+    // only reads, so an unresolvable root is reported as absent, not fatal.
+    const report = collectDaemonDoctor({
+        hqRoot: process.env.HQ_ROOT?.trim() || findAncestorHqRoot(process.cwd()) || undefined,
+    });
     if (opts.json) {
         console.log(JSON.stringify({ ok: !report.unhealthy, ...report }, null, 2));
         return;

package/dist/commands/onboard-create-identity.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Who a new company is created for, when `hq onboard create-company` is run
+ * without `--email` / `--person-name`.
+ *
+ * The signed-in account already carries both on its ID token. Asking the
+ * person to type their own name again — which is what the setup bot had to do,
+ * because `hq whoami` shows only the email — is a question HQ can answer
+ * itself. Explicit flags still win.
+ */
+export interface CreateCompanyIdentity {
+    email: string;
+    personName: string;
+}
+export type CreateCompanyIdentityResult = {
+    ok: true;
+    identity: CreateCompanyIdentity;
+} | {
+    ok: false;
+    message: string;
+};
+/** Pure: flags first, then the ID token's claims. */
+export declare function resolveCreateCompanyIdentity(flags: {
+    email?: string;
+    personName?: string;
+}, claims: Record<string, unknown>): CreateCompanyIdentityResult;
+//# sourceMappingURL=onboard-create-identity.d.ts.map

package/dist/commands/onboard-create-identity.js

@@ -0,0 +1,23 @@
+function text(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+/** Pure: flags first, then the ID token's claims. */
+export function resolveCreateCompanyIdentity(flags, claims) {
+    const email = text(flags.email) || text(claims.email);
+    const personName = text(flags.personName) ||
+        text(claims.name) ||
+        [text(claims.given_name), text(claims.family_name)].filter(Boolean).join(" ");
+    const missing = [];
+    if (!email)
+        missing.push("--email");
+    if (!personName)
+        missing.push("--person-name");
+    if (missing.length > 0) {
+        return {
+            ok: false,
+            message: `Your HQ sign-in does not say ${missing.length === 2 ? "your email or name" : missing[0] === "--email" ? "your email" : "your name"}. Pass ${missing.join(" and ")}.`,
+        };
+    }
+    return { ok: true, identity: { email, personName } };
+}
+//# sourceMappingURL=onboard-create-identity.js.map

package/dist/commands/onboard.js

@@ -20,11 +20,13 @@
  */
 import chalk from "chalk";
 import { runOnboardCli, readCheckpoint } from "../lib/onboarding/index.js";
-import { DEFAULT_HQ_ROOT, DEFAULT_VAULT_API_URL, ensureCognitoToken, buildVaultConfig, } from "../utils/cognito-session.js";
+import { DEFAULT_HQ_ROOT, DEFAULT_VAULT_API_URL, ensureCognitoIdToken, ensureCognitoToken, buildVaultConfig, } from "../utils/cognito-session.js";
 import { createDefaultVaultClient } from "./cloud-provision.js";
 import { detectOnboardingIdentityMismatch } from "./onboard-identity-guard.js";
 import { planOnboardJoin } from "./onboard-join.js";
 import { buildCreateCompanyWarning } from "./onboard-warning.js";
+import { resolveCreateCompanyIdentity } from "./onboard-create-identity.js";
+import { peekIdToken } from "../utils/id-token.js";
 import { addBotToNewCompany, botToAddAfterCreateCompany } from "./onboard-bot-membership.js";
 // ---------------------------------------------------------------------------
 // Command registration
@@ -40,11 +42,18 @@ export function registerOnboardCommand(program) {
         "a same-named company makes a separate one you'd be alone in.")
         .requiredOption("--slug <slug>", "Company slug (used as bucket name suffix)")
         .requiredOption("--name <name>", "Company display name")
-        .requiredOption("--email <email>", "Your email (must match Cognito sign-in)")
-        .requiredOption("--person-name <name>", "Your display name")
+        .option("--email <email>", "Your email (default: your HQ sign-in's email; must match it)")
+        .option("--person-name <name>", "Your display name (default: the name on your HQ sign-in)")
         .option("--hq-root <path>", `Local HQ tree root (default: ${DEFAULT_HQ_ROOT})`, DEFAULT_HQ_ROOT)
-        .action(async (options) => {
+        .action(async (flags) => {
         try {
+            const idToken = await ensureCognitoIdToken();
+            const resolved = resolveCreateCompanyIdentity(flags, peekIdToken(idToken));
+            if (!resolved.ok) {
+                console.error(chalk.red(`\n✗ ${resolved.message}`));
+                process.exit(1);
+            }
+            const options = { ...flags, ...resolved.identity };
             console.log(chalk.bold(`\nHQ Onboard — Create Company`));
             console.log(`  Company:  ${options.name} (${options.slug})`);
             console.log(`  Person:   ${options.personName} <${options.email}>`);

package/dist/lib/bot/progress.d.ts

@@ -15,6 +15,10 @@
  * - the final answer is posted only when it adds something: text already
  *   posted (or about to be) is never repeated, including Grok's final result
  *   that is just every message concatenated
+ * - an in-between message that asks the person something (it has a "?") is
+ *   held, not posted: the model often asks, keeps working, then asks the same
+ *   thing again in its final answer, and the person read the question twice.
+ *   It goes out only if the turn ends without a final answer of its own
  *
  * Posts are sent strictly in order. A failed post is logged by the caller's
  * `send` and does not stop the turn.
@@ -46,6 +50,8 @@ export declare class ProgressPoster {
     private readonly workingNoticeMs;
     private readonly workingNoticeText;
     private pending;
+    /** In-between questions, held until the turn ends (see the header). */
+    private heldQuestions;
     /** Every message the model has said this turn (posted or pending), in order. */
     private readonly said;
     private flushTimer;

package/dist/lib/bot/progress.js

@@ -15,6 +15,10 @@
  * - the final answer is posted only when it adds something: text already
  *   posted (or about to be) is never repeated, including Grok's final result
  *   that is just every message concatenated
+ * - an in-between message that asks the person something (it has a "?") is
+ *   held, not posted: the model often asks, keeps working, then asks the same
+ *   thing again in its final answer, and the person read the question twice.
+ *   It goes out only if the turn ends without a final answer of its own
  *
  * Posts are sent strictly in order. A failed post is logged by the caller's
  * `send` and does not stop the turn.
@@ -37,6 +41,8 @@ export class ProgressPoster {
     workingNoticeMs;
     workingNoticeText;
     pending = [];
+    /** In-between questions, held until the turn ends (see the header). */
+    heldQuestions = [];
     /** Every message the model has said this turn (posted or pending), in order. */
     said = [];
     flushTimer = null;
@@ -75,6 +81,10 @@ export class ProgressPoster {
             return;
         this.cancelNotice();
         this.said.push(t);
+        if (t.includes("?")) {
+            this.heldQuestions.push(t);
+            return;
+        }
         this.pending.push(t);
         this.scheduleFlush();
     }
@@ -97,8 +107,12 @@ export class ProgressPoster {
         this.cancelNotice();
         this.cancelFlush();
         const final = finalText.trim();
+        const held = this.heldQuestions;
+        this.heldQuestions = [];
         if (final && !this.repeatsSaid(final))
             this.pending.push(final);
+        else if (held.length > 0)
+            this.pending.push(...held);
         if (this.pending.length === 0 && this.delivered === 0 && !final)
             this.pending.push("(no reply)");
         this.flushNow();
@@ -114,6 +128,8 @@ export class ProgressPoster {
         this.finished = true;
         this.cancelNotice();
         this.cancelFlush();
+        this.pending.push(...this.heldQuestions);
+        this.heldQuestions = [];
         this.flushNow();
         return this.chain;
     }

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,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