@indigoai-us/hq-cli 5.345.156 → 5.345.160

package/dist/commands/lanes-resume.js

@@ -98,6 +98,8 @@ export function createLaneResumeHandlers(deps) {
         const hqRoot = ctx.hqRoot();
         const resolution = await deps.resolveCommandLane(ctx, laneId);
         let lane = resolution.lane;
+        // Use the resolved identity for every later exact-path write and audit.
+        laneId = lane.lane_id;
         if (opts.freshThread === true && lane.loop_mode !== true) {
             throw new LanesError("fresh_thread_loop_only", "--fresh-thread is reserved for loop-lane phases", { lane_id: laneId });
         }
@@ -333,9 +335,10 @@ export function createLaneResumeHandlers(deps) {
                     .map((reason) => reason.quota_reset_at)
                     .filter((value) => typeof value === "string" && Number.isFinite(Date.parse(value)))
                     .sort((a, b) => Date.parse(a) - Date.parse(b));
-                if (resets.length === 0)
+                const companyUnavailable = reasons.some((reason) => reason.reason === "company_mismatch");
+                if (resets.length === 0 && !companyUnavailable)
                     throw err;
-                quotaHoldDeferred = { quota_reset_at: resets[0], account_reasons: reasons };
+                quotaHoldDeferred = { ...(resets[0] !== undefined ? { quota_reset_at: resets[0] } : {}), account_reasons: reasons };
             }
         }
         const profileRefreshAccount = opts.account === undefined && refreshProfileSettings && resumeProfile !== undefined &&
@@ -555,12 +558,24 @@ export function createLaneResumeHandlers(deps) {
                     ...(opts.workingDirectory ? { working_directory: opts.workingDirectory } : {}),
                     at: quotaHoldAt,
                 };
-                resumed = markSpawnFailure(hqRoot, laneId, "account_quota_exhausted", {
-                    provider: lane.provider,
-                    account: lane.account ?? null,
-                    quota_reset_at: quotaHoldDeferred.quota_reset_at,
-                    account_reasons: quotaHoldDeferred.account_reasons,
-                }, { resumeTrigger: "resume", pendingResume, at: quotaHoldAt });
+                resumed = quotaHoldDeferred.quota_reset_at === undefined
+                    ? casUpdateLane(hqRoot, laneId, (current) => ({
+                        ...current,
+                        state: "queued",
+                        queued_reason: "account_retry",
+                        queued_details: undefined,
+                        queued_at: quotaHoldAt,
+                        admission_reserved_at: undefined,
+                        terminal_reason: undefined,
+                        terminal_details: undefined,
+                        pending_resume: pendingResume,
+                    }))
+                    : markSpawnFailure(hqRoot, laneId, "account_quota_exhausted", {
+                        provider: lane.provider,
+                        account: lane.account ?? null,
+                        quota_reset_at: quotaHoldDeferred.quota_reset_at,
+                        account_reasons: quotaHoldDeferred.account_reasons,
+                    }, { resumeTrigger: "resume", pendingResume, at: quotaHoldAt });
                 queuedOnQuotaHold = true;
             }
             else if (move?.queued) {
@@ -617,6 +632,7 @@ export function createLaneResumeHandlers(deps) {
                         }
                         const started = spawnLaneWorker(hqRoot, lane, {
                             env: ctx.env,
+                            readClaudeCredential: ctx.readClaudeCredential,
                             modelDeps: {
                                 readFileSync: ctx.readFileSync,
                                 probe: ctx.probeProvider,
@@ -624,6 +640,7 @@ export function createLaneResumeHandlers(deps) {
                             },
                             existsSync: ctx.existsSync,
                             spawnProcess: ctx.spawnProcess,
+                            statfs: ctx.statfs,
                             proveDetached: ctx.proveDetached,
                             killProcess: ctx.killProcess,
                             now: ctx.now,
@@ -647,8 +664,14 @@ export function createLaneResumeHandlers(deps) {
                             compact: opts.compact !== false,
                             effort: resumeEffort ?? recordedResumeEffort(lane),
                         });
-                        storySwitchWorkerStarted = true;
-                        deps.onLaneWorkerStarted?.(laneId, "resume");
+                        if (started.state === "running") {
+                            storySwitchWorkerStarted = true;
+                            deps.onLaneWorkerStarted?.(laneId, "resume");
+                        }
+                        else if (started.state === "queued") {
+                            // The spawn preflight can hold on disk even after admission passed.
+                            queuedOnAdmission = true;
+                        }
                         return started;
                     }, hireGrantContext);
                 }, ctx.sleep);
@@ -658,7 +681,7 @@ export function createLaneResumeHandlers(deps) {
                 : null;
             if (deliveryText !== undefined && messageId !== undefined) {
                 // Same audit copy a message resume leaves; nothing drains it. Archive only
-                // after a successful spawn so a concurrent resume cannot leave a phantom.
+                // after the launch starts or durably queues its resume instruction.
                 archiveResumeMessage(hqRoot, laneId, {
                     at,
                     message_id: messageId,
@@ -703,10 +726,10 @@ export function createLaneResumeHandlers(deps) {
                 delivery_status: move?.queued
                     ? "queued_on_target_account"
                     : queuedOnQuotaHold
-                        ? "queued_on_quota_hold"
+                        ? quotaHoldDeferred?.quota_reset_at === undefined ? "queued_on_account" : "queued_on_quota_hold"
                         : queuedOnAdmission
                             ? "queued_on_admission"
-                            : "worker_spawned",
+                            : next.state === "running" ? "worker_spawned" : "not_started",
                 account_move: move ? accountMoveSummary(move) : null,
                 resumed_session_id: resumed.last_resume?.session_id ?? null,
                 last_resume: next.last_resume ?? null,

package/dist/commands/lanes-shared.d.ts

@@ -1,8 +1,10 @@
+import type { StatFs } from "../lib/lanes/disk-guard.js";
 import type { LaneCompanyRef, LanePlacementPolicy, LaneRecord, LanesConfig, QuestionAnswer, QuestionBody, QuestionRecord, SeniorRef, AccountHistoryEntry, LaneAccountSelection, PendingResume, QueuedReason, ResolvedLaneWorker, LivenessDeps, MachineIdentity, MonitorEvidenceReader, ReconcileHost, RunCommand, ThrottleDeps, withLaneAdmissionLock, withLaneHireLocks } from "../lib/lanes/index.js";
 import type { OutpostIdentity } from "../lib/lanes/admission-host.js";
 import type { OutpostDispatchResult } from "../lib/lanes/outpost-dispatch.js";
 import type { CpuBusySource, MemoryHold } from "../lib/lanes/throttle.js";
 import type { ProbeCommand } from "../lib/lanes/models.js";
+import type { ClaudeCredentialReader } from "../lib/lanes/claude-credential.js";
 import type { FocusGuardReason } from "../lib/lanes/focus-guard.js";
 import type { KillProcessFn, ProveDetachedFn, SpawnProcessFn } from "../lib/lanes/spawn.js";
 import type { WatcherLoopDeps } from "../lib/lanes/watcher.js";
@@ -284,6 +286,7 @@ export interface Ctx {
     mesh: LanesMesh;
     sleep: (ms: number) => Promise<void>;
     spawnProcess?: SpawnProcessFn;
+    statfs?: StatFs;
     proveDetached?: ProveDetachedFn;
     killProcess?: KillProcessFn;
     isAlive?: (pid: number) => boolean;
@@ -296,6 +299,8 @@ export interface Ctx {
     runSystemctl?: RunCommand;
     /** Runs a provider CLI probe (`grok models`, `claude --help`) for --model validation. */
     probeProvider?: ProbeCommand;
+    /** Claude access-token expiry check for account status. Absent in tests that fake the probe. */
+    readClaudeCredential?: ClaudeCredentialReader;
     resolveMachineIdentity: () => MachineIdentity;
     runCompaction?: RunCompactionFn;
     locateTranscript?: (home: string, sessionId: string) => string | null;

package/dist/commands/lanes-shared.js

@@ -25,13 +25,23 @@ export function assertCurrentResumeAccountAvailable(ctx, lane) {
             ? `Lane ${lane.lane_id} records account ${JSON.stringify(lane.account)} which is not configured for ${lane.provider}`
             : `Account ${JSON.stringify(lane.account)} is disabled${account.disabled_reason ? `: ${account.disabled_reason}` : ""}`, { provider: lane.provider, account: lane.account ?? "", ...(account?.disabled_reason !== undefined ? { reason: account.disabled_reason } : {}) });
     }
-    if (accountStatus(lane.provider, lane.account, config, {
+    const status = accountStatus(lane.provider, lane.account, config, {
         existsSync: ctx.existsSync,
         hostname: ctx.hostname(),
         probe: ctx.probeProvider,
+        readClaudeCredential: ctx.readClaudeCredential,
         env: ctx.env,
-    }).logged_in !== true) {
-        throw new LanesError("account_not_logged_in", `Account ${lane.account} for ${lane.provider} is not logged in (no credential file)`, { provider: lane.provider, account: lane.account, lane_id: lane.lane_id });
+    });
+    if (status.logged_in !== true) {
+        const expired = status.sign_in_state === "expired";
+        throw new LanesError("account_not_logged_in", expired
+            ? `Account ${lane.account} for ${lane.provider} has an expired Claude sign-in; open Claude Code on this account and run /login`
+            : `Account ${lane.account} for ${lane.provider} is not logged in (no credential file)`, {
+            provider: lane.provider,
+            account: lane.account,
+            lane_id: lane.lane_id,
+            ...(expired ? { sign_in_state: "expired", sign_in_expires_at: status.sign_in_expires_at ?? null } : {}),
+        });
     }
 }
 export function accountMoveSummary(move) {

package/dist/commands/lanes-watch.js

@@ -80,6 +80,7 @@ export function createLaneWatchHandlers(deps) {
                             localStatusCache.set(key, accountStatus(lane.provider, lane.account, config, {
                                 existsSync: ctx.existsSync,
                                 probe: ctx.probeProvider,
+                                readClaudeCredential: ctx.readClaudeCredential,
                                 env: ctx.env,
                                 hostname: currentHostname,
                             }).logged_in);

package/dist/commands/lanes.d.ts

@@ -7,11 +7,12 @@
  */
 import { Command } from "commander";
 import type { MonitorLaneMessagePayload, MonitorLaneMessageResult } from "./lanes-message.js";
-import { type Ctx, type LanesMesh, type OutpostRouteIdentity, type SpawnLoginResult } from "./lanes-shared.js";
+import { type Ctx, type LanesMesh, type OutpostRouteIdentity, type ResolvedResumeProfile, type ResumeProfileRepinAuthorization, type SpawnLoginResult } from "./lanes-shared.js";
 export type { LanesMesh, SpawnLoginResult } from "./lanes-shared.js";
 export { CLAUDE_ACCOUNT_BALANCE_SIGNALS_FLAG, LANE_OUTPOST_LOAD_BALANCING_FLAG } from "./lanes-shared.js";
 export { resolveAnswerChoice } from "./lanes-questions.js";
 import { type FocusGuardPullRequest } from "../lib/lanes/focus-guard.js";
+import { type StatFs } from "../lib/lanes/disk-guard.js";
 import type { OutpostIdentity } from "../lib/lanes/admission-host.js";
 export { OUTPOST_DIR, OUTPOST_ID_PATH, readOutpostIdentity } from "../lib/lanes/admission-host.js";
 export type { OutpostIdentity } from "../lib/lanes/admission-host.js";
@@ -20,8 +21,10 @@ import { emitLaneDecisionEvents } from "../lib/lanes/mesh-events.js";
 import { MAX_LANE_DEPTH, withLaneAdmissionLock, withLaneHireLocks, type LaneCompanyRef, type QuestionBody, type LaneRecord, type QuestionRecord, type ResolvedLaneWorker, type SeniorRef, type LivenessDeps, type MachineIdentity, type MonitorEvidenceReader, 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 { type ResolvedEffort } from "../lib/lanes/effort.js";
 import type { WatcherLoopDeps } from "../lib/lanes/watcher.js";
 import { type KnownModelsDeps, type ProbeCommand } from "../lib/lanes/models.js";
+import { type ClaudeCredentialReader } from "../lib/lanes/claude-credential.js";
 import { spawnLaneWorker, type KillProcessFn, type ProveDetachedFn, type SpawnProcessFn } from "../lib/lanes/spawn.js";
 export { spawnLaneWorker };
 export declare function openPullRequestsForProject(hqRoot: string, metadata: Record<string, unknown>): FocusGuardPullRequest[];
@@ -67,6 +70,8 @@ export interface LanesCommandDeps {
     mesh?: LanesMesh;
     sleep?: (ms: number) => Promise<void>;
     spawnProcess?: SpawnProcessFn;
+    /** Inject the worker disk preflight without depending on host free space. */
+    statfs?: StatFs;
     proveDetached?: ProveDetachedFn;
     killProcess?: KillProcessFn;
     isAlive?: (pid: number) => boolean;
@@ -81,6 +86,11 @@ export interface LanesCommandDeps {
     runSystemctl?: RunCommand;
     /** Provider CLI probe for --model validation; tests inject a fake. */
     probeProvider?: ProbeCommand;
+    /**
+     * Claude access-token expiry check. Defaults to the real Keychain/file
+     * read when the real probe is used; a test that fakes the probe passes its own.
+     */
+    readClaudeCredential?: ClaudeCredentialReader;
     resolveMachineIdentity?: () => MachineIdentity;
     stageOutpostPayload?: (outpostId: string, bytes: Uint8Array) => Promise<{
         getUrl: string;
@@ -157,6 +167,15 @@ export declare function pickupFailureUpdater(reasonRaw: string, details: Record<
  */
 export declare function applyOutpostAccountPickup(hqRoot: string, laneId: string, modelDeps?: KnownModelsDeps): LaneRecord;
 export declare function cancelPendingQuestionsForLane(hqRoot: string, laneId: string, nowIso: string, operatorReason?: string): QuestionRecord[];
+/** @internal Exported for regression tests of the profile-refresh company check. */
+export declare function applyResumeProfileAndEffort(hqRoot: string, current: LaneRecord, next: LaneRecord, input: {
+    profile?: ResolvedResumeProfile;
+    profileRepin?: ResumeProfileRepinAuthorization;
+    effort?: ResolvedEffort;
+    keepAlive?: boolean;
+    at?: string;
+    refreshProfileSettings?: boolean;
+}): void;
 export declare function stopCommittedState(state: LaneRecord["state"]): "cancelled" | "killed";
 export declare function readLaneReapStopEnabled(hqRoot: string, lane: LaneRecord, env: NodeJS.ProcessEnv): Promise<boolean>;
 export declare function registerLanesCommand(parent: Command, deps?: LanesCommandDeps): Command;