@indigoai-us/hq-cli 5.147.0 → 5.149.1

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

@@ -42,7 +42,7 @@
  * of opening a browser nobody is watching, and the watcher records
  * `mesh_event_failed` and moves on. No credential file is read here.
  */
-import { appendThreadEvent, clamp, ensureProjectThread, patchStoryStatus, requireToken, resolveMeshCompany, } from "../mesh/api.js";
+import { appendThreadEvent, clamp, ensureProjectThread, getProjectView, patchStoryStatus, putProjectView, requireToken, registerMeshProject, resolveMeshCompany, } from "../mesh/api.js";
 import { LanesError } from "./errors.js";
 export const LANE_MESH_EVENTS = [
     "lane_started",
@@ -163,9 +163,64 @@ export function toWireThreadEvent(event, payload) {
         }
     }
 }
+function isProjectViewNotFound(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    const candidate = error;
+    return (candidate.code === "PROJECT_VIEW_NOT_FOUND" ||
+        (typeof candidate.message === "string" && candidate.message.includes("PROJECT_VIEW_NOT_FOUND")));
+}
+function isAlreadyRegistered(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    const candidate = error;
+    return (candidate.code === "PROJECT_ALREADY_REGISTERED" ||
+        (typeof candidate.message === "string" && candidate.message.includes("PROJECT_ALREADY_REGISTERED")));
+}
+async function repairProjectView(input) {
+    const company = { companyUid: input.company.uid, companySlug: input.company.slug };
+    await ensureProjectThread(input.token, company, input.projectId, {
+        summary: `HQ lane ${input.projectId}`,
+    });
+    let current;
+    try {
+        current = await getProjectView(input.token, input.company.uid, input.projectId);
+    }
+    catch (error) {
+        if (!isProjectViewNotFound(error))
+            throw error;
+    }
+    const stories = [...(current?.stories ?? [])];
+    const index = stories.findIndex((story) => story.id === input.storyId);
+    const nextStory = {
+        ...(index >= 0 ? stories[index] : {}),
+        id: input.storyId,
+        title: index >= 0 ? stories[index]?.title || input.storyId : input.storyId,
+        status: input.status,
+    };
+    if (index >= 0)
+        stories[index] = nextStory;
+    else
+        stories.push(nextStory);
+    await putProjectView(input.token, input.company.uid, input.projectId, {
+        name: current?.name || input.projectId,
+        description: current?.description || "HQ lane project",
+        stories,
+        repos: current?.repos ?? [],
+        ...(current?.version !== undefined ? { expectedVersion: current.version } : {}),
+    });
+    try {
+        await registerMeshProject(input.token, input.company.uid, input.projectId);
+    }
+    catch (error) {
+        if (!isAlreadyRegistered(error))
+            throw error;
+    }
+}
 export function createLaneMesh(opts = {}) {
     const interactive = opts.interactive ?? true;
     const token = opts.token ?? (() => requireToken({ interactive }));
+    const repair = opts.repairProjectView ?? repairProjectView;
     return {
         async ensureProjectThread(company, projectId) {
             const tok = await token();
@@ -182,7 +237,21 @@ export function createLaneMesh(opts = {}) {
         },
         async patchStoryStatus(company, projectId, storyId, status) {
             const tok = await token();
-            await patchStoryStatus(tok, company.uid, projectId, storyId, status);
+            try {
+                await patchStoryStatus(tok, company.uid, projectId, storyId, status);
+            }
+            catch (error) {
+                if (!isProjectViewNotFound(error))
+                    throw error;
+                await repair({
+                    token: tok,
+                    company,
+                    projectId,
+                    storyId,
+                    status,
+                });
+                await patchStoryStatus(tok, company.uid, projectId, storyId, status);
+            }
         },
     };
 }
@@ -232,10 +301,18 @@ export async function emitLaneDecisionEvents(mesh, lane, envelope, opts = {}) {
             return;
         }
         case "blocked":
-            await mesh.appendThreadEvent(company, threadId, "lane_blocked", {
-                ...baseIdentity(lane),
-                blocked_reason: envelope.blocked_reason ?? "",
-            });
+            {
+                const outcomes = await Promise.allSettled([
+                    mesh.appendThreadEvent(company, threadId, "lane_blocked", {
+                        ...baseIdentity(lane),
+                        blocked_reason: envelope.blocked_reason ?? "",
+                    }),
+                    mesh.patchStoryStatus(company, lane.project_id, lane.story_id, "in_progress"),
+                ]);
+                const failure = outcomes.find((outcome) => outcome.status === "rejected");
+                if (failure?.status === "rejected")
+                    throw failure.reason;
+            }
             return;
         case "ask":
             // A mesh question event has one `questionId`; sending one event per id

package/dist/lib/lanes/outpost-dispatch.d.ts

@@ -26,6 +26,16 @@ export interface OutpostDispatchResult {
     stdout: string;
     stderr: string;
 }
+export interface OutpostLaneCommand {
+    action: "message" | "resume";
+    laneId: string;
+    text?: string;
+    project?: string;
+    story?: string;
+    account?: string;
+    model?: string;
+    compact?: boolean;
+}
 export interface OutpostExecPort {
     stageExecInput: (outpostId?: string) => Promise<{
         putUrl: string;
@@ -47,6 +57,8 @@ export interface OutpostExecPort {
 export declare function parseOutpostPickupPayload(raw: unknown): OutpostPickupPayload;
 /** Same wrapping `hq outposts exec` applies: run from the box's HQ folder. */
 export declare function buildOutpostPickupCommand(payloadUrl: string): string;
+/** Build the same `hq outposts exec` remote command used by lane pickup. */
+export declare function buildOutpostLaneCommand(input: OutpostLaneCommand): string;
 export declare function stageOutpostPayload(port: Pick<OutpostExecPort, "stageExecInput">, outpostId: string, bytes: Uint8Array, put?: typeof fetch): Promise<{
     getUrl: string;
 }>;

package/dist/lib/lanes/outpost-dispatch.js

@@ -42,6 +42,23 @@ export function parseOutpostPickupPayload(raw) {
 export function buildOutpostPickupCommand(payloadUrl) {
     return withRemoteHqDir(joinCommandParts(["hq", "lanes", "pickup", "--payload-url", payloadUrl]));
 }
+/** Build the same `hq outposts exec` remote command used by lane pickup. */
+export function buildOutpostLaneCommand(input) {
+    const args = ["hq", "lanes", input.action, input.laneId];
+    for (const [flag, value] of [
+        ["--text", input.text],
+        ["--project", input.project],
+        ["--story", input.story],
+        ["--account", input.account],
+        ["--model", input.model],
+    ]) {
+        if (value !== undefined)
+            args.push(flag, value);
+    }
+    if (input.compact === false)
+        args.push("--no-compact");
+    return withRemoteHqDir(joinCommandParts(args));
+}
 export async function stageOutpostPayload(port, outpostId, bytes, put = fetch) {
     const staged = await port.stageExecInput(outpostId);
     const upload = await put(staged.putUrl, {

package/dist/lib/lanes/reconcile.js

@@ -20,6 +20,7 @@ import { applyDefaultQuotaHold, readQuotaSignal, recordAccountQuota } from "./qu
 import { answeredQuestionEntries, raiseEnvelopeQuestions } from "./questions.js";
 import { SILENCE_MS, classifyLaneExit, isPidAlive, readLatestEnvelope, readLatestEnvelopeFile, readLatestEnvelopeRecord, } from "./watcher.js";
 import { createLaneMesh, emitLaneDecisionEvents, laneMeshCompany } from "./mesh-events.js";
+import { laneStories, storyStatusForEnvelope } from "./stories.js";
 import { decideEnvelopeRepair, envelopeQuestionIds, routeProviderFailure } from "./watcher.js";
 import { providerRejectionDetails, readProviderRejection, } from "./provider-rejection.js";
 /** Spec §9: unanswered at the current hop for 60 minutes → one hop. */
@@ -882,18 +883,44 @@ async function heartbeatAndDeadHosts(hqRoot, lanes, summary, deps, now) {
                     (latest.envelope.questions?.length ?? 0) > 0) {
                     raiseEnvelopeQuestions(hqRoot, readLane(hqRoot, lane.lane_id), latest.envelope, latest.ref, nowIso);
                 }
-                const result = casLaneIf(hqRoot, lane.lane_id, (current) => current.state === "running", (current) => ({
-                    ...current,
-                    state: repairedClassification.state,
-                    queued_reason: undefined,
-                    terminal_reason: repairedClassification.reason ?? "host_lost",
-                    ...(providerRejection
-                        ? { terminal_details: providerRejectionDetails(providerRejection, current) }
-                        : {}),
-                    ...(quota?.quota_reset_at ? { quota_reset_at: quota.quota_reset_at } : {}),
-                    ...(quota?.marker ? { model_quota_marker: quota.marker } : {}),
-                    last_host_report_at: nowIso,
-                }), deps.dryRun);
+                const result = casLaneIf(hqRoot, lane.lane_id, (current) => current.state === "running", (current) => {
+                    const next = {
+                        ...current,
+                        state: repairedClassification.state,
+                        queued_reason: undefined,
+                        terminal_reason: repairedClassification.reason ?? "host_lost",
+                        ...(providerRejection
+                            ? { terminal_details: providerRejectionDetails(providerRejection, current) }
+                            : {}),
+                        ...(quota?.quota_reset_at ? { quota_reset_at: quota.quota_reset_at } : {}),
+                        ...(quota?.marker ? { model_quota_marker: quota.marker } : {}),
+                        last_host_report_at: nowIso,
+                    };
+                    if (latest?.envelope) {
+                        const envelope = latest.envelope;
+                        next.story_status = envelope.story_status;
+                        if (envelope.story_complete !== undefined) {
+                            next.story_complete = envelope.story_complete;
+                            next.story_complete_reason = envelope.story_complete_reason;
+                        }
+                        const storyStatus = envelope.decision === "blocked"
+                            ? "blocked"
+                            : envelope.decision === "done"
+                                ? "review"
+                                : storyStatusForEnvelope(envelope.story_status);
+                        next.stories = laneStories(current).map((story) => story.project_id === current.project_id && story.story_id === current.story_id
+                            ? {
+                                ...story,
+                                status: storyStatus,
+                                updated_at: nowIso,
+                                ...(envelope.decision === "blocked"
+                                    ? { blocked_reason: envelope.blocked_reason ?? "" }
+                                    : { blocked_reason: undefined }),
+                            }
+                            : story);
+                    }
+                    return next;
+                }, deps.dryRun);
                 if (result.changed) {
                     summary.dead_host.push({
                         id: lane.lane_id,

package/dist/lib/lanes/session-relink.d.ts

@@ -0,0 +1,25 @@
+import { type SessionCopyResult } from "./move-account.js";
+import type { LaneProvider } from "./types.js";
+export interface EnsureSessionHomeInput {
+    provider: Exclude<LaneProvider, "grok">;
+    sessionId: string;
+    cwd: string;
+    targetHome: string;
+    registeredHomes: string[];
+    providerHomeAtSpawn?: string;
+}
+export interface EnsureSessionHomeResult extends SessionCopyResult {
+    source_home: string;
+    transcript_path: string;
+    homes_searched: string[];
+}
+/**
+ * Older Claude account homes can share a registered `account-N/.claude`
+ * parent even after one account is re-registered elsewhere. Discover only
+ * those sibling homes, then inspect the exact session path; credential files
+ * are never opened.
+ */
+export declare function discoverSiblingAccountHomes(provider: EnsureSessionHomeInput["provider"], registeredHomes: string[]): string[];
+/** Find, copy, and verify a provider transcript in the home the next run uses. */
+export declare function ensureSessionHome(input: EnsureSessionHomeInput): EnsureSessionHomeResult;
+//# sourceMappingURL=session-relink.d.ts.map

package/dist/lib/lanes/session-relink.js

@@ -0,0 +1,216 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { copySessionFiles, encodeClaudeProjectDir, planSessionCopy, } from "./move-account.js";
+import { LanesError } from "./errors.js";
+function statDirectory(target) {
+    try {
+        return fs.statSync(target).isDirectory();
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT" || code === "ENOTDIR")
+            return false;
+        throw err;
+    }
+}
+function claudeTranscriptPath(home, cwd, sessionId) {
+    return path.join(home, "projects", encodeClaudeProjectDir(cwd), `${sessionId}.jsonl`);
+}
+function findCodexRollouts(home, sessionId) {
+    const root = path.join(home, "sessions");
+    if (!statDirectory(root))
+        return [];
+    const suffix = `-${sessionId}.jsonl`;
+    const stack = [{ dir: root, depth: 0 }];
+    const matches = [];
+    while (stack.length > 0) {
+        const { dir, depth } = stack.pop();
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch (err) {
+            const code = err.code;
+            if (code === "ENOENT" || code === "ENOTDIR")
+                continue;
+            throw new LanesError("provider_home_search_failed", `Could not search provider home ${home}: ${err instanceof Error ? err.message : String(err)}`, { provider: "codex", home });
+        }
+        for (const entry of entries) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (depth < 3)
+                    stack.push({ dir: full, depth: depth + 1 });
+            }
+            else if (entry.isFile() &&
+                entry.name.startsWith("rollout-") &&
+                entry.name.endsWith(suffix)) {
+                matches.push(full);
+            }
+        }
+    }
+    return matches;
+}
+function sessionTranscripts(provider, home, cwd, sessionId) {
+    if (provider === "codex")
+        return findCodexRollouts(home, sessionId);
+    const transcript = claudeTranscriptPath(home, cwd, sessionId);
+    try {
+        return fs.statSync(transcript).isFile() ? [transcript] : [];
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT" || code === "ENOTDIR")
+            return [];
+        throw new LanesError("provider_home_search_failed", `Could not check provider home ${home}: ${err instanceof Error ? err.message : String(err)}`, { provider, home });
+    }
+}
+/**
+ * Older Claude account homes can share a registered `account-N/.claude`
+ * parent even after one account is re-registered elsewhere. Discover only
+ * those sibling homes, then inspect the exact session path; credential files
+ * are never opened.
+ */
+export function discoverSiblingAccountHomes(provider, registeredHomes) {
+    const roots = new Set();
+    for (const home of registeredHomes) {
+        if (provider === "claude") {
+            const accountDir = path.dirname(home);
+            if (path.basename(home) === ".claude" &&
+                path.basename(accountDir).startsWith("account-")) {
+                roots.add(path.dirname(accountDir));
+            }
+        }
+        else if (path.basename(home).startsWith("account-")) {
+            roots.add(path.dirname(home));
+        }
+    }
+    const homes = [];
+    for (const root of [...roots].sort()) {
+        let entries;
+        try {
+            entries = fs.readdirSync(root, { withFileTypes: true });
+        }
+        catch (err) {
+            const code = err.code;
+            if (code === "ENOENT" || code === "ENOTDIR")
+                continue;
+            throw new LanesError("provider_home_search_failed", `Could not search provider account directory ${root}: ${err instanceof Error ? err.message : String(err)}`, { provider, home: root });
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory() || !entry.name.startsWith("account-"))
+                continue;
+            const home = provider === "claude"
+                ? path.join(root, entry.name, ".claude")
+                : path.join(root, entry.name);
+            if (statDirectory(home))
+                homes.push(home);
+        }
+    }
+    return homes;
+}
+function uniqueHomes(homes) {
+    const unique = new Set();
+    for (const home of homes) {
+        if (typeof home !== "string" || home.trim() === "")
+            continue;
+        unique.add(path.resolve(home));
+    }
+    return [...unique];
+}
+function missingTranscript(input, homes) {
+    return new LanesError("provider_transcript_missing", `Provider transcript for session ${input.sessionId} was not found. Homes searched: ${homes.join(", ")}`, { provider: input.provider, session_id: input.sessionId, homes_searched: homes });
+}
+function copyVerifiedTranscript(input, sourceHome, targetHome, searched) {
+    let copied;
+    try {
+        copied = copySessionFiles(planSessionCopy(input.provider, {
+            sourceHome,
+            targetHome,
+            cwd: input.cwd,
+            sessionId: input.sessionId,
+        }));
+    }
+    catch (err) {
+        if (err instanceof LanesError && err.error === "provider_session_missing") {
+            throw missingTranscript(input, searched);
+        }
+        throw err;
+    }
+    const target = sessionTranscripts(input.provider, targetHome, input.cwd, input.sessionId);
+    if (target.length !== 1) {
+        throw new LanesError("provider_transcript_relink_failed", `Could not verify session ${input.sessionId} in target home ${targetHome}`, { provider: input.provider, session_id: input.sessionId, target_home: targetHome });
+    }
+    return {
+        ...copied,
+        source_home: sourceHome,
+        transcript_path: target[0],
+        homes_searched: searched,
+    };
+}
+/** Find, copy, and verify a provider transcript in the home the next run uses. */
+export function ensureSessionHome(input) {
+    const targetHome = path.resolve(input.targetHome);
+    const homes = uniqueHomes([
+        targetHome,
+        ...input.registeredHomes,
+        ...(input.providerHomeAtSpawn ? [input.providerHomeAtSpawn] : []),
+        ...discoverSiblingAccountHomes(input.provider, input.registeredHomes),
+    ]);
+    const searched = [targetHome];
+    const current = sessionTranscripts(input.provider, targetHome, input.cwd, input.sessionId);
+    if (current.length > 1) {
+        throw new LanesError("provider_transcript_ambiguous", `Multiple ${input.provider} transcripts for session ${input.sessionId} exist in ${targetHome}`, { provider: input.provider, session_id: input.sessionId, homes_searched: searched, matches: current });
+    }
+    const lastRunHome = input.providerHomeAtSpawn
+        ? path.resolve(input.providerHomeAtSpawn)
+        : undefined;
+    if (lastRunHome !== undefined && lastRunHome !== targetHome) {
+        searched.push(lastRunHome);
+        const lastRun = sessionTranscripts(input.provider, lastRunHome, input.cwd, input.sessionId);
+        if (lastRun.length > 1) {
+            throw new LanesError("provider_transcript_ambiguous", `Multiple ${input.provider} transcripts for session ${input.sessionId} exist in the last run home ${lastRunHome}`, { provider: input.provider, session_id: input.sessionId, homes_searched: searched, matches: lastRun });
+        }
+        if (lastRun.length === 1) {
+            return copyVerifiedTranscript(input, lastRunHome, targetHome, searched);
+        }
+    }
+    if (current.length === 1) {
+        const plan = planSessionCopy(input.provider, {
+            sourceHome: targetHome,
+            targetHome,
+            cwd: input.cwd,
+            sessionId: input.sessionId,
+        });
+        return {
+            ...plan,
+            copied: [],
+            source_home: targetHome,
+            transcript_path: current[0],
+            homes_searched: searched,
+        };
+    }
+    const matches = [];
+    for (const home of homes.slice(1)) {
+        if (home === lastRunHome && searched.includes(home))
+            continue;
+        searched.push(home);
+        const found = sessionTranscripts(input.provider, home, input.cwd, input.sessionId);
+        if (found.length > 1) {
+            throw new LanesError("provider_transcript_ambiguous", `Multiple ${input.provider} transcripts for session ${input.sessionId} exist in ${home}`, { provider: input.provider, session_id: input.sessionId, homes_searched: searched, matches: found });
+        }
+        if (found.length === 1)
+            matches.push({ home, transcript: found[0] });
+    }
+    if (matches.length === 0)
+        throw missingTranscript(input, searched);
+    if (matches.length > 1) {
+        throw new LanesError("provider_transcript_ambiguous", `Provider transcript for session ${input.sessionId} exists in multiple homes: ${matches.map((match) => match.home).join(", ")}`, {
+            provider: input.provider,
+            session_id: input.sessionId,
+            homes_searched: searched,
+            matching_homes: matches.map((match) => match.home),
+        });
+    }
+    return copyVerifiedTranscript(input, matches[0].home, targetHome, searched);
+}
+//# sourceMappingURL=session-relink.js.map

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

@@ -235,6 +235,7 @@ export interface SpawnManifestFile {
     resume?: {
         session_id: string;
     } | null;
+    provider_home_at_spawn?: string;
     /** Byte length of logs/worker.out before this run started; its result is after this. */
     worker_out_offset?: number;
     fast_mode?: boolean;

package/dist/lib/lanes/spawn.js

@@ -22,6 +22,7 @@ import { AccountResolutionError, LanesError } from "./errors.js";
 import { ignoredWorkerProfileFields, loadWorkerProfile, materializeWorkerProfile, workerProfilePrompt, } from "./profile.js";
 import { resolveMachineIdentity, } from "./machine-identity.js";
 import { readLane, retryUpdateLane } from "./store.js";
+import { ensureSessionHome } from "./session-relink.js";
 import { LANE_ENVELOPE_JSON_SCHEMA, parseLaneProvider, } from "./types.js";
 export const LANES_RUNS_REL = path.join("workspace", "lanes-runs");
 /** Written by reconcile before a resume spawn; the worker prompt names this path. */
@@ -1027,6 +1028,9 @@ export function readSpawnManifest(runDir) {
     const out = {};
     if (typeof rec.envelope_path === "string")
         out.envelope_path = rec.envelope_path;
+    if (typeof rec.provider_home_at_spawn === "string") {
+        out.provider_home_at_spawn = rec.provider_home_at_spawn;
+    }
     if (typeof rec.worker_out_offset === "number" &&
         Number.isInteger(rec.worker_out_offset) &&
         rec.worker_out_offset >= 0) {
@@ -1053,6 +1057,10 @@ export function readSpawnManifest(runDir) {
     }
     return out;
 }
+function laneLaunchResult(lane) {
+    const { provider_home_at_spawn: _providerHomeAtSpawn, ...safe } = lane;
+    return safe;
+}
 function inferTrigger(lane) {
     if (lane.state === "awaiting_input")
         return { kind: "answered_questions" };
@@ -1075,12 +1083,32 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
     const spawnProcess = deps.spawnProcess ?? defaultSpawnProcess;
     const proveDetached = deps.proveDetached ?? defaultProveDetached;
     const killProcess = deps.killProcess ?? defaultKillProcess;
-    const existing = readLane(hqRoot, lane.lane_id);
+    const runDir = laneRunDir(hqRoot, lane.lane_id);
+    const previousSpawn = readSpawnManifest(runDir);
+    const stored = readLane(hqRoot, lane.lane_id);
+    const recoveredSessionId = (typeof stored.provider_session_id === "string" && stored.provider_session_id.trim()
+        ? stored.provider_session_id
+        : undefined) ??
+        (typeof stored.last_resume?.session_id === "string" && stored.last_resume.session_id.trim()
+            ? stored.last_resume.session_id
+            : undefined) ??
+        (typeof previousSpawn.resume?.session_id === "string" && previousSpawn.resume.session_id.trim()
+            ? previousSpawn.resume.session_id
+            : undefined);
+    const existing = {
+        ...stored,
+        ...(stored.provider_session_id === undefined && recoveredSessionId !== undefined
+            ? { provider_session_id: recoveredSessionId }
+            : {}),
+        ...(stored.provider_home_at_spawn === undefined && previousSpawn.provider_home_at_spawn !== undefined
+            ? { provider_home_at_spawn: previousSpawn.provider_home_at_spawn }
+            : {}),
+    };
     if (existing.state === "running") {
         if (launch.trigger?.kind === "resume") {
             throw new LanesError("lane_not_resumable", `Lane ${lane.lane_id} is already running`, { lane_id: lane.lane_id, state: existing.state });
         }
-        return existing;
+        return laneLaunchResult(existing);
     }
     // A queued lane that a move parked at the target's cap carries the turn
     // it was resumed with: the admit spawn continues that session instead of
@@ -1098,7 +1126,6 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
     if (existing.host.kind === "outpost") {
         refuseOutpostSelfTarget(hqRoot, existing, deps);
     }
-    const runDir = laneRunDir(hqRoot, lane.lane_id);
     const logsDir = path.join(runDir, "logs");
     ensureDir(logsDir);
     ensureDir(path.join(runDir, "envelopes"));
@@ -1159,6 +1186,17 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
     if (profileDefaultsApply && profileModel !== undefined && pinnedModel === undefined) {
         validateProfileLaneModel(existing.provider, profileModel, resolved.home, profile.id, modelDeps);
     }
+    if (plan.mode === "resume" && existing.provider !== "grok") {
+        ensureSessionHome({
+            provider: existing.provider,
+            sessionId: plan.session_id,
+            cwd: hqRoot,
+            targetHome: resolved.home,
+            registeredHomes: Object.values(config.providers[existing.provider].accounts)
+                .map((account) => account.home),
+            providerHomeAtSpawn: existing.provider_home_at_spawn,
+        });
+    }
     if (lane.account !== resolved.id) {
         retryUpdateLane(hqRoot, lane.lane_id, "spawn", (current) => {
             if (current.account === resolved.id)
@@ -1325,6 +1363,7 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
             // An account move's reservation ends with the claim.
             pending_resume: undefined,
             account: resolved.id,
+            provider_home_at_spawn: resolved.home,
             ...(model !== undefined ? { model } : {}),
             ...(model !== undefined
                 ? {
@@ -1348,6 +1387,10 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
                 }
                 : {}),
         };
+        if (resume !== undefined) {
+            next.provider_session_id = resume.session_id;
+            next.provider_session_id_absent = undefined;
+        }
         if (effort.effort !== undefined)
             next.effort = effort.effort;
         else
@@ -1406,7 +1449,7 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
                 last_compaction: record,
             }));
         }
-        return claimedRecord;
+        return laneLaunchResult(claimedRecord);
     }
     const workerOutPath = path.join(logsDir, "worker.out");
     const workerOutOffset = fileSizeOrZero(workerOutPath);
@@ -1476,7 +1519,7 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
         }
         throw err;
     }
-    return readLane(hqRoot, lane.lane_id);
+    return laneLaunchResult(readLane(hqRoot, lane.lane_id));
 }
 /**
  * `resume`: claude and codex continue the recorded session with the repair