@indigoai-us/hq-cli 5.125.0 → 5.127.0

package/dist/command-registration-plan.d.ts

@@ -400,6 +400,13 @@ export declare const REGISTRATION_PLAN: readonly [{
     readonly parent: "program";
     readonly module: "./commands/mesh.js";
     readonly exportName: "registerMeshCommand";
+}, {
+    readonly type: "registrar";
+    readonly root: "lanes";
+    readonly parent: "program";
+    readonly module: "./commands/lanes.js";
+    readonly exportName: "registerLanesCommand";
+    readonly hidden: true;
 }, {
     readonly type: "registrar";
     readonly root: "bot";

package/dist/command-registration-plan.js

@@ -69,13 +69,15 @@ export const REGISTRATION_PLAN = [
     { type: "registrar", root: "index", parent: "program", module: "./commands/index-cmd.js", exportName: "registerIndexCommand" },
     { type: "registrar", root: "doctor", parent: "program", module: "./commands/doctor.js", exportName: "registerDoctorCommand" },
     { type: "registrar", root: "mesh", parent: "program", module: "./commands/mesh.js", exportName: "registerMeshCommand" },
+    { type: "registrar", root: "lanes", parent: "program", module: "./commands/lanes.js", exportName: "registerLanesCommand", hidden: true },
     { type: "registrar", root: "bot", parent: "program", module: "./commands/bot.js", exportName: "registerBotCommand" },
 ];
 async function executePlan(program, steps) {
     const parents = new Map([["program", program]]);
     for (const step of steps) {
         if (step.type === "group") {
-            parents.set(step.id, program.command(step.name).description(step.description));
+            const group = program.command(step.name, step.hidden ? { hidden: true } : {});
+            parents.set(step.id, group.description(step.description));
             continue;
         }
         const parent = parents.get(step.parent);
@@ -86,6 +88,14 @@ async function executePlan(program, steps) {
         if (!register)
             throw new Error(`Missing command registrar '${step.exportName}' from '${step.module}'`);
         const result = register(parent);
+        if (step.hidden) {
+            const command = result ??
+                parent.commands.find((candidate) => candidate.name() === step.root);
+            if (!command) {
+                throw new Error(`Command registrar '${step.exportName}' did not register hidden command '${step.root}'`);
+            }
+            command._hidden = true;
+        }
         if (step.result) {
             if (!result)
                 throw new Error(`Command registrar '${step.exportName}' did not return '${step.result}'`);

package/dist/commands/agents.d.ts

@@ -130,6 +130,18 @@ export interface CompanyAgentView {
     };
     [key: string]: unknown;
 }
+/**
+ * STATUS column for `hq agents list`.
+ *
+ * `agentStatus` is the agent's own stored runtime status and is NOT rewritten
+ * when a teardown starts — an agent that never finished provisioning and is
+ * now being removed keeps reading `provisioning` until the teardown completes
+ * and archives it. Observed live on liverecover/sean 2026-09-21: a removal that
+ * stalled on an object-locked vault bucket sat in the roster as `provisioning`,
+ * so the operator believed the removal had never been accepted. The roster
+ * already carries `setupPhase`, so prefer it whenever a teardown is in flight.
+ */
+export declare function rosterStatusLabel(agent: CompanyAgentView): string;
 export interface ProfilePatch {
     displayName?: string;
     title?: string;

package/dist/commands/agents.js

@@ -216,6 +216,24 @@ export class AgentsHttpError extends Error {
         this.agentCreatePlanLimit = agentCreatePlanLimit;
     }
 }
+/**
+ * STATUS column for `hq agents list`.
+ *
+ * `agentStatus` is the agent's own stored runtime status and is NOT rewritten
+ * when a teardown starts — an agent that never finished provisioning and is
+ * now being removed keeps reading `provisioning` until the teardown completes
+ * and archives it. Observed live on liverecover/sean 2026-09-21: a removal that
+ * stalled on an object-locked vault bucket sat in the roster as `provisioning`,
+ * so the operator believed the removal had never been accepted. The roster
+ * already carries `setupPhase`, so prefer it whenever a teardown is in flight.
+ */
+export function rosterStatusLabel(agent) {
+    if (agent.setupPhase === "deprovisioning")
+        return "removing";
+    if (agent.setupPhase === "deprovisioned")
+        return "removed";
+    return agent.agentStatus ?? "";
+}
 /**
  * Authenticated JSON round-trip against the agents control plane. Throws
  * `AgentsHttpError` on any non-2xx (never swallows — hq-never-swallow-errors),
@@ -466,11 +484,37 @@ function signInProviderName(url) {
         return "Claude";
     return "your provider";
 }
+/**
+ * Brain slot a device sign-in URL belongs to, or null when the provider has no
+ * per-brain slot (Claude) or the host is unknown.
+ */
+function signInBrainSlot(url) {
+    const provider = signInProviderName(url);
+    if (provider === "Grok")
+        return "grok";
+    if (provider === "Codex")
+        return "codex";
+    return null;
+}
+/**
+ * True when the box probe already reports that brain as signed in. A device
+ * pairing file can outlive the sign-in it started, so the probe — not the
+ * leftover code — decides whether a human still has work to do.
+ */
+function brainAlreadySignedIn(status, url) {
+    const slot = signInBrainSlot(url);
+    if (!slot)
+        return false;
+    const brains = recordValue(recordValue(status.agent)?.brains);
+    return brains?.[slot] === "signed-in";
+}
 function currentDeviceSignInAction(status) {
     const pairing = recordValue(status.pairing);
     const url = safeActionUrl(pairing?.url);
     if (!url)
         return null;
+    if (brainAlreadySignedIn(status, url))
+        return null;
     const rawCode = nonEmptyString(pairing?.code);
     const code = rawCode && /^[A-Z0-9]{4,8}-[A-Z0-9]{4,8}$/i.test(rawCode)
         ? rawCode
@@ -1370,7 +1414,7 @@ export function registerAgentsCommand(program) {
             }
             const nameW = Math.max(4, ...roster.map((a) => (a.name ?? "").length));
             const slugW = Math.max(4, ...roster.map((a) => (a.slug ?? "").length));
-            const statusW = Math.max(6, ...roster.map((a) => (a.agentStatus ?? "").length));
+            const statusW = Math.max(6, ...roster.map((a) => rosterStatusLabel(a).length));
             const modelW = Math.max(5, ...roster.map((a) => (a.codexModel ?? "").length));
             console.log(chalk.bold([
                 "NAME".padEnd(nameW),
@@ -1383,7 +1427,7 @@ export function registerAgentsCommand(program) {
                 console.log([
                     (a.name ?? "").padEnd(nameW),
                     (a.slug ?? "").padEnd(slugW),
-                    (a.agentStatus ?? "").padEnd(statusW),
+                    rosterStatusLabel(a).padEnd(statusW),
                     (a.codexModel ?? "").padEnd(modelW),
                     a.uid,
                 ].join("  "));

package/dist/commands/bot.d.ts

@@ -27,6 +27,16 @@ export interface BotRow {
     lastHeartbeatOk: boolean | null;
     lastInboxPollAt: string | null;
     lastInboxPollOk: boolean | null;
+    /**
+     * The bot is mid-turn right now: it has taken a message and has not finished
+     * answering. Read from the bot's own in-flight marker on this machine, so it
+     * is true even while the model is still thinking and nothing has been posted
+     * yet. Surfaces are what show "thinking"; a progress post in the middle of a
+     * turn does not end it.
+     */
+    busy: boolean;
+    /** When the oldest turn still in flight started (ISO), else null. */
+    busySince: string | null;
     /** Present while the coding tool needs a new sign-in before the bot can work. */
     runtimeSignIn: RuntimeSignInIssue | null;
     daemonInstalled: boolean;

package/dist/commands/bot.js

@@ -1,5 +1,6 @@
 import { OwnerContextCache, lookupOwnerContext } from "../lib/bot/owner-context.js";
 import { hasActivePromotion } from "../lib/bot/promotion-receipt.js";
+import { readInflightTurns } from "../lib/bot/inflight.js";
 import { hasPromotionHold, promotionHoldSummary } from "../lib/bot/promotion-hold.js";
 /**
  * `hq bot` — personal local bots (local-bots US-003/US-004/US-005).
@@ -117,6 +118,8 @@ function rowFor(name, opts = {}) {
     const status = readBotStatus(dir);
     const pid = status?.pid ?? null;
     const processAlive = pid !== null && isPidAlive(pid) && status?.state === "running";
+    // Turns this bot has taken and not finished: what "thinking" means.
+    const inflightTurns = readInflightTurns(dir);
     let daemonInstalled = false;
     let daemonLoaded = false;
     if (opts.withDaemon !== false) {
@@ -147,6 +150,8 @@ function rowFor(name, opts = {}) {
         lastHeartbeatOk: status?.lastHeartbeatOk ?? null,
         lastInboxPollAt: status?.lastInboxPollAt ?? null,
         lastInboxPollOk: status?.lastInboxPollOk ?? null,
+        busy: processAlive && inflightTurns.length > 0,
+        busySince: processAlive ? (inflightTurns[0]?.startedAt ?? null) : null,
         runtimeSignIn: status?.runtimeSignIn ?? null,
         daemonInstalled,
         daemonLoaded,
@@ -723,6 +728,7 @@ async function runBotStatus(nameArg, opts) {
     else if (status?.lastInboxPollAt) {
         console.log(`  inbox:      last poll ${status.lastInboxPollAt}`);
     }
+    console.log(`  answering:  ${row.busy ? chalk.green(`yes${row.busySince ? `, since ${row.busySince}` : ""}`) : chalk.gray("no")}`);
     console.log(`  launchd:    ${row.daemonInstalled ? (row.daemonLoaded ? "installed, loaded" : "installed, not loaded") : "not installed"}`);
     console.log(`  creds:      ${creds ? `present for ${creds.entityUid}` : chalk.red("missing")}`);
     if (status) {

package/dist/commands/lanes.d.ts

@@ -0,0 +1,114 @@
+/**
+ * `hq lanes` — worker lane management and decision queue (spec §5–§7, §10–§11).
+ *
+ * Every command prints JSON on stdout and takes no interactive input, except
+ * `accounts login`, which hands the terminal to the vendor's own sign-in.
+ */
+import { Command } from "commander";
+import { type OutpostDispatchResult } from "../lib/lanes/outpost-dispatch.js";
+import { emitLaneDecisionEvents, type LaneMesh } from "../lib/lanes/mesh-events.js";
+import { type LaneCompanyRef, type LaneRecord, type QuestionRecord, type ResolvedLaneWorker, type SeniorRef, type LivenessDeps, type MachineIdentity, type RunCommand, type ThrottleDeps } from "../lib/lanes/index.js";
+import { questionBodyAbsPath } from "../lib/lanes/questions.js";
+import { type RunCompactionFn } from "../lib/lanes/compaction.js";
+import { spawnLaneWorker, type KillProcessFn, type ProveDetachedFn, type SpawnProcessFn } from "../lib/lanes/spawn.js";
+export { spawnLaneWorker };
+export { questionBodyAbsPath };
+export declare const MAX_LANE_DEPTH = 2;
+export declare const OUTPOST_ID_PATH = "/etc/outpost/outpost-id";
+export declare const OUTPOST_DIR = "/etc/outpost";
+export declare const LANES_RUNS_REL: string;
+export type OutpostIdentity = {
+    kind: "id";
+    id: string;
+} | {
+    kind: "unknown";
+} | {
+    kind: "not_outpost";
+};
+export interface SpawnLoginResult {
+    status: number;
+}
+/** The lane → mesh seam. Defined in lib/lanes/mesh-events.ts; the watcher shares it. */
+export type LanesMesh = LaneMesh;
+export { emitLaneDecisionEvents };
+export interface LanesCommandDeps {
+    hqRoot?: () => string;
+    /** Start HQ-root walk here instead of process.cwd(). Tests only. */
+    cwd?: () => string;
+    env?: NodeJS.ProcessEnv;
+    now?: () => Date;
+    hostname?: () => string;
+    resolveCompany?: (company?: string) => Promise<LaneCompanyRef>;
+    listOutpostIds?: () => Promise<string[]>;
+    readOutpostIdentity?: () => OutpostIdentity;
+    spawnLogin?: (opts: {
+        command: string;
+        args: string[];
+        env: NodeJS.ProcessEnv;
+        cwd?: string;
+    }) => Promise<SpawnLoginResult>;
+    throttleDeps?: ThrottleDeps;
+    existsSync?: (p: string) => boolean;
+    readFileSync?: (p: string, encoding: "utf8") => string;
+    homedir?: () => string;
+    mesh?: LanesMesh;
+    sleep?: (ms: number) => Promise<void>;
+    spawnProcess?: SpawnProcessFn;
+    proveDetached?: ProveDetachedFn;
+    killProcess?: KillProcessFn;
+    isAlive?: (pid: number) => boolean;
+    stopSleepMs?: (ms: number) => void;
+    livenessDeps?: LivenessDeps;
+    presenceConnected?: boolean;
+    systemdRoot?: string;
+    runSystemctl?: RunCommand;
+    resolveMachineIdentity?: () => MachineIdentity;
+    stageOutpostPayload?: (outpostId: string, bytes: Uint8Array) => Promise<{
+        getUrl: string;
+    }>;
+    dispatchOutpostExec?: (input: {
+        outpostId: string;
+        command: string;
+    }) => Promise<OutpostDispatchResult>;
+    fetchText?: (url: string) => Promise<string>;
+    runCompaction?: RunCompactionFn;
+    locateTranscript?: (home: string, sessionId: string) => string | null;
+}
+export declare function readOutpostIdentity(existsSync?: (p: string) => boolean, readFileSync?: (p: string) => string): OutpostIdentity;
+export declare function parseSeniorRef(raw: string): SeniorRef;
+export declare function resolveAnswerChoice(choice: string, options: string[], freeform: boolean): string;
+/**
+ * Spec §5.1: `hq lanes ask` from inside a lane can hit a binary or dist
+ * being replaced mid-call (ENOENT / ETXTBSY / a module that no longer
+ * resolves) or a record written by a newer CLI. Three attempts, waits of
+ * 5 s then 15 s, 20 s of backoff in total, inside the 30 s bound.
+ */
+export declare const ASK_BACKOFF_MS: readonly [5000, 15000];
+export declare const ASK_ATTEMPTS: number;
+export declare function casUpdateQuestion(hqRoot: string, questionId: string, updater: (current: QuestionRecord) => QuestionRecord): QuestionRecord;
+export declare function casUpdateLane(hqRoot: string, laneId: string, updater: (current: LaneRecord) => LaneRecord): LaneRecord;
+/**
+ * Spec §5.3: an approval gate ends the run. The lane stops at each
+ * checkpoint with a `decision: ask` envelope whose question names it; the
+ * reconcile pass resumes the lane once every question is answered.
+ */
+export declare function checkpointInstruction(worker: Pick<ResolvedLaneWorker, "approvalRequired" | "humanCheckpoints">): string;
+export declare function composeWorkerBrief(worker: ResolvedLaneWorker, taskBrief: string): string;
+/**
+ * A lane with no worker still carries the standing authorization paragraph
+ * and the foreground-only rule.
+ */
+export declare function composeGeneralBrief(taskBrief: string): string;
+export declare function parseMaxRuntimeSeconds(raw: unknown, workerId: string): number | undefined;
+export declare const PICKUP_TERMINAL_REASONS: readonly ["account_not_logged_in", "unknown_account", "account_disabled"];
+export declare const DISPATCH_TERMINAL_REASON: "outpost_dispatch_failed";
+export type PickupTerminalReason = (typeof PICKUP_TERMINAL_REASONS)[number];
+/**
+ * Outpost-side account bind (spec §5.2). Writes a named terminal reason,
+ * never a plain `failed`.
+ */
+export declare function applyOutpostAccountPickup(hqRoot: string, laneId: string): LaneRecord;
+export declare function cancelPendingQuestionsForLane(hqRoot: string, laneId: string, nowIso: string, operatorReason?: string): QuestionRecord[];
+export declare function stopCommittedState(state: LaneRecord["state"]): "cancelled" | "killed";
+export declare function registerLanesCommand(parent: Command, deps?: LanesCommandDeps): Command;
+//# sourceMappingURL=lanes.d.ts.map