@indigoai-us/hq-cli 5.298.0 → 5.300.0

package/dist/commands/lanes-resume.js

@@ -5,6 +5,7 @@ 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 { accountMoveSummary, accountRequestKeepsCurrentLane, assertCurrentResumeAccountAvailable, hasKeepAliveProgress, recordedResumeEffort, resetKeepAliveProgress, resolveResumeEffort } from "./lanes-shared.js";
 export function createLaneResumeHandlers(deps) {
@@ -195,6 +196,8 @@ export function createLaneResumeHandlers(deps) {
         }
         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) {
@@ -253,41 +256,60 @@ export function createLaneResumeHandlers(deps) {
             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 } : {}),
-                ...(hireGrantContext !== undefined ? { grantContext: hireGrantContext } : {}),
-                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,
-                },
+        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,
+                };
             });
-            lane = move.lane;
         }
-        else if (automaticAccountSelection !== undefined) {
-            const selection = automaticAccountSelection.selection;
-            if (selection.account !== lane.account) {
+        try {
+            let move = null;
+            if (opts.account !== undefined && !keepCurrentAccount) {
                 move = await prepareAccountMove(ctx, lane, {
-                    account: selection.account,
-                    cliModel: undefined,
-                    ...(automaticAccountSelection.historyReason !== undefined
-                        ? { accountHistoryReason: automaticAccountSelection.historyReason }
-                        : {}),
-                    ...(automaticAccountSelection.preservedModel !== undefined
-                        ? { preservedModel: automaticAccountSelection.preservedModel }
-                        : {}),
+                    account: opts.account,
+                    cliModel: opts.model?.trim() || undefined,
                     ...(resumeProfile !== undefined ? { workerProfile: resumeProfile } : {}),
                     ...(profileRepin !== undefined ? { profileRepin } : {}),
                     ...(resumeEffort !== undefined ? { effort: resumeEffort } : {}),
@@ -299,204 +321,219 @@ export function createLaneResumeHandlers(deps) {
                         ...(failedResumeExpectedSenior !== undefined
                             ? { expected_senior: failedResumeExpectedSenior }
                             : {}),
-                        ...(text !== undefined ? { text } : {}),
+                        ...(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;
-                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 }
-                                        : {}),
-                                    ...(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 } : {}),
+            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
-                                ? { expectedSenior: failedResumeExpectedSenior }
+                                ? { expected_senior: failedResumeExpectedSenior }
                                 : {}),
-                            ...(text !== undefined ? { text } : {}),
+                            ...(deliveryText !== undefined ? { text: deliveryText } : {}),
                             ...(messageId !== undefined ? { message_id: messageId } : {}),
+                            compact: opts.compact !== false,
                         },
-                        compact: opts.compact !== false,
-                        effort: resumeEffort ?? recordedResumeEffort(lane),
+                        accountSelection: selection,
                     });
-                }, 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,
+                    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 next = resumed;
-        if (failedResumeActor !== undefined &&
-            failedResumeReason !== undefined &&
-            recoveredFailure !== undefined) {
-            next = casUpdateLane(hqRoot, laneId, (current) => ({
-                ...current,
-                failed_resume_history: appendCappedHistory(current.failed_resume_history ?? [], {
+            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_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, {
+                            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 }
+                                    : {}),
+                                ...(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);
+            }
+            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,
-                    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,
+                    message_id: messageId,
+                    text: deliveryText,
                     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,
+                    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,
+                lane: next,
             });
         }
-        if (text === undefined && hasKeepAliveProgress(next)) {
-            next = casUpdateLane(hqRoot, laneId, (current) => resetKeepAliveProgress(current));
+        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;
         }
-        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 };
 }

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

@@ -144,6 +144,8 @@ export interface OutpostLaneDispatchBehavior {
     expectedOwnerHost?: LaneRecord["host"];
 }
 export interface LaneMessageHandlerDeps {
+    /** Test seam invoked after a provider worker has been started. */
+    onLaneWorkerStarted?: (laneId: string, command: "message" | "resume") => void;
     archiveResumeMessage(hqRoot: string, laneId: string, message: {
         message_id: string;
         [key: string]: unknown;
@@ -184,7 +186,7 @@ export interface LaneMessageHandlerDeps {
     validateResumeProfileModel(ctx: Ctx, lane: LaneRecord, profile: WorkerProfile): void;
     withResumeHireAdmission<T>(ctx: Ctx, lane: LaneRecord, fn: () => T, grantContext?: OutpostHireGrantContext): Promise<T>;
 }
-export interface LaneResumeHandlerDeps extends Pick<LaneMessageHandlerDeps, "archiveResumeMessage" | "assertLaneRunsHereForAdmission" | "assertLaneRunsHereForOperatorMutation" | "assessLaneAdmission" | "casUpdateLane" | "laneIsHostedHere" | "laneWithRecoveredProviderSession" | "mintMessageId" | "prepareAccountMove" | "persistClaudeAccountSelection" | "printJson" | "recordResumeSetup" | "resolveCommandLane" | "resolveResumeProfile" | "selectAutomaticClaudeResumeAccount" | "validateResumeProfileModel" | "withResumeHireAdmission"> {
+export interface LaneResumeHandlerDeps extends Pick<LaneMessageHandlerDeps, "onLaneWorkerStarted" | "archiveResumeMessage" | "assertLaneRunsHereForAdmission" | "assertLaneRunsHereForOperatorMutation" | "assessLaneAdmission" | "casUpdateLane" | "laneIsHostedHere" | "laneWithRecoveredProviderSession" | "mintMessageId" | "prepareAccountMove" | "persistClaudeAccountSelection" | "printJson" | "recordResumeSetup" | "resolveCommandLane" | "resolveResumeProfile" | "selectAutomaticClaudeResumeAccount" | "validateResumeProfileModel" | "withResumeHireAdmission"> {
     dispatchOutpostLaneCommand(ctx: Ctx, lane: LaneRecord, action: "resume", options: LaneResumeOptions, behavior?: OutpostLaneDispatchBehavior): Promise<void>;
     authorizeFailedResume(ctx: Ctx, lane: LaneRecord, encodedContext?: string): string;
     authorizeResumeProfileRepin(ctx: Ctx, lane: LaneRecord, profile: ResolvedResumeProfile | undefined, encodedContext: string | undefined): ResumeProfileRepinAuthorization | undefined;

package/dist/commands/lanes.d.ts

@@ -29,6 +29,8 @@ export declare const LANE_REMOTE_MIRROR_SYNC_FLAG = "lanes.remote-done-mirror";
 /** The lane → mesh seam. Defined in lib/lanes/mesh-events.ts; the watcher shares it. */
 export { emitLaneDecisionEvents };
 export interface LanesCommandDeps {
+    /** Test seam for failures after a lane provider worker is started. */
+    onLaneWorkerStarted?: (laneId: string, command: "message" | "resume") => void;
     hqRoot?: () => string;
     /** Start HQ-root walk here instead of process.cwd(). Tests only. */
     cwd?: () => string;

package/dist/commands/lanes.js

@@ -7837,6 +7837,7 @@ export function registerLanesCommand(parent, deps = {}) {
         writeAnswerDeliveryFailed,
     });
     const messageHandlerDeps = {
+        onLaneWorkerStarted: deps.onLaneWorkerStarted,
         archiveResumeMessage,
         assertLaneRunsHereForAdmission,
         assertLaneRunsHereForOperatorMutation,
@@ -7862,6 +7863,7 @@ export function registerLanesCommand(parent, deps = {}) {
     };
     const messageHandlers = createLaneMessageHandlers(messageHandlerDeps);
     const resumeHandlers = createLaneResumeHandlers({
+        onLaneWorkerStarted: deps.onLaneWorkerStarted,
         archiveResumeMessage,
         assertLaneRunsHereForAdmission,
         assertLaneRunsHereForOperatorMutation,
@@ -8214,8 +8216,8 @@ export function registerLanesCommand(parent, deps = {}) {
         .description("Send a follow-up message to a lane")
         .argument("<lane-id>", "Lane id")
         .requiredOption("--text <msg>", "Message text")
-        .option("--project <slug>", "Re-point project attribution from this message")
-        .option("--story <id>", "Re-point story attribution from this message")
+        .option("--project <slug>", "Re-point project attribution; a changed story is named in the resumed prompt")
+        .option("--story <id>", "Re-point story attribution; a changed story is named in the resumed prompt")
         .option("--account <id>", "Move the lane's session to this account of its provider before the message resumes it")
         .option("--model <id>", "Model for the moved lane (with --account only)")
         .option("--effort <level>", "Reasoning effort for the resumed provider turn")
@@ -8292,8 +8294,8 @@ export function registerLanesCommand(parent, deps = {}) {
         .option("--text <msg>", "Operator message for the resumed turn")
         .option("--from-failed", "Explicitly resume a failed lane as its senior")
         .option("--reason <text>", "Required explanation for resuming from failed")
-        .option("--project <slug>", "Re-point project attribution from this resume")
-        .option("--story <id>", "Re-point story attribution from this resume")
+        .option("--project <slug>", "Re-point project attribution; a changed story is named in the resumed prompt")
+        .option("--story <id>", "Re-point story attribution; a changed story is named in the resumed prompt")
         .option("--account <id>", "Move the lane's session to this account of its provider before resuming")
         .option("--model <id>", "Model for the moved lane (with --account only)")
         .option("--effort <level>", "Reasoning effort for the resumed provider turn")
@@ -8453,6 +8455,16 @@ export function registerLanesCommand(parent, deps = {}) {
         .action(wrap(async (provider, accountId, opts) => {
         await accountHandlers.runAccountsLogin(ctx, provider, accountId, opts);
     }));
+    accounts
+        .command("clear-quota")
+        .description("Clear quota reset marks for a provider account")
+        .argument("<provider>", "claude | codex | grok")
+        .argument("<account-id>", "Account id")
+        .option("--model <model>", "Clear only this model's reset")
+        .option("--json", "JSON on stdout (always)")
+        .action(wrap(async (provider, accountId, opts) => {
+        await accountHandlers.runAccountsClearQuota(ctx, provider, accountId, opts);
+    }));
     accounts
         .command("enable")
         .description("Enable an account without touching credentials")

package/dist/lib/daemon/legacy.d.ts

@@ -3,8 +3,9 @@
  * still runs a service, the daemon leaves that service alone instead of
  * starting a second copy, and `hq daemon migrate` lists it.
  *
- * Detection only reads the filesystem (and asks schtasks on Windows). Nothing
- * here stops or removes a unit.
+ * Detection reads unit files and checks for an orphaned loaded macOS mesh job
+ * whose plist was removed. Windows scheduled tasks are probed through
+ * schtasks. Nothing here stops or removes a unit.
  */
 import type { ServiceName } from "./catalog.js";
 export interface LegacyUnit {
@@ -22,6 +23,8 @@ export interface LegacyProbeDeps {
     home: string;
     existsSync: (p: string) => boolean;
     listDir: (dir: string) => string[];
+    /** True when launchctl can print the GUI-domain job despite a missing plist. */
+    launchdJobLoaded: (label: string) => boolean;
     windowsTaskExists: (taskName: string) => boolean;
 }
 export declare function describeLegacyUnit(unit: LegacyUnit): string;

package/dist/lib/daemon/legacy.js

@@ -3,8 +3,9 @@
  * still runs a service, the daemon leaves that service alone instead of
  * starting a second copy, and `hq daemon migrate` lists it.
  *
- * Detection only reads the filesystem (and asks schtasks on Windows). Nothing
- * here stops or removes a unit.
+ * Detection reads unit files and checks for an orphaned loaded macOS mesh job
+ * whose plist was removed. Windows scheduled tasks are probed through
+ * schtasks. Nothing here stops or removes a unit.
  */
 import * as path from "node:path";
 const KIT_SERVICES = ["sync", "inbox", "heartbeat"];
@@ -52,8 +53,9 @@ function darwinUnits(deps) {
     const units = [];
     const at = (label) => path.join(dir, `${label}.plist`);
     const add = (unitId, service, label, migratable = true) => units.push({ unitId, service, kind: "launchd", name: label, path: at(label), migratable });
-    if (deps.existsSync(at("ai.getindigo.hq-mesh-daemon")))
-        add("mesh", "mesh", "ai.getindigo.hq-mesh-daemon");
+    const meshLabel = "ai.getindigo.hq-mesh-daemon";
+    if (deps.existsSync(at(meshLabel)) || deps.launchdJobLoaded(meshLabel))
+        add("mesh", "mesh", meshLabel);
     for (const file of safeList(deps, dir).sort()) {
         const m = /^ai\.getindigo\.hq-bot\.(.+)\.plist$/.exec(file);
         if (m)