@indigoai-us/hq-cli 5.192.0 → 5.192.1

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## [Unreleased]
 
+## [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.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";
@@ -3208,6 +3208,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) {
@@ -6464,9 +6597,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 +6651,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,

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.1",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {