@indigoai-us/hq-cli 5.300.0 → 5.302.0

package/dist/commands/integrations-connect.js

@@ -185,6 +185,12 @@ export function assertAuthMode(value) {
         throw new IntegrationsCliError("--auth must be none, key, or oauth.", { expected: true });
     }
 }
+/** RFC 7230 token characters accepted for an HTTP field name. */
+export function assertAuthHeader(value) {
+    if (value !== undefined && !/^[A-Za-z0-9!#$%&'*+.^_`|~-]+$/.test(value)) {
+        throw new IntegrationsCliError("--auth-header must be a non-empty HTTP header name using RFC 7230 token characters.", { expected: true });
+    }
+}
 /** Single-quote a value for a copy-pasteable shell command. */
 export function shellQuote(value) {
     return `'${value.replace(/'/g, `'\\''`)}'`;
@@ -904,7 +910,9 @@ function reportInstall(result, opts, expectedRevivedConnectionId) {
  */
 async function connectApp(token, companyUid, app, opts, expectedRevivedConnectionId) {
     const target = await resolveTarget(token, companyUid, app, opts, expectedRevivedConnectionId !== undefined);
-    const authMode = opts.auth ?? target.authClass;
+    const authMode = opts.authHeader
+        ? "key"
+        : opts.auth ?? target.authClass;
     assertUserClientApplicable(opts, target, authMode);
     assertScopesApplicable(opts, target, authMode);
     if (authMode === "oauth") {
@@ -922,7 +930,13 @@ async function connectApp(token, companyUid, app, opts, expectedRevivedConnectio
         const result = await installIntegration(token, companyUid, {
             ...target.ref,
             ...(bearerToken
-                ? { authMode: "bearer", bearerToken }
+                ? {
+                    authMode: "bearer",
+                    bearerToken,
+                    ...(opts.authHeader
+                        ? { authScheme: { placement: "header", header: opts.authHeader } }
+                        : {}),
+                }
                 : authMode === "none"
                     ? { authMode: "none" }
                     : {}),
@@ -1173,6 +1187,7 @@ export function registerConnectCommands(integrations) {
         .option("--display-name <name>", "Display name for a custom --mcp-url")
         .option("--token <key>", "API key (prefer --token-stdin: --token lands in shell history)")
         .option("--token-stdin", "Read the API key from stdin")
+        .option("--auth-header <name>", "Send the API key in this HTTP header (implies --auth key)")
         .option("--auth <mode>", "Force the auth mode: none, key, or oauth (default: detect)")
         .option("--client-id <id>", "Client id of an OAuth app you registered with the provider yourself")
         .option("--client-secret-stdin", "Read that app's client secret from stdin")
@@ -1183,6 +1198,10 @@ export function registerConnectCommands(integrations) {
         .option("--json", "Machine-readable output")
         .action(async (app, opts) => {
         assertAuthMode(opts.auth);
+        assertAuthHeader(opts.authHeader);
+        if (opts.authHeader && opts.auth !== undefined && opts.auth !== "key") {
+            throw new IntegrationsCliError("--auth-header can only be used with --auth key.", { expected: true });
+        }
         const token = await ensureCognitoIdToken();
         const companyUid = await getCompanyUid(token, opts.company);
         if (await refuseIfAlreadyConnected(token, companyUid, app, opts))

package/dist/commands/integrations-manage.js

@@ -610,9 +610,6 @@ export function registerManageCommands(integrations) {
         const companyUid = await getCompanyUid(token, opts.company);
         const connection = await resolveConnection(token, companyUid, app, opts);
         const installationId = connection.installation?.id;
-        if (!installationId) {
-            throw new IntegrationsCliError(`${connectionLabel(connection)} was not installed through the app catalog, so it cannot be disconnected from here.`, { expected: true });
-        }
         if (!opts.yes) {
             const label = connectionLabel(connection);
             // Warning + prompt go to stderr: with --json, stdout must stay parseable,
@@ -625,7 +622,7 @@ export function registerManageCommands(integrations) {
                 throw new IntegrationsCliError("Not disconnected. Re-run with --yes if you are sure.", { expected: true });
             }
         }
-        const result = await uninstallIntegration(token, companyUid, installationId);
+        const result = await uninstallIntegration(token, companyUid, installationId ? { installationId } : { connectionId: connection.id });
         if (opts.json) {
             printJson(result);
             return;

package/dist/commands/lanes-message.js

@@ -247,6 +247,7 @@ export function createLaneMessageHandlers(deps) {
         }
         let lane = resolution.lane;
         if (resolution.remoteOnly || (lane.host.kind === "outpost" && !laneIsHostedHere(ctx, lane))) {
+            const fallbackAt = lane.state === "awaiting_input" ? ctx.now().toISOString() : undefined;
             const callerLaneId = ctx.env.HQ_LANE_ID?.trim();
             const supersededMessageCallerId = callerLaneId === undefined || resolution.remoteOnly
                 ? undefined
@@ -262,9 +263,14 @@ export function createLaneMessageHandlers(deps) {
                 ...opts,
                 ...(supersededMessageCallerId === undefined ? {} : { supersededMessageCallerId }),
                 ...(supersededMessageSessionId === undefined ? {} : { supersededMessageSessionId }),
-            }, resolution.remoteOnly
-                ? { syncPrimary: false, expectedOwnerHost: resolution.ownerHost }
-                : undefined);
+            }, {
+                ...(resolution.remoteOnly
+                    ? { syncPrimary: false, expectedOwnerHost: resolution.ownerHost }
+                    : {}),
+                ...(fallbackAt === undefined ? {} : {
+                    afterFallbackResume: () => deps.cancelFallbackQuestionsForLane(ctx, lane, "message", fallbackAt),
+                }),
+            });
             return;
         }
         assertLaneRunsHereForOperatorMutation(ctx, lane, "message");
@@ -350,6 +356,19 @@ export function createLaneMessageHandlers(deps) {
             if (opts.account !== undefined && !keepCurrentAccount && !providerSessionPortable(lane.provider)) {
                 throw new LanesError("provider_session_not_portable", sessionNotPortableMessage(lane.provider), { lane_id: laneId, provider: lane.provider });
             }
+            const pendingAnswerableQuestion = lane.state === "awaiting_input"
+                ? await deps.hasPendingQuestionForLane(ctx, lane)
+                : false;
+            if (pendingAnswerableQuestion) {
+                const message = deliveryRefusalReason(lane);
+                throw new LanesError("lane_not_accepting_messages", message, {
+                    lane_id: laneId,
+                    state: lane.state,
+                    provider: lane.provider,
+                    message,
+                });
+            }
+            const awaitingInputFallback = lane.state === "awaiting_input" && !pendingAnswerableQuestion;
             // One decision point for how a follow-up reaches this lane (delivery.ts).
             // `none` refuses before anything is written: no inbox append, no spawn.
             const mechanism = laneDeliveryMechanism(lane);
@@ -488,6 +507,8 @@ export function createLaneMessageHandlers(deps) {
                 });
                 lane = move.lane;
                 if (move.queued) {
+                    storySwitchDeliveryStarted = true;
+                    deps.onLaneMessageQueued?.(laneId, "account_move");
                     archiveResumeMessage(hqRoot, laneId, dropboxMessage);
                 }
             }
@@ -513,8 +534,11 @@ export function createLaneMessageHandlers(deps) {
                             accountSelection: selection,
                         });
                         lane = move.lane;
-                        if (move.queued)
+                        if (move.queued) {
+                            storySwitchDeliveryStarted = true;
+                            deps.onLaneMessageQueued?.(laneId, "account_move");
                             archiveResumeMessage(hqRoot, laneId, dropboxMessage);
+                        }
                     }
                     else {
                         lane = persistClaudeAccountSelection(hqRoot, lane, selection);
@@ -531,9 +555,13 @@ export function createLaneMessageHandlers(deps) {
                     ...(keepCurrentAccount && opts.model !== undefined ? { cliModel: opts.model } : {}),
                 });
             }
+            let questionCancellation = null;
             if (move?.queued) {
                 // Parked at the target's cap: reconcile resumes the session there.
                 markAccepted();
+                questionCancellation = awaitingInputFallback
+                    ? await deps.cancelFallbackQuestionsForLane(ctx, lane, "message", at)
+                    : null;
             }
             else {
                 const dispatched = await dispatchLaneDelivery(lane, {
@@ -565,7 +593,7 @@ export function createLaneMessageHandlers(deps) {
                                     }
                                     archiveResumeMessage(hqRoot, laneId, dropboxMessage);
                                     queuedOnAdmission = true;
-                                    return casUpdateLane(hqRoot, laneId, (current) => {
+                                    const queued = casUpdateLane(hqRoot, laneId, (current) => {
                                         if (current.version !== lane.version || current.state !== lane.state) {
                                             throw new LanesError("lane_admission_conflict", `Lane ${laneId} changed while message admission was checked`, {
                                                 lane_id: laneId,
@@ -592,6 +620,9 @@ export function createLaneMessageHandlers(deps) {
                                             },
                                         };
                                     });
+                                    storySwitchDeliveryStarted = true;
+                                    deps.onLaneMessageQueued?.(laneId, "admission");
+                                    return queued;
                                 }
                                 const started = spawnLaneWorker(hqRoot, lane, {
                                     env: ctx.env,
@@ -629,6 +660,9 @@ export function createLaneMessageHandlers(deps) {
                 if (dispatched.mechanism === "resume")
                     resumed = dispatched.value;
                 markAccepted();
+                questionCancellation = awaitingInputFallback
+                    ? await deps.cancelFallbackQuestionsForLane(ctx, lane, "message", at)
+                    : null;
             }
             // Every accepted message moves the compaction reference forward.
             const next = casUpdateLane(hqRoot, laneId, (current) => ({
@@ -671,6 +705,10 @@ export function createLaneMessageHandlers(deps) {
                     inbox_path: mechanism === "dropbox" ? dropboxInboxPath(hqRoot, laneId) : null,
                     drain_hook: drainHook,
                     warning,
+                    ...(questionCancellation === null ? {} : {
+                        cancelled_questions: questionCancellation.cancelled_question_ids,
+                        question_cancellation_failures: questionCancellation.failures,
+                    }),
                     resumed_session_id: resumed?.last_resume?.session_id ?? null,
                     compaction: resumed?.last_compaction && resumed.last_compaction.resume_at === resumed.last_resume?.at
                         ? resumed.last_compaction

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

@@ -1,7 +1,9 @@
-import { type QuestionBody, type QuestionRecord } from "../lib/lanes/index.js";
-import type { Ctx, LaneQuestionsHandlerDeps } from "./lanes-shared.js";
+import { type QuestionBody, type LaneRecord, type QuestionRecord } from "../lib/lanes/index.js";
+import type { Ctx, FallbackQuestionCancellationResult, LaneQuestionsHandlerDeps } from "./lanes-shared.js";
 export declare function resolveAnswerChoice(choice: string, options: string[], freeform: boolean): string;
 export declare function createLaneQuestionsHandlers(deps: LaneQuestionsHandlerDeps): {
+    hasPendingQuestionForLane: (ctx: Ctx, lane: LaneRecord) => Promise<boolean>;
+    cancelFallbackQuestionsForLane: (ctx: Ctx, lane: LaneRecord, trigger: "message" | "resume", at: string) => Promise<FallbackQuestionCancellationResult>;
     runQuestionsList: (ctx: Ctx, opts: {
         allHosts?: boolean;
         for?: string;

package/dist/commands/lanes-questions.js

@@ -1,4 +1,4 @@
-import { buildOutpostQuestionAnswerCommand, buildOutpostQuestionShowCommand, dispatchErrorMessage } from "../lib/lanes/outpost-dispatch.js";
+import { buildOutpostQuestionAnswerCommand, buildOutpostQuestionCancelCommand, buildOutpostQuestionShowCommand, dispatchErrorMessage } from "../lib/lanes/outpost-dispatch.js";
 import { assertNoSecretText } from "../lib/lanes/text-scan.js";
 import { sessionIdFromEnv } from "../lib/mesh/live/session-identity.js";
 import { appendCappedHistory, createQuestion, isLanesError, listSessionLiveness, parseLivenessState, parseQuestionRecord, parseQuestionStatus, readDaemonPresenceConnected, readLane, readQuestion, wakeAnsweredLaneNow, sessionLiveness, appendDropboxMessage, answerDropboxMessage, laneAcceptsDropboxDelivery, laneIdForAnswerDelivery, writeQuestionBody } from "../lib/lanes/index.js";
@@ -20,7 +20,7 @@ export function resolveAnswerChoice(choice, options, freeform) {
     throw new LanesError("off_menu_choice", `Choice ${JSON.stringify(choice)} is not on the menu. Pass --freeform to allow it.`, { choice, options });
 }
 export function createLaneQuestionsHandlers(deps) {
-    const { CAPACITY_PROBE_TIMEOUT_MS, MAX_PLACEMENT_OUTPOSTS, OUTPOST_QUESTION_LOOKUP_CONCURRENCY, assertLaneRunsHereForOperatorMutation, assertQuestionAnswerAuthorized, assertQuestionCompanyMatchesLane, casUpdateQuestion, effectiveLaneQuestionCompany, emitLaneMeshEvent, groupQuestionLanesByCompany, isQuestionAnswer, laneIsHostedHere, livenessDepsFromCtx, loadAllLanes, loadAllQuestions, mapWithConcurrency, mintMessageId, parseOutpostQuestionAudience, parseOutpostQuestionBody, parseRemoteJson, parseSeniorRef, questionCompanyForLane, questionCompanyRefMatches, questionListCompanyArg, readOutpostQuestionRecords, readQuestionBody, printJson, readSessionMeta, reconcileHostFromCtx, resolveActiveQuestionCompany, resolveAudience, sameQuestionAnswer, sameQuestionCompany, seniorOfSession, writeAnswerDeliveryFailed } = deps;
+    const { CAPACITY_PROBE_TIMEOUT_MS, MAX_PLACEMENT_OUTPOSTS, OUTPOST_QUESTION_LOOKUP_CONCURRENCY, assertLaneRunsHereForOperatorMutation, assertQuestionAnswerAuthorized, assertQuestionCompanyMatchesLane, casUpdateQuestion, casUpdateLane, effectiveLaneQuestionCompany, emitLaneMeshEvent, groupQuestionLanesByCompany, isQuestionAnswer, laneIsHostedHere, livenessDepsFromCtx, loadAllLanes, loadAllQuestions, mapWithConcurrency, mintMessageId, parseOutpostQuestionAudience, parseOutpostQuestionBody, parseRemoteJson, parseSeniorRef, questionCompanyForLane, questionCompanyRefMatches, questionListCompanyArg, readOutpostQuestionRecords, readQuestionBody, printJson, readSessionMeta, reconcileHostFromCtx, resolveActiveQuestionCompany, resolveAudience, sameQuestionAnswer, sameQuestionCompany, seniorOfSession, writeAnswerDeliveryFailed } = deps;
     function requireQuestionBody(hqRoot, question) {
         const body = readQuestionBody(hqRoot, question);
         if (!body) {
@@ -52,6 +52,16 @@ export function createLaneQuestionsHandlers(deps) {
             return audience.kind === "user";
         return audience.kind === filter.kind && audience.id === filter.id;
     }
+    function questionAudienceMatchesSenior(audience, lane, ctx) {
+        if (audienceMatches(audience, lane.senior))
+            return true;
+        const sessionId = sessionIdFromEnv(ctx.env);
+        if (sessionId && audienceMatches(audience, { kind: "session", id: sessionId }))
+            return true;
+        const callerLaneId = ctx.env.HQ_LANE_ID?.trim();
+        return callerLaneId !== undefined && callerLaneId.length > 0 &&
+            audienceMatches(audience, { kind: "lane", id: callerLaneId });
+    }
     function parseForFilter(raw, ctx) {
         const trimmed = raw.trim();
         if (trimmed === "me") {
@@ -384,6 +394,115 @@ export function createLaneQuestionsHandlers(deps) {
             errors: [...new Map(errors.map((entry) => [entry.host, entry])).values()],
         };
     }
+    async function cancelFallbackQuestionsForLane(ctx, lane, trigger, at) {
+        const hqRoot = ctx.hqRoot();
+        const caller = ctx.env.HQ_LANE_ID?.trim() || sessionIdFromEnv(ctx.env) || "user";
+        const reason = `Fallback ${trigger} by ${caller} at ${at}`;
+        const failures = [];
+        const cancelledQuestionIds = [];
+        const remoteOwner = lane.host.kind === "outpost" && !laneIsHostedHere(ctx, lane);
+        let pending;
+        try {
+            pending = remoteOwner
+                ? (await readOutpostQuestionRecords(ctx, lane.host.id, effectiveLaneQuestionCompany(lane, hqRoot)))
+                    .map(({ question }) => question)
+                    .filter((question) => question.origin.id === lane.lane_id && question.status === "pending")
+                : loadAllQuestions(hqRoot).filter((question) => question.origin.id === lane.lane_id && question.status === "pending");
+        }
+        catch (err) {
+            failures.push({ error: dispatchErrorMessage(err) });
+            pending = [];
+        }
+        for (const question of pending) {
+            try {
+                if (remoteOwner) {
+                    const outpostId = lane.host.id;
+                    const dispatched = await ctx.dispatchOutpostExec({
+                        outpostId,
+                        command: buildOutpostQuestionCancelCommand({ questionId: question.question_id, reason }),
+                        timeoutSeconds: Math.ceil(CAPACITY_PROBE_TIMEOUT_MS / 1000),
+                        waitMs: CAPACITY_PROBE_TIMEOUT_MS,
+                    });
+                    const remote = parseRemoteJson(dispatched.stdout, "Outpost question cancel");
+                    const remoteQuestion = remote?.question !== null && typeof remote?.question === "object"
+                        ? remote.question
+                        : null;
+                    if (dispatched.done !== true || dispatched.status !== "Success" || dispatched.exitCode !== 0 ||
+                        remote?.ok !== true || remote.action !== "questions.cancel" ||
+                        remoteQuestion?.question_id !== question.question_id || remoteQuestion.status !== "cancelled") {
+                        throw new LanesError("outpost_question_cancel_unconfirmed", `Outpost ${outpostId} did not confirm cancellation of question ${question.question_id}`, { lane_id: lane.lane_id, question_id: question.question_id, outpost_id: outpostId });
+                    }
+                }
+                else {
+                    const cancellationEntry = {
+                        hop: question.hop,
+                        audience: resolveAudience(hqRoot, question, ctx),
+                        at,
+                        reason: "cancelled",
+                        detail: reason,
+                    };
+                    const updated = casUpdateQuestion(hqRoot, question.question_id, (current) => {
+                        if (current.status !== "pending")
+                            return current;
+                        return {
+                            ...current,
+                            status: "cancelled",
+                            routing_history: appendCappedHistory(current.routing_history, cancellationEntry),
+                        };
+                    });
+                    if (updated.status !== "cancelled")
+                        continue;
+                }
+                cancelledQuestionIds.push(question.question_id);
+            }
+            catch (err) {
+                failures.push({ question_id: question.question_id, error: dispatchErrorMessage(err) });
+            }
+        }
+        if (failures.length > 0) {
+            const failure = {
+                at,
+                caller,
+                trigger,
+                question_ids: failures.flatMap((entry) => entry.question_id ? [entry.question_id] : []),
+                error: failures.map((entry) => entry.error).join("; "),
+            };
+            try {
+                casUpdateLane(hqRoot, lane.lane_id, (current) => {
+                    const history = current.fallback_question_cancellation_failures ?? [];
+                    const duplicate = history.some((entry) => entry.at === failure.at && entry.caller === caller && entry.trigger === trigger);
+                    return duplicate
+                        ? current
+                        : {
+                            ...current,
+                            fallback_question_cancellation_failures: [...history, failure].slice(-20),
+                        };
+                });
+            }
+            catch (err) {
+                const message = `Could not record fallback question cancellation failure for lane ${lane.lane_id}: ${dispatchErrorMessage(err)}\n`;
+                process.stderr.write(message);
+                failures.push({ error: `Failure record could not be persisted: ${dispatchErrorMessage(err)}` });
+            }
+        }
+        return { cancelled_question_ids: cancelledQuestionIds, failures };
+    }
+    async function hasPendingQuestionForLane(ctx, lane) {
+        const hqRoot = ctx.hqRoot();
+        const local = loadAllQuestions(hqRoot).some((question) => question.lane_id === lane.lane_id &&
+            question.status === "pending" &&
+            questionAudienceMatchesSenior(resolveAudience(hqRoot, question, ctx), lane, ctx));
+        if (local)
+            return true;
+        if (lane.host.kind !== "outpost" || laneIsHostedHere(ctx, lane))
+            return false;
+        // Reuse the owner lookup used by questions list/answer. An unreachable
+        // owner leaves no answerable question, so the message/resume path can recover.
+        const lookup = await loadPrimaryOwnedOutpostQuestions(ctx, hqRoot);
+        return lookup.questions.some(({ question, lane: ownerLane, audience }) => ownerLane.lane_id === lane.lane_id &&
+            question.status === "pending" &&
+            questionAudienceMatchesSenior(audience, ownerLane, ctx));
+    }
     function syncPrimaryQuestionDelivery(hqRoot, owner) {
         const deliveredAt = owner.question.delivered_at;
         if (!deliveredAt)
@@ -870,6 +989,8 @@ export function createLaneQuestionsHandlers(deps) {
         });
     }
     return {
+        hasPendingQuestionForLane,
+        cancelFallbackQuestionsForLane,
         runQuestionsList,
         runQuestionsShow,
         runQuestionsAnswer,

package/dist/commands/lanes-resume.js

@@ -75,7 +75,8 @@ export function createLaneResumeHandlers(deps) {
     }
     /**
      * `hq lanes resume <lane-id> [--text <msg>]`: the explicit opt-in that
-     * continues a lane in `interrupted`, `done` or `blocked`, or a failed lane
+     * continues a lane in `interrupted`, `done` or `blocked`, an `awaiting_input`
+     * lane with no answerable pending question, or a failed lane
      * whose only terminal reason is an invalid envelope after its repair turn,
      * on its recorded
      * provider session. `hq lanes message` keeps refusing `interrupted`; this
@@ -124,12 +125,21 @@ export function createLaneResumeHandlers(deps) {
             throw new LanesError("worker_profile_hash_mismatch", "Profile re-pin context is only valid on an Outpost owner dispatch", { lane_id: laneId });
         }
         if (resolution.remoteOnly || (lane.host.kind === "outpost" && !laneIsHostedHere(ctx, lane))) {
+            const fallbackAt = lane.state === "awaiting_input" ? ctx.now().toISOString() : undefined;
             if (!resolution.remoteOnly) {
                 await withResumeHireAdmission(ctx, lane, () => undefined);
             }
             await dispatchOutpostLaneCommand(ctx, lane, "resume", opts, resolution.remoteOnly
-                ? { syncPrimary: false, expectedOwnerHost: resolution.ownerHost }
-                : undefined);
+                ? {
+                    syncPrimary: false,
+                    expectedOwnerHost: resolution.ownerHost,
+                    ...(fallbackAt === undefined ? {} : {
+                        afterFallbackResume: () => deps.cancelFallbackQuestionsForLane(ctx, lane, "resume", fallbackAt),
+                    }),
+                }
+                : fallbackAt === undefined
+                    ? undefined
+                    : { afterFallbackResume: () => deps.cancelFallbackQuestionsForLane(ctx, lane, "resume", fallbackAt) });
             return;
         }
         // Fail before provider/session work if a terminal child would consume a
@@ -171,7 +181,10 @@ export function createLaneResumeHandlers(deps) {
             opts.compact === false)) {
             throw new LanesError("worker_profile_recovery_options_invalid", "Queued worker-profile recovery accepts only --worker; rerun hq lanes resume after reconcile admits the lane", { lane_id: laneId });
         }
-        const refusal = queuedProfileRecovery
+        const pendingQuestion = lane.state === "awaiting_input"
+            ? await deps.hasPendingQuestionForLane(ctx, lane)
+            : false;
+        const refusal = queuedProfileRecovery || (lane.state === "awaiting_input" && !pendingQuestion)
             ? null
             : resumeCommandRefusal(lane, { allowFailed: opts.fromFailed === true });
         if (refusal !== null) {
@@ -444,6 +457,7 @@ export function createLaneResumeHandlers(deps) {
                             trigger: {
                                 kind: "resume",
                                 from: resumedFrom,
+                                ...(resumedFrom === "awaiting_input" && !pendingQuestion ? { allowAwaitingInput: true } : {}),
                                 ...(opts.fromFailed === true ? { fromFailed: true } : {}),
                                 ...(failedResumeExpectedSenior !== undefined
                                     ? { expectedSenior: failedResumeExpectedSenior }
@@ -460,6 +474,9 @@ export function createLaneResumeHandlers(deps) {
                     }, hireGrantContext);
                 }, ctx.sleep);
             }
+            const questionCancellation = resumedFrom === "awaiting_input" && !pendingQuestion
+                ? await deps.cancelFallbackQuestionsForLane(ctx, lane, "resume", at)
+                : null;
             if (deliveryText !== undefined && messageId !== undefined) {
                 // Same audit copy a message resume leaves; nothing drains it. Archive only
                 // after a successful spawn so a concurrent resume cannot leave a phantom.
@@ -519,6 +536,10 @@ export function createLaneResumeHandlers(deps) {
                 story_id: next.story_id,
                 stories: laneStories(next),
                 story_warning: storyWarning(next) ?? null,
+                ...(questionCancellation === null ? {} : {
+                    cancelled_questions: questionCancellation.cancelled_question_ids,
+                    question_cancellation_failures: questionCancellation.failures,
+                }),
                 lane: next,
             });
         }

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

@@ -137,15 +137,26 @@ export type CommandLaneResolution = {
     outpostId: string;
     ownerHost: LaneRecord["host"];
 };
+export interface FallbackQuestionCancellationResult {
+    cancelled_question_ids: string[];
+    failures: Array<{
+        question_id?: string;
+        error: string;
+    }>;
+}
 export interface OutpostLaneDispatchBehavior {
     /** Keep remote-only lanes out of the primary lane store. */
     syncPrimary?: boolean;
     /** Host identity returned by the remote record lookup for a remote-only lane. */
     expectedOwnerHost?: LaneRecord["host"];
+    /** Run after a successful remote awaiting_input fallback, before printing. */
+    afterFallbackResume?: () => Promise<FallbackQuestionCancellationResult>;
 }
 export interface LaneMessageHandlerDeps {
     /** Test seam invoked after a provider worker has been started. */
     onLaneWorkerStarted?: (laneId: string, command: "message" | "resume") => void;
+    /** Test seam invoked after a message has been durably queued for a lane. */
+    onLaneMessageQueued?: (laneId: string, path: "admission" | "account_move") => void;
     archiveResumeMessage(hqRoot: string, laneId: string, message: {
         message_id: string;
         [key: string]: unknown;
@@ -175,6 +186,8 @@ export interface LaneMessageHandlerDeps {
     recordResumeSetup(ctx: Ctx, lane: LaneRecord, input: RecordResumeSetupInput): LaneRecord;
     resolveCommandLane(ctx: Ctx, laneId: string): Promise<CommandLaneResolution>;
     resolveActiveQuestionCompany(ctx: Ctx, message?: string): Promise<LaneCompanyRef>;
+    hasPendingQuestionForLane(ctx: Ctx, lane: LaneRecord): Promise<boolean>;
+    cancelFallbackQuestionsForLane(ctx: Ctx, lane: LaneRecord, trigger: "message" | "resume", at: string): Promise<FallbackQuestionCancellationResult>;
     resolveResumeProfile(ctx: Ctx, lane: LaneRecord, workerId: string): ResolvedResumeProfile;
     selectAutomaticClaudeResumeAccount(ctx: Ctx, lane: LaneRecord, workerProfile?: ResolvedResumeProfile, options?: {
         repairUnavailableAccount?: boolean;
@@ -186,7 +199,7 @@ export interface LaneMessageHandlerDeps {
     validateResumeProfileModel(ctx: Ctx, lane: LaneRecord, profile: WorkerProfile): void;
     withResumeHireAdmission<T>(ctx: Ctx, lane: LaneRecord, fn: () => T, grantContext?: OutpostHireGrantContext): Promise<T>;
 }
-export interface LaneResumeHandlerDeps extends Pick<LaneMessageHandlerDeps, "onLaneWorkerStarted" | "archiveResumeMessage" | "assertLaneRunsHereForAdmission" | "assertLaneRunsHereForOperatorMutation" | "assessLaneAdmission" | "casUpdateLane" | "laneIsHostedHere" | "laneWithRecoveredProviderSession" | "mintMessageId" | "prepareAccountMove" | "persistClaudeAccountSelection" | "printJson" | "recordResumeSetup" | "resolveCommandLane" | "resolveResumeProfile" | "selectAutomaticClaudeResumeAccount" | "validateResumeProfileModel" | "withResumeHireAdmission"> {
+export interface LaneResumeHandlerDeps extends Pick<LaneMessageHandlerDeps, "onLaneWorkerStarted" | "archiveResumeMessage" | "assertLaneRunsHereForAdmission" | "assertLaneRunsHereForOperatorMutation" | "assessLaneAdmission" | "casUpdateLane" | "laneIsHostedHere" | "laneWithRecoveredProviderSession" | "mintMessageId" | "prepareAccountMove" | "persistClaudeAccountSelection" | "printJson" | "recordResumeSetup" | "resolveCommandLane" | "hasPendingQuestionForLane" | "cancelFallbackQuestionsForLane" | "resolveResumeProfile" | "selectAutomaticClaudeResumeAccount" | "validateResumeProfileModel" | "withResumeHireAdmission"> {
     dispatchOutpostLaneCommand(ctx: Ctx, lane: LaneRecord, action: "resume", options: LaneResumeOptions, behavior?: OutpostLaneDispatchBehavior): Promise<void>;
     authorizeFailedResume(ctx: Ctx, lane: LaneRecord, encodedContext?: string): string;
     authorizeResumeProfileRepin(ctx: Ctx, lane: LaneRecord, profile: ResolvedResumeProfile | undefined, encodedContext: string | undefined): ResumeProfileRepinAuthorization | undefined;
@@ -380,6 +393,7 @@ export interface LaneQuestionsHandlerDeps {
     assertQuestionAnswerAuthorized(ctx: Ctx, lane: LaneRecord): void;
     assertQuestionCompanyMatchesLane(question: QuestionRecord, lane: Pick<LaneRecord, "lane_id" | "company" | "mesh_company" | "project_id">, code: string, hqRoot?: string): void;
     casUpdateQuestion(hqRoot: string, questionId: string, updater: (current: QuestionRecord) => QuestionRecord): QuestionRecord;
+    casUpdateLane(hqRoot: string, laneId: string, updater: (current: LaneRecord) => LaneRecord): LaneRecord;
     effectiveLaneQuestionCompany(lane: Pick<LaneRecord, "company" | "mesh_company" | "project_id" | "lane_id">, hqRoot?: string): LaneCompanyRef | null;
     emitLaneMeshEvent(ctx: Ctx, company: LaneCompanyRef | null | undefined, threadId: string | undefined, event: LaneMeshEvent, payload: Record<string, unknown>): Promise<void>;
     groupQuestionLanesByCompany(hqRoot: string, lanes: LaneRecord[], fallbackCompany?: LaneCompanyRef): QuestionCompanyGroup[];

package/dist/commands/lanes-watch.js

@@ -1,5 +1,5 @@
 import { accountStatus, coveredLaneIds, loadLanesConfig, MAX_WATCHED_LANES, MONITOR_ENGINES, MONITOR_MAX_TIMEOUT_MS, MONITOR_UNCOVERED_EXIT_CODE, monitorReminderText, runLaneWatch, } from "../lib/lanes/index.js";
-import { LEAD_LANE_KEEP_ALIVE_FLAG } from "../lib/lanes/keep-alive.js";
+import { LEAD_LANE_KEEP_ALIVE_FLAG, LEAD_LANE_KEEP_ALIVE_NEXT_CHECK_FLAG } from "../lib/lanes/keep-alive.js";
 import { resolveLaneCompany } from "../lib/lanes/lane-company.js";
 import { readLanesRegistryFlag } from "../lib/lanes/registry-flag.js";
 import { isLanesError, LanesError } from "../lib/lanes/errors.js";
@@ -50,6 +50,10 @@ export function createLaneWatchHandlers(deps) {
                 company: resolveLaneCompany(hqRoot, lane).company ?? undefined,
                 env: ctx.env,
             }),
+            keepAliveNextCheckAtEnabled: (lane) => readLanesRegistryFlag(LEAD_LANE_KEEP_ALIVE_NEXT_CHECK_FLAG, {
+                company: resolveLaneCompany(hqRoot, lane).company ?? undefined,
+                env: ctx.env,
+            }),
             readAccountStatuses: async (lanes) => {
                 if (lanes.length === 0)
                     return [];

package/dist/commands/lanes.d.ts

@@ -31,6 +31,8 @@ export { emitLaneDecisionEvents };
 export interface LanesCommandDeps {
     /** Test seam for failures after a lane provider worker is started. */
     onLaneWorkerStarted?: (laneId: string, command: "message" | "resume") => void;
+    /** Test seam for failures after a message is durably queued. */
+    onLaneMessageQueued?: (laneId: string, path: "admission" | "account_move") => void;
     hqRoot?: () => string;
     /** Start HQ-root walk here instead of process.cwd(). Tests only. */
     cwd?: () => string;