@indigoai-us/hq-cli 5.202.1 → 5.204.0

package/dist/lib/lanes/account-home.d.ts

@@ -0,0 +1,8 @@
+import type { AccountConfig } from "./types.js";
+export type EffectiveAccountHome = {
+    home: string;
+    source: "host" | "default";
+};
+/** Resolve the account home for this host; an empty host identity fails back to the default. */
+export declare function effectiveAccountHome(account: AccountConfig, hostname?: string): EffectiveAccountHome;
+//# sourceMappingURL=account-home.d.ts.map

package/dist/lib/lanes/account-home.js

@@ -0,0 +1,10 @@
+import * as os from "node:os";
+/** Resolve the account home for this host; an empty host identity fails back to the default. */
+export function effectiveAccountHome(account, hostname = os.hostname()) {
+    const host = hostname.trim();
+    const hostHome = host ? account.hosts?.[host]?.home : undefined;
+    return hostHome === undefined
+        ? { home: account.home, source: "default" }
+        : { home: hostHome, source: "host" };
+}
+//# sourceMappingURL=account-home.js.map

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

@@ -19,7 +19,7 @@ export declare const CLAUDE_CREDENTIALS_NAME = ".credentials.json";
  * file here at all.
  */
 export declare const PROVIDER_CREDENTIAL_FILES: Record<LaneProvider, readonly string[]>;
-export type AuthState = "file" | "status" | "absent" | "unknown";
+export type AuthState = "file" | "status" | "absent" | "unknown" | "home_missing";
 export interface AccountStatusProbeResult {
     status: number | null;
     stdout: string;
@@ -27,12 +27,14 @@ export interface AccountStatusProbeResult {
 }
 export interface AccountDeps {
     existsSync: (p: string) => boolean;
+    hostname?: string;
     /** Provider status output is parsed for a boolean only; it is never printed. */
     probe?: (command: string, args: string[], env: NodeJS.ProcessEnv) => AccountStatusProbeResult;
     env?: NodeJS.ProcessEnv;
 }
 export interface AccountResolveContext {
     hqRoot?: string;
+    hostname?: string;
     existsSync?: (p: string) => boolean;
     accountDeps?: Omit<AccountDeps, "existsSync">;
     loadLanes?: (hqRoot: string) => LaneRecord[];
@@ -61,6 +63,7 @@ export interface AccountStatus {
     provider: LaneProvider;
     id: string;
     home: string;
+    home_source?: "host" | "default";
     enabled: boolean;
     disabled_reason?: string;
     /** Present in personal/lanes/config.json. */

package/dist/lib/lanes/accounts.js

@@ -8,6 +8,7 @@
  * module never reads, prints, copies, or hashes credential files.
  */
 import * as fs from "node:fs";
+import { effectiveAccountHome } from "./account-home.js";
 import * as path from "node:path";
 import { AccountResolutionError } from "./errors.js";
 import { isTerminalLaneState } from "./types.js";
@@ -179,11 +180,11 @@ function throwIfQuotaBlocked(block, provider, accountId) {
         quota_reset_at: block.quota_reset_at ?? null,
     });
 }
-function boundAccount(provider, id, account) {
+function boundAccount(provider, id, account, hostname) {
     return {
         provider,
         id,
-        home: account.home,
+        home: effectiveAccountHome(account, hostname).home,
         enabled: true,
         envVar: PROVIDER_HOME_ENV[provider],
     };
@@ -209,6 +210,7 @@ export function selectBalancedAccount(provider, config, ctx = {}) {
             existsSync,
             ...(ctx.accountDeps?.probe ? { probe: ctx.accountDeps.probe } : {}),
             ...(ctx.accountDeps?.env ? { env: ctx.accountDeps.env } : {}),
+            ...(ctx.hostname !== undefined ? { hostname: ctx.hostname } : {}),
         });
         if (status.logged_in === true)
             proven.push(id);
@@ -251,7 +253,7 @@ export function selectBalancedAccount(provider, config, ctx = {}) {
     }))
         .sort(compareEligible);
     const chosen = preferred ?? ranked[0].id;
-    return boundAccount(provider, chosen, providerCfg.accounts[chosen]);
+    return boundAccount(provider, chosen, providerCfg.accounts[chosen], ctx.hostname);
 }
 export function resolveAccount(provider, requestedId, config, ctx = {}) {
     const providerCfg = config.providers[provider];
@@ -276,7 +278,7 @@ export function resolveAccount(provider, requestedId, config, ctx = {}) {
             const block = quotaBlockFor(loadQuotaState(ctx.hqRoot), provider, requestedId, modelForAccount(provider, requestedId, config, ctx), now);
             throwIfQuotaBlocked(block, provider, requestedId);
         }
-        return boundAccount(provider, requestedId, account);
+        return boundAccount(provider, requestedId, account, ctx.hostname);
     }
     return selectBalancedAccount(provider, config, ctx);
 }
@@ -299,12 +301,14 @@ export function accountStatus(provider, accountId, config, deps = defaultAccount
             envVar,
         };
     }
-    const present = hasCredentialFile(provider, account.home, deps.existsSync);
-    let auth_state = authStateFor(provider, present);
-    let logged_in = loggedInFromAuthState(auth_state);
-    if (!present && provider === "claude" && deps.probe !== undefined) {
+    const effective = effectiveAccountHome(account, deps.hostname);
+    const homeExists = deps.existsSync(effective.home);
+    const present = homeExists && hasCredentialFile(provider, effective.home, deps.existsSync);
+    let auth_state = homeExists ? authStateFor(provider, present) : "home_missing";
+    let logged_in = homeExists ? loggedInFromAuthState(auth_state) : false;
+    if (homeExists && !present && provider === "claude" && deps.probe !== undefined) {
         try {
-            const result = deps.probe("claude", ["auth", "status"], { ...(deps.env ?? process.env), CLAUDE_CONFIG_DIR: account.home });
+            const result = deps.probe("claude", ["auth", "status"], { ...(deps.env ?? process.env), CLAUDE_CONFIG_DIR: effective.home });
             const providerStatus = claudeLoginStatus(result);
             if (providerStatus !== null) {
                 auth_state = "status";
@@ -318,7 +322,8 @@ export function accountStatus(provider, accountId, config, deps = defaultAccount
     const status = {
         provider,
         id: accountId,
-        home: account.home,
+        home: effective.home,
+        home_source: effective.source,
         enabled: account.enabled,
         configured: true,
         logged_in,

package/dist/lib/lanes/claude-account-balance.d.ts

@@ -1,3 +1,4 @@
+import type { AuthState } from "./accounts.js";
 import type { HostCapacityAccount, HostCapacitySnapshot } from "./host-capacity.js";
 import type { LaneHost, LaneRecord, LanesConfig } from "./types.js";
 export declare const CLAUDE_ACCOUNT_BALANCE_FLAG = "lanes.claude-account-balance";
@@ -20,6 +21,8 @@ export interface AccountHostLoad {
     host: LaneHost;
     enabled: boolean;
     logged_in: boolean | null;
+    account_in_snapshot: boolean;
+    auth_state?: AuthState;
     live_lanes: number | null;
     lane_counts: {
         running: number | null;

package/dist/lib/lanes/claude-account-balance.js

@@ -21,7 +21,8 @@ function accountHostLoad(host, accountId) {
         return {
             host: host.capacity.host,
             enabled: false,
-            logged_in: false,
+            logged_in: null,
+            account_in_snapshot: false,
             live_lanes: host.laneListAvailable ? countLaneStates(host.lanes, accountId).live : null,
             lane_counts: host.laneListAvailable
                 ? countLaneStates(host.lanes, accountId)
@@ -35,6 +36,8 @@ function accountHostLoad(host, accountId) {
             host: host.capacity.host,
             enabled: hostCapacity.enabled,
             logged_in: hostCapacity.logged_in,
+            account_in_snapshot: true,
+            ...(hostCapacity.auth_state !== undefined ? { auth_state: hostCapacity.auth_state } : {}),
             live_lanes: counts.live,
             lane_counts: { running: counts.running, queued: counts.queued, awaiting_input: counts.awaiting_input },
             count_source: "lane_list",
@@ -45,6 +48,8 @@ function accountHostLoad(host, accountId) {
             host: host.capacity.host,
             enabled: hostCapacity.enabled,
             logged_in: hostCapacity.logged_in,
+            account_in_snapshot: true,
+            ...(hostCapacity.auth_state !== undefined ? { auth_state: hostCapacity.auth_state } : {}),
             live_lanes: hostCapacity.lane_counts.live,
             lane_counts: {
                 running: hostCapacity.lane_counts.running,
@@ -58,6 +63,8 @@ function accountHostLoad(host, accountId) {
         host: host.capacity.host,
         enabled: hostCapacity.enabled,
         logged_in: hostCapacity.logged_in,
+        account_in_snapshot: true,
+        ...(hostCapacity.auth_state !== undefined ? { auth_state: hostCapacity.auth_state } : {}),
         live_lanes: hostCapacity.running + hostCapacity.queued,
         lane_counts: { running: hostCapacity.running, queued: hostCapacity.queued, awaiting_input: null },
         count_source: "capacity_partial",
@@ -74,10 +81,16 @@ function selectionSignal(loads) {
         : "lane_count";
 }
 function targetIneligibilityReason(accountId, globalEnabled, allowedAccounts, target) {
-    if (!globalEnabled || !target.enabled)
+    if (!globalEnabled)
         return "disabled";
     if (allowedAccounts !== undefined && !allowedAccounts.includes(accountId))
         return "not_allowed_by_lane";
+    if (!target.account_in_snapshot)
+        return "not_in_snapshot";
+    if (!target.enabled)
+        return "disabled";
+    if (target.auth_state === "home_missing")
+        return "home_missing";
     if (target.logged_in === false)
         return "not_logged_in";
     if (target.logged_in === null)
@@ -203,6 +216,9 @@ export function planClaudeBalanceMoves(input) {
         const hostSnapshot = input.hosts.find((row) => sameHost(row.capacity.host, host));
         if (!hostSnapshot)
             continue;
+        const sourceStatus = hostSnapshot.capacity.providers.claude.accounts[source];
+        if (sourceStatus === undefined)
+            continue;
         const candidates = Object.keys(input.config.providers.claude.accounts)
             .filter((account) => account !== source && input.config.providers.claude.accounts[account]?.enabled === true)
             .map((account) => ({
@@ -212,8 +228,7 @@ export function planClaudeBalanceMoves(input) {
         }))
             .filter((candidate) => candidate.targetStatus?.enabled === true && candidate.targetStatus.logged_in === true)
             .sort((a, b) => a.load - b.load || a.account.localeCompare(b.account));
-        const sourceStatus = hostSnapshot.capacity.providers.claude.accounts[source];
-        const sourceUnavailable = sourceStatus?.enabled !== true || sourceStatus.logged_in !== true;
+        const sourceUnavailable = sourceStatus.enabled !== true || sourceStatus.logged_in !== true;
         const target = candidates[0];
         const laneIsLive = isBalanceLive(lane);
         if (!target || (!sourceUnavailable && (!laneIsLive || target.load >= sourceLoad)))

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

@@ -7,7 +7,7 @@
  * 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";
+import { type AccountConfig, 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;
@@ -55,6 +55,7 @@ export declare function expandHome(home: string, homedir: string): string;
  * 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 assertUniqueAccountHomes(provider: LaneProvider, accounts: Record<string, AccountConfig>): void;
 export declare function documentedDefaultConfig(deps?: ConfigLoadDeps): LanesConfig;
 export declare function parseLanesConfig(raw: unknown, deps?: ConfigLoadDeps): LanesConfig;
 export declare function lanesConfigPath(hqRoot: string): string;

package/dist/lib/lanes/config.js

@@ -110,6 +110,17 @@ export function canonicalizeHome(home, deps = defaultDeps()) {
     }
     return expanded;
 }
+function canonicalizeHostHome(hostname, home, deps) {
+    if (hostname === os.hostname())
+        return canonicalizeHome(home, deps);
+    if (home === "~" || home.startsWith("~/")) {
+        return home === "~" ? home : `~/${path.posix.normalize(home.slice(2))}`;
+    }
+    if (!path.isAbsolute(home)) {
+        throw new LanesConfigError("invalid_config", `Host-scoped home for remote host ${JSON.stringify(hostname)} must be absolute or start with ~/`, { hostname, home });
+    }
+    return path.normalize(home);
+}
 function isPlainObject(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -143,6 +154,27 @@ function parseAccount(provider, id, raw, deps) {
         home: canonicalizeHome(raw.home, deps),
         enabled: raw.enabled,
     };
+    if (raw.hosts !== undefined) {
+        const field = `providers.${provider}.accounts.${id}.hosts`;
+        if (!isPlainObject(raw.hosts)) {
+            throw new LanesConfigError("invalid_config", `${field} must be an object keyed by non-empty hostnames`, { provider, account: id, field });
+        }
+        const hosts = Object.create(null);
+        for (const [hostname, value] of Object.entries(raw.hosts)) {
+            const hostField = `${field}.${hostname}`;
+            if (hostname.trim().length === 0 || hostname.trim() !== hostname) {
+                throw new LanesConfigError("invalid_config", `${field} hostnames must be non-empty and have no surrounding whitespace`, { provider, account: id, field, hostname });
+            }
+            if (!isPlainObject(value) || Object.keys(value).some((key) => key !== "home")) {
+                throw new LanesConfigError("invalid_config", `${hostField} must be an object containing only a home field`, { provider, account: id, field: hostField });
+            }
+            if (typeof value.home !== "string" || value.home.trim().length === 0) {
+                throw new LanesConfigError("invalid_config", `${hostField}.home must be a non-empty string`, { provider, account: id, field: `${hostField}.home` });
+            }
+            hosts[hostname] = { home: canonicalizeHostHome(hostname, value.home, deps) };
+        }
+        account.hosts = hosts;
+    }
     if (raw.disabled_reason !== undefined) {
         if (typeof raw.disabled_reason !== "string") {
             throw new LanesConfigError("invalid_config", `providers.${provider}.accounts.${id}.disabled_reason must be a string`, { provider, account: id });
@@ -198,19 +230,29 @@ function parsePreferredAccounts(provider, value, accounts) {
     }
     return [...preferred];
 }
-function rejectDuplicateHomes(provider, accounts) {
-    const seen = new Map();
-    for (const [id, account] of Object.entries(accounts)) {
-        const prior = seen.get(account.home);
-        if (prior !== undefined) {
-            throw new LanesConfigError("duplicate_account_home", `providers.${provider} accounts ${JSON.stringify(prior)} and ${JSON.stringify(id)} resolve to the same home ${account.home}`, {
-                provider,
-                accounts: [prior, id],
-                home: account.home,
-            });
+export function assertUniqueAccountHomes(provider, accounts) {
+    const hostnames = new Set(Object.values(accounts).flatMap((account) => Object.keys(account.hosts ?? {})));
+    const check = (hostname) => {
+        const seen = new Map();
+        for (const [id, account] of Object.entries(accounts)) {
+            const home = hostname === undefined
+                ? account.home
+                : account.hosts?.[hostname]?.home ?? account.home;
+            const prior = seen.get(home);
+            if (prior !== undefined) {
+                throw new LanesConfigError("duplicate_account_home", `providers.${provider} accounts ${JSON.stringify(prior)} and ${JSON.stringify(id)} resolve to the same home ${home}${hostname === undefined ? "" : ` on host ${JSON.stringify(hostname)}`}`, {
+                    provider,
+                    accounts: [prior, id],
+                    home,
+                    ...(hostname !== undefined ? { hostname } : {}),
+                });
+            }
+            seen.set(home, id);
         }
-        seen.set(account.home, id);
-    }
+    };
+    check();
+    for (const hostname of hostnames)
+        check(hostname);
 }
 function defaultAccountMap(provider, deps) {
     return {
@@ -240,7 +282,7 @@ function parseProvider(provider, raw, deps) {
             accounts[id] = parseAccount(provider, id, value, deps);
         }
     }
-    rejectDuplicateHomes(provider, accounts);
+    assertUniqueAccountHomes(provider, accounts);
     // default_account is accepted so existing files parse, and ignored for
     // selection. An omitted field is not an error.
     let defaultAccount;

package/dist/lib/lanes/delivery-core.d.ts

@@ -0,0 +1,15 @@
+import { type DeliveryLane, type LaneDeliveryMechanism } from "./delivery.js";
+export interface LaneDeliveryHandlers<T> {
+    dropbox: () => T | Promise<T>;
+    resume: () => T | Promise<T>;
+}
+/**
+ * The shared side-effect seam for lane messages. Both `hq lanes message` and
+ * `hq monitor` use the same delivery decision and cannot choose a provider
+ * path from state independently.
+ */
+export declare function dispatchLaneDelivery<T>(lane: DeliveryLane, handlers: LaneDeliveryHandlers<T>, resolvedMechanism?: LaneDeliveryMechanism): Promise<{
+    mechanism: LaneDeliveryMechanism;
+    value: T;
+}>;
+//# sourceMappingURL=delivery-core.d.ts.map

package/dist/lib/lanes/delivery-core.js

@@ -0,0 +1,21 @@
+import { deliveryRefusalReason, laneDeliveryMechanism, } from "./delivery.js";
+import { LanesError } from "./errors.js";
+/**
+ * The shared side-effect seam for lane messages. Both `hq lanes message` and
+ * `hq monitor` use the same delivery decision and cannot choose a provider
+ * path from state independently.
+ */
+export async function dispatchLaneDelivery(lane, handlers, resolvedMechanism = laneDeliveryMechanism(lane)) {
+    const mechanism = resolvedMechanism;
+    if (mechanism === "none") {
+        const message = deliveryRefusalReason(lane);
+        throw new LanesError("lane_not_accepting_messages", message, {
+            state: lane.state,
+            provider: lane.provider,
+            message,
+        });
+    }
+    const value = await handlers[mechanism]();
+    return { mechanism, value };
+}
+//# sourceMappingURL=delivery-core.js.map

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

@@ -7,11 +7,11 @@
  * which continues the recorded session and keeps its prompt cache. Codex
  * (0.155.1) has `codex exec resume <thread-id>`; the id is the `thread_id`
  * of the `thread.started` event on the `--json` stdout stream, and the same
- * id comes back on every resumed turn. Grok's CLI (1.0.34) has
- * `--resume <id>` and its `--single --output-format json` result carries a
- * `sessionId`, but no live run has shown `--single --resume` continue a
- * session (the grok account was out of balance when this was written), so
- * an exited grok lane keeps no delivery path until that is proven.
+ * id comes back on every resumed turn. Grok's CLI (1.0.34) prints a
+ * `sessionId` in its `--single --output-format json` result, and
+ * `grok --single <prompt> --resume <id>` continues that session with the same
+ * id and a warm prompt cache (verified live 2026-09-26: the resumed turn
+ * recalled the earlier turn's tool calls and read 33,792 cached tokens).
  *
  * Every dispatch site (`hq lanes message`, spawn, reconcile resume) asks this
  * module rather than testing provider or state inline. A guard bound at one
@@ -21,6 +21,14 @@ import { type LaneProvider, type LaneRecord, type LaneState } from "./types.js";
 /** Which providers can continue an exited worker from a recorded session id. */
 export declare const PROVIDER_SESSION_RESUME: Record<LaneProvider, boolean>;
 export declare function providerSupportsSessionResume(provider: LaneProvider): boolean;
+/**
+ * Which providers' sessions can be copied to another account's home before a
+ * resume (move-account.ts). Grok resumes on the account that recorded the
+ * session, but copying its session directory between homes is not proven.
+ */
+export declare const PROVIDER_SESSION_PORTABLE: Record<LaneProvider, boolean>;
+export declare function providerSessionPortable(provider: LaneProvider): boolean;
+export declare function sessionNotPortableMessage(provider: LaneProvider): string;
 /**
  * States an operator message may resume from, given a session id.
  *
@@ -96,6 +104,13 @@ export declare function parseClaudeResultOutput(text: string): WorkerRunResult;
  * Nothing else on the stream is read out.
  */
 export declare function parseCodexEventOutput(text: string): WorkerRunResult;
+/**
+ * Parse the `grok --single --output-format json` result. Grok prints one
+ * pretty-printed JSON object (`sessionId`, `usage`, ...) at the end of the
+ * run, so the last top-level object in this run's stdout is the result.
+ * Only `sessionId` and the two cache counters are read out.
+ */
+export declare function parseGrokResultOutput(text: string): WorkerRunResult;
 /** Per-provider stdout parser; null for a provider whose exit carries nothing to record. */
 export declare function parseWorkerRunOutput(provider: LaneProvider, text: string): WorkerRunResult | null;
 /**
@@ -118,6 +133,7 @@ export type LaunchTrigger = {
     kind: "message";
     text: string;
     message_id: string;
+    monitor_event?: true;
 } | {
     /** `hq lanes resume`: the operator's explicit opt-in to continue an exited lane. */
     kind: "resume";

package/dist/lib/lanes/delivery.js

@@ -7,11 +7,11 @@
  * which continues the recorded session and keeps its prompt cache. Codex
  * (0.155.1) has `codex exec resume <thread-id>`; the id is the `thread_id`
  * of the `thread.started` event on the `--json` stdout stream, and the same
- * id comes back on every resumed turn. Grok's CLI (1.0.34) has
- * `--resume <id>` and its `--single --output-format json` result carries a
- * `sessionId`, but no live run has shown `--single --resume` continue a
- * session (the grok account was out of balance when this was written), so
- * an exited grok lane keeps no delivery path until that is proven.
+ * id comes back on every resumed turn. Grok's CLI (1.0.34) prints a
+ * `sessionId` in its `--single --output-format json` result, and
+ * `grok --single <prompt> --resume <id>` continues that session with the same
+ * id and a warm prompt cache (verified live 2026-09-26: the resumed turn
+ * recalled the earlier turn's tool calls and read 33,792 cached tokens).
  *
  * Every dispatch site (`hq lanes message`, spawn, reconcile resume) asks this
  * module rather than testing provider or state inline. A guard bound at one
@@ -25,11 +25,30 @@ import { parseLaneProvider, ENVELOPE_INVALID_REASON, } from "./types.js";
 export const PROVIDER_SESSION_RESUME = {
     claude: true,
     codex: true,
-    grok: false,
+    grok: true,
 };
 export function providerSupportsSessionResume(provider) {
     return PROVIDER_SESSION_RESUME[parseLaneProvider(provider)];
 }
+/**
+ * Which providers' sessions can be copied to another account's home before a
+ * resume (move-account.ts). Grok resumes on the account that recorded the
+ * session, but copying its session directory between homes is not proven.
+ */
+export const PROVIDER_SESSION_PORTABLE = {
+    claude: true,
+    codex: true,
+    grok: false,
+};
+export function providerSessionPortable(provider) {
+    const parsed = parseLaneProvider(provider);
+    return PROVIDER_SESSION_RESUME[parsed] && PROVIDER_SESSION_PORTABLE[parsed];
+}
+export function sessionNotPortableMessage(provider) {
+    return providerSupportsSessionResume(provider)
+        ? `Provider ${provider} session files are not copied between accounts, so the lane cannot move to another ${provider} account`
+        : `Provider ${provider} has no session resume, so a lane cannot move between its accounts`;
+}
 /**
  * States an operator message may resume from, given a session id.
  *
@@ -230,6 +249,51 @@ export function parseCodexEventOutput(text) {
         cache_creation_input_tokens: nonNegativeInt(usage.cache_write_input_tokens),
     };
 }
+/**
+ * Parse the `grok --single --output-format json` result. Grok prints one
+ * pretty-printed JSON object (`sessionId`, `usage`, ...) at the end of the
+ * run, so the last top-level object in this run's stdout is the result.
+ * Only `sessionId` and the two cache counters are read out.
+ */
+export function parseGrokResultOutput(text) {
+    const lines = text.split("\n");
+    let sawJson = false;
+    for (let i = lines.length - 1; i >= 0; i -= 1) {
+        if (!(lines[i] ?? "").startsWith("{"))
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(lines.slice(i).join("\n").trim());
+        }
+        catch {
+            continue;
+        }
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            continue;
+        sawJson = true;
+        const rec = parsed;
+        if (!("sessionId" in rec) && !("stopReason" in rec))
+            continue;
+        const usage = rec.usage && typeof rec.usage === "object" && !Array.isArray(rec.usage)
+            ? rec.usage
+            : {};
+        const sessionId = typeof rec.sessionId === "string" && rec.sessionId.trim().length > 0
+            ? rec.sessionId.trim()
+            : null;
+        return {
+            session_id: sessionId,
+            session_id_absent: sessionId === null ? "no_session_id_field" : null,
+            cache_read_input_tokens: nonNegativeInt(usage.cache_read_input_tokens),
+            cache_creation_input_tokens: nonNegativeInt(usage.cache_creation_input_tokens),
+        };
+    }
+    return {
+        session_id: null,
+        session_id_absent: sawJson ? "no_session_id_field" : "no_result_json",
+        cache_read_input_tokens: null,
+        cache_creation_input_tokens: null,
+    };
+}
 /** Per-provider stdout parser; null for a provider whose exit carries nothing to record. */
 export function parseWorkerRunOutput(provider, text) {
     switch (parseLaneProvider(provider)) {
@@ -238,7 +302,7 @@ export function parseWorkerRunOutput(provider, text) {
         case "codex":
             return parseCodexEventOutput(text);
         case "grok":
-            return null;
+            return parseGrokResultOutput(text);
         default:
             return null;
     }

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

@@ -20,6 +20,9 @@ export interface DropboxMessage {
     kind?: string;
     question_id?: string;
     choice?: string;
+    monitor_id?: string;
+    description?: string;
+    sequence?: number;
     text: string;
     [key: string]: unknown;
 }
@@ -38,6 +41,8 @@ export interface DrainDeps {
     readStarttime?: (pid: number) => number | null;
     /** Test seam: after observing inbox bytes, before the consume rename. */
     afterObserveInbox?: () => void;
+    /** Abort a drain that lost its session waiter claim before consuming bytes. */
+    canDrain?: () => boolean;
     /** Test seam: runs after this process has claimed and read its bytes. */
     afterRead?: () => void;
 }
@@ -62,14 +67,21 @@ export interface ToolActivityRecord {
 export declare function recordToolActivity(hqRoot: string, laneId: string, at?: string): ToolActivityRecord;
 export declare function readToolActivity(hqRoot: string, laneId: string): ToolActivityRecord | null;
 export declare function appendDropboxMessage(hqRoot: string, laneId: string, message: DropboxMessage): DropboxMessage;
+/** Append using the same on-disk layout for lane and monitor-session inboxes. */
+export declare function appendDropboxMessageAtPath(box: string, message: DropboxMessage): DropboxMessage;
 /**
  * Drain this lane's inbox exactly once. Concurrent callers: one rename wins;
  * the loser sees ENOENT and returns whatever it separately claimed (usually
  * nothing). Leftovers in draining/ and dead inflight dirs are recovered.
  */
 export declare function drainDropbox(hqRoot: string, laneId: string, depsInput?: Partial<DrainDeps>): DropboxMessage[];
+/** Drain an existing inbox directory with the same atomic rename/archive path. */
+export declare function drainDropboxAtPath(box: string, depsInput?: Partial<DrainDeps>): DropboxMessage[];
 export declare function formatOperatorInstruction(messages: DropboxMessage[]): string;
-export declare function hookAdditionalContextJson(messages: DropboxMessage[]): string;
+export declare function formatMonitorEvent(message: DropboxMessage): string;
+/** Keep event order while framing monitor output separately from operator messages. */
+export declare function formatDropboxMessages(messages: DropboxMessage[]): string;
+export declare function hookAdditionalContextJson(messages: DropboxMessage[], hookEventName?: "PreToolUse" | "UserPromptSubmit"): string;
 export interface DrainHookResult {
     exitCode: number;
     stdout: string;