@indigoai-us/hq-cli 5.154.0 → 5.156.0

package/dist/lib/lanes/mesh-events.js

@@ -42,7 +42,7 @@
  * of opening a browser nobody is watching, and the watcher records
  * `mesh_event_failed` and moves on. No credential file is read here.
  */
-import { appendThreadEvent, clamp, ensureProjectThread, getProjectView, patchStoryStatus, putProjectView, requireToken, registerMeshProject, resolveMeshCompany, } from "../mesh/api.js";
+import { appendThreadEvent, clamp, ensureLaneMeshThread, ensureProjectThread, getProjectView, patchStoryStatus, putProjectView, requireToken, registerMeshProject, resolveMeshCompany, } from "../mesh/api.js";
 import { LanesError } from "./errors.js";
 export const LANE_MESH_EVENTS = [
     "lane_started",
@@ -52,12 +52,17 @@ export const LANE_MESH_EVENTS = [
     "lane_ask",
     "lane_blocked",
     "lane_done",
+    "lane_failed",
+    "lane_interrupted",
+    "lane_cancelled",
+    "lane_killed",
 ];
 /** Roster kinds this module emits. Subset of the server's `validKinds`. */
 export const WIRE_EVENT_KINDS = [
     "run_started",
     "run_progress",
     "run_complete",
+    "blocked",
     "question",
     "note",
 ];
@@ -94,6 +99,30 @@ function nonEmpty(text, fallback) {
 export function toWireThreadEvent(event, payload) {
     const kind = parseLaneMeshEvent(event);
     const id = identity(payload);
+    const laneId = str(payload.lane_id ?? payload.laneId).trim();
+    const senior = payload.senior && typeof payload.senior === "object" && !Array.isArray(payload.senior)
+        ? payload.senior
+        : undefined;
+    const lane = laneId
+        ? {
+            laneId,
+            ...(str(payload.story_id ?? payload.storyId) ? { storyId: str(payload.story_id ?? payload.storyId) } : {}),
+            ...(str(payload.worker_profile ?? payload.workerProfile) ? { workerProfile: str(payload.worker_profile ?? payload.workerProfile) } : {}),
+            ...(str(payload.model) ? { model: str(payload.model) } : {}),
+            ...(str(payload.account) ? { account: str(payload.account) } : {}),
+            ...(str(payload.parent_lane_id ?? payload.parentLaneId) ? { parentLaneId: str(payload.parent_lane_id ?? payload.parentLaneId) } : {}),
+            ...(senior && ["user", "session", "lane"].includes(String(senior.kind))
+                ? { senior: { kind: senior.kind, ...(typeof senior.id === "string" ? { id: senior.id } : {}) } }
+                : {}),
+            laneVersion: Number.isSafeInteger(Number(payload.lane_version ?? payload.laneVersion)) && Number(payload.lane_version ?? payload.laneVersion) > 0
+                ? Number(payload.lane_version ?? payload.laneVersion)
+                : 1,
+        }
+        : undefined;
+    const laneFields = (laneStatus) => ({
+        ...(lane ? { lane } : {}),
+        ...(laneStatus ? { laneStatus } : {}),
+    });
     switch (kind) {
         case "lane_started":
             return {
@@ -101,6 +130,7 @@ export function toWireThreadEvent(event, payload) {
                 payload: {
                     title: clamp(`lane_started ${str(payload.lane_id) || "unknown-lane"}`, WIRE_ACTIVITY_TEXT_MAX),
                     summary: clamp(`Lane ${id} started`, WIRE_ACTIVITY_TEXT_MAX),
+                    ...laneFields("running"),
                 },
             };
         case "lane_progress": {
@@ -109,29 +139,47 @@ export function toWireThreadEvent(event, payload) {
                 eventKind: "run_progress",
                 payload: {
                     summary: clamp(nonEmpty(`lane_progress ${id}${detail ? `: ${detail}` : ""}`, "lane_progress"), WIRE_ACTIVITY_TEXT_MAX),
+                    ...laneFields("running"),
                 },
             };
         }
         case "lane_done": {
             const summary = str(payload.summary);
+            const suppliedStatus = str(payload.lane_status ?? payload.laneStatus);
+            const laneStatus = isMeshLaneStatus(suppliedStatus) ? suppliedStatus : "done";
             return {
                 eventKind: "run_complete",
                 payload: {
                     title: clamp(`lane_done ${str(payload.lane_id) || "unknown-lane"}`, WIRE_ACTIVITY_TEXT_MAX),
                     summary: clamp(nonEmpty(`${id}: ${summary}`.replace(/:\s*$/, ""), `lane_done ${id}`), WIRE_ACTIVITY_TEXT_MAX),
+                    ...laneFields(laneStatus),
                 },
             };
         }
         case "lane_blocked": {
-            const reason = str(payload.blocked_reason);
-            // The roster's `blocked` event kind would flip the shared project
-            // thread, which spec §8 keeps lane events away from. Use the accepted
-            // audit note kind to preserve a filterable blocked marker.
+            const reason = str(payload.blocked_reason ?? payload.reason);
+            const suppliedStatus = str(payload.lane_status ?? payload.laneStatus);
+            const laneStatus = isMeshLaneStatus(suppliedStatus) ? suppliedStatus : "blocked";
             return {
-                eventKind: "note",
+                eventKind: "blocked",
                 payload: {
-                    text: clamp(`lane_blocked ${id}${reason ? `: ${reason}` : ""}`, WIRE_NOTE_TEXT_MAX),
-                    noteKind: "audit",
+                    reason: clamp(`lane_blocked ${id}${reason ? `: ${reason}` : ""}`, WIRE_NOTE_TEXT_MAX),
+                    ...laneFields(laneStatus),
+                },
+            };
+        }
+        case "lane_failed":
+        case "lane_interrupted":
+        case "lane_cancelled":
+        case "lane_killed": {
+            const laneStatus = kind.slice("lane_".length);
+            const summary = str(payload.summary ?? payload.reason ?? payload.blocked_reason);
+            return {
+                eventKind: "run_complete",
+                payload: {
+                    title: clamp(`${kind} ${str(payload.lane_id) || "unknown-lane"}`, WIRE_ACTIVITY_TEXT_MAX),
+                    summary: clamp(nonEmpty(`${id}: ${summary}`.replace(/:\s*$/, ""), `${kind} ${id}`), WIRE_ACTIVITY_TEXT_MAX),
+                    ...laneFields(laneStatus),
                 },
             };
         }
@@ -144,6 +192,7 @@ export function toWireThreadEvent(event, payload) {
             };
             if (questionId)
                 out.questionId = questionId;
+            Object.assign(out, laneFields());
             return { eventKind: "question", payload: out };
         }
         case "lane_ask": {
@@ -155,6 +204,7 @@ export function toWireThreadEvent(event, payload) {
             };
             if (ids[0])
                 out.questionId = ids[0];
+            Object.assign(out, laneFields("awaiting_input"));
             return { eventKind: "question", payload: out };
         }
         default: {
@@ -224,12 +274,28 @@ export function createLaneMesh(opts = {}) {
     return {
         async ensureProjectThread(company, projectId) {
             const tok = await token();
-            const resolved = await resolveMeshCompany(tok, company.slug);
+            const resolved = await resolveMeshCompany(tok, company.uid);
             const ensured = await ensureProjectThread(tok, resolved, projectId, {
                 summary: `HQ lane ${projectId}`,
             });
             return ensured.threadId;
         },
+        async ensureLaneThread(company, lane, laneStatus = lane.state, signal) {
+            const tok = await token();
+            const resolved = await resolveMeshCompany(tok, company.uid);
+            const descriptor = {
+                laneId: lane.lane_id,
+                ...(lane.story_id ? { storyId: lane.story_id } : {}),
+                ...(lane.worker_profile ? { workerProfile: lane.worker_profile } : {}),
+                ...(lane.model ? { model: lane.model } : {}),
+                ...(lane.account ? { account: lane.account } : {}),
+                ...(lane.senior.kind === "lane" ? { parentLaneId: lane.senior.id } : {}),
+                senior: { kind: lane.senior.kind, id: lane.senior.id },
+                laneVersion: lane.version,
+            };
+            const ensured = await ensureLaneMeshThread(tok, resolved, lane.project_id, descriptor, isMeshLaneStatus(laneStatus) ? laneStatus : "running", signal);
+            return ensured.threadId;
+        },
         async appendThreadEvent(company, threadId, event, payload, signal) {
             const wire = toWireThreadEvent(event, payload);
             const tok = await token();
@@ -263,34 +329,51 @@ export function laneMeshCompany(lane) {
 export function laneCanEmit(lane) {
     return laneMeshCompany(lane) !== undefined && !!lane.thread_id;
 }
-function baseIdentity(lane) {
+export function laneMeshEventIdentity(lane) {
     const lastMove = lane.account_history?.[lane.account_history.length - 1];
     return {
         lane_id: lane.lane_id,
         project_id: lane.project_id,
         story_id: lane.story_id,
+        worker_profile: lane.worker_profile,
+        model: lane.model,
+        lane_version: lane.version,
+        senior: { kind: lane.senior.kind, id: lane.senior.id },
+        ...(lane.senior.kind === "lane" ? { parent_lane_id: lane.senior.id } : {}),
         ...(lane.account !== undefined ? { account: lane.account } : {}),
         // A moved lane names the move on every event its run emits (US-023 §8).
         ...(lastMove !== undefined ? { account_move: { from: lastMove.from, to: lastMove.to, at: lastMove.at } } : {}),
     };
 }
+function isMeshLaneStatus(value) {
+    return ["queued", "running", "awaiting_input", "blocked", "done", "failed", "interrupted", "cancelled", "killed"].includes(value);
+}
+// hq-pro derives lane thread ids from company + lane identity; opaque ids may
+// be legacy shared project threads and must be migrated before a lane closes.
+const STABLE_LANE_THREAD_ID = /^lane-[0-9a-f]{32}$/;
+async function ensureLaneEventThread(mesh, company, lane, laneStatus, signal) {
+    if (mesh.ensureLaneThread && !STABLE_LANE_THREAD_ID.test(lane.thread_id ?? "")) {
+        return mesh.ensureLaneThread(company, lane, laneStatus, signal);
+    }
+    return lane.thread_id;
+}
 /**
  * Spec §8 terminal-envelope events. `done` → lane_done and story → review;
  * `blocked` → lane_blocked; `ask` → lane_ask with the queue ids. The story is
  * never set to `done` here: promotion belongs to the senior.
  */
 export async function emitLaneDecisionEvents(mesh, lane, envelope, opts = {}) {
-    if (!laneCanEmit(lane))
-        return;
     const company = laneMeshCompany(lane);
-    const threadId = lane.thread_id;
+    if (!company)
+        return;
+    const threadId = await ensureLaneEventThread(mesh, company, lane, lane.state, opts.signal);
     if (!company || !threadId)
         return;
     switch (envelope.decision) {
         case "done": {
             const outcomes = await Promise.allSettled([
                 mesh.appendThreadEvent(company, threadId, "lane_done", {
-                    ...baseIdentity(lane),
+                    ...laneMeshEventIdentity(lane),
                     summary: envelope.summary,
                 }, opts.signal),
                 mesh.patchStoryStatus(company, lane.project_id, lane.story_id, "review"),
@@ -304,7 +387,7 @@ export async function emitLaneDecisionEvents(mesh, lane, envelope, opts = {}) {
             {
                 const outcomes = await Promise.allSettled([
                     mesh.appendThreadEvent(company, threadId, "lane_blocked", {
-                        ...baseIdentity(lane),
+                        ...laneMeshEventIdentity(lane),
                         blocked_reason: envelope.blocked_reason ?? "",
                     }),
                     mesh.patchStoryStatus(company, lane.project_id, lane.story_id, "in_progress"),
@@ -322,7 +405,7 @@ export async function emitLaneDecisionEvents(mesh, lane, envelope, opts = {}) {
                 for (const questionId of opts.questionIds ?? []) {
                     try {
                         await mesh.appendThreadEvent(company, threadId, "lane_ask", {
-                            ...baseIdentity(lane),
+                            ...laneMeshEventIdentity(lane),
                             question_ids: [questionId],
                         }, opts.signal);
                     }
@@ -340,15 +423,28 @@ export async function emitLaneDecisionEvents(mesh, lane, envelope, opts = {}) {
         }
     }
 }
-export async function emitLaneProgressEvent(mesh, lane, detail, signal) {
-    if (!laneCanEmit(lane))
+/** Emit an abnormal terminal state even when the worker produced no envelope. */
+export async function emitLaneTerminalStateEvent(mesh, lane, state, summary, signal) {
+    const company = laneMeshCompany(lane);
+    if (!company)
         return;
+    const threadId = await ensureLaneEventThread(mesh, company, lane, state, signal);
+    if (!company || !threadId)
+        return;
+    await mesh.appendThreadEvent(company, threadId, `lane_${state}`, {
+        ...laneMeshEventIdentity(lane),
+        ...(summary ? { summary } : {}),
+    }, signal);
+}
+export async function emitLaneProgressEvent(mesh, lane, detail, signal) {
     const company = laneMeshCompany(lane);
-    const threadId = lane.thread_id;
+    if (!company)
+        return;
+    const threadId = await ensureLaneEventThread(mesh, company, lane, lane.state, signal);
     if (!company || !threadId)
         return;
     await mesh.appendThreadEvent(company, threadId, "lane_progress", {
-        ...baseIdentity(lane),
+        ...laneMeshEventIdentity(lane),
         detail,
     }, signal);
 }

package/dist/lib/lanes/provider-rejection.d.ts

@@ -37,6 +37,7 @@ export interface ProviderRejection {
     /** Which event on the stream carried the failure. */
     event: "codex.turn.failed" | "claude.result.is_error" | "grok.error";
 }
+export declare function isProviderLoginFailure(failure: ProviderRejection | null): boolean;
 export declare function capMessage(message: string): string;
 /**
  * Whether a later run could succeed without the operator changing anything.
@@ -56,10 +57,9 @@ export declare function retryableFromStatus(status: number | null): boolean;
 export declare function parseCodexTurnFailed(text: string): ProviderRejection | null;
 /**
  * Claude `-p --output-format json`: the last `type: "result"` object with
- * `is_error: true` and a numeric `api_error_status`. A result that is an
- * error with no status is not a provider rejection: it is either the quota
- * text shape quota.ts reads, or the worker's own failure, and keeps the
- * existing classification.
+ * `is_error: true` and a numeric `api_error_status`, or the CLI's explicit
+ * unauthenticated message. Other status-less errors keep the existing
+ * classification because they may be quota text or a worker failure.
  */
 export declare function parseClaudeResultRejection(text: string): ProviderRejection | null;
 /**

package/dist/lib/lanes/provider-rejection.js

@@ -24,6 +24,25 @@ export const PROVIDER_REJECTED_REASON = "provider_rejected";
 export const PROVIDER_REJECTION_MESSAGE_CAP = 2000;
 /** Status the watcher routes to the quota path instead of `provider_rejected`. */
 export const QUOTA_STATUS = 429;
+/** Exact auth failures observed from each installed CLI in an empty home. */
+function isProviderLoginMessage(provider, message) {
+    switch (provider) {
+        case "claude":
+            return /\bnot logged in\b/i.test(message);
+        case "codex":
+            return /\bnot logged in\b/i.test(message) ||
+                /\bmissing bearer or basic authentication in header\b/i.test(message);
+        case "grok":
+            return /^\s*not signed in\b/i.test(message);
+        default: {
+            const _exhaustive = provider;
+            return _exhaustive;
+        }
+    }
+}
+export function isProviderLoginFailure(failure) {
+    return failure !== null && isProviderLoginMessage(failure.provider, failure.message);
+}
 function isPlainObject(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -134,10 +153,9 @@ export function parseCodexTurnFailed(text) {
 }
 /**
  * Claude `-p --output-format json`: the last `type: "result"` object with
- * `is_error: true` and a numeric `api_error_status`. A result that is an
- * error with no status is not a provider rejection: it is either the quota
- * text shape quota.ts reads, or the worker's own failure, and keeps the
- * existing classification.
+ * `is_error: true` and a numeric `api_error_status`, or the CLI's explicit
+ * unauthenticated message. Other status-less errors keep the existing
+ * classification because they may be quota text or a worker failure.
  */
 export function parseClaudeResultRejection(text) {
     // The last `result` decides: a success or a status-less error there is
@@ -148,9 +166,9 @@ export function parseClaudeResultRejection(text) {
         if (rec.is_error !== true)
             return NOT_REJECTED;
         const status = statusOf(rec.api_error_status);
-        if (status === null)
-            return NOT_REJECTED;
         const message = typeof rec.result === "string" ? rec.result : "";
+        if (status === null && !isProviderLoginMessage("claude", message))
+            return NOT_REJECTED;
         return {
             reason: PROVIDER_REJECTED_REASON,
             provider: "claude",

package/dist/lib/lanes/reconcile.js

@@ -15,13 +15,13 @@ import { MAX_LANE_DEPTH } from "./constants.js";
 import { AccountResolutionError, LanesError, isLaneVersionConflict } from "./errors.js";
 import { loadWorkerProfile } from "./profile.js";
 import { classifySessionLiveness, defaultLivenessDeps, loadLivenessIndex, readDaemonPresenceConnected, } from "./liveness.js";
-import { ANSWERED_QUESTIONS_FILE, armLaneWatcher, isPidRecordAlive, laneRunDir, readPidRecord, readSpawnManifest, markSpawnFailure, spawnEnvelopeRepair, spawnLaneWorker, } from "./spawn.js";
+import { ANSWERED_QUESTIONS_FILE, armLaneWatcher, isPidRecordAlive, laneRunDir, readPidRecord, readSpawnManifest, markSpawnFailure, spawnEnvelopeRepair, spawnLaneWorker, retryLaneOnAlternateAccount, } from "./spawn.js";
 import { appendCappedHistory, lanesStoreRoot, parseLaneRecord, parseQuestionRecord, readLane, readQuestion, updateLane, updateQuestion, } from "./store.js";
 import { applyThrottleDecision, decideAdmission, defaultThrottleDeps, emptyThrottleState, evaluateThrottle, isCpuCheckEnabled, readAvailableMemMb, readThrottleState, resolveCpuBusyFraction, throttleStatePath, writeThrottleState, } from "./throttle.js";
 import { applyDefaultQuotaHold, readQuotaSignal, recordAccountQuota } from "./quota.js";
 import { answeredQuestionEntries, raiseEnvelopeQuestions } from "./questions.js";
 import { SILENCE_MS, classifyLaneExit, isPidAlive, readLatestEnvelope, readLatestEnvelopeFile, readLatestEnvelopeRecord, } from "./watcher.js";
-import { createLaneMesh, emitLaneDecisionEvents, laneMeshCompany } from "./mesh-events.js";
+import { createLaneMesh, emitLaneDecisionEvents, emitLaneTerminalStateEvent, laneMeshCompany, } from "./mesh-events.js";
 import { laneStories, storyStatusForEnvelope } from "./stories.js";
 import { decideEnvelopeRepair, envelopeQuestionIds, routeProviderFailure } from "./watcher.js";
 import { providerRejectionDetails, readProviderRejection, } from "./provider-rejection.js";
@@ -916,6 +916,11 @@ async function heartbeatAndDeadHosts(hqRoot, lanes, summary, deps, now) {
                 const repairedClassification = invalidEnvelope
                     ? classifyLaneExit({ envelope: null, hasPartialOutput: false, invalidEnvelope })
                     : classification;
+                const accountRetryReason = quota
+                    ? "usage_limit"
+                    : providerRejection && classification.reason === "account_not_logged_in"
+                        ? "account_unavailable"
+                        : null;
                 if (!deps.dryRun &&
                     quota &&
                     classified.account &&
@@ -923,6 +928,30 @@ async function heartbeatAndDeadHosts(hqRoot, lanes, summary, deps, now) {
                         classification.reason === "account_model_unavailable")) {
                     recordAccountQuota(hqRoot, classified.provider, classified.account, quota);
                 }
+                if (!deps.dryRun && accountRetryReason && classified.account) {
+                    try {
+                        const recovered = await retryLaneOnAlternateAccount(hqRoot, classified, accountRetryReason, "reconcile", {
+                            ...(deps.spawnLaneDeps ?? {}),
+                            admissionHost: deps.host,
+                        });
+                        summary.dead_host.push({
+                            id: lane.lane_id,
+                            from: "running",
+                            to: recovered.state,
+                            reason: accountRetryReason,
+                        });
+                        summary.heartbeats.push(`${lane.lane_id}:account-retry`);
+                        continue;
+                    }
+                    catch (err) {
+                        const message = err instanceof Error ? err.message : String(err);
+                        process.stderr.write(`hq lanes reconcile: account failover failed for ${lane.lane_id}: ${message}\n`);
+                        if (readLane(hqRoot, lane.lane_id).state !== "running") {
+                            summary.errors.push({ message: `${lane.lane_id}: account failover left a non-running record after ${message}` });
+                            continue;
+                        }
+                    }
+                }
                 if (!deps.dryRun &&
                     classification.state === "awaiting_input" &&
                     latest &&
@@ -1003,6 +1032,34 @@ async function heartbeatAndDeadHosts(hqRoot, lanes, summary, deps, now) {
                             }
                         }
                     }
+                    else if (!deps.dryRun &&
+                        (result.record.state === "failed" || result.record.state === "interrupted" ||
+                            result.record.state === "cancelled" || result.record.state === "killed")) {
+                        const mesh = deps.mesh === undefined ? createLaneMesh({ interactive: false }) : deps.mesh;
+                        if (mesh) {
+                            const meshEmitTimeoutMs = deps.meshEmitTimeoutMs ?? 10_000;
+                            let timer;
+                            try {
+                                await Promise.race([
+                                    emitLaneTerminalStateEvent(mesh, result.record, result.record.state, result.record.terminal_reason),
+                                    new Promise((_resolve, reject) => {
+                                        timer = setTimeout(() => reject(new Error(`terminal mesh emit timed out after ${meshEmitTimeoutMs}ms`)), meshEmitTimeoutMs);
+                                    }),
+                                ]);
+                            }
+                            catch (err) {
+                                markDirty(summary, {
+                                    kind: "lane",
+                                    id: lane.lane_id,
+                                    why: `terminal mesh emit failed: ${err instanceof Error ? err.message : String(err)}`,
+                                });
+                            }
+                            finally {
+                                if (timer)
+                                    clearTimeout(timer);
+                            }
+                        }
+                    }
                 }
             }
             catch (err) {
@@ -1031,6 +1088,32 @@ async function heartbeatAndDeadHosts(hqRoot, lanes, summary, deps, now) {
                     to: "interrupted",
                     reason: "host_lost",
                 });
+                const mesh = !deps.dryRun
+                    ? deps.mesh === undefined ? createLaneMesh({ interactive: false }) : deps.mesh
+                    : null;
+                if (mesh) {
+                    const meshEmitTimeoutMs = deps.meshEmitTimeoutMs ?? 10_000;
+                    let timer;
+                    try {
+                        await Promise.race([
+                            emitLaneTerminalStateEvent(mesh, result.record, "interrupted", "host_lost"),
+                            new Promise((_resolve, reject) => {
+                                timer = setTimeout(() => reject(new Error(`terminal mesh emit timed out after ${meshEmitTimeoutMs}ms`)), meshEmitTimeoutMs);
+                            }),
+                        ]);
+                    }
+                    catch (err) {
+                        markDirty(summary, {
+                            kind: "lane",
+                            id: lane.lane_id,
+                            why: `terminal mesh emit failed: ${err instanceof Error ? err.message : String(err)}`,
+                        });
+                    }
+                    finally {
+                        if (timer)
+                            clearTimeout(timer);
+                    }
+                }
             }
         }
         catch (err) {

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

@@ -12,7 +12,8 @@ import { type RunCompactionFn } from "./compaction.js";
 import { type KnownModelsDeps } from "./models.js";
 import { type LaunchTrigger } from "./delivery.js";
 import { type MachineIdentity } from "./machine-identity.js";
-import { type LaneCompanyRef, type LaneProvider, type LaneRecord } from "./types.js";
+import { type AdmissionHost } from "./admission.js";
+import { type LaneCompanyRef, type LaneProvider, type LaneRecord, type AccountHistoryEntry } from "./types.js";
 export declare const LANES_RUNS_REL: string;
 /** Written by reconcile before a resume spawn; the worker prompt names this path. */
 export declare const ANSWERED_QUESTIONS_FILE = "answered-questions.json";
@@ -32,6 +33,9 @@ export declare function resolveLaneModel(input: {
     accountModel?: string;
     providerModel?: string;
 }): string | undefined;
+type AutomaticAccountChangeReason = Exclude<AccountHistoryEntry["reason"], "operator_move">;
+/** Change account only after a provider/runtime account failure, then re-admit. */
+export declare function retryLaneOnAlternateAccount(hqRoot: string, lane: LaneRecord, reason: Extract<AutomaticAccountChangeReason, "usage_limit" | "account_unavailable">, writer?: "watcher" | "reconcile", deps?: SpawnLaneDeps): Promise<LaneRecord>;
 export declare function appendModelFlag(provider: LaneProvider, args: string[], model: string | undefined): string[];
 /** Add Codex fast-mode flags before the prompt/positional separator. */
 export declare function appendFastModeFlags(provider: LaneProvider, args: string[], enabled: boolean | undefined): string[];
@@ -63,8 +67,12 @@ export type ProveDetachedFn = (pid: number) => DetachProof;
 export type KillProcessFn = (pid: number, signal?: NodeJS.Signals) => void;
 export interface SpawnLaneDeps {
     env?: NodeJS.ProcessEnv;
+    /** The caller's host scope for admission checks; reconcile supplies its resolved host. */
+    admissionHost?: AdmissionHost;
     /** Provider model catalog dependencies, shared with create in tests. */
     modelDeps?: KnownModelsDeps;
+    /** Create validated this exact account/model candidate before its admission lock. */
+    currentModelValidated?: boolean;
     existsSync?: (p: string) => boolean;
     spawnProcess?: SpawnProcessFn;
     proveDetached?: ProveDetachedFn;