@indigoai-us/hq-cli 5.313.0 → 5.314.0

package/dist/commands/lanes-resume.js

@@ -1,564 +0,0 @@
-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 { artifactIdentityKeys, rollbackStorySwitchAttribution, storySwitchNotice } from "../lib/lanes/story-switch.js";
-import { spawnLaneWorker } from "../lib/lanes/spawn.js";
-import { lowDiskGuardEnabledForLane } from "../lib/lanes/disk-guard.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`, an `awaiting_input`
-     * lane with no answerable pending question, or a failed lane
-     * whose only terminal reason is an invalid envelope after its repair turn,
-     * on its recorded
-     * provider session. `hq lanes message` keeps refusing `interrupted`; this
-     * 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();
-        const resolution = await deps.resolveCommandLane(ctx, laneId);
-        let lane = resolution.lane;
-        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 (resolution.remoteOnly || (lane.host.kind === "outpost" && !laneIsHostedHere(ctx, lane))) {
-            const fallbackAt = lane.state === "awaiting_input" ? ctx.now().toISOString() : undefined;
-            if (!resolution.remoteOnly) {
-                await withResumeHireAdmission(ctx, lane, () => undefined);
-            }
-            await dispatchOutpostLaneCommand(ctx, lane, "resume", opts, resolution.remoteOnly
-                ? {
-                    syncPrimary: false,
-                    expectedOwnerHost: resolution.ownerHost,
-                    ...(fallbackAt === undefined ? {} : {
-                        afterFallbackResume: () => deps.cancelFallbackQuestionsForLane(ctx, lane, "resume", fallbackAt),
-                    }),
-                }
-                : fallbackAt === undefined
-                    ? undefined
-                    : { afterFallbackResume: () => deps.cancelFallbackQuestionsForLane(ctx, lane, "resume", fallbackAt) });
-            return;
-        }
-        // Fail before provider/session work if a terminal child would consume a
-        // 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" &&
-            (lane.queued_reason !== "worker_profile_changed" || opts.worker === undefined)) {
-            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 queuedProfileRecovery = lane.state === "queued" &&
-            lane.queued_reason === "worker_profile_changed" &&
-            opts.worker !== undefined;
-        if (queuedProfileRecovery && (opts.text !== undefined ||
-            opts.project !== undefined ||
-            opts.story !== undefined ||
-            opts.account !== undefined ||
-            opts.model !== undefined ||
-            opts.effort !== undefined ||
-            opts.keepAlive !== undefined ||
-            opts.meshCompany !== undefined ||
-            opts.compact === false)) {
-            throw new LanesError("worker_profile_recovery_options_invalid", "Queued worker-profile recovery accepts only --worker; rerun hq lanes resume after reconcile admits the lane", { lane_id: laneId });
-        }
-        const pendingQuestion = lane.state === "awaiting_input"
-            ? await deps.hasPendingQuestionForLane(ctx, lane)
-            : false;
-        const refusal = queuedProfileRecovery || (lane.state === "awaiting_input" && !pendingQuestion)
-            ? null
-            : resumeCommandRefusal(lane, { allowFailed: opts.fromFailed === true });
-        if (refusal !== null) {
-            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;
-        const notice = storySwitchNotice(lane.project_id, lane.story_id, projectId, storyId);
-        const deliveryText = notice === undefined ? text : `${notice}${text === undefined ? "" : `\n\n${text}`}`;
-        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);
-        }
-        if (lane.state === "queued" && lane.queued_reason === "worker_profile_changed") {
-            if (resumeProfile === undefined) {
-                throw new LanesError("worker_profile_required", `Lane ${laneId} needs --worker ${lane.worker_profile ?? "<profile>"} to recover its queued profile`, { lane_id: laneId, worker: lane.worker_profile ?? null });
-            }
-            const recovered = recordResumeSetup(ctx, lane, {
-                profile: resumeProfile,
-                ...(profileRepin !== undefined ? { profileRepin } : {}),
-                clearWorkerProfileChangedQueue: true,
-            });
-            printJson({
-                ok: true,
-                action: "resume",
-                lane_id: laneId,
-                delivery: "profile_repin",
-                delivery_status: "queued_for_reconcile",
-                profile_repin: profileRepin !== undefined
-                    ? recovered.worker_profile_repin_history?.at(-1) ?? null
-                    : null,
-                lane: recovered,
-            });
-            return;
-        }
-        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 storySwitchRollback;
-        let storySwitchWorkerStarted = false;
-        if (messageId !== undefined && attributionChanged) {
-            lane = casUpdateLane(hqRoot, laneId, (current) => {
-                const already = current.attribution_history.some((entry) => entry.message_id === messageId);
-                if (already)
-                    return current;
-                const existingStory = laneStory(current, projectId, storyId);
-                storySwitchRollback = {
-                    message_id: messageId,
-                    project_id: current.project_id,
-                    story_id: current.story_id,
-                    no_story_reason: current.no_story_reason,
-                    ...(!existingStory ? {
-                        added_story: { project_id: projectId, story_id: storyId, status: "in_progress", added_at: at, updated_at: at },
-                    } : {}),
-                    story_switch_unacknowledged: current.story_switch_unacknowledged,
-                };
-                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,
-                    }),
-                    story_switch_pending: {
-                        previous_project_id: current.project_id,
-                        previous_story_id: current.story_id,
-                        project_id: projectId,
-                        story_id: storyId,
-                        message_id: messageId,
-                        at,
-                        previous_artifact_keys: artifactIdentityKeys(current.last_envelope?.artifacts),
-                    },
-                    story_switch_unacknowledged: undefined,
-                };
-            });
-        }
-        try {
-            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 } : {}),
-                    ...(hireGrantContext !== undefined ? { grantContext: hireGrantContext } : {}),
-                    pending: {
-                        trigger: "resume",
-                        resumed_from: resumedFrom,
-                        ...(opts.fromFailed === true ? { from_failed: true } : {}),
-                        ...(failedResumeExpectedSenior !== undefined
-                            ? { expected_senior: failedResumeExpectedSenior }
-                            : {}),
-                        ...(deliveryText !== undefined ? { text: deliveryText } : {}),
-                        ...(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 } : {}),
-                        ...(hireGrantContext !== undefined ? { grantContext: hireGrantContext } : {}),
-                        pending: {
-                            trigger: "resume",
-                            resumed_from: resumedFrom,
-                            ...(opts.fromFailed === true ? { from_failed: true } : {}),
-                            ...(failedResumeExpectedSenior !== undefined
-                                ? { expected_senior: failedResumeExpectedSenior }
-                                : {}),
-                            ...(deliveryText !== undefined ? { text: deliveryText } : {}),
-                            ...(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;
-                    const guardEnabled = admission.action === "queue" ? false : await lowDiskGuardEnabledForLane(hqRoot, lane);
-                    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_details: undefined,
-                                    queued_at: at,
-                                    pending_resume: {
-                                        session_id: sessionId,
-                                        trigger: "resume",
-                                        caller: ctx.env.HQ_LANE_ID?.trim() || "user",
-                                        resumed_from: resumedFrom,
-                                        ...(opts.fromFailed === true ? { from_failed: true } : {}),
-                                        ...(failedResumeExpectedSenior !== undefined
-                                            ? { expected_senior: failedResumeExpectedSenior }
-                                            : {}),
-                                        ...(deliveryText !== undefined ? { text: deliveryText } : {}),
-                                        ...(messageId !== undefined ? { message_id: messageId } : {}),
-                                        compact: opts.compact !== false,
-                                        at,
-                                    },
-                                };
-                            });
-                        }
-                        const started = spawnLaneWorker(hqRoot, lane, {
-                            lowDiskGuardEnabled: guardEnabled,
-                            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,
-                                ...(resumedFrom === "awaiting_input" && !pendingQuestion ? { allowAwaitingInput: true } : {}),
-                                ...(opts.fromFailed === true ? { fromFailed: true } : {}),
-                                ...(failedResumeExpectedSenior !== undefined
-                                    ? { expectedSenior: failedResumeExpectedSenior }
-                                    : {}),
-                                ...(deliveryText !== undefined ? { text: deliveryText } : {}),
-                                ...(messageId !== undefined ? { message_id: messageId } : {}),
-                            },
-                            compact: opts.compact !== false,
-                            effort: resumeEffort ?? recordedResumeEffort(lane),
-                        });
-                        storySwitchWorkerStarted = true;
-                        deps.onLaneWorkerStarted?.(laneId, "resume");
-                        return started;
-                    }, hireGrantContext);
-                }, ctx.sleep);
-            }
-            const questionCancellation = resumedFrom === "awaiting_input" && !pendingQuestion
-                ? await deps.cancelFallbackQuestionsForLane(ctx, lane, "resume", at)
-                : null;
-            if (deliveryText !== undefined && messageId !== undefined) {
-                // Same audit copy a message resume leaves; nothing drains it. Archive only
-                // after a successful spawn so a concurrent resume cannot leave a phantom.
-                archiveResumeMessage(hqRoot, laneId, {
-                    at,
-                    message_id: messageId,
-                    text: deliveryText,
-                    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 (deliveryText !== 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 (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,
-                ...(questionCancellation === null ? {} : {
-                    cancelled_questions: questionCancellation.cancelled_question_ids,
-                    question_cancellation_failures: questionCancellation.failures,
-                }),
-                lane: next,
-            });
-        }
-        catch (err) {
-            if (storySwitchRollback !== undefined && !storySwitchWorkerStarted) {
-                try {
-                    casUpdateLane(hqRoot, laneId, (current) => rollbackStorySwitchAttribution(current, storySwitchRollback));
-                }
-                catch (rollbackErr) {
-                    const rollbackMessage = rollbackErr instanceof Error ? rollbackErr.message : String(rollbackErr);
-                    process.stderr.write(`Could not roll back story attribution after resume failure: ${rollbackMessage}\n`);
-                }
-            }
-            throw err;
-        }
-    }
-    return { runClaudeBalanceMoveTarget, runResume };
-}
-//# sourceMappingURL=lanes-resume.js.map

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

@@ -1,10 +0,0 @@
-import type { Command } from "commander";
-type WrapHandler = <Args extends unknown[]>(action: (...args: Args) => Promise<void>) => (...args: Args) => Promise<void>;
-export interface LaneReviewCommandDeps {
-    hqRoot: () => string;
-    env: NodeJS.ProcessEnv;
-    now: () => Date;
-}
-export declare function registerLaneReviewCommand(lanes: Command, deps: LaneReviewCommandDeps, wrap: WrapHandler): void;
-export {};
-//# sourceMappingURL=lanes-review.d.ts.map

package/dist/commands/lanes-review.js

@@ -1,56 +0,0 @@
-import { LanesError } from "../lib/lanes/errors.js";
-import { canonicalLaneReviewRepo, listLaneReviews, parseLaneReviewPr, readLaneReview, recordLaneReview, } from "../lib/lanes/reviews.js";
-import { sessionIdFromEnv } from "../lib/mesh/live/session-identity.js";
-function fail(error, message, details = {}) {
-    throw new LanesError(error, message, details);
-}
-function printJson(value) {
-    console.log(JSON.stringify(value));
-}
-export function registerLaneReviewCommand(lanes, deps, wrap) {
-    const review = lanes.command("review").description("Record manager review of pull-request heads");
-    review.command("record <repo> <pr-number>")
-        .description("Record a review against an exact pull-request head")
-        .requiredOption("--head <sha>", "40-character commit SHA that was reviewed")
-        .option("--worker <lane-id>", "Worker lane whose output was reviewed")
-        .option("--note <text>", "Short note about the review")
-        .option("--json", "Print JSON")
-        .action(wrap(async (repoArg, prArg, options) => {
-        const reviewRecord = await recordLaneReview(deps.hqRoot(), {
-            repo: repoArg,
-            pr: prArg,
-            headSha: options.head,
-            reviewerLane: deps.env.HQ_LANE_ID?.trim() || null,
-            reviewerSession: sessionIdFromEnv(deps.env) ?? null,
-            ...(options.worker === undefined ? {} : { workerLane: options.worker }),
-            ...(options.note === undefined ? {} : { note: options.note }),
-            recordedAt: deps.now(),
-        });
-        printJson({ ok: true, action: "lanes.review.record", review: reviewRecord });
-    }));
-    review.command("show <repo> <pr-number>")
-        .description("Show the review record for one pull request")
-        .option("--json", "Print JSON")
-        .action(wrap(async (repoArg, prArg) => {
-        const repo = canonicalLaneReviewRepo(repoArg);
-        const pr = parseLaneReviewPr(prArg);
-        const record = readLaneReview(deps.hqRoot(), repo, pr);
-        if (!record)
-            fail("review_record_missing", `No review record exists for ${repo} PR ${pr}`, { repo, pr });
-        printJson({ ok: true, action: "lanes.review.show", review: record });
-    }));
-    review.command("list")
-        .description("List recorded pull-request reviews")
-        .option("--repo <owner/repo>", "Limit results to one repository")
-        .option("--json", "Print JSON")
-        .action(wrap(async (options) => {
-        const repo = options.repo === undefined ? undefined : canonicalLaneReviewRepo(options.repo);
-        const listing = listLaneReviews(deps.hqRoot());
-        const reviews = listing.reviews.filter((item) => repo === undefined || item.repo === repo);
-        if (listing.skipped > 0) {
-            console.error(`hq lanes review list: skipped ${listing.skipped} invalid or unreadable review item(s)`);
-        }
-        printJson({ ok: true, action: "lanes.review.list", reviews, reviews_skipped: listing.skipped });
-    }));
-}
-//# sourceMappingURL=lanes-review.js.map