@indigoai-us/hq-cli 5.301.0 → 5.303.0

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,11 +137,20 @@ 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. */
@@ -177,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;
@@ -188,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;
@@ -382,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.js

@@ -55,11 +55,11 @@ import { createLaneMesh, emitLaneDecisionEvents, emitLaneTerminalStateEvent, lan
 import { sessionIdFromEnv } from "../lib/mesh/live/session-identity.js";
 import { listLaneReviews } from "../lib/lanes/reviews.js";
 import { effectiveAccountHome } from "../lib/lanes/account-home.js";
-import { AccountResolutionError, compareLaneQueueOrder, LANE_PROVIDERS, LANE_STATES, QUESTION_STATUSES, SENIOR_KINDS, accountStatus, appendCappedHistory, canonicalizeHome, createLane, decideAdmission, defaultLivenessDeps, defaultSystemdUserDir, defaultThrottleDeps, installReconcileTimer, providerPathEnv, probeDrainHookRegistration, isLanesError, isLaneVersionConflict, isTerminalLaneState, aliveDirectChildren, assignedChildHireGrants, hireGrantCapacityError, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, laneStoryLedgerEnabled, validateProjectStories, buildLaneStatusSnapshot, formatLaneStatusHuman, listLaneIds, listQuestionIds, loadLanesConfig, laneRunsHere, MAX_LANE_DEPTH, MONITOR_ERROR_EXIT_CODE, readLiveMonitorEvidence, resolveMachineIdentity as lookupMachineIdentity, loadLivenessIndex, parseLaneProvider, parseLaneRecord, parseLaneState, parseQuestionRecord, parseSeniorKind, readAllLanes, readLane, sanitizeHostComponent, retryUpdateLane, syncLaneRecordFromOwner, readQuestion, resolveAccount, resolveLaneWorker, ignoredWorkerProfileFields, loadWorkerProfile, loadWorkerProfileWithRegistry, registryWorkerRecord, runReconcilePass, sessionLiveness, tryReadLane, uninstallReconcileTimer, updateLane, updateQuestion, dropboxDir, laneDeliveryMechanism, hasActiveAdmissionReservation, hasActivePendingResume, hasRecordedSessionId, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, providerSupportsSessionResume, providerSessionPortable, sessionNotPortableMessage, withLaneAdmissionLock, withAllLaneAdmissionLocks, readWorkerRunResult, resumeCommandRefusal, withLaneHireLocks, raiseLaneQuestion, sha256Text, } from "../lib/lanes/index.js";
+import { AccountResolutionError, compareLaneQueueOrder, LANE_PROVIDERS, LANE_STATES, QUESTION_STATUSES, SENIOR_KINDS, accountStatus, appendCappedHistory, canonicalizeHome, createLane, decideAdmission, defaultLivenessDeps, defaultSystemdUserDir, defaultThrottleDeps, installReconcileTimer, providerPathEnv, probeDrainHookRegistration, isLanesError, isLaneVersionConflict, isTerminalLaneState, aliveDirectChildren, assignedChildHireGrants, hireGrantCapacityError, planHireGrantBackfill, terminalChildResumeHireGrantError, withHireGrantAdmission, laneStoryLedgerEnabled, validateProjectStories, buildLaneStatusSnapshot, formatLaneStatusHuman, listLaneIds, listQuestionIds, loadLanesConfig, laneRunsHere, MAX_LANE_DEPTH, MONITOR_ERROR_EXIT_CODE, readLiveMonitorEvidence, resolveMachineIdentity as lookupMachineIdentity, loadLivenessIndex, parseLaneProvider, parseLaneRecord, parseLaneState, parseQuestionRecord, parseSeniorKind, readAllLanes, readLane, sanitizeHostComponent, retryUpdateLane, syncLaneRecordFromOwner, readQuestion, resolveAccount, resolveLaneWorker, ignoredWorkerProfileFields, loadWorkerProfile, loadWorkerProfileWithRegistry, registryWorkerRecord, runReconcilePass, DEAD_HOST_MS, sessionLiveness, tryReadLane, uninstallReconcileTimer, updateLane, updateQuestion, dropboxDir, laneDeliveryMechanism, hasActiveAdmissionReservation, hasActivePendingResume, hasRecordedSessionId, hasEarlierEligibleQueuedLane, laneAdmissionCapReason, providerSupportsSessionResume, providerSessionPortable, sessionNotPortableMessage, withLaneAdmissionLock, withAllLaneAdmissionLocks, readWorkerRunResult, resumeCommandRefusal, withLaneHireLocks, raiseLaneQuestion, sha256Text, } from "../lib/lanes/index.js";
 import { laneStories, storyWarning, } from "../lib/lanes/stories.js";
 import { resolveLaneKeepAlive } from "../lib/lanes/profile.js";
 import { resolveLaneCompany } from "../lib/lanes/lane-company.js";
-import { doneKeepAliveVerdict, hasPendingKeepAliveWork, keepAliveExclusion, LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, loadRetiredLaneIds, } from "../lib/lanes/keep-alive.js";
+import { doneKeepAliveVerdict, hasPendingKeepAliveWork, keepAliveNextCheckAtMs, keepAliveExclusion, LANE_SUPERSESSION_LINEAGE_AWARE_FLAG, LEAD_LANE_KEEP_ALIVE_NEXT_CHECK_FLAG, loadRetiredLaneIds, } from "../lib/lanes/keep-alive.js";
 import { questionBodyAbsPath, resolveQuestionCompanyWithFallback, resolveProjectQuestionCompany, } from "../lib/lanes/questions.js";
 import { assertQuestionBodySecretSafe } from "../lib/lanes/questions.js";
 import { compactionAfterUsage, } from "../lib/lanes/compaction.js";
@@ -1260,6 +1260,8 @@ async function refreshRemoteLaneMirrors(ctx, hqRoot, records, parentLaneIds, opt
         unverifiedRemote: new Map(),
         missingOnOwner: new Map(),
     };
+    const now = ctx.now();
+    const nowMs = now.getTime();
     const host = reconcileHostFromCtx(ctx);
     if (ctx.env.HQ_LANES_REMOTE_READ === "1" || parentLaneIds?.size === 0)
         return result;
@@ -1282,6 +1284,9 @@ async function refreshRemoteLaneMirrors(ctx, hqRoot, records, parentLaneIds, opt
         ((parentLaneIds === undefined || (lane.senior.kind === "lane" &&
             lane.senior.id !== undefined &&
             parentLaneIds.has(lane.senior.id))) || options.laneIds?.has(lane.lane_id) === true) &&
+        !(isTerminalLaneState(lane.state) &&
+            lane.terminal_reason === DISPATCH_TERMINAL_REASON &&
+            lane.last_host_report_at === undefined) &&
         (options.includeTerminalMirrors === true || !isTerminalLaneState(lane.state)))
         .sort((a, b) => {
         const terminalOrder = Number(isTerminalLaneState(a.state)) - Number(isTerminalLaneState(b.state));
@@ -1389,11 +1394,20 @@ async function refreshRemoteLaneMirrors(ctx, hqRoot, records, parentLaneIds, opt
                 result.updated.set(mirror.lane_id, before);
                 continue;
             }
+            const ownerReportAtMs = Date.parse(owner.last_host_report_at ?? "");
+            const ownerReportIsFresh = owner.state === "running" &&
+                Number.isFinite(ownerReportAtMs) &&
+                ownerReportAtMs <= nowMs + 60_000 &&
+                nowMs - ownerReportAtMs < DEAD_HOST_MS;
+            const mirroredReportAt = ownerReportIsFresh
+                ? new Date(Math.min(ownerReportAtMs, nowMs)).toISOString()
+                : undefined;
             const needsUpdate = before.state !== owner.state ||
                 before.queued_reason !== (owner.state === "queued" ? owner.queued_reason : undefined) ||
                 JSON.stringify(before.queued_details) !== JSON.stringify(owner.state === "queued" ? owner.queued_details : undefined) ||
                 before.ended_at !== endedAt ||
                 before.envelope_summary !== envelopeSummary ||
+                (mirroredReportAt !== undefined && before.last_host_report_at !== mirroredReportAt) ||
                 (isTerminalLaneState(owner.state) && (JSON.stringify(before.last_envelope) !== JSON.stringify(owner.last_envelope) ||
                     before.story_complete !== owner.story_complete ||
                     before.story_complete_reason !== owner.story_complete_reason ||
@@ -1420,6 +1434,8 @@ async function refreshRemoteLaneMirrors(ctx, hqRoot, records, parentLaneIds, opt
                     queued_details: owner.state === "queued" ? owner.queued_details : undefined,
                     ended_at: endedAt,
                     envelope_summary: envelopeSummary,
+                    // Preserve a fresh owner report; clamp small clock skew to the primary's time.
+                    ...(mirroredReportAt !== undefined ? { last_host_report_at: mirroredReportAt } : {}),
                     ...(isTerminalLaneState(owner.state) ? {
                         last_envelope: owner.last_envelope,
                         story_complete: owner.story_complete,
@@ -4261,10 +4277,29 @@ async function dispatchOutpostLaneCommand(ctx, lane, action, options, behavior =
             remote.delivery_status === "queued_on_target_account" ||
             remote.delivery_status === "queued_on_admission")) {
         const ownerLane = dispatchedOwnerLane(ctx, lane.lane_id, outpostId, remote.lane, behavior);
+        const questionCancellation = lane.state === "awaiting_input" && behavior.afterFallbackResume
+            ? await behavior.afterFallbackResume()
+            : undefined;
+        const ownerCancelledQuestions = Array.isArray(remote.cancelled_questions)
+            ? remote.cancelled_questions.filter((id) => typeof id === "string")
+            : [];
+        const ownerCancellationFailures = Array.isArray(remote.question_cancellation_failures)
+            ? remote.question_cancellation_failures
+            : [];
         printJson({
             ...remote,
             lane_id: ownerLane.lane_id,
             lane: ownerLane,
+            ...(questionCancellation === undefined ? {} : {
+                cancelled_questions: [...new Set([
+                        ...ownerCancelledQuestions,
+                        ...questionCancellation.cancelled_question_ids,
+                    ])],
+                question_cancellation_failures: [
+                    ...ownerCancellationFailures,
+                    ...questionCancellation.failures,
+                ],
+            }),
             outpost_id: outpostId,
             outpost_command_id: dispatched.commandId,
             outpost_transport: "outposts_exec",
@@ -4281,10 +4316,29 @@ async function dispatchOutpostLaneCommand(ctx, lane, action, options, behavior =
                 descendants.push(syncLaneRecordFromOwner(ctx.hqRoot(), descendantId, outpostId, ownerDescendant, undefined, { allowNonTerminal: true }));
             }
         }
+        const questionCancellation = action === "resume" && lane.state === "awaiting_input" && behavior.afterFallbackResume
+            ? await behavior.afterFallbackResume()
+            : undefined;
+        const ownerCancelledQuestions = Array.isArray(remote.cancelled_questions)
+            ? remote.cancelled_questions.filter((id) => typeof id === "string")
+            : [];
+        const ownerCancellationFailures = Array.isArray(remote.question_cancellation_failures)
+            ? remote.question_cancellation_failures
+            : [];
         printJson({
             ...remote,
             lane_id: ownerLane.lane_id,
             lane: ownerLane,
+            ...(questionCancellation === undefined ? {} : {
+                cancelled_questions: [...new Set([
+                        ...ownerCancelledQuestions,
+                        ...questionCancellation.cancelled_question_ids,
+                    ])],
+                question_cancellation_failures: [
+                    ...ownerCancellationFailures,
+                    ...questionCancellation.failures,
+                ],
+            }),
             ...(action === "reparent"
                 ? { changed_descendant_ids: changedDescendantIds, descendants }
                 : {}),
@@ -5009,7 +5063,7 @@ async function refreshOutpostLaneCopiesForShow(ctx, lane, localLanes) {
     const refreshedLane = refreshed[0] ?? null;
     return refreshedLane ?? lane;
 }
-async function runShow(ctx, laneId) {
+async function runShow(ctx, laneId, hasPendingQuestionForLane) {
     const hqRoot = ctx.hqRoot();
     const initialLane = readLane(hqRoot, laneId);
     const initialLanes = loadAllLanes(hqRoot);
@@ -5023,10 +5077,24 @@ async function runShow(ctx, laneId) {
         ? { ...storedLane, state: "remote", remote_state: storedLane.state, queued_reason: undefined, queued_details: undefined }
         : storedLane;
     const askDeliveryFailed = readJsonFile(askDeliveryFailedPath(hqRoot, laneId));
+    const delivery = storedLane.state === "awaiting_input" &&
+        await hasPendingQuestionForLane(ctx, storedLane)
+        ? "questions"
+        : laneDeliveryMechanism(storedLane);
     const keepAliveState = resolveLaneKeepAlive(hqRoot, storedLane);
     const keepAliveCompany = resolveLaneCompany(hqRoot, storedLane);
+    const now = ctx.now().getTime();
+    const nextCheckAtEnabled = storedLane.state === "done" && storedLane.keep_alive === true
+        ? await readLanesRegistryFlag(LEAD_LANE_KEEP_ALIVE_NEXT_CHECK_FLAG, {
+            company: keepAliveCompany.company ?? undefined,
+            env: ctx.env,
+        })
+        : false;
+    const hasPendingWork = storedLane.keep_alive_standing === true || nextCheckAtEnabled
+        ? hasPendingKeepAliveWork(hqRoot, storedLane)
+        : false;
     const doneStateVerdict = storedLane.state === "done" && storedLane.keep_alive === true
-        ? doneKeepAliveVerdict(storedLane, { decision: storedLane.last_envelope?.decision, story_complete: storedLane.story_complete }, storedLane.keep_alive_standing === true && hasPendingKeepAliveWork(hqRoot, storedLane))
+        ? doneKeepAliveVerdict(storedLane, { decision: storedLane.last_envelope?.decision, story_complete: storedLane.story_complete, next_check_at: storedLane.last_envelope?.next_check_at }, storedLane.keep_alive_standing === true && hasPendingWork, { nextCheckAtEnabled, hasPendingWork, nowMs: now })
         : null;
     let managerStatusTarget;
     let managerStatusGateError;
@@ -5048,7 +5116,15 @@ async function runShow(ctx, laneId) {
         now: ctx.now().getTime(),
     });
     const laneIsSenior = allLanes.some((item) => item.senior.kind === "lane" && item.senior.id === laneId);
-    const now = ctx.now().getTime();
+    const requestedNextCheckMs = nextCheckAtEnabled && !hasPendingWork
+        ? keepAliveNextCheckAtMs(storedLane.last_envelope?.next_check_at, now, Date.parse(storedLane.last_envelope?.at ?? storedLane.updated_at))
+        : undefined;
+    const storedNextEligibleMs = Date.parse(storedLane.keep_alive_next_eligible_at ?? "");
+    const nextEligibleAt = Number.isFinite(storedNextEligibleMs) && requestedNextCheckMs !== undefined
+        ? new Date(Math.max(storedNextEligibleMs, requestedNextCheckMs)).toISOString()
+        : requestedNextCheckMs !== undefined
+            ? new Date(requestedNextCheckMs).toISOString()
+            : storedLane.keep_alive_next_eligible_at ?? null;
     const reviewListing = laneIsSenior
         ? listLaneReviews(hqRoot, laneId)
         : { reviews: [], skipped: 0 };
@@ -5075,7 +5151,7 @@ async function runShow(ctx, laneId) {
         stalled_at: lane.stalled_at ?? null,
         stalled_reason: lane.stalled_reason ?? null,
         ask_delivery_failed: askDeliveryFailed,
-        delivery: laneDeliveryMechanism(storedLane),
+        delivery,
         provider_session_id: lane.provider_session_id ?? null,
         provider_session_id_absent: lane.provider_session_id_absent ?? null,
         envelope_repair_mode: lane.envelope_repair?.mode ?? null,
@@ -5108,7 +5184,7 @@ async function runShow(ctx, laneId) {
             consecutive_auto_resumes: lane.keep_alive_resume_count ?? 0,
             last_auto_resume_at: lane.keep_alive_last_resume_at ?? null,
             keep_alive_history: lane.keep_alive_history ?? [],
-            next_eligible_at: lane.keep_alive_next_eligible_at ?? null,
+            next_eligible_at: nextEligibleAt,
             exhausted_at: lane.keep_alive_exhausted_at ?? null,
         },
         manager_status_gate: managerStatusGateError !== undefined
@@ -5134,6 +5210,7 @@ async function runShow(ctx, laneId) {
                 escalated: blockerFreshness.stale.length > 0 &&
                     storedLane.blocker_freshness_state?.escalated_fingerprint ===
                         blockerFreshnessFingerprint(blockerFreshness.stale),
+                undeliverable_reason: storedLane.blocker_freshness_state?.undeliverable_reason ?? null,
             }
             : null,
         kr_freshness: krFreshness,
@@ -7807,6 +7884,7 @@ export function registerLanesCommand(parent, deps = {}) {
         assertQuestionAnswerAuthorized,
         assertQuestionCompanyMatchesLane,
         casUpdateQuestion,
+        casUpdateLane,
         effectiveLaneQuestionCompany,
         emitLaneMeshEvent,
         groupQuestionLanesByCompany,
@@ -7857,6 +7935,8 @@ export function registerLanesCommand(parent, deps = {}) {
         recordResumeSetup,
         resolveCommandLane: (commandCtx, laneId) => resolveCommandLaneTarget(commandCtx, laneId),
         resolveActiveQuestionCompany,
+        hasPendingQuestionForLane: questionHandlers.hasPendingQuestionForLane,
+        cancelFallbackQuestionsForLane: questionHandlers.cancelFallbackQuestionsForLane,
         resolveResumeProfile,
         selectAutomaticClaudeResumeAccount,
         validateResumeProfileModel,
@@ -7882,6 +7962,8 @@ export function registerLanesCommand(parent, deps = {}) {
         printJson,
         recordResumeSetup,
         resolveCommandLane: (commandCtx, laneId) => resolveCommandLaneTarget(commandCtx, laneId),
+        hasPendingQuestionForLane: questionHandlers.hasPendingQuestionForLane,
+        cancelFallbackQuestionsForLane: questionHandlers.cancelFallbackQuestionsForLane,
         resolveResumeProfile,
         selectAutomaticClaudeResumeAccount,
         validateResumeProfileModel,
@@ -8153,7 +8235,7 @@ export function registerLanesCommand(parent, deps = {}) {
         .description("Show one lane")
         .argument("<lane-id>", "Lane id")
         .action(wrap(async (laneId) => {
-        await runShow(ctx, laneId);
+        await runShow(ctx, laneId, questionHandlers.hasPendingQuestionForLane);
     }));
     const stories = lanes
         .command("story")
@@ -8290,7 +8372,7 @@ export function registerLanesCommand(parent, deps = {}) {
     }));
     lanes
         .command("resume")
-        .description("Resume an interrupted, done or blocked lane on its recorded provider session; recover failed lanes with the senior-only --from-failed option")
+        .description("Resume an interrupted, done or blocked lane, or an awaiting_input lane with no answerable question; recover failed lanes with the senior-only --from-failed option")
         .argument("<lane-id>", "Lane id")
         .option("--text <msg>", "Operator message for the resumed turn")
         .option("--from-failed", "Explicitly resume a failed lane as its senior")

package/dist/commands/monitor.js

@@ -278,6 +278,7 @@ async function startMonitor(options, argv = []) {
         cwd: meta.cwd,
         env: { ...env, HQ_ROOT: hqRoot },
         detached: true,
+        windowsHide: true,
         stdio: "ignore",
     });
     child.once("error", (err) => {
@@ -347,7 +348,21 @@ async function showMonitor(id, json) {
     const state = stateForDisplay(hqRoot, id, readJson(statePath(hqRoot, id)));
     if (!meta || !state)
         throw new LanesError("monitor_not_found", `Monitor ${id} was not found.`, { monitor_id: id });
-    const events = fs.readFileSync(path.join(dir, "events.jsonl"), "utf8").split("\n").filter(Boolean).map((line) => JSON.parse(line));
+    const events = [];
+    for (const line of fs.readFileSync(path.join(dir, "events.jsonl"), "utf8").split("\n")) {
+        if (!line.trim())
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+            continue;
+        events.push(parsed);
+    }
     if (json)
         printJson({ meta, state, events });
     else
@@ -712,7 +727,7 @@ export async function runSupervisor(id, deps = {}) {
     const args = meta.command !== null ? childArgs : childArgs.slice(1);
     if (!executable)
         throw new LanesError("monitor_command_required", "No command was recorded for this monitor.");
-    commandChild = (deps.spawn ?? spawn)(executable, args, { cwd: meta.cwd, env: process.env, detached: true, stdio: ["ignore", "pipe", "pipe"] });
+    commandChild = (deps.spawn ?? spawn)(executable, args, { cwd: meta.cwd, env: process.env, detached: true, windowsHide: true, stdio: ["ignore", "pipe", "pipe"] });
     if (commandChild.pid) {
         state = { ...state, child_pid: commandChild.pid, child_starttime: readProcStarttime(commandChild.pid) };
         writeJsonAtomic(statePath(hqRoot, id), state);

package/dist/commands/report.js

@@ -6,6 +6,7 @@ import * as path from "node:path";
 import { ensureCognitoToken, } from "../utils/cognito-session.js";
 import { vaultApiFetch } from "../utils/vault-api.js";
 import { DEPLOY_API_URL, deployApiRequest, deployHeaders } from "../lib/deploy-api.js";
+import { listDeployApps } from "../lib/deploy-apps.js";
 import { listReportTemplates } from "../lib/report-templates.js";
 import { adoptReport, buildReportTarball, conventionReportDir, deployOrgContext, ReportPublishError, plainFailureReason, publishReport, } from "../lib/report-publish.js";
 const REPORT_CHANNEL_STATE_FILE = "report-channels.json";
@@ -259,8 +260,10 @@ async function orgFor(token, report) {
     return deployOrgContext(report, slug);
 }
 export async function findOrCreateApp(token, slug, org) {
-    const listed = await deployJson(token, "/api/apps", "GET", undefined, org.headers);
-    const apps = Array.isArray(listed.apps) ? listed.apps : [];
+    const apps = await listDeployApps((cursor) => {
+        const route = cursor ? `/api/apps?cursor=${encodeURIComponent(cursor)}` : "/api/apps";
+        return deployJson(token, route, "GET", undefined, org.headers);
+    });
     const mine = (name) => apps.find((app) => !!app && typeof app === "object" && (app.subdomain === name || app.name === name));
     let app;
     for (const name of candidateSlugs(slug)) {

package/dist/commands/rescue.d.ts

@@ -45,5 +45,9 @@ export declare function shouldAttemptSelfUpdate(opts: {
     check?: boolean;
     selfUpdate?: boolean;
 }): boolean;
+/** Latest release tag for a repo, e.g. `v12.3.0`. Throws on failure. */
+export declare function getLatestReleaseTag(repo: string, token?: string): Promise<string>;
+/** Resolve a tag to its commit SHA, dereferencing annotated tags. */
+export declare function resolveTagSha(repo: string, tag: string, token?: string): Promise<string>;
 export declare function registerRescueCommand(program: Command): void;
 //# sourceMappingURL=rescue.d.ts.map