@indigoai-us/hq-cli 5.192.0 → 5.192.2

package/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 ## [Unreleased]
 
+## [5.192.2] — 2026-09-25
+
+### Fixed
+
+- Create, resume, automatic repair, and apply now read
+  `lanes.claude-account-balance` from hq-flags. `HQ_FLAG_*` remains the local
+  override, and a registry read failure keeps the gate off. The
+  `accounts balance --json` report includes `balance_gate_enabled`.
+- `hq lanes accounts balance --apply` now honors each lane's company-scoped
+  gate, skips disabled company lanes, and rechecks the gate before moving.
+
+## [5.192.1] — 2026-09-25
+
+### Fixed
+
+- `hq lanes questions answer` now resumes an asking lane as soon as its final
+  pending question is answered. When capacity or throttling prevents a start,
+  hq-cli queues the lane with an `answered_questions` resume and the answer
+  timestamp. It sends Outpost answers to the lane's owner and reports any
+  unanswered sibling questions or a named wake error. After the owner confirms
+  the answer, the primary's question copy is marked answered as well.
+
 ## [5.192.0] — 2026-09-25
 
 ### Added

package/dist/commands/lanes.d.ts

@@ -86,8 +86,8 @@ export interface LanesCommandDeps {
     isSsmOwnerDispatch?: () => boolean;
     /** Test seam for changing a lane between pre-lock and locked grant reads. */
     withGrantHireLocks?: typeof withLaneHireLocks;
-    /** Test seam for the default-off Claude account-balancing gate. */
-    laneClaudeAccountBalanceEnabled?: () => boolean;
+    /** Test seam for the Claude account-balancing gate. */
+    laneClaudeAccountBalanceEnabled?: (company?: LaneCompanyRef | null) => boolean | Promise<boolean>;
 }
 export declare const LANE_OUTPOST_LOAD_BALANCING_FLAG = "lanes.outpost-load-balancing";
 export declare function parseSeniorRef(raw: string): SeniorRef;

package/dist/commands/lanes.js

@@ -21,7 +21,7 @@ import { createOutpostHireGrantContext, parseOutpostHireGrantContext, sameHireGr
 import { OUTPOST_DIR, OUTPOST_ID_PATH, readOutpostIdentity, resolveAdmissionHost, } from "../lib/lanes/admission-host.js";
 export { OUTPOST_DIR, OUTPOST_ID_PATH, readOutpostIdentity } from "../lib/lanes/admission-host.js";
 export { LANE_HIRE_GRANTS_FLAG };
-import { buildOutpostCapacityCommand, buildOutpostBalanceMoveCommand, buildOutpostIdentityBackfillCommand, buildOutpostLaneCommand, buildOutpostMoveTargetCommand, buildOutpostPickupCommand, createOutpostsClient, dispatchErrorMessage, dispatchOutpostPickup, buildOutpostLaneListCommand, outpostRejectedEffortOption, parseOutpostPickupPayload, stageOutpostPayload, } from "../lib/lanes/outpost-dispatch.js";
+import { buildOutpostCapacityCommand, buildOutpostBalanceMoveCommand, buildOutpostIdentityBackfillCommand, buildOutpostLaneCommand, buildOutpostMoveTargetCommand, buildOutpostQuestionAnswerCommand, buildOutpostPickupCommand, createOutpostsClient, dispatchErrorMessage, dispatchOutpostPickup, buildOutpostLaneListCommand, outpostRejectedEffortOption, parseOutpostPickupPayload, stageOutpostPayload, } from "../lib/lanes/outpost-dispatch.js";
 import { buildHostCapacitySnapshot, chooseHostForLane, parseHostCapacitySnapshot, } from "../lib/lanes/host-capacity.js";
 import { BALANCE_MOVABLE_STATES, CLAUDE_ACCOUNT_BALANCE_FLAG, accountLoadsForReport, assertBalanceApplyEnabled, planClaudeBalanceMoves, selectClaudeAccount, } from "../lib/lanes/claude-account-balance.js";
 import { parseUserYaml } from "../utils/user-yaml-error.js";
@@ -30,7 +30,7 @@ import { vaultApiFetch } from "../utils/vault-api.js";
 import { openMeshTransport } from "../lib/mesh/client.js";
 import { createLaneMesh, emitLaneDecisionEvents, emitLaneTerminalStateEvent, laneMeshEventIdentity, } from "../lib/lanes/mesh-events.js";
 import { sessionIdFromEnv } from "../lib/mesh/live/session-identity.js";
-import { AccountResolutionError, compareLaneQueueOrder, coveredLaneIds, DEFAULT_ACCOUNT_HOMES, LANE_PROVIDERS, LANE_STATES, PROVIDER_HOME_ENV, QUESTION_STATUSES, SENIOR_KINDS, accountStatus, appendCappedHistory, canonicalizeHome, createLane, decideAdmission, defaultLivenessDeps, defaultSystemdUserDir, defaultThrottleDeps, installDrainHook, installReconcileTimer, providerPathEnv, probeDrainHookRegistration, isLanesError, isLaneVersionConflict, isTerminalLaneState, aliveDirectChildren, assignedChildHireGrants, LANE_HIRE_GRANTS_FLAG, planHireGrantBackfill, withHireGrantAdmission, laneStoryLedgerEnabled, validateProjectStories, buildLaneStatusSnapshot, formatLaneStatusHuman, listAccountStatuses, listLaneIds, listQuestionIds, listSessionLiveness, loadLanesConfig, laneRunsHere, MAX_LANE_DEPTH, MONITOR_ERROR_EXIT_CODE, MONITOR_ENGINES, MONITOR_MAX_TIMEOUT_MS, MONITOR_UNCOVERED_EXIT_CODE, MAX_WATCHED_LANES, monitorReminderText, readLiveMonitorEvidence, resolveMachineIdentity as lookupMachineIdentity, loadLivenessIndex, parseLaneProvider, parseLaneRecord, parseLaneState, parseLivenessState, parseQuestionStatus, parseSeniorKind, readDaemonPresenceConnected, readLane, retryUpdateLane, syncLaneRecordFromOwner, readQuestion, resolveAccount, resolveLaneWorker, ignoredWorkerProfileFields, loadWorkerProfile, runReconcilePass, runLaneWatch, sessionLiveness, tryReadLane, uninstallReconcileTimer, updateLane, updateQuestion, writeLanesConfig, appendDropboxMessage, answerDropboxMessage, deliveryRefusalReason, resumeCommandRefusal, dropboxDir, dropboxInboxPath, laneAcceptsDropboxDelivery, laneAcceptsOperatorMessage, laneDeliveryMechanism, hasActiveAdmissionReservation, hasActivePendingResume, hasRecordedSessionId, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, providerSupportsSessionResume, withLaneAdmissionLock, withLaneHireLocks, laneIdForAnswerDelivery, operatorMessageRefusalReason, raiseLaneQuestion, sha256Text, writeQuestionBody, } from "../lib/lanes/index.js";
+import { AccountResolutionError, compareLaneQueueOrder, coveredLaneIds, DEFAULT_ACCOUNT_HOMES, LANE_PROVIDERS, LANE_STATES, PROVIDER_HOME_ENV, QUESTION_STATUSES, SENIOR_KINDS, accountStatus, appendCappedHistory, canonicalizeHome, createLane, decideAdmission, defaultLivenessDeps, defaultSystemdUserDir, defaultThrottleDeps, installDrainHook, installReconcileTimer, providerPathEnv, probeDrainHookRegistration, isLanesError, isLaneVersionConflict, isTerminalLaneState, aliveDirectChildren, assignedChildHireGrants, LANE_HIRE_GRANTS_FLAG, planHireGrantBackfill, withHireGrantAdmission, laneStoryLedgerEnabled, validateProjectStories, buildLaneStatusSnapshot, formatLaneStatusHuman, listAccountStatuses, listLaneIds, listQuestionIds, listSessionLiveness, loadLanesConfig, laneRunsHere, MAX_LANE_DEPTH, MONITOR_ERROR_EXIT_CODE, MONITOR_ENGINES, MONITOR_MAX_TIMEOUT_MS, MONITOR_UNCOVERED_EXIT_CODE, MAX_WATCHED_LANES, monitorReminderText, readLiveMonitorEvidence, resolveMachineIdentity as lookupMachineIdentity, loadLivenessIndex, parseLaneProvider, parseLaneRecord, parseLaneState, parseLivenessState, parseQuestionRecord, parseQuestionStatus, parseSeniorKind, readDaemonPresenceConnected, readLane, retryUpdateLane, syncLaneRecordFromOwner, readQuestion, resolveAccount, resolveLaneWorker, ignoredWorkerProfileFields, loadWorkerProfile, runReconcilePass, wakeAnsweredLaneNow, runLaneWatch, sessionLiveness, tryReadLane, uninstallReconcileTimer, updateLane, updateQuestion, writeLanesConfig, appendDropboxMessage, answerDropboxMessage, deliveryRefusalReason, resumeCommandRefusal, dropboxDir, dropboxInboxPath, laneAcceptsDropboxDelivery, laneAcceptsOperatorMessage, laneDeliveryMechanism, hasActiveAdmissionReservation, hasActivePendingResume, hasRecordedSessionId, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, providerSupportsSessionResume, withLaneAdmissionLock, withLaneHireLocks, laneIdForAnswerDelivery, operatorMessageRefusalReason, raiseLaneQuestion, sha256Text, writeQuestionBody, } from "../lib/lanes/index.js";
 import { activeLaneStories, laneStories, laneStory, storyWarning, } from "../lib/lanes/stories.js";
 import { questionBodyAbsPath } from "../lib/lanes/questions.js";
 import { compactionAfterUsage, } from "../lib/lanes/compaction.js";
@@ -57,8 +57,10 @@ export const LANE_OUTPOST_LOAD_BALANCING_FLAG = "lanes.outpost-load-balancing";
 function defaultLanePlacementEnabled() {
     return resolveProcessFlagGate(LANE_OUTPOST_LOAD_BALANCING_FLAG, { fallback: false }, () => false);
 }
-function defaultLaneClaudeAccountBalanceEnabled() {
-    return resolveProcessFlagGate(CLAUDE_ACCOUNT_BALANCE_FLAG, { fallback: false }, () => false);
+function defaultLaneClaudeAccountBalanceEnabled(company) {
+    // Keep the local HQ_FLAG override and the registry reader's fail-closed
+    // behavior, matching the lane hire-grants gate.
+    return readLanesRegistryFlag(CLAUDE_ACCOUNT_BALANCE_FLAG, { company });
 }
 function defaultLaneHireGrantsEnabled(company) {
     return readLanesRegistryFlag(LANE_HIRE_GRANTS_FLAG, { company });
@@ -2516,7 +2518,7 @@ async function runCreate(ctx, opts) {
     }
     const allowedAccounts = validatedAccounts.size > 0 ? [...validatedAccounts] : profileAccounts;
     let accountSelection;
-    if (provider === "claude" && ctx.laneClaudeAccountBalanceEnabled()) {
+    if (provider === "claude" && await ctx.laneClaudeAccountBalanceEnabled(company)) {
         const targetHost = placementHostOverride ?? (outpostId !== undefined
             ? { kind: "outpost", id: outpostId }
             : laneHostFromCtx(ctx));
@@ -3208,6 +3210,139 @@ async function dispatchOutpostLaneCommand(ctx, lane, action, options) {
         outpost_transport: "outposts_exec",
     });
 }
+async function dispatchOutpostQuestionAnswer(ctx, lane, questionId, options) {
+    if (lane.host.kind !== "outpost") {
+        throw new LanesError("outpost_dispatch_failed", `Lane ${lane.lane_id} has no Outpost host to answer its question`, { lane_id: lane.lane_id, question_id: questionId });
+    }
+    const outpostId = lane.host.id;
+    let dispatched;
+    try {
+        dispatched = await ctx.dispatchOutpostExec({
+            outpostId,
+            command: buildOutpostQuestionAnswerCommand({
+                questionId,
+                choice: options.choice,
+                freeform: options.freeform,
+                notes: options.notes,
+            }),
+        });
+    }
+    catch (err) {
+        throw new LanesError("outpost_dispatch_failed", `Could not dispatch question ${questionId} to Outpost ${outpostId}: ${dispatchErrorMessage(err)}`, { lane_id: lane.lane_id, question_id: questionId, outpost_id: outpostId });
+    }
+    if (dispatched.done !== true || dispatched.status !== "Success" || dispatched.exitCode !== 0) {
+        throw new LanesError("outpost_dispatch_failed", `Outpost ${outpostId} did not confirm the answer for question ${questionId}`, {
+            lane_id: lane.lane_id,
+            question_id: questionId,
+            outpost_id: outpostId,
+            command_id: dispatched.commandId,
+            status: dispatched.status,
+            done: dispatched.done ?? false,
+            exit_code: dispatched.exitCode,
+        });
+    }
+    const remote = parseRemoteJson(dispatched.stdout, "Outpost question answer");
+    if (remote?.error !== undefined) {
+        throw new LanesError("outpost_remote_command_failed", typeof remote.message === "string"
+            ? remote.message
+            : `Outpost ${outpostId} rejected the answer for question ${questionId}`, {
+            lane_id: lane.lane_id,
+            question_id: questionId,
+            outpost_id: outpostId,
+            command_id: dispatched.commandId,
+            remote_error: remote.error,
+        });
+    }
+    const remoteQuestion = remote?.question !== null && typeof remote?.question === "object"
+        ? remote.question
+        : null;
+    const awaitingWakeConfirmed = lane.state !== "awaiting_input" ||
+        (remote?.wake_status === "resumed" && remote.lane_state === "running") ||
+        (remote?.wake_status === "queued" && remote.lane_state === "queued") ||
+        (remote?.wake_status === "awaiting_answers" && remote.lane_state === "awaiting_input");
+    if (remote?.ok !== true ||
+        remote.action !== "questions.answer" ||
+        remoteQuestion?.question_id !== questionId ||
+        remoteQuestion.lane_id !== lane.lane_id ||
+        remoteQuestion.status !== "answered" ||
+        typeof remote.delivery !== "string" ||
+        !awaitingWakeConfirmed) {
+        throw new LanesError("outpost_delivery_unconfirmed", `Outpost ${outpostId} completed exec without confirming the answer and wake status for question ${questionId}`, {
+            lane_id: lane.lane_id,
+            question_id: questionId,
+            outpost_id: outpostId,
+            command_id: dispatched.commandId,
+        });
+    }
+    let ownerQuestion;
+    try {
+        ownerQuestion = parseQuestionRecord(remoteQuestion);
+    }
+    catch (err) {
+        throw new LanesError("outpost_delivery_unconfirmed", `Outpost ${outpostId} did not return a valid answered question record for ${questionId}: ${dispatchErrorMessage(err)}`, {
+            lane_id: lane.lane_id,
+            question_id: questionId,
+            outpost_id: outpostId,
+            command_id: dispatched.commandId,
+        });
+    }
+    const ownerAnswer = ownerQuestion.answer;
+    if (!isQuestionAnswer(ownerAnswer)) {
+        throw new LanesError("outpost_delivery_unconfirmed", `Outpost ${outpostId} did not return the confirmed answer for question ${questionId}`, {
+            lane_id: lane.lane_id,
+            question_id: questionId,
+            outpost_id: outpostId,
+            command_id: dispatched.commandId,
+        });
+    }
+    const syncedQuestion = casUpdateQuestion(ctx.hqRoot(), questionId, (current) => {
+        if (current.lane_id !== lane.lane_id) {
+            throw new LanesError("outpost_question_sync_conflict", `Primary question ${questionId} belongs to a different lane than Outpost ${outpostId} confirmed`, { lane_id: lane.lane_id, question_id: questionId, outpost_id: outpostId });
+        }
+        if (current.status === "pending") {
+            return { ...current, status: "answered", answer: ownerAnswer };
+        }
+        if (current.status === "answered" && sameQuestionAnswer(current.answer, ownerAnswer)) {
+            return current;
+        }
+        throw new LanesError("outpost_question_sync_conflict", `Primary question ${questionId} is ${current.status} or has a different answer than Outpost ${outpostId} confirmed`, { lane_id: lane.lane_id, question_id: questionId, outpost_id: outpostId });
+    });
+    printJson({
+        ...remote,
+        lane_id: lane.lane_id,
+        question: syncedQuestion,
+        outpost_id: outpostId,
+        outpost_command_id: dispatched.commandId,
+        outpost_transport: "outposts_exec",
+    });
+}
+function isQuestionAnswer(value) {
+    if (value === null || typeof value !== "object")
+        return false;
+    const answer = value;
+    return (typeof answer.choice === "string" &&
+        answer.choice.trim() !== "" &&
+        (answer.answer_kind === undefined ||
+            answer.answer_kind === "option" ||
+            answer.answer_kind === "freeform") &&
+        (answer.notes_ref === undefined || typeof answer.notes_ref === "string") &&
+        typeof answer.answered_by === "string" &&
+        answer.answered_by.trim() !== "" &&
+        typeof answer.answered_at === "string" &&
+        Number.isFinite(Date.parse(answer.answered_at)) &&
+        typeof answer.answered_level === "number" &&
+        Number.isInteger(answer.answered_level) &&
+        answer.answered_level > 0);
+}
+function sameQuestionAnswer(left, right) {
+    return (left !== undefined &&
+        left.choice === right.choice &&
+        left.answer_kind === right.answer_kind &&
+        left.notes_ref === right.notes_ref &&
+        left.answered_by === right.answered_by &&
+        left.answered_at === right.answered_at &&
+        left.answered_level === right.answered_level);
+}
 function ingestPickupPayload(hqRoot, payload, now) {
     const laneId = payload.lane.lane_id;
     if (!laneId) {
@@ -4708,7 +4843,7 @@ async function prepareAccountMove(ctx, lane, input) {
 async function selectAutomaticClaudeResumeAccount(ctx, lane) {
     if (lane.provider !== "claude")
         return undefined;
-    if (!ctx.laneClaudeAccountBalanceEnabled()) {
+    if (!await ctx.laneClaudeAccountBalanceEnabled(lane.company)) {
         if (lane.account === undefined)
             return undefined;
         const config = loadLanesConfig(ctx.hqRoot());
@@ -5112,6 +5247,7 @@ async function applyClaudeBalanceMove(ctx, suggestion) {
         return { lane_id: suggestion.lane_id, host: suggestion.host, from: suggestion.from, to: suggestion.to, state: suggestion.state };
     }
     const lane = laneWithRecoveredProviderSession(ctx.hqRoot(), readLane(ctx.hqRoot(), suggestion.lane_id));
+    assertBalanceApplyEnabled(await ctx.laneClaudeAccountBalanceEnabled(lane.company));
     if (lane.state === "running") {
         throw new LanesError("lane_running", `Lane ${lane.lane_id} is running; balance never moves a running turn`, {
             lane_id: lane.lane_id,
@@ -5140,8 +5276,8 @@ async function applyClaudeBalanceMove(ctx, suggestion) {
     return { lane_id: moved.lane.lane_id, host: moved.lane.host, from: moved.from ?? suggestion.from, to: moved.to, state: moved.lane.state };
 }
 async function runClaudeBalanceMoveTarget(ctx, laneId, opts) {
-    assertBalanceApplyEnabled(ctx.laneClaudeAccountBalanceEnabled());
     const lane = laneWithRecoveredProviderSession(ctx.hqRoot(), readLane(ctx.hqRoot(), laneId));
+    assertBalanceApplyEnabled(await ctx.laneClaudeAccountBalanceEnabled(lane.company));
     assertLaneRunsHereForOperatorMutation(ctx, lane, "balance-move-target");
     if (lane.provider !== "claude") {
         throw new LanesError("claude_account_balance_provider_mismatch", `Lane ${laneId} does not use Claude`, {
@@ -6464,9 +6600,16 @@ async function runQuestionsShow(ctx, questionId) {
 async function runQuestionsAnswer(ctx, questionId, opts) {
     const hqRoot = ctx.hqRoot();
     const question = readQuestion(hqRoot, questionId);
-    throwIfQuestionNotPending(question);
     await yieldEventLoop();
     const askingLane = readLane(hqRoot, laneIdForAnswerDelivery(question));
+    if (askingLane.host.kind === "outpost" && !laneIsHostedHere(ctx, askingLane)) {
+        await dispatchOutpostQuestionAnswer(ctx, askingLane, questionId, opts);
+        return;
+    }
+    throwIfQuestionNotPending(question);
+    if (askingLane.state === "awaiting_input") {
+        assertLaneRunsHereForOperatorMutation(ctx, askingLane, "wake after answering");
+    }
     if (laneAcceptsDropboxDelivery(askingLane)) {
         assertLaneRunsHereForOperatorMutation(ctx, askingLane, "deliver an answer to");
     }
@@ -6511,6 +6654,53 @@ async function runQuestionsAnswer(ctx, questionId, opts) {
             },
         };
     });
+    const latestAskingLane = readLane(hqRoot, askingLane.lane_id);
+    if (latestAskingLane.state === "awaiting_input") {
+        let wake;
+        try {
+            wake = await wakeAnsweredLaneNow(hqRoot, askingLane.lane_id, {
+                now: ctx.now,
+                host: reconcileHostFromCtx(ctx),
+                dryRun: false,
+                spawnLaneDeps: {
+                    env: ctx.env,
+                    existsSync: ctx.existsSync,
+                    spawnProcess: ctx.spawnProcess,
+                    proveDetached: ctx.proveDetached,
+                    killProcess: ctx.killProcess,
+                    now: ctx.now,
+                    resolveMachineIdentity: ctx.resolveMachineIdentity,
+                    runCompaction: ctx.runCompaction,
+                    locateTranscript: ctx.locateTranscript,
+                },
+                throttleDeps: ctx.throttleDeps,
+                livenessDeps: livenessDepsFromCtx(ctx),
+                presenceConnected: ctx.presenceConnected,
+                mesh: ctx.mesh,
+                env: ctx.env,
+            });
+        }
+        catch (err) {
+            throw new LanesError("question_wake_failed", `Question ${questionId} was recorded, but lane ${askingLane.lane_id} could not be woken: ${dispatchErrorMessage(err)}`, { lane_id: askingLane.lane_id, question_id: questionId });
+        }
+        if (wake.status === "failed") {
+            throw new LanesError("question_wake_failed", `Question ${questionId} was recorded, but lane ${askingLane.lane_id} could not be woken: ${wake.error}`, { lane_id: askingLane.lane_id, question_id: questionId, wake_error: wake.error });
+        }
+        printJson({
+            ok: true,
+            action: "questions.answer",
+            lane_id: askingLane.lane_id,
+            question: updated,
+            delivery: wake.status === "awaiting_answers" ? "awaiting_other_answers" : wake.status,
+            wake_status: wake.status,
+            lane_state: wake.lane_state,
+            ...(wake.queued_reason !== undefined ? { queued_reason: wake.queued_reason } : {}),
+            ...(wake.remaining_question_ids !== undefined
+                ? { remaining_question_ids: wake.remaining_question_ids }
+                : {}),
+        });
+        return;
+    }
     const delivery = deliverAnswerToAskingLane(ctx, updated, choice, at);
     printJson({
         ok: true,
@@ -6686,11 +6876,30 @@ async function runAccountsBalance(ctx, opts) {
             accepted: ["claude"],
         });
     }
-    if (opts.apply)
-        assertBalanceApplyEnabled(ctx.laneClaudeAccountBalanceEnabled());
     const hqRoot = ctx.hqRoot();
     const config = loadLanesConfig(hqRoot);
     const loaded = await loadClaudeBalanceHostSnapshots(ctx, hqRoot, config);
+    const laneBalanceGateEnabled = new Map();
+    const companyBalanceGateEnabled = new Map();
+    const lanes = loaded.snapshots.flatMap((host) => host.lanes);
+    for (const lane of lanes) {
+        const companyKey = JSON.stringify([lane.company?.uid ?? null, lane.company?.slug ?? null]);
+        let enabled = companyBalanceGateEnabled.get(companyKey);
+        if (enabled === undefined) {
+            enabled = await ctx.laneClaudeAccountBalanceEnabled(lane.company);
+            companyBalanceGateEnabled.set(companyKey, enabled);
+        }
+        laneBalanceGateEnabled.set(lane.lane_id, enabled);
+    }
+    // With no lanes there is no tenant scope to resolve, so report and enforce
+    // the unscoped/default gate. Otherwise the report reflects whether any
+    // represented lane company has the gate enabled.
+    if (lanes.length === 0) {
+        companyBalanceGateEnabled.set(JSON.stringify([null, null]), await ctx.laneClaudeAccountBalanceEnabled());
+    }
+    const balanceGateEnabled = [...companyBalanceGateEnabled.values()].some(Boolean);
+    if (opts.apply)
+        assertBalanceApplyEnabled(balanceGateEnabled);
     const loads = accountLoadsForReport({ hosts: loaded.snapshots, config });
     const suggestions = planClaudeBalanceMoves({ hosts: loaded.snapshots, config });
     const selections = loaded.snapshots.map((host) => {
@@ -6752,6 +6961,16 @@ async function runAccountsBalance(ctx, opts) {
                 });
                 continue;
             }
+            if (laneBalanceGateEnabled.get(suggestion.lane_id) !== true) {
+                skipped.push({
+                    lane_id: suggestion.lane_id,
+                    host: suggestion.host,
+                    from: suggestion.from,
+                    to: suggestion.to,
+                    reason: "claude_account_balance_disabled",
+                });
+                continue;
+            }
             try {
                 moved.push(await applyClaudeBalanceMove(ctx, suggestion));
             }
@@ -6770,6 +6989,7 @@ async function runAccountsBalance(ctx, opts) {
         ok: true,
         action: "accounts.balance",
         provider: "claude",
+        balance_gate_enabled: balanceGateEnabled,
         accounts,
         selections,
         unavailable_hosts: loaded.unavailableHosts,

package/dist/lib/lanes/admission.js

@@ -135,6 +135,8 @@ export function hasActivePendingResume(lane, nowMs) {
     const pending = lane.pending_resume;
     if (!pending)
         return false;
+    if (lane.state === "queued" && pending.trigger === "answered_questions")
+        return false;
     const reservedAt = Date.parse(pending.at);
     const ageMs = nowMs - reservedAt;
     return Number.isFinite(reservedAt) && ageMs >= 0 && ageMs < ADMISSION_RESERVATION_GRACE_MS;

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

@@ -42,8 +42,8 @@ export { AUTH_JSON_NAME, CLAUDE_CREDENTIALS_NAME, PROVIDER_CREDENTIAL_FILES, PRO
 export type { AccountResolveContext, AccountStatus, AuthState, ResolvedAccount, } from "./accounts.js";
 export { LIVE_WITHIN_MS, LIVENESS_EVENT_KINDS, SILENT_LOST_MS, TURN_START_LOST_MS, buildLivenessIndexFromSpool, classifySessionLiveness, defaultLivenessDeps, defaultSpoolPath, ingestSpoolLine, listSessionLiveness, livenessIndexPath, loadLivenessIndex, readDaemonPresenceConnected, readLivenessIndex, rebuildLivenessIndex, sessionLiveness, } from "./liveness.js";
 export type { LivenessDeps, LivenessEventKind, LivenessIndex, SessionIndexEntry, } from "./liveness.js";
-export { DEAD_HOST_MS, MAX_AGED_ADVANCES, QUESTION_AGE_MS, RECONCILE_TIMER_NAME, RECONCILE_UNIT_NAME, agedAdvanceCount, currentHopStartedAtMs, isDeadlinePassed, laneRunsHere, readTimeoutDeadline, reconcileHeartbeatPath, resolveQuestionAudience, runReconcilePass, shouldAdvanceAudienceEnded, shouldAgeQuestion, timeoutPath, } from "./reconcile.js";
-export type { ReconcileChange, ReconcileDeps, ReconcileHost, ReconcileSkip, ReconcileSummary, } from "./reconcile.js";
+export { DEAD_HOST_MS, MAX_AGED_ADVANCES, QUESTION_AGE_MS, RECONCILE_TIMER_NAME, RECONCILE_UNIT_NAME, wakeAnsweredLaneNow, agedAdvanceCount, currentHopStartedAtMs, isDeadlinePassed, laneRunsHere, readTimeoutDeadline, reconcileHeartbeatPath, resolveQuestionAudience, runReconcilePass, shouldAdvanceAudienceEnded, shouldAgeQuestion, timeoutPath, } from "./reconcile.js";
+export type { AnsweredLaneWakeResult, ReconcileChange, ReconcileDeps, ReconcileHost, ReconcileSkip, ReconcileSummary, } from "./reconcile.js";
 export { RECONCILE_TIMER_INTERVAL, defaultSystemdUserDir, installReconcileTimer, providerPathEnv, renderReconcileService, renderReconcileTimer, uninstallReconcileTimer, } from "./reconcile-install.js";
 export type { ProviderPathEnv, ReconcileInstallOpts, ReconcileInstallResult, RunCommand, RunCommandResult, } from "./reconcile-install.js";
 export { unitPathEnv } from "./reconcile-install.js";

package/dist/lib/lanes/index.js

@@ -23,7 +23,7 @@ export { LANE_MESH_EVENTS, WIRE_EVENT_KINDS, createLaneMesh, emitLaneDecisionEve
 export { CPU_SAMPLE_MS, LANES_CPU_BUSY_OVERRIDE, LANES_CPU_CHECK, PROC_MEMINFO, STARVATION_MAX_DEFERRALS, STARVATION_MAX_MS, applyThrottleDecision, busyFractionFromDeltas, cpuTimesSnapshot, decideAdmission, defaultThrottleDeps, emptyThrottleState, evaluateThrottle, isCpuCheckEnabled, parseMemAvailableKb, readAvailableMemMb, readThrottleState, resolveCpuBusyFraction, sampleCpuBusyFraction, starvationBoundReached, throttleStatePath, writeThrottleState, } from "./throttle.js";
 export { AUTH_JSON_NAME, CLAUDE_CREDENTIALS_NAME, PROVIDER_CREDENTIAL_FILES, PROVIDER_HOME_ENV, accountEnv, accountStatus, authJsonPath, authStateFor, credentialPaths, hasCredentialFile, isCredentialProven, isLoggedOut, isOccupyingLaneState, lastStartedAt, listAccountStatuses, occupyingLaneCount, resolveAccount, runningLaneCount, selectBalancedAccount, } from "./accounts.js";
 export { LIVE_WITHIN_MS, LIVENESS_EVENT_KINDS, SILENT_LOST_MS, TURN_START_LOST_MS, buildLivenessIndexFromSpool, classifySessionLiveness, defaultLivenessDeps, defaultSpoolPath, ingestSpoolLine, listSessionLiveness, livenessIndexPath, loadLivenessIndex, readDaemonPresenceConnected, readLivenessIndex, rebuildLivenessIndex, sessionLiveness, } from "./liveness.js";
-export { DEAD_HOST_MS, MAX_AGED_ADVANCES, QUESTION_AGE_MS, RECONCILE_TIMER_NAME, RECONCILE_UNIT_NAME, agedAdvanceCount, currentHopStartedAtMs, isDeadlinePassed, laneRunsHere, readTimeoutDeadline, reconcileHeartbeatPath, resolveQuestionAudience, runReconcilePass, shouldAdvanceAudienceEnded, shouldAgeQuestion, timeoutPath, } from "./reconcile.js";
+export { DEAD_HOST_MS, MAX_AGED_ADVANCES, QUESTION_AGE_MS, RECONCILE_TIMER_NAME, RECONCILE_UNIT_NAME, wakeAnsweredLaneNow, agedAdvanceCount, currentHopStartedAtMs, isDeadlinePassed, laneRunsHere, readTimeoutDeadline, reconcileHeartbeatPath, resolveQuestionAudience, runReconcilePass, shouldAdvanceAudienceEnded, shouldAgeQuestion, timeoutPath, } from "./reconcile.js";
 export { RECONCILE_TIMER_INTERVAL, defaultSystemdUserDir, installReconcileTimer, providerPathEnv, renderReconcileService, renderReconcileTimer, uninstallReconcileTimer, } from "./reconcile-install.js";
 export { unitPathEnv } from "./reconcile-install.js";
 export { PROVIDER_REJECTED_REASON, PROVIDER_REJECTION_MESSAGE_CAP, parseClaudeResultRejection, parseCodexTurnFailed, parseGrokErrorOutput, parseProviderRejection, readProviderRejection, retryableFromStatus, } from "./provider-rejection.js";

package/dist/lib/lanes/outpost-dispatch.d.ts

@@ -41,6 +41,13 @@ export interface OutpostLaneCommand {
     grantContext?: string;
     compact?: boolean;
 }
+export declare function buildOutpostQuestionAnswerCommand(input: {
+    questionId: string;
+    choice?: string;
+    freeform?: string;
+    notes?: string;
+    hqBinary?: string;
+}): string;
 export interface OutpostExecPort {
     stageExecInput: (outpostId?: string) => Promise<{
         putUrl: string;

package/dist/lib/lanes/outpost-dispatch.js

@@ -10,6 +10,24 @@ import { OutpostsClient, joinCommandParts, withRemoteHqDir } from "@indigoai-us/
 import { LanesError } from "./errors.js";
 export const PICKUP_EXEC_TIMEOUT_SECONDS = 120;
 export const PICKUP_WAIT_MS = PICKUP_EXEC_TIMEOUT_SECONDS * 1000;
+export function buildOutpostQuestionAnswerCommand(input) {
+    const args = [
+        input.hqBinary?.trim() || "hq",
+        "lanes",
+        "questions",
+        "answer",
+        input.questionId,
+    ];
+    for (const [flag, value] of [
+        ["--choice", input.choice],
+        ["--freeform", input.freeform],
+        ["--notes", input.notes],
+    ]) {
+        if (value !== undefined)
+            args.push(flag, value);
+    }
+    return withRemoteHqDir(joinCommandParts(args));
+}
 export function parseOutpostPickupPayload(raw) {
     if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
         throw new LanesError("outpost_payload_invalid", "Outpost pickup payload must be a JSON object", {});

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

@@ -8,7 +8,7 @@
 import { type LivenessDeps } from "./liveness.js";
 import { type EnvelopeRepairSpawnInput, type SpawnLaneDeps } from "./spawn.js";
 import { type ThrottleDeps } from "./throttle.js";
-import type { LaneRecord, LivenessState, QuestionRecord, SeniorRef } from "./types.js";
+import type { LaneRecord, LivenessState, QueuedReason, QuestionRecord, SeniorRef } from "./types.js";
 import { type LaneMesh } from "./mesh-events.js";
 /** Spec §9: unanswered at the current hop for 60 minutes → one hop. */
 export declare const QUESTION_AGE_MS: number;
@@ -102,4 +102,13 @@ export declare function runPassBody(hqRoot: string, deps: ReconcileDeps): Promis
  * `ok: false` rather than being swallowed.
  */
 export declare function runReconcilePass(hqRoot: string, deps: ReconcileDeps): Promise<ReconcileSummary>;
+export interface AnsweredLaneWakeResult {
+    status: "resumed" | "queued" | "awaiting_answers" | "failed";
+    lane_state: LaneRecord["state"];
+    queued_reason?: QueuedReason;
+    remaining_question_ids?: string[];
+    error?: string;
+}
+/** Run the reconcile answer-resume path for one lane before questions answer returns. */
+export declare function wakeAnsweredLaneNow(hqRoot: string, laneId: string, deps: ReconcileDeps): Promise<AnsweredLaneWakeResult>;
 //# sourceMappingURL=reconcile.d.ts.map

package/dist/lib/lanes/reconcile.js

@@ -1284,9 +1284,11 @@ async function admitQueued(hqRoot, lanes, summary, deps, now) {
         writeThrottleState(filePath, applyThrottleDecision(base, applied, nowMs), throttleDeps);
     }
 }
-async function resumeAwaiting(hqRoot, lanes, questions, summary, deps) {
+async function resumeAwaiting(hqRoot, lanes, questions, summary, deps, onlyLaneIds) {
     const config = loadLanesConfig(hqRoot);
-    const awaiting = lanes.filter((lane) => lane.state === "awaiting_input" && laneRunsHere(lane, deps.host));
+    const awaiting = lanes.filter((lane) => lane.state === "awaiting_input" &&
+        laneRunsHere(lane, deps.host) &&
+        (onlyLaneIds === undefined || onlyLaneIds.has(lane.lane_id)));
     if (awaiting.length === 0)
         return;
     const throttleDeps = deps.throttleDeps ?? defaultThrottleDeps(deps.env ?? process.env);
@@ -1307,10 +1309,24 @@ async function resumeAwaiting(hqRoot, lanes, questions, summary, deps) {
         const throttle = await decideAdmission(hqRoot, config.throttle, throttleDeps);
         throttleDecision = throttle.decision;
     }
-    if (!throttleDecision.admit)
-        return;
     const spawnFn = deps.spawn ?? ((root, lane) => spawnLaneWorker(root, lane, deps.spawnLaneDeps));
     const nowMs = deps.now().getTime();
+    const fallbackAnswerAt = new Date(nowMs).toISOString();
+    const answerAtByLane = new Map();
+    for (const question of questions) {
+        if (question.status !== "answered")
+            continue;
+        const at = question.answer?.answered_at ?? question.asked_at;
+        const previous = answerAtByLane.get(question.origin.id);
+        if (previous === undefined || Date.parse(at) > Date.parse(previous)) {
+            answerAtByLane.set(question.origin.id, at);
+        }
+    }
+    const latestAnswerAt = (lane) => answerAtByLane.get(lane.lane_id) ?? fallbackAnswerAt;
+    awaiting.sort((a, b) => {
+        const byAnswerTime = Date.parse(latestAnswerAt(a)) - Date.parse(latestAnswerAt(b));
+        return byAnswerTime || compareLaneQueueOrder(a, b);
+    });
     const capacityLanes = lanes.map((lane) => {
         try {
             return readLane(hqRoot, lane.lane_id);
@@ -1336,7 +1352,55 @@ async function resumeAwaiting(hqRoot, lanes, questions, summary, deps) {
             if (current.worker_profile !== undefined) {
                 profileMaxConcurrent = loadWorkerProfile(hqRoot, current.worker_profile).meta.max_concurrent;
             }
-            if (laneAdmissionCapReason(running, current, config, deps.host, profileMaxConcurrent, nowMs) !== undefined) {
+            const capReason = laneAdmissionCapReason(running, current, config, deps.host, profileMaxConcurrent, nowMs);
+            const answeredAt = latestAnswerAt(current);
+            const queueCandidate = { ...current, state: "queued", queued_at: answeredAt };
+            const earlierQueued = capacityLanes.some((queued) => queued.lane_id !== current.lane_id &&
+                queued.state === "queued" &&
+                queued.provider === current.provider &&
+                laneRunsHere(queued, deps.host) &&
+                compareLaneQueueOrder(queued, queueCandidate) < 0);
+            const queueReason = !throttleDecision.admit
+                ? "throttle"
+                : capReason ?? (earlierQueued ? "queue_position" : undefined);
+            if (queueReason !== undefined) {
+                const queuedCount = capacityLanes.filter((queued) => queued.state === "queued" &&
+                    queued.provider === current.provider &&
+                    laneRunsHere(queued, deps.host) &&
+                    !hasFreshAdmissionReservation(queued, nowMs)).length;
+                const maxQueued = config.providers[current.provider].max_queued;
+                if (queuedCount >= maxQueued) {
+                    summary.skipped.push({
+                        kind: "lane",
+                        id: current.lane_id,
+                        why: `lane_queue_full: ${current.provider} queue has ${queuedCount}/${maxQueued} lanes`,
+                    });
+                    continue;
+                }
+            }
+            if (!deps.dryRun)
+                writeAnsweredQuestions(hqRoot, current, questions);
+            if (queueReason !== undefined) {
+                const queued = casLaneIf(hqRoot, current.lane_id, (latest) => latest.state === "awaiting_input", (latest) => ({
+                    ...latest,
+                    state: "queued",
+                    queued_reason: queueReason,
+                    queued_at: answeredAt,
+                    pending_resume: {
+                        ...(latest.provider_session_id
+                            ? { session_id: latest.provider_session_id }
+                            : {}),
+                        trigger: "answered_questions",
+                        at: answeredAt,
+                    },
+                }), deps.dryRun);
+                summary.resumed.push({
+                    id: queued.record.lane_id,
+                    from: "awaiting_input",
+                    to: "queued",
+                    reason: queueReason,
+                });
+                capacityLanes.push(queued.record);
                 continue;
             }
             if (deps.dryRun) {
@@ -1348,7 +1412,6 @@ async function resumeAwaiting(hqRoot, lanes, questions, summary, deps) {
                 running.push({ ...current, state: "running" });
                 continue;
             }
-            writeAnsweredQuestions(hqRoot, lane, questions);
             const started = spawnFn(hqRoot, lane);
             if (started.state === "running")
                 running.push(started);
@@ -1376,4 +1439,47 @@ async function resumeAwaiting(hqRoot, lanes, questions, summary, deps) {
 export async function runReconcilePass(hqRoot, deps) {
     return withReconcileLock(hqRoot, async () => runPassBody(hqRoot, deps));
 }
+/** Run the reconcile answer-resume path for one lane before questions answer returns. */
+export async function wakeAnsweredLaneNow(hqRoot, laneId, deps) {
+    const summary = emptySummary(deps.dryRun);
+    await withReconcileLock(hqRoot, async () => {
+        await withAllLaneAdmissionLocks(hqRoot, async () => {
+            const lanes = loadLaneRecords(hqRoot, summary);
+            const questions = loadQuestionRecords(hqRoot, summary);
+            if (!lanes.some((lane) => lane.lane_id === laneId)) {
+                throw new LanesError("lane_not_found", `Lane ${laneId} was not found`, { lane_id: laneId });
+            }
+            await resumeAwaiting(hqRoot, lanes, questions, summary, deps, new Set([laneId]));
+        });
+    });
+    const latest = readLane(hqRoot, laneId);
+    const laneQuestions = loadQuestionRecords(hqRoot, emptySummary(false)).filter((question) => question.origin.id === laneId);
+    const remaining = laneQuestions
+        .filter((question) => question.status === "pending")
+        .map((question) => question.question_id)
+        .sort();
+    if (latest.state === "running") {
+        return { status: "resumed", lane_state: latest.state };
+    }
+    if (latest.state === "queued" && latest.pending_resume?.trigger === "answered_questions") {
+        return {
+            status: "queued",
+            lane_state: latest.state,
+            ...(latest.queued_reason !== undefined ? { queued_reason: latest.queued_reason } : {}),
+        };
+    }
+    if (latest.state === "awaiting_input" && remaining.length > 0) {
+        return {
+            status: "awaiting_answers",
+            lane_state: latest.state,
+            remaining_question_ids: remaining,
+        };
+    }
+    const failure = summary.skipped.find((skip) => skip.kind === "lane" && skip.id === laneId);
+    return {
+        status: "failed",
+        lane_state: latest.state,
+        error: failure?.why ?? `Lane ${laneId} did not leave awaiting_input after its questions were answered`,
+    };
+}
 //# sourceMappingURL=reconcile.js.map

package/dist/lib/lanes/spawn.js

@@ -1553,9 +1553,13 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
     // state and the caller sees the error. Admission and question resume keep
     // today's behaviour of naming the terminal reason on the record.
     const markPreSpawnFailure = trigger.kind !== "message" && trigger.kind !== "resume";
-    const plan = pendingResume !== undefined && providerSupportsSessionResume(existing.provider)
-        ? { mode: "resume", session_id: pendingResume.session_id }
-        : planLaneLaunch(existing, trigger);
+    const plan = pendingResume?.trigger === "answered_questions"
+        ? pendingResume.session_id !== undefined && providerSupportsSessionResume(existing.provider)
+            ? { mode: "resume", session_id: pendingResume.session_id }
+            : planLaneLaunch(existing, { kind: "answered_questions" })
+        : pendingResume?.session_id !== undefined && providerSupportsSessionResume(existing.provider)
+            ? { mode: "resume", session_id: pendingResume.session_id }
+            : planLaneLaunch(existing, trigger);
     if (existing.host.kind === "outpost") {
         refuseOutpostSelfTarget(hqRoot, existing, deps);
     }

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

@@ -508,7 +508,8 @@ export interface AccountHistoryEntry {
     reason: "first_assignment" | "model_change" | "usage_limit" | "account_unavailable" | "operator_move";
 }
 export interface PendingResume {
-    session_id: string;
+    /** Fresh answered-question launches need no previous session id. */
+    session_id?: string;
     trigger: "answered_questions" | "message" | "resume";
     resumed_from?: "interrupted" | "done" | "blocked" | "failed";
     text?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.192.0",
+  "version": "5.192.2",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {