@indigoai-us/hq-cli 5.275.0 → 5.277.0

package/dist/commands/lanes-accounts.js

@@ -130,6 +130,10 @@ export function createLaneAccountsHandlers(deps) {
             return {
                 ...status,
                 effective_home: status.home,
+                ...(status.auth_state === "home_missing" ? {
+                    error: "home_missing",
+                    fix_command: `hq lanes accounts set-home ${provider} ${status.id} <host-home>`,
+                } : {}),
                 model: accountCfg?.model ?? null,
                 effort: accountCfg?.effort ?? null,
                 effective_model: model ?? null,
@@ -165,6 +169,7 @@ export function createLaneAccountsHandlers(deps) {
         // Retain the established response field for clients; balancing is now
         // unconditional, so this compatibility value is always true.
         const balanceGateEnabled = true;
+        const recentUsageEnabled = await deps.readClaudeAccountBalanceSignalsEnabled(ctx);
         const loads = accountLoadsForReport({ hosts: loaded.snapshots, config });
         const suggestions = planClaudeBalanceMoves({ hosts: loaded.snapshots, config });
         const selections = loaded.snapshots.map((host) => {
@@ -173,6 +178,8 @@ export function createLaneAccountsHandlers(deps) {
                     hosts: loaded.snapshots,
                     targetHost: host.capacity.host,
                     config,
+                    recentUsageEnabled,
+                    now: ctx.now(),
                     unavailableHosts: loaded.unavailableHosts,
                 });
                 return {
@@ -192,11 +199,19 @@ export function createLaneAccountsHandlers(deps) {
         });
         const accounts = Object.keys(config.providers.claude.accounts).sort().map((account) => {
             const load = loads.find((row) => row.account === account);
+            const currentStatus = loaded.snapshots[0]?.capacity.providers.claude.accounts[account];
+            const currentHomeMissing = config.providers.claude.accounts[account]?.enabled === true &&
+                currentStatus?.auth_state === "home_missing";
             return {
                 account,
                 enabled: config.providers.claude.accounts[account]?.enabled === true,
                 live_lanes: load?.live_lanes ?? 0,
                 counts_complete: load?.counts_complete ?? false,
+                ...(load ? { recent_usage_at: load.recent_usage_at } : {}),
+                ...(currentHomeMissing ? {
+                    error: "home_missing",
+                    fix_command: `hq lanes accounts set-home claude ${account} <host-home>`,
+                } : {}),
                 hosts: loaded.snapshots.map((host) => {
                     const accountStatus = host.capacity.providers.claude.accounts[account];
                     const accountLoad = load?.hosts.find((row) => row.host.kind === host.capacity.host.kind && row.host.id === host.capacity.host.id);
@@ -204,6 +219,11 @@ export function createLaneAccountsHandlers(deps) {
                         host: host.capacity.host,
                         enabled: accountStatus?.enabled ?? false,
                         logged_in: accountStatus?.logged_in ?? null,
+                        ...(accountStatus?.auth_state !== undefined ? { auth_state: accountStatus.auth_state } : {}),
+                        ...(accountStatus?.auth_state === "home_missing" ? {
+                            error: "home_missing",
+                            fix_command: `hq lanes accounts set-home claude ${account} <host-home>`,
+                        } : {}),
                         live_lanes: accountLoad?.live_lanes ?? null,
                         lane_counts: accountLoad?.lane_counts ?? { running: null, queued: null, awaiting_input: null },
                         count_source: accountLoad?.count_source ?? "unavailable",
@@ -251,6 +271,10 @@ export function createLaneAccountsHandlers(deps) {
             suggestions,
             ...(opts.apply ? { moved, skipped } : {}),
         });
+        const currentHostMissing = Object.entries(config.providers.claude.accounts).some(([account, accountConfig]) => accountConfig.enabled &&
+            loaded.snapshots[0]?.capacity.providers.claude.accounts[account]?.auth_state === "home_missing");
+        if (currentHostMissing)
+            process.exitCode = 1;
     }
     async function runAccountsLogin(ctx, providerRaw, accountId, opts) {
         const callerCwd = ctx.callerCwd();
@@ -276,6 +300,12 @@ export function createLaneAccountsHandlers(deps) {
         if (opts.company !== undefined) {
             await resolveSelectedAccountHomeCompany(ctx, opts.company);
         }
+        if (process.platform === "linux" &&
+            requestedHome === undefined &&
+            registeredAccount !== undefined &&
+            effectiveAccountHome(registeredAccount, hostname).source !== "host") {
+            throw new LanesError("account_host_home_required", `Account ${id} for ${provider} has no home for this Linux host; pass --home <host-home> to store a host-specific home`, { provider, account: id, hostname });
+        }
         const homeRaw = requestedHome ??
             (registeredAccount !== undefined
                 ? effectiveAccountHome(registeredAccount, hostname).home
@@ -291,10 +321,22 @@ export function createLaneAccountsHandlers(deps) {
             existsSync: (p) => fs.existsSync(p),
         });
         const nextAccount = registeredAccount === undefined
-            ? { home, enabled: true }
+            ? process.platform === "linux"
+                ? {
+                    home: id === "a" ? DEFAULT_ACCOUNT_HOMES[provider] : `~/.${provider}-${id}`,
+                    hosts: { [hostname]: { home } },
+                    enabled: true,
+                }
+                : { home, enabled: true }
             : { ...registeredAccount, enabled: true };
         if (registeredAccount !== undefined && requestedHome !== undefined) {
-            if (home === registeredAccount.home) {
+            if (process.platform === "linux") {
+                nextAccount.hosts = {
+                    ...(registeredAccount.hosts ?? {}),
+                    [hostname]: { home },
+                };
+            }
+            else if (home === registeredAccount.home) {
                 if (nextAccount.hosts !== undefined) {
                     delete nextAccount.hosts[hostname];
                     if (Object.keys(nextAccount.hosts).length === 0)

package/dist/commands/lanes-message.js

@@ -9,7 +9,7 @@ import { dropboxInboxHasMessages, drainDropbox, formatDropboxMessages, formatMon
 import { isPidAlive, runWatcherLoop, WATCHER_OUT_MAX_BYTES, watcherOutLogPath, writeWatcherDecision } from "../lib/lanes/watcher.js";
 import { laneStories, laneStory, storyWarning } from "../lib/lanes/stories.js";
 import { laneRunDir, probePidRecord, readPidRecord, readProcStarttime, spawnLaneWorker } from "../lib/lanes/spawn.js";
-import { keepAliveExclusion, keepAliveSupersededBy, LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, loadRetiredLaneIds } from "../lib/lanes/keep-alive.js";
+import { keepAliveExclusion, keepAliveSupersededBy, LANE_RUNNING_SUPERSEDED_MESSAGE_DELIVERY_FLAG, LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, loadRetiredLaneIds } from "../lib/lanes/keep-alive.js";
 import { managerStatusGateEnabledForLane } from "../lib/lanes/manager-status-gate.js";
 import { readLanesRegistryFlag } from "../lib/lanes/registry-flag.js";
 import { resolveLaneCompany } from "../lib/lanes/lane-company.js";
@@ -90,20 +90,20 @@ export function createLaneMessageHandlers(deps) {
             company: companyForLane(lane),
             env: ctx.env,
         });
-        const currentLane = readLane(ctx.hqRoot(), lane.lane_id);
+        let currentLane = readLane(ctx.hqRoot(), lane.lane_id);
         if (currentLane.state === "killed" || currentLane.state === "cancelled") {
             return { lane: currentLane, exclusion: currentLane.state };
         }
         const localLanes = loadAllLanes(ctx.hqRoot());
         let lanes = localLanes;
-        const retiredLaneIds = loadRetiredLaneIds(ctx.hqRoot());
+        let retiredLaneIds = loadRetiredLaneIds(ctx.hqRoot());
         const dispatchedCallerId = grantContext?.superseded_message_caller_id;
         const dispatchedSessionId = grantContext?.superseded_message_session_id;
-        const dispatchedContextBound = grantContext !== undefined &&
+        let dispatchedContextBound = grantContext !== undefined &&
             ctx.isSsmOwnerDispatch() &&
             sameHireGrantSenior(grantContext.expected_senior, currentLane.senior);
-        const dispatchedSessionContext = dispatchedContextBound && currentLane.senior.kind === "session";
-        const dispatchedContextAuthorized = dispatchedContextBound && (dispatchedCallerId !== undefined ||
+        let dispatchedSessionContext = dispatchedContextBound && currentLane.senior.kind === "session";
+        let dispatchedContextAuthorized = dispatchedContextBound && (dispatchedCallerId !== undefined ||
             (dispatchedSessionId !== undefined && dispatchedSessionId === currentLane.senior.id));
         if (dispatchedContextBound && grantContext &&
             (dispatchedCallerId !== undefined || dispatchedSessionContext)) {
@@ -116,7 +116,61 @@ export function createLaneMessageHandlers(deps) {
             merged.set(currentLane.lane_id, currentLane);
             lanes = [...merged.values()];
         }
-        const exclusion = keepAliveExclusion(currentLane, lanes, retiredLaneIds, lineageAware, companyForLane);
+        let exclusion = keepAliveExclusion(currentLane, lanes, retiredLaneIds, lineageAware, companyForLane);
+        if (exclusion === "superseded" && currentLane.state !== "done" && currentLane.state !== "interrupted") {
+            const runningSupersededMessageDeliveryEnabled = await readLanesRegistryFlag(LANE_RUNNING_SUPERSEDED_MESSAGE_DELIVERY_FLAG, { company: companyForLane(currentLane), env: ctx.env });
+            if (runningSupersededMessageDeliveryEnabled) {
+                const latestLane = readLane(ctx.hqRoot(), currentLane.lane_id);
+                if (latestLane.state === "killed" || latestLane.state === "cancelled") {
+                    return { lane: latestLane, exclusion: latestLane.state };
+                }
+                const latestLocalLanes = loadAllLanes(ctx.hqRoot());
+                currentLane = latestLane;
+                let latestLanes = latestLocalLanes;
+                dispatchedContextBound =
+                    grantContext !== undefined &&
+                        ctx.isSsmOwnerDispatch() &&
+                        sameHireGrantSenior(grantContext.expected_senior, currentLane.senior);
+                dispatchedSessionContext = dispatchedContextBound && currentLane.senior.kind === "session";
+                dispatchedContextAuthorized = dispatchedContextBound && (dispatchedCallerId !== undefined ||
+                    (dispatchedSessionId !== undefined && dispatchedSessionId === currentLane.senior.id));
+                if (dispatchedContextBound && grantContext &&
+                    (dispatchedCallerId !== undefined || dispatchedSessionContext)) {
+                    const merged = new Map(latestLocalLanes.map((record) => [record.lane_id, record]));
+                    for (const snapshot of grantContext.hierarchy) {
+                        const contextLane = keepAliveLaneFromSnapshot(snapshot);
+                        if (contextLane)
+                            merged.set(contextLane.lane_id, contextLane);
+                    }
+                    merged.set(currentLane.lane_id, currentLane);
+                    latestLanes = [...merged.values()];
+                }
+                lanes = latestLanes;
+                retiredLaneIds = loadRetiredLaneIds(ctx.hqRoot());
+                exclusion = keepAliveExclusion(currentLane, lanes, retiredLaneIds, lineageAware, companyForLane);
+                if (exclusion === "superseded" && currentLane.state !== "done" && currentLane.state !== "interrupted") {
+                    const callerLaneId = dispatchedContextBound ? dispatchedCallerId : undefined;
+                    const callerSessionId = dispatchedContextBound
+                        ? (dispatchedSessionId === undefined ? null : dispatchedSessionId)
+                        : undefined;
+                    const callerMayMessage = callerMayMessageSupersededLane(ctx, currentLane, lanes, lineageAware, companyForLane, callerLaneId, callerSessionId);
+                    return {
+                        lane: currentLane,
+                        exclusion: undefined,
+                        ...(!dispatchedContextAuthorized && callerMayMessage && ctx.env.HQ_LANE_ID?.trim()
+                            ? { supersededMessageCallerId: ctx.env.HQ_LANE_ID.trim() }
+                            : {}),
+                        ...(callerMayMessage && !dispatchedContextBound && currentLane.senior.kind === "session" &&
+                            typeof currentLane.senior.id === "string" &&
+                            currentLane.senior.id.length > 0 &&
+                            callerMatchesSessionSenior(ctx, currentLane.senior.id)
+                            ? { supersededMessageSessionId: currentLane.senior.id }
+                            : {}),
+                        supersededMessageWarning: `A newer lead supersedes this ${currentLane.state} lane; message delivery is allowed while the lane remains active.`,
+                    };
+                }
+            }
+        }
         const callerLaneId = dispatchedContextBound ? dispatchedCallerId : undefined;
         const callerSessionId = dispatchedContextBound
             ? (dispatchedSessionId === undefined ? null : dispatchedSessionId)
@@ -552,11 +606,14 @@ export function createLaneMessageHandlers(deps) {
                     : mechanism === "dropbox"
                         ? "awaiting_next_tool_call"
                         : "worker_spawned";
-            const warning = mechanism === "dropbox" && drainHook !== null && !drainHook.registered
-                ? `The drain hook is not registered in ${drainHook.path}; the running worker will not receive this message. It stays in the inbox and is delivered on the lane's next start.`
-                : mechanism === "dropbox" && next.stalled === true
-                    ? `The worker has made no tool call since ${next.stalled_at ?? "an unknown time"} (${next.stalled_reason ?? "stalled"}); delivery waits on its next tool call.`
-                    : null;
+            const warning = [
+                eligibility.supersededMessageWarning,
+                mechanism === "dropbox" && drainHook !== null && !drainHook.registered
+                    ? `The drain hook is not registered in ${drainHook.path}; the running worker will not receive this message. It stays in the inbox and is delivered on the lane's next start.`
+                    : mechanism === "dropbox" && next.stalled === true
+                        ? `The worker has made no tool call since ${next.stalled_at ?? "an unknown time"} (${next.stalled_reason ?? "stalled"}); delivery waits on its next tool call.`
+                        : null,
+            ].filter((message) => message !== undefined && message !== null).join(" ") || null;
             if (!opts.silent)
                 printJson({
                     ok: true,

package/dist/commands/lanes-resume.js

@@ -223,6 +223,7 @@ export function createLaneResumeHandlers(deps) {
                 ...(resumeProfile !== undefined ? { workerProfile: resumeProfile } : {}),
                 ...(profileRepin !== undefined ? { profileRepin } : {}),
                 ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
+                ...(hireGrantContext !== undefined ? { grantContext: hireGrantContext } : {}),
                 pending: {
                     trigger: "resume",
                     resumed_from: resumedFrom,
@@ -252,6 +253,7 @@ export function createLaneResumeHandlers(deps) {
                     ...(resumeProfile !== undefined ? { workerProfile: resumeProfile } : {}),
                     ...(profileRepin !== undefined ? { profileRepin } : {}),
                     ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
+                    ...(hireGrantContext !== undefined ? { grantContext: hireGrantContext } : {}),
                     pending: {
                         trigger: "resume",
                         resumed_from: resumedFrom,

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

@@ -245,9 +245,11 @@ export interface Ctx {
     mergeReviewEnabled?: (company: LaneCompanyRef) => boolean | Promise<boolean>;
 }
 export declare const LANE_OUTPOST_LOAD_BALANCING_FLAG = "lanes.outpost-load-balancing";
+export declare const CLAUDE_ACCOUNT_BALANCE_SIGNALS_FLAG = "lanes.claude-account-balance-signals";
 export declare function defaultLanePlacementEnabled(company: LaneCompanyRef | undefined): Promise<boolean>;
 export declare function readLanePlacementEnabled(ctx: Ctx, company: LaneCompanyRef | undefined): Promise<boolean>;
 export declare function processLanePlacementCompany(ctx: Ctx): LaneCompanyRef | undefined;
+export declare function readClaudeAccountBalanceSignalsEnabled(ctx: Ctx, company?: LaneCompanyRef): Promise<boolean>;
 export declare function parsePlacementPolicy(raw: string): LanePlacementPolicy;
 export declare function assertPlacementEnabled(ctx: Ctx, company: LaneCompanyRef | undefined, readPlacementEnabled?: () => Promise<boolean>): Promise<void>;
 /** Match a direct session-senior caller while refusing lane-worker identities. */
@@ -349,6 +351,7 @@ export interface LaneAccountsHandlerDeps {
         to: string;
     }>;
     printJson(value: unknown): void;
+    readClaudeAccountBalanceSignalsEnabled(ctx: Ctx): Promise<boolean>;
     reconcileHostFromCtx(ctx: Ctx): ReconcileHost;
     resolveCallerPath(callerCwd: string, filePath: string): string;
 }

package/dist/commands/lanes-shared.js

@@ -72,9 +72,9 @@ export function resolveResumeEffort(ctx, lane, input) {
         ? undefined
         : providerConfig.accounts[accountId];
     const profileDefaultsApply = input.profile?.profile.meta.provider === lane.provider;
-    const pinnedModel = lane.model_source === undefined || lane.model_source === "cli" || lane.model_source === "preserved"
+    const pinnedModel = lane.pending_settings?.model ?? (lane.model_source === undefined || lane.model_source === "cli" || lane.model_source === "preserved"
         ? lane.model
-        : undefined;
+        : undefined);
     const model = resolveLaneModel({
         cliModel: input.model?.trim() || pinnedModel,
         profileModel: profileDefaultsApply ? input.profile?.profile.meta.model : undefined,
@@ -90,12 +90,16 @@ export function resolveResumeEffort(ctx, lane, input) {
     });
 }
 export function recordedResumeEffort(lane) {
+    if (lane.pending_settings?.effort !== undefined) {
+        return { effort: lane.pending_settings.effort, source: "cli" };
+    }
     return {
         ...(lane.effort !== undefined ? { effort: lane.effort } : {}),
         source: lane.effort_source ?? "none",
     };
 }
 export const LANE_OUTPOST_LOAD_BALANCING_FLAG = "lanes.outpost-load-balancing";
+export const CLAUDE_ACCOUNT_BALANCE_SIGNALS_FLAG = "lanes.claude-account-balance-signals";
 function lanePlacementFlagErrorCode(error) {
     if (error && typeof error === "object") {
         for (const key of ["code", "error", "name"]) {
@@ -135,6 +139,12 @@ export function processLanePlacementCompany(ctx) {
         return undefined;
     return { slug: context.companySlug, uid: context.companyUid ?? "" };
 }
+export function readClaudeAccountBalanceSignalsEnabled(ctx, company) {
+    return readLanesRegistryFlag(CLAUDE_ACCOUNT_BALANCE_SIGNALS_FLAG, {
+        company: company ?? processLanePlacementCompany(ctx),
+        env: ctx.env,
+    });
+}
 export function parsePlacementPolicy(raw) {
     const value = raw.trim();
     if (value === "local")

package/dist/commands/lanes.d.ts

@@ -8,7 +8,7 @@
 import { Command } from "commander";
 import { type LanesMesh, type SpawnLoginResult } from "./lanes-shared.js";
 export type { LanesMesh, SpawnLoginResult } from "./lanes-shared.js";
-export { LANE_OUTPOST_LOAD_BALANCING_FLAG } 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 { OutpostIdentity } from "../lib/lanes/admission-host.js";
 export { OUTPOST_DIR, OUTPOST_ID_PATH, readOutpostIdentity } from "../lib/lanes/admission-host.js";
@@ -139,5 +139,9 @@ 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[];
 export declare function stopCommittedState(state: LaneRecord["state"]): "cancelled" | "killed";
+/** Stderr notice that `stop` ends a lane for good, naming the resumable path. */
+export declare function stopTerminalWarning(laneId: string): string;
+/** Stderr notice when an interrupted lane has no session to resume from. */
+export declare function interruptNotResumableWarning(laneId: string): string;
 export declare function registerLanesCommand(parent: Command, deps?: LanesCommandDeps): Command;
 //# sourceMappingURL=lanes.d.ts.map