@indigoai-us/hq-cli 5.191.0 → 5.192.1

package/dist/lib/agents/model-catalog.d.ts

@@ -0,0 +1,61 @@
+export declare const AGENT_MODEL_PROVIDERS: readonly ["codex", "grok", "claude"];
+export type AgentModelProvider = (typeof AGENT_MODEL_PROVIDERS)[number];
+export interface AgentCatalogModel {
+    id: string;
+    label: string;
+    visibility: string;
+    isNew: boolean;
+    authModes: string[];
+    efforts: string[];
+    selectable: boolean;
+    unavailableReason?: string | null;
+}
+export interface AgentCatalogProvider {
+    models: AgentCatalogModel[];
+    defaultModel: string;
+}
+export interface AgentModelCatalog {
+    providers: Record<AgentModelProvider, AgentCatalogProvider>;
+    generatedAt: string;
+}
+export type AgentModelCatalogResult = {
+    ok: true;
+    catalog: AgentModelCatalog;
+    etag: string;
+    fetchedAt: number;
+    source: "network" | "cache";
+} | {
+    ok: false;
+    reason: "unavailable";
+} | {
+    ok: false;
+    reason: "request_failed";
+    status: number;
+};
+export interface ReadAgentModelCatalogOptions {
+    baseUrl?: string;
+    cacheFile?: string;
+    now?: () => number;
+    request?: (headers: Record<string, string>, signal: AbortSignal) => Promise<Response>;
+    timeoutMs?: number;
+}
+/** Use the same effective state directory as the CLI's person-token cache. */
+export declare function agentModelCatalogCacheFile(baseUrl?: string, home?: string, env?: NodeJS.ProcessEnv): string;
+/** Parse the documented response without constraining forward-compatible string values. */
+export declare function parseAgentModelCatalog(value: unknown): AgentModelCatalog | null;
+/** Read the live endpoint, conditionally refresh it, and fall back to the last good cache. */
+export declare function readAgentModelCatalog(token: string, options?: ReadAgentModelCatalogOptions): Promise<AgentModelCatalogResult>;
+export type ModelSelectionResult = {
+    ok: true;
+} | {
+    ok: false;
+    reason: "unknown" | "not_selectable";
+    provider?: AgentModelProvider;
+    suggestions: string[];
+};
+/** Check an explicit model against the selected provider or inferred agents-v2 brain. */
+export declare function validateAgentModelSelection(catalog: AgentModelCatalog, modelId: string, chosenProvider?: string): ModelSelectionResult;
+export declare function modelSelectionErrorMessage(modelId: string, result: Extract<ModelSelectionResult, {
+    ok: false;
+}>): string;
+//# sourceMappingURL=model-catalog.d.ts.map

package/dist/lib/agents/model-catalog.js

@@ -0,0 +1,275 @@
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { DEFAULT_VAULT_API_URL, personTokenCacheFile } from "../../utils/cognito-session.js";
+import { vaultApiFetch } from "../../utils/vault-api.js";
+export const AGENT_MODEL_PROVIDERS = ["codex", "grok", "claude"];
+const MODEL_CATALOG_REQUEST_TIMEOUT_MS = 15_000;
+/** Use the same effective state directory as the CLI's person-token cache. */
+export function agentModelCatalogCacheFile(baseUrl = DEFAULT_VAULT_API_URL, home = os.homedir(), env = process.env) {
+    const scope = createHash("sha256").update(baseUrl).digest("hex").slice(0, 16);
+    return path.join(path.dirname(personTokenCacheFile(home, env)), `agent-model-catalog-${scope}.json`);
+}
+/** Parse the documented response without constraining forward-compatible string values. */
+export function parseAgentModelCatalog(value) {
+    if (!isRecord(value) || !isRecord(value.providers))
+        return null;
+    if (typeof value.generatedAt !== "string" || !Number.isFinite(Date.parse(value.generatedAt))) {
+        return null;
+    }
+    const providers = {};
+    for (const provider of AGENT_MODEL_PROVIDERS) {
+        const rawProvider = value.providers[provider];
+        if (!isRecord(rawProvider) ||
+            !Array.isArray(rawProvider.models) ||
+            typeof rawProvider.defaultModel !== "string") {
+            return null;
+        }
+        const models = [];
+        for (const rawModel of rawProvider.models) {
+            if (!isRecord(rawModel) ||
+                typeof rawModel.id !== "string" ||
+                !/^[A-Za-z0-9._-]{1,128}$/.test(rawModel.id) ||
+                typeof rawModel.label !== "string" ||
+                typeof rawModel.visibility !== "string" ||
+                typeof rawModel.isNew !== "boolean" ||
+                !isStringArray(rawModel.authModes) ||
+                !isStringArray(rawModel.efforts) ||
+                typeof rawModel.selectable !== "boolean" ||
+                (rawModel.unavailableReason !== undefined &&
+                    rawModel.unavailableReason !== null &&
+                    typeof rawModel.unavailableReason !== "string")) {
+                return null;
+            }
+            models.push({
+                id: rawModel.id,
+                label: rawModel.label,
+                visibility: rawModel.visibility,
+                isNew: rawModel.isNew,
+                authModes: rawModel.authModes,
+                efforts: rawModel.efforts,
+                selectable: rawModel.selectable,
+                ...(rawModel.unavailableReason !== undefined
+                    ? { unavailableReason: rawModel.unavailableReason }
+                    : {}),
+            });
+        }
+        if (!models.some((model) => model.id === rawProvider.defaultModel && model.selectable)) {
+            return null;
+        }
+        providers[provider] = { models, defaultModel: rawProvider.defaultModel };
+    }
+    return { providers, generatedAt: value.generatedAt };
+}
+/** Read the live endpoint, conditionally refresh it, and fall back to the last good cache. */
+export async function readAgentModelCatalog(token, options = {}) {
+    const baseUrl = options.baseUrl ?? DEFAULT_VAULT_API_URL;
+    const cacheFile = options.cacheFile ?? agentModelCatalogCacheFile(baseUrl);
+    const now = options.now ?? Date.now;
+    const signal = AbortSignal.timeout(options.timeoutMs ?? MODEL_CATALOG_REQUEST_TIMEOUT_MS);
+    const cached = readCache(cacheFile);
+    const headers = cached
+        ? { "If-None-Match": cached.etag }
+        : {};
+    let response;
+    try {
+        response = options.request
+            ? await options.request(headers, signal)
+            : await vaultApiFetch({ token, baseUrl, path: "/v1/agents/models", headers, signal });
+    }
+    catch {
+        return cached ? fromCache(cached) : { ok: false, reason: "unavailable" };
+    }
+    if (response.status === 304) {
+        if (!cached)
+            return { ok: false, reason: "unavailable" };
+        const refreshed = {
+            ...cached,
+            etag: response.headers.get("etag") ?? cached.etag,
+            fetchedAt: now(),
+        };
+        if (isStrongEtag(refreshed.etag))
+            writeCache(cacheFile, refreshed);
+        return fromCache(refreshed, "network");
+    }
+    if (response.status === 404 || response.status === 429 || response.status >= 500) {
+        return cached ? fromCache(cached) : { ok: false, reason: "unavailable" };
+    }
+    if (!response.ok) {
+        return { ok: false, reason: "request_failed", status: response.status };
+    }
+    try {
+        const catalog = parseAgentModelCatalog(await response.json());
+        const etag = response.headers.get("etag");
+        if (!catalog || !etag || !isStrongEtag(etag)) {
+            return cached ? fromCache(cached) : { ok: false, reason: "unavailable" };
+        }
+        const entry = {
+            version: 1,
+            catalog,
+            etag,
+            fetchedAt: now(),
+        };
+        writeCache(cacheFile, entry);
+        return { ok: true, ...entry, source: "network" };
+    }
+    catch {
+        return cached ? fromCache(cached) : { ok: false, reason: "unavailable" };
+    }
+}
+/** Check an explicit model against the selected provider or inferred agents-v2 brain. */
+export function validateAgentModelSelection(catalog, modelId, chosenProvider) {
+    const provider = isCatalogProvider(chosenProvider) ? chosenProvider : undefined;
+    const inferred = providerFromModelId(modelId);
+    const providers = provider
+        ? [provider]
+        : inferred
+            ? [inferred]
+            : [...AGENT_MODEL_PROVIDERS];
+    const rows = providers.flatMap((name) => catalog.providers[name].models.map((model) => ({ provider: name, model })));
+    const exact = rows.find(({ model }) => model.id.toLowerCase() === modelId.toLowerCase());
+    if (exact?.model.selectable)
+        return { ok: true };
+    const suggestions = closestSelectableModels(modelId, rows.filter(({ model }) => model.selectable).map(({ model }) => model.id));
+    return {
+        ok: false,
+        reason: exact ? "not_selectable" : "unknown",
+        ...(providers.length === 1 ? { provider: providers[0] } : {}),
+        suggestions,
+    };
+}
+export function modelSelectionErrorMessage(modelId, result) {
+    const scope = result.provider ? `the ${result.provider} catalog` : "the model catalog";
+    const problem = result.reason === "not_selectable" ? "not selectable in" : "not listed in";
+    const suggestion = result.suggestions.length
+        ? ` Close matches: ${result.suggestions.join(", ")}.`
+        : "";
+    const command = result.provider
+        ? ` Run \`hq agents models --provider ${result.provider}\` to see available models.`
+        : " Run `hq agents models` to see available models.";
+    return `Model '${modelId}' is ${problem} ${scope}.${suggestion}${command}`;
+}
+function providerFromModelId(modelId) {
+    const normalized = modelId.toLowerCase();
+    if (normalized.startsWith("gpt-"))
+        return "codex";
+    if (normalized.startsWith("grok-"))
+        return "grok";
+    if (normalized.startsWith("claude-"))
+        return "claude";
+    return undefined;
+}
+function closestSelectableModels(modelId, candidates) {
+    const needle = modelId.toLowerCase();
+    return candidates
+        .map((id) => ({
+        id,
+        distance: editDistance(needle, id.toLowerCase()),
+        prefix: commonPrefixLength(needle, id.toLowerCase()),
+    }))
+        .filter(({ distance, id }) => distance <= Math.max(2, Math.floor(needle.length / 4)) ||
+        id.toLowerCase().startsWith(needle))
+        .sort((a, b) => a.distance - b.distance || b.prefix - a.prefix || a.id.localeCompare(b.id))
+        .slice(0, 3)
+        .map(({ id }) => id);
+}
+function editDistance(left, right) {
+    let previous = Array.from({ length: right.length + 1 }, (_, index) => index);
+    for (let i = 1; i <= left.length; i += 1) {
+        const current = [i];
+        for (let j = 1; j <= right.length; j += 1) {
+            current[j] = Math.min(current[j - 1] + 1, previous[j] + 1, previous[j - 1] + (left[i - 1] === right[j - 1] ? 0 : 1));
+        }
+        previous = current;
+    }
+    return previous[right.length];
+}
+function commonPrefixLength(left, right) {
+    let index = 0;
+    while (index < left.length && index < right.length && left[index] === right[index])
+        index += 1;
+    return index;
+}
+function readCache(file) {
+    let serialized;
+    try {
+        serialized = fs.readFileSync(file, "utf8");
+    }
+    catch (error) {
+        if (isMissingFile(error))
+            return null;
+        console.warn("Unable to read the model catalog cache; continuing without cached data.");
+        return null;
+    }
+    let value;
+    try {
+        value = JSON.parse(serialized);
+    }
+    catch {
+        console.warn("Ignoring an invalid model catalog cache file.");
+        return null;
+    }
+    if (!isRecord(value) || value.version !== 1 || !isStrongEtag(value.etag)) {
+        console.warn("Ignoring an invalid model catalog cache file.");
+        return null;
+    }
+    if (typeof value.fetchedAt !== "number" || !Number.isFinite(value.fetchedAt)) {
+        console.warn("Ignoring an invalid model catalog cache file.");
+        return null;
+    }
+    const catalog = parseAgentModelCatalog(value.catalog);
+    if (!catalog) {
+        console.warn("Ignoring an invalid model catalog cache file.");
+        return null;
+    }
+    return { version: 1, catalog, etag: value.etag, fetchedAt: value.fetchedAt };
+}
+function writeCache(file, cache) {
+    const temporary = `${file}.${process.pid}.${cache.fetchedAt}.tmp`;
+    try {
+        fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+        fs.writeFileSync(temporary, JSON.stringify(cache), { encoding: "utf8", mode: 0o600 });
+        fs.renameSync(temporary, file);
+    }
+    catch {
+        console.warn("Unable to save the model catalog cache; offline use may be unavailable.");
+        try {
+            fs.rmSync(temporary, { force: true });
+        }
+        catch (error) {
+            if (!isMissingFile(error)) {
+                console.warn("Unable to remove a temporary model catalog cache file.");
+            }
+        }
+    }
+}
+function fromCache(cache, source = "cache") {
+    return {
+        ok: true,
+        catalog: cache.catalog,
+        etag: cache.etag,
+        fetchedAt: cache.fetchedAt,
+        source,
+    };
+}
+function isStrongEtag(value) {
+    return typeof value === "string" &&
+        value.length >= 2 &&
+        value.startsWith('"') &&
+        value.endsWith('"') &&
+        !/[\r\n]/.test(value);
+}
+function isMissingFile(error) {
+    return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+function isCatalogProvider(value) {
+    return value !== undefined && AGENT_MODEL_PROVIDERS.includes(value);
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=model-catalog.js.map

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/dist/lib/report-publish.d.ts

@@ -106,6 +106,7 @@ export declare function ownerFailureNotice(input: {
     body: string;
 } | null;
 export interface ReportAdoptDependencies {
+    preflightJobCreation(): Promise<void>;
     createJob(input: {
         prompt: string;
         schedule: {
@@ -124,8 +125,8 @@ export interface ReportAdoptDependencies {
     patch(report: ChannelReport, patch: ReportPatch): Promise<ChannelReport>;
 }
 export declare class ReportPublishError extends Error {
-    readonly code: "already-running" | "source-invalid" | "deploy-failed" | "job-failed" | "revision-conflict";
-    constructor(message: string, code?: "already-running" | "source-invalid" | "deploy-failed" | "job-failed" | "revision-conflict");
+    readonly code: "already-running" | "source-invalid" | "deploy-failed" | "job-failed" | "job-execution-disabled" | "revision-conflict";
+    constructor(message: string, code?: "already-running" | "source-invalid" | "deploy-failed" | "job-failed" | "job-execution-disabled" | "revision-conflict");
 }
 /** A deliberately boring, token-safe failure reason stored on the report. */
 export declare function plainFailureReason(error: unknown): string;

package/dist/lib/report-publish.js

@@ -41,7 +41,7 @@ export class ReportPublishError extends Error {
 /** A deliberately boring, token-safe failure reason stored on the report. */
 export function plainFailureReason(error) {
     if (error instanceof ReportPublishError) {
-        if (error.code === "source-invalid" || error.code === "job-failed" || error.code === "revision-conflict")
+        if (error.code === "source-invalid" || error.code === "job-failed" || error.code === "job-execution-disabled" || error.code === "revision-conflict")
             return error.message.slice(0, 240);
         if (error.code === "already-running")
             return "already running";
@@ -231,9 +231,11 @@ export async function adoptReport(report, deps) {
         throw new ReportPublishError("Report schedule is missing.", "source-invalid");
     }
     try {
+        const cron = reportJobCron(schedule);
+        if (cron)
+            await deps.preflightJobCreation();
         if (report.jobId)
             await deps.cancelJob(report.jobId);
-        const cron = reportJobCron(schedule);
         if (!cron) {
             return deps.patch(report, { jobId: null, jobState: "adopted", jobStateReason: null });
         }