@indigoai-us/hq-cli 5.247.0 → 5.248.0

package/dist/commands/lanes-resume.js

@@ -0,0 +1,455 @@
+import { BALANCE_MOVABLE_STATES } from "../lib/lanes/claude-balance.js";
+import { LanesError } from "../lib/lanes/errors.js";
+import { appendCappedHistory, providerSessionPortable, providerSupportsSessionResume, readLane, resumeCommandRefusal, sessionNotPortableMessage, validateProjectStories, withLaneAdmissionLock } from "../lib/lanes/index.js";
+import { parseCliEffort } from "../lib/lanes/effort.js";
+import { parseOutpostHireGrantContext } from "../lib/lanes/hire-grant-dispatch.js";
+import { assertNoSecretText } from "../lib/lanes/text-scan.js";
+import { laneStories, laneStory, storyWarning } from "../lib/lanes/stories.js";
+import { spawnLaneWorker } from "../lib/lanes/spawn.js";
+import { accountMoveSummary, accountRequestKeepsCurrentLane, assertCurrentResumeAccountAvailable, hasKeepAliveProgress, recordedResumeEffort, resetKeepAliveProgress, resolveResumeEffort } from "./lanes-shared.js";
+export function createLaneResumeHandlers(deps) {
+    const { archiveResumeMessage, assertLaneRunsHereForAdmission, assertLaneRunsHereForOperatorMutation, assessLaneAdmission, automaticBalanceMoveHistoryReason, authorizeFailedResume, authorizeResumeProfileRepin, casUpdateLane, dispatchOutpostLaneCommand, laneIsHostedHere, laneWithRecoveredProviderSession, mintMessageId, persistClaudeAccountSelection, prepareAccountMove, printJson, recordResumeSetup, resolveResumeProfile, selectAutomaticClaudeResumeAccount, validateResumeProfileModel, withResumeHireAdmission } = deps;
+    async function runClaudeBalanceMoveTarget(ctx, laneId, opts) {
+        const lane = laneWithRecoveredProviderSession(ctx.hqRoot(), readLane(ctx.hqRoot(), laneId));
+        assertLaneRunsHereForOperatorMutation(ctx, lane, "balance-move-target");
+        if (lane.provider !== "claude") {
+            throw new LanesError("claude_account_balance_provider_mismatch", `Lane ${laneId} does not use Claude`, {
+                lane_id: laneId,
+                provider: lane.provider,
+            });
+        }
+        const expectedFrom = opts.fromAccount?.trim();
+        if (!expectedFrom) {
+            throw new LanesError("claude_account_balance_source_invalid", "Balance move requires --from-account <id>", {
+                lane_id: laneId,
+            });
+        }
+        if (lane.account !== expectedFrom) {
+            throw new LanesError("claude_account_balance_source_changed", `Lane ${laneId} no longer uses the planned source account`, {
+                lane_id: laneId,
+                expected_account: expectedFrom,
+                actual_account: lane.account ?? null,
+            });
+        }
+        const expectedState = opts.expectedState?.trim();
+        if (!expectedState) {
+            throw new LanesError("claude_account_balance_state_invalid", "Balance move requires --expected-state <state>", {
+                lane_id: laneId,
+            });
+        }
+        if (lane.state !== expectedState) {
+            throw new LanesError("claude_account_balance_state_changed", `Lane ${laneId} changed state after balance was calculated`, {
+                lane_id: laneId,
+                expected_state: expectedState,
+                actual_state: lane.state,
+            });
+        }
+        if (!BALANCE_MOVABLE_STATES.includes(lane.state) || lane.pending_resume !== undefined) {
+            throw new LanesError("claude_account_balance_state_not_movable", `Lane ${laneId} is not between turns`, {
+                lane_id: laneId,
+                state: lane.state,
+                pending_resume: lane.pending_resume !== undefined,
+            });
+        }
+        const account = opts.account?.trim();
+        if (!account) {
+            throw new LanesError("claude_account_balance_account_invalid", "Balance move requires --account <id>", {
+                lane_id: laneId,
+            });
+        }
+        const moved = await prepareAccountMove(ctx, lane, {
+            account,
+            cliModel: undefined,
+            accountHistoryReason: automaticBalanceMoveHistoryReason(ctx, lane),
+            deferTurnStart: true,
+        });
+        printJson({
+            ok: true,
+            action: "balance-move-target",
+            lane_id: laneId,
+            from: moved.from,
+            state: moved.lane.state,
+            account: moved.lane.account,
+        });
+    }
+    /**
+     * `hq lanes resume <lane-id> [--text <msg>]`: the explicit opt-in that
+     * continues a lane in `interrupted`, `done` or `blocked`, 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
+     * command is the path its refusal names. The launch is the same
+     * `spawnLaneWorker` a message resume uses, so the resume-time compaction
+     * rule and the watcher's mesh events are the same. The record gains
+     * `last_resume` with `trigger: "resume"`, `resumed_from` and the text.
+     */
+    async function runResume(ctx, laneId, opts) {
+        const hqRoot = ctx.hqRoot();
+        let lane = readLane(hqRoot, laneId);
+        const failedResumeReason = opts.reason?.trim();
+        if (opts.reason !== undefined && opts.fromFailed !== true) {
+            throw new LanesError("failed_resume_reason_requires_flag", "--reason on hq lanes resume requires --from-failed", { lane_id: laneId });
+        }
+        if (opts.fromFailed === true && !failedResumeReason) {
+            throw new LanesError("failed_resume_reason_required", "--from-failed requires a non-empty --reason", { lane_id: laneId });
+        }
+        if (opts.reason !== undefined)
+            assertNoSecretText("resume reason", opts.reason);
+        if (opts.failedResumeContext !== undefined && opts.fromFailed !== true) {
+            throw new LanesError("failed_resume_authorization_invalid", "Failed-resume authorization context requires --from-failed", { lane_id: laneId });
+        }
+        const failedResumeActor = opts.fromFailed === true
+            ? authorizeFailedResume(ctx, lane, opts.failedResumeContext)
+            : undefined;
+        if (opts.fromFailed === true && lane.state !== "failed") {
+            throw new LanesError("lane_not_failed", `Lane ${laneId} is ${lane.state}; --from-failed only applies to a failed lane`, { lane_id: laneId, state: lane.state });
+        }
+        const failedResumeExpectedSenior = opts.fromFailed === true
+            ? { ...lane.senior }
+            : undefined;
+        const recoveredFailure = opts.fromFailed === true
+            ? lane.terminal_reason ?? "failure_reason_unavailable"
+            : undefined;
+        const hireGrantContext = opts.grantContext === undefined
+            ? undefined
+            : (() => {
+                if (!ctx.isSsmOwnerDispatch()) {
+                    throw new LanesError("hire_grant_dispatch_unauthorized", "Resume grant context is only valid on an Outpost owner dispatch", { lane_id: laneId });
+                }
+                return parseOutpostHireGrantContext(opts.grantContext, laneId);
+            })();
+        if (opts.profileRepinContext !== undefined && !ctx.isSsmOwnerDispatch()) {
+            throw new LanesError("worker_profile_hash_mismatch", "Profile re-pin context is only valid on an Outpost owner dispatch", { lane_id: laneId });
+        }
+        if (lane.host.kind === "outpost" && !laneIsHostedHere(ctx, lane)) {
+            await withResumeHireAdmission(ctx, lane, () => undefined);
+            await dispatchOutpostLaneCommand(ctx, lane, "resume", opts);
+            return;
+        }
+        // Fail before provider/session work if a terminal child would consume a
+        // slot that its senior has already assigned elsewhere.
+        await withResumeHireAdmission(ctx, lane, () => undefined, hireGrantContext);
+        assertLaneRunsHereForOperatorMutation(ctx, lane, "resume");
+        const cliEffort = parseCliEffort(lane.provider, opts.effort);
+        if (cliEffort !== undefined && !providerSupportsSessionResume(lane.provider)) {
+            throw new LanesError("effort_resume_unsupported", `Provider ${lane.provider} cannot change effort on a resumed session`, { lane_id: laneId, provider: lane.provider });
+        }
+        lane = laneWithRecoveredProviderSession(hqRoot, lane);
+        if (opts.model !== undefined && opts.account === undefined) {
+            throw new LanesError("model_requires_account", "--model on hq lanes resume is only accepted together with --account", {});
+        }
+        if (opts.account !== undefined && lane.state === "running") {
+            throw new LanesError("lane_running", `Lane ${laneId} is running; stop it or wait for it to exit before moving its session`, {
+                lane_id: laneId,
+                state: lane.state,
+            });
+        }
+        if (opts.account !== undefined && !providerSessionPortable(lane.provider)) {
+            throw new LanesError("provider_session_not_portable", sessionNotPortableMessage(lane.provider), { lane_id: laneId, provider: lane.provider });
+        }
+        if (lane.state === "queued") {
+            throw new LanesError("lane_not_resumable", `Lane ${laneId} is queued; use hq lanes admit ${laneId} to request admission`, { lane_id: laneId, state: lane.state, admission_command: `hq lanes admit ${laneId}` });
+        }
+        const refusal = resumeCommandRefusal(lane, { allowFailed: opts.fromFailed === true });
+        if (refusal !== null) {
+            throw new LanesError(refusal.error, refusal.message, {
+                lane_id: laneId,
+                state: lane.state,
+                provider: lane.provider,
+                message: refusal.message,
+            });
+        }
+        assertLaneRunsHereForAdmission(ctx, lane);
+        const resumedFrom = lane.state;
+        const text = opts.text?.trim() ? opts.text : undefined;
+        const at = ctx.now().toISOString();
+        const projectId = opts.project?.trim() || lane.project_id;
+        const storyId = opts.story?.trim() || lane.story_id;
+        if (opts.story !== undefined && !opts.story.trim()) {
+            throw new LanesError("missing_story", "--story must be non-empty", {});
+        }
+        if ((opts.project !== undefined || opts.story !== undefined) && ctx.storyLedgerEnabled()) {
+            validateProjectStories(hqRoot, projectId, [storyId], lane.company?.slug);
+        }
+        const attributionChanged = projectId !== lane.project_id || storyId !== lane.story_id;
+        const messageId = text !== undefined || attributionChanged ? mintMessageId() : undefined;
+        let requestedMeshCompany;
+        let meshThreadId;
+        if (opts.meshCompany !== undefined) {
+            const meshCompanySlug = opts.meshCompany.trim();
+            if (!meshCompanySlug) {
+                throw new LanesError("missing_mesh_company", "--mesh-company must be a non-empty company slug", {});
+            }
+            requestedMeshCompany = await ctx.resolveCompany(meshCompanySlug);
+            if (lane.company !== null &&
+                (lane.company.uid !== requestedMeshCompany.uid || lane.company.slug !== requestedMeshCompany.slug)) {
+                throw new LanesError("mesh_company_mismatch", "--mesh-company must match the lane's company when the lane is company-owned", { company: lane.company.slug, mesh_company: requestedMeshCompany.slug });
+            }
+            meshThreadId = await ctx.mesh.ensureProjectThread(requestedMeshCompany, projectId);
+        }
+        const resumeProfile = opts.worker !== undefined
+            ? resolveResumeProfile(ctx, lane, opts.worker)
+            : undefined;
+        const profileRepin = authorizeResumeProfileRepin(ctx, lane, resumeProfile, opts.profileRepinContext);
+        const keepAlive = opts.keepAlive === true
+            ? true
+            : resumeProfile?.profile.meta.keep_alive;
+        const keepCurrentAccount = opts.account !== undefined && accountRequestKeepsCurrentLane(lane, opts.account);
+        if (keepCurrentAccount)
+            assertCurrentResumeAccountAvailable(ctx, lane);
+        if (resumeProfile !== undefined && (opts.account === undefined || keepCurrentAccount)) {
+            validateResumeProfileModel(ctx, lane, resumeProfile.profile);
+        }
+        const automaticAccountSelection = opts.account === undefined
+            ? await selectAutomaticClaudeResumeAccount(ctx, lane, resumeProfile, { repairUnavailableAccount: true })
+            : undefined;
+        const resumeEffort = resolveResumeEffort(ctx, lane, {
+            cliEffort,
+            profile: resumeProfile,
+            account: keepCurrentAccount ? lane.account : opts.account ?? automaticAccountSelection?.selection.account,
+            model: opts.model,
+        });
+        let move = null;
+        if (opts.account !== undefined && !keepCurrentAccount) {
+            move = await prepareAccountMove(ctx, lane, {
+                account: opts.account,
+                cliModel: opts.model?.trim() || undefined,
+                ...(resumeProfile !== undefined ? { workerProfile: resumeProfile } : {}),
+                ...(profileRepin !== undefined ? { profileRepin } : {}),
+                ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
+                pending: {
+                    trigger: "resume",
+                    resumed_from: resumedFrom,
+                    ...(opts.fromFailed === true ? { from_failed: true } : {}),
+                    ...(failedResumeExpectedSenior !== undefined
+                        ? { expected_senior: failedResumeExpectedSenior }
+                        : {}),
+                    ...(text !== undefined ? { text } : {}),
+                    ...(messageId !== undefined ? { message_id: messageId } : {}),
+                    compact: opts.compact !== false,
+                },
+            });
+            lane = move.lane;
+        }
+        else if (automaticAccountSelection !== undefined) {
+            const selection = automaticAccountSelection.selection;
+            if (selection.account !== lane.account) {
+                move = await prepareAccountMove(ctx, lane, {
+                    account: selection.account,
+                    cliModel: undefined,
+                    ...(automaticAccountSelection.historyReason !== undefined
+                        ? { accountHistoryReason: automaticAccountSelection.historyReason }
+                        : {}),
+                    ...(automaticAccountSelection.preservedModel !== undefined
+                        ? { preservedModel: automaticAccountSelection.preservedModel }
+                        : {}),
+                    ...(resumeProfile !== undefined ? { workerProfile: resumeProfile } : {}),
+                    ...(profileRepin !== undefined ? { profileRepin } : {}),
+                    ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
+                    pending: {
+                        trigger: "resume",
+                        resumed_from: resumedFrom,
+                        ...(opts.fromFailed === true ? { from_failed: true } : {}),
+                        ...(failedResumeExpectedSenior !== undefined
+                            ? { expected_senior: failedResumeExpectedSenior }
+                            : {}),
+                        ...(text !== undefined ? { text } : {}),
+                        ...(messageId !== undefined ? { message_id: messageId } : {}),
+                        compact: opts.compact !== false,
+                    },
+                    accountSelection: selection,
+                });
+                lane = move.lane;
+            }
+            else {
+                lane = persistClaudeAccountSelection(hqRoot, lane, selection);
+            }
+        }
+        lane = recordResumeSetup(ctx, lane, {
+            ...(move === null && resumeProfile !== undefined ? { profile: resumeProfile } : {}),
+            ...(move === null && profileRepin !== undefined ? { profileRepin } : {}),
+            ...(move === null && resumeEffort !== undefined ? { effort: resumeEffort } : {}),
+            ...(keepAlive !== undefined ? { keepAlive } : {}),
+            ...(move === null && keepCurrentAccount && opts.model !== undefined ? { cliModel: opts.model } : {}),
+            ...(requestedMeshCompany !== undefined
+                ? { meshCompany: requestedMeshCompany, threadId: meshThreadId }
+                : {}),
+        });
+        let queuedOnAdmission = false;
+        let resumed;
+        if (move?.queued) {
+            resumed = lane;
+        }
+        else {
+            resumed = await withLaneAdmissionLock(hqRoot, lane.provider, async () => {
+                const admission = await assessLaneAdmission(ctx, lane, { queueAt: at });
+                if (admission.action === "refuse" && admission.error)
+                    throw admission.error;
+                return withResumeHireAdmission(ctx, lane, () => {
+                    if (admission.action === "queue") {
+                        const sessionId = lane.provider_session_id;
+                        if (!sessionId) {
+                            throw new LanesError("no_provider_session", `Lane ${laneId} has no provider session id to queue this resume`, {
+                                lane_id: laneId,
+                                provider: lane.provider,
+                            });
+                        }
+                        queuedOnAdmission = true;
+                        return casUpdateLane(hqRoot, laneId, (current) => {
+                            if (current.version !== lane.version || current.state !== lane.state) {
+                                throw new LanesError("lane_admission_conflict", `Lane ${laneId} changed while resume admission was checked`, {
+                                    lane_id: laneId,
+                                    prepared_version: lane.version,
+                                    version: current.version,
+                                    state: current.state,
+                                });
+                            }
+                            return {
+                                ...current,
+                                state: "queued",
+                                queued_reason: admission.reason ?? "throttle",
+                                queued_at: at,
+                                pending_resume: {
+                                    session_id: sessionId,
+                                    trigger: "resume",
+                                    resumed_from: resumedFrom,
+                                    ...(opts.fromFailed === true ? { from_failed: true } : {}),
+                                    ...(failedResumeExpectedSenior !== undefined
+                                        ? { expected_senior: failedResumeExpectedSenior }
+                                        : {}),
+                                    ...(text !== undefined ? { text } : {}),
+                                    ...(messageId !== undefined ? { message_id: messageId } : {}),
+                                    compact: opts.compact !== false,
+                                    at,
+                                },
+                            };
+                        });
+                    }
+                    return spawnLaneWorker(hqRoot, lane, {
+                        env: ctx.env,
+                        modelDeps: {
+                            readFileSync: ctx.readFileSync,
+                            probe: ctx.probeProvider,
+                            env: ctx.env,
+                        },
+                        existsSync: ctx.existsSync,
+                        spawnProcess: ctx.spawnProcess,
+                        proveDetached: ctx.proveDetached,
+                        killProcess: ctx.killProcess,
+                        now: ctx.now,
+                        resolveMachineIdentity: ctx.resolveMachineIdentity,
+                        runCompaction: ctx.runCompaction,
+                        locateTranscript: ctx.locateTranscript,
+                    }, {
+                        trigger: {
+                            kind: "resume",
+                            from: resumedFrom,
+                            ...(opts.fromFailed === true ? { fromFailed: true } : {}),
+                            ...(failedResumeExpectedSenior !== undefined
+                                ? { expectedSenior: failedResumeExpectedSenior }
+                                : {}),
+                            ...(text !== undefined ? { text } : {}),
+                            ...(messageId !== undefined ? { message_id: messageId } : {}),
+                        },
+                        compact: opts.compact !== false,
+                        effort: resumeEffort ?? recordedResumeEffort(lane),
+                    });
+                }, hireGrantContext);
+            }, ctx.sleep);
+        }
+        if (text !== 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.
+            archiveResumeMessage(hqRoot, laneId, {
+                at,
+                message_id: messageId,
+                text,
+                project_id: projectId,
+                story_id: storyId,
+                resumed_from: resumedFrom,
+            });
+        }
+        let next = resumed;
+        if (failedResumeActor !== undefined &&
+            failedResumeReason !== undefined &&
+            recoveredFailure !== undefined) {
+            next = casUpdateLane(hqRoot, laneId, (current) => ({
+                ...current,
+                failed_resume_history: appendCappedHistory(current.failed_resume_history ?? [], {
+                    at,
+                    actor: failedResumeActor,
+                    reason: failedResumeReason,
+                    failure: recoveredFailure,
+                }),
+            }));
+        }
+        if (text !== undefined) {
+            // An operator text moves the compaction reference forward, as a message does.
+            next = casUpdateLane(hqRoot, laneId, (current) => ({
+                ...resetKeepAliveProgress(current),
+                last_message_at: at,
+            }));
+        }
+        if (messageId !== undefined && attributionChanged) {
+            next = casUpdateLane(hqRoot, laneId, (current) => {
+                const already = current.attribution_history.some((entry) => entry.message_id === messageId);
+                if (already)
+                    return current;
+                return {
+                    ...current,
+                    project_id: projectId,
+                    story_id: storyId,
+                    no_story_reason: storyId ? undefined : current.no_story_reason,
+                    stories: laneStory(current, projectId, storyId)
+                        ? laneStories(current)
+                        : [
+                            ...laneStories(current),
+                            {
+                                project_id: projectId,
+                                story_id: storyId,
+                                status: "in_progress",
+                                added_at: at,
+                                updated_at: at,
+                            },
+                        ],
+                    attribution_history: appendCappedHistory(current.attribution_history, {
+                        project_id: projectId,
+                        story_id: storyId,
+                        message_id: messageId,
+                        at,
+                    }),
+                };
+            });
+        }
+        if (text === undefined && hasKeepAliveProgress(next)) {
+            next = casUpdateLane(hqRoot, laneId, (current) => resetKeepAliveProgress(current));
+        }
+        printJson({
+            ok: true,
+            action: "resume",
+            lane_id: laneId,
+            resumed_from: resumedFrom,
+            message_id: messageId ?? null,
+            text: text ?? null,
+            delivery: "resume",
+            delivery_status: move?.queued
+                ? "queued_on_target_account"
+                : queuedOnAdmission
+                    ? "queued_on_admission"
+                    : "worker_spawned",
+            account_move: move ? accountMoveSummary(move) : null,
+            resumed_session_id: resumed.last_resume?.session_id ?? null,
+            last_resume: next.last_resume ?? null,
+            compaction: resumed.last_compaction && resumed.last_compaction.resume_at === resumed.last_resume?.at
+                ? resumed.last_compaction
+                : null,
+            project_id: next.project_id,
+            story_id: next.story_id,
+            stories: laneStories(next),
+            story_warning: storyWarning(next) ?? null,
+            lane: next,
+        });
+    }
+    return { runClaudeBalanceMoveTarget, runResume };
+}
+//# sourceMappingURL=lanes-resume.js.map

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

@@ -1,4 +1,4 @@
-import type { LaneCompanyRef, LaneRecord, LanesConfig, QuestionAnswer, QuestionBody, QuestionRecord, SeniorRef, AccountHistoryEntry, LivenessDeps, MachineIdentity, MonitorEvidenceReader, ReconcileHost, RunCommand, ThrottleDeps, withLaneHireLocks } from "../lib/lanes/index.js";
+import type { LaneCompanyRef, LaneRecord, LanesConfig, QuestionAnswer, QuestionBody, QuestionRecord, SeniorRef, AccountHistoryEntry, LaneAccountSelection, PendingResume, QueuedReason, ResolvedLaneWorker, LivenessDeps, MachineIdentity, MonitorEvidenceReader, ReconcileHost, RunCommand, ThrottleDeps, withLaneHireLocks } from "../lib/lanes/index.js";
 import type { OutpostIdentity } from "../lib/lanes/admission-host.js";
 import type { OutpostDispatchResult } from "../lib/lanes/outpost-dispatch.js";
 import type { ProbeCommand } from "../lib/lanes/models.js";
@@ -7,6 +7,158 @@ import type { WatcherLoopDeps } from "../lib/lanes/watcher.js";
 import type { RunCompactionFn } from "../lib/lanes/compaction.js";
 import type { LaneMesh, LaneMeshEvent } from "../lib/lanes/mesh-events.js";
 import type { BalanceHostGap, BalanceHostSnapshot } from "../lib/lanes/claude-balance.js";
+import { type ResolvedEffort } from "../lib/lanes/effort.js";
+import type { SessionCopyResult } from "../lib/lanes/move-account.js";
+import type { WorkerProfile } from "../lib/lanes/profile.js";
+import type { OutpostHireGrantContext } from "../lib/lanes/hire-grant-dispatch.js";
+import { LanesError } from "../lib/lanes/errors.js";
+export type { LaneCompanyRef, LaneRecord } from "../lib/lanes/index.js";
+export interface LaneAccountMove {
+    lane: LaneRecord;
+    from: string | null;
+    to: string;
+    copy: SessionCopyResult;
+    queued: boolean;
+}
+export type ResolvedResumeProfile = ResolvedLaneWorker & {
+    profile: NonNullable<ResolvedLaneWorker["profile"]>;
+};
+export interface ResumeProfileRepinAuthorization {
+    kind: "senior" | "ssm-owner-dispatch";
+    expectedSenior: SeniorRef;
+    actor: string;
+    reason: "resume --worker";
+    newHash: string;
+}
+export interface LaneMessageOptions {
+    text?: string;
+    project?: string;
+    story?: string;
+    compact?: boolean;
+    account?: string;
+    model?: string;
+    effort?: string;
+    worker?: string;
+    grantContext?: string;
+    monitorEvent?: {
+        monitor_id: string;
+        description: string;
+        sequence: number;
+    };
+    /** Internal recovery messages do not emit a second command response. */
+    silent?: boolean;
+    /** Internal recovery claim is safe to archive once this callback runs. */
+    onAccepted?: () => void;
+}
+export interface LaneResumeOptions {
+    text?: string;
+    fromFailed?: boolean;
+    reason?: string;
+    failedResumeContext?: string;
+    project?: string;
+    story?: string;
+    compact?: boolean;
+    account?: string;
+    model?: string;
+    effort?: string;
+    worker?: string;
+    keepAlive?: boolean;
+    meshCompany?: string;
+    profileRepinContext?: string;
+    grantContext?: string;
+}
+export interface LaneBalanceMoveTargetOptions {
+    account?: string;
+    fromAccount?: string;
+    expectedState?: string;
+}
+export interface AdmissionResult {
+    action: "start" | "queue" | "refuse";
+    reason?: QueuedReason;
+    error?: LanesError;
+}
+export interface PrepareAccountMoveInput {
+    account: string;
+    cliModel: string | undefined;
+    preservedModel?: string;
+    accountHistoryReason?: AccountHistoryEntry["reason"];
+    workerProfile?: ResolvedResumeProfile;
+    profileRepin?: ResumeProfileRepinAuthorization;
+    effort?: ResolvedEffort;
+    grantContext?: OutpostHireGrantContext;
+    pending?: Omit<PendingResume, "session_id" | "at"> & {
+        trigger: PendingResume["trigger"];
+    };
+    /** Copy the session and change account while preserving the between-turn state. */
+    deferTurnStart?: boolean;
+    accountSelection?: LaneAccountSelection;
+}
+export interface RecordResumeSetupInput {
+    profile?: ResolvedResumeProfile;
+    effort?: ResolvedEffort;
+    keepAlive?: boolean;
+    cliModel?: string;
+    meshCompany?: LaneCompanyRef;
+    threadId?: string;
+    profileRepin?: ResumeProfileRepinAuthorization;
+}
+export declare function accountRequestKeepsCurrentLane(lane: LaneRecord, rawAccount: string): boolean;
+export declare function assertCurrentResumeAccountAvailable(ctx: Ctx, lane: LaneRecord): void;
+export declare function accountMoveSummary(move: LaneAccountMove): Record<string, unknown>;
+export declare function hasKeepAliveProgress(lane: LaneRecord): boolean;
+export declare function resetKeepAliveProgress(lane: LaneRecord): LaneRecord;
+export declare function resolveResumeEffort(ctx: Ctx, lane: LaneRecord, input: {
+    cliEffort?: string;
+    profile?: ResolvedResumeProfile;
+    account?: string;
+    model?: string;
+}): ResolvedEffort | undefined;
+export declare function recordedResumeEffort(lane: LaneRecord): ResolvedEffort;
+export interface LaneMessageHandlerDeps {
+    archiveResumeMessage(hqRoot: string, laneId: string, message: {
+        message_id: string;
+        [key: string]: unknown;
+    }): void;
+    assertLaneRunsHereForAdmission(ctx: Ctx, lane: LaneRecord): void;
+    assertLaneRunsHereForOperatorMutation(ctx: Ctx, lane: LaneRecord, action: string): void;
+    assessLaneAdmission(ctx: Ctx, lane: LaneRecord, options: {
+        account?: string;
+        queueAt: string;
+        alreadyQueued?: boolean;
+    }): Promise<AdmissionResult>;
+    casUpdateLane(hqRoot: string, laneId: string, updater: (current: LaneRecord) => LaneRecord): LaneRecord;
+    dispatchOutpostLaneCommand(ctx: Ctx, lane: LaneRecord, action: "message" | "resume", options: LaneMessageOptions | LaneResumeOptions): Promise<void>;
+    drainHookStatusFor(ctx: Ctx, lane: LaneRecord): {
+        registered: boolean;
+        kind: string;
+        path: string;
+    } | null;
+    laneIsHostedHere(ctx: Ctx, lane: LaneRecord): boolean;
+    laneWithRecoveredProviderSession(hqRoot: string, lane: LaneRecord): LaneRecord;
+    loadAllLanes(hqRoot: string): LaneRecord[];
+    mintMessageId(): string;
+    prepareAccountMove(ctx: Ctx, lane: LaneRecord, input: PrepareAccountMoveInput): Promise<LaneAccountMove>;
+    persistClaudeAccountSelection(hqRoot: string, lane: LaneRecord, selection: LaneAccountSelection): LaneRecord;
+    printJson(value: unknown): void;
+    recordResumeSetup(ctx: Ctx, lane: LaneRecord, input: RecordResumeSetupInput): LaneRecord;
+    resolveActiveQuestionCompany(ctx: Ctx, message?: string): Promise<LaneCompanyRef>;
+    resolveResumeProfile(ctx: Ctx, lane: LaneRecord, workerId: string): ResolvedResumeProfile;
+    selectAutomaticClaudeResumeAccount(ctx: Ctx, lane: LaneRecord, workerProfile?: ResolvedResumeProfile, options?: {
+        repairUnavailableAccount?: boolean;
+    }): Promise<{
+        selection: LaneAccountSelection;
+        historyReason?: AccountHistoryEntry["reason"];
+        preservedModel?: string;
+    } | undefined>;
+    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, "archiveResumeMessage" | "assertLaneRunsHereForAdmission" | "assertLaneRunsHereForOperatorMutation" | "assessLaneAdmission" | "casUpdateLane" | "laneIsHostedHere" | "laneWithRecoveredProviderSession" | "mintMessageId" | "prepareAccountMove" | "persistClaudeAccountSelection" | "printJson" | "recordResumeSetup" | "resolveResumeProfile" | "selectAutomaticClaudeResumeAccount" | "validateResumeProfileModel" | "withResumeHireAdmission"> {
+    dispatchOutpostLaneCommand(ctx: Ctx, lane: LaneRecord, action: "resume", options: LaneResumeOptions): Promise<void>;
+    authorizeFailedResume(ctx: Ctx, lane: LaneRecord, encodedContext?: string): string;
+    authorizeResumeProfileRepin(ctx: Ctx, lane: LaneRecord, profile: ResolvedResumeProfile | undefined, encodedContext: string | undefined): ResumeProfileRepinAuthorization | undefined;
+    automaticBalanceMoveHistoryReason(ctx: Ctx, lane: LaneRecord): AccountHistoryEntry["reason"];
+}
 export interface SpawnLoginResult {
     status: number;
 }