@indigoai-us/hq-cli 5.148.0 → 5.150.0

package/dist/lib/lanes/reconcile.js

@@ -8,18 +8,21 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { parseUserYaml } from "../../utils/user-yaml-error.js";
-import { accountMaxRunning, loadLanesConfig, providerQuotaDefaultHoldMs } from "./config.js";
+import { compareLaneQueueOrder, hasActiveAdmissionReservation, hasActivePendingResume, laneAdmissionCapReason, laneRunsOnHost, withAllLaneAdmissionLocks, } from "./admission.js";
+import { accountStatus, isCredentialProven, resolveAccount } from "./accounts.js";
+import { loadLanesConfig, providerQuotaDefaultHoldMs } from "./config.js";
 import { MAX_LANE_DEPTH } from "./constants.js";
-import { LanesError, isLaneVersionConflict } from "./errors.js";
+import { AccountResolutionError, LanesError, isLaneVersionConflict } from "./errors.js";
 import { loadWorkerProfile } from "./profile.js";
 import { classifySessionLiveness, defaultLivenessDeps, loadLivenessIndex, readDaemonPresenceConnected, } from "./liveness.js";
 import { ANSWERED_QUESTIONS_FILE, armLaneWatcher, isPidRecordAlive, laneRunDir, readPidRecord, readSpawnManifest, markSpawnFailure, spawnEnvelopeRepair, spawnLaneWorker, } from "./spawn.js";
 import { appendCappedHistory, lanesStoreRoot, parseLaneRecord, parseQuestionRecord, readLane, readQuestion, updateLane, updateQuestion, } from "./store.js";
-import { applyThrottleDecision, defaultThrottleDeps, emptyThrottleState, evaluateThrottle, isCpuCheckEnabled, readAvailableMemMb, readThrottleState, resolveCpuBusyFraction, throttleStatePath, writeThrottleState, } from "./throttle.js";
+import { applyThrottleDecision, decideAdmission, defaultThrottleDeps, emptyThrottleState, evaluateThrottle, isCpuCheckEnabled, readAvailableMemMb, readThrottleState, resolveCpuBusyFraction, throttleStatePath, writeThrottleState, } from "./throttle.js";
 import { applyDefaultQuotaHold, readQuotaSignal, recordAccountQuota } from "./quota.js";
 import { answeredQuestionEntries, raiseEnvelopeQuestions } from "./questions.js";
 import { SILENCE_MS, classifyLaneExit, isPidAlive, readLatestEnvelope, readLatestEnvelopeFile, readLatestEnvelopeRecord, } from "./watcher.js";
 import { createLaneMesh, emitLaneDecisionEvents, laneMeshCompany } from "./mesh-events.js";
+import { 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. */
@@ -87,10 +90,10 @@ export function timeoutPath(hqRoot, laneId) {
     return path.join(laneRunDir(hqRoot, laneId), "timeout.json");
 }
 export function laneRunsHere(lane, host) {
-    if (host.outpostId && lane.host.kind === "outpost") {
-        return lane.host.id === host.outpostId;
-    }
-    return lane.host.kind === "local" && lane.host.id === host.hostname;
+    return laneRunsOnHost(lane, host);
+}
+function hasFreshAdmissionReservation(lane, nowMs) {
+    return hasActiveAdmissionReservation(lane, nowMs);
 }
 export function agedAdvanceCount(question) {
     return question.routing_history.filter((entry) => entry.reason === "unanswered_timeout").length;
@@ -162,11 +165,6 @@ export function isDeadlinePassed(deadlineAt, nowMs) {
         return false;
     return nowMs > at;
 }
-function compareQueueOrder(a, b) {
-    if (b.priority !== a.priority)
-        return b.priority - a.priority;
-    return a.created_at.localeCompare(b.created_at);
-}
 function readDirJsonIds(dir, label) {
     let names;
     try {
@@ -307,6 +305,53 @@ function casLaneIf(hqRoot, laneId, shouldWrite, updater, dryRun) {
     }
     throw new LanesError("version_conflict", `Exhausted CAS retries for lane ${laneId}`, { lane_id: laneId });
 }
+function writeQueueReason(hqRoot, lane, reason, dryRun) {
+    if (lane.queued_reason === reason)
+        return;
+    casLaneIf(hqRoot, lane.lane_id, (current) => current.state === "queued" && current.queued_reason !== reason, (current) => ({ ...current, queued_reason: reason, admission_reserved_at: undefined }), dryRun);
+}
+function availableBalancedAccount(hqRoot, lane, occupying, config, host, profileMaxConcurrent, nowMs) {
+    if (!lane.account || !lane.admission_accounts?.includes(lane.account))
+        return undefined;
+    if (laneAdmissionCapReason(occupying, lane, config, host, profileMaxConcurrent, nowMs) !== "account_cap") {
+        return undefined;
+    }
+    const pinnedModel = lane.model_source === undefined || lane.model_source === "cli"
+        ? lane.model
+        : lane.model_source === "profile"
+            ? lane.model
+            : undefined;
+    for (const account of lane.admission_accounts) {
+        if (account === lane.account)
+            continue;
+        if (config.providers[lane.provider].accounts[account]?.enabled !== true)
+            continue;
+        const status = accountStatus(lane.provider, account, config);
+        if (!isCredentialProven(status))
+            continue;
+        try {
+            resolveAccount(lane.provider, account, config, {
+                hqRoot,
+                ...(pinnedModel !== undefined ? { model: pinnedModel } : {}),
+            });
+        }
+        catch (err) {
+            if (err instanceof AccountResolutionError)
+                continue;
+            throw err;
+        }
+        const candidate = { ...lane, account };
+        if (laneAdmissionCapReason(occupying, candidate, config, host, profileMaxConcurrent, nowMs) === undefined) {
+            return account;
+        }
+    }
+    return undefined;
+}
+function writeAdmissionAccount(hqRoot, lane, account, dryRun) {
+    return casLaneIf(hqRoot, lane.lane_id, (current) => current.state === "queued" &&
+        current.account === lane.account &&
+        current.admission_accounts?.includes(account) === true, (current) => ({ ...current, account }), dryRun).record;
+}
 function casQuestionIf(hqRoot, questionId, shouldWrite, updater, dryRun) {
     for (let i = 0; i < 5; i += 1) {
         const current = readQuestion(hqRoot, questionId);
@@ -706,10 +751,12 @@ export async function runPassBody(hqRoot, deps) {
             });
         }
     }
-    const freshLanes = loadLaneRecords(hqRoot, summary);
-    const freshQuestions = loadQuestionRecords(hqRoot, summary);
-    await admitQueued(hqRoot, freshLanes, summary, deps, now);
-    await resumeAwaiting(hqRoot, freshLanes, freshQuestions, summary, deps);
+    await withAllLaneAdmissionLocks(hqRoot, async () => {
+        const freshLanes = loadLaneRecords(hqRoot, summary);
+        const freshQuestions = loadQuestionRecords(hqRoot, summary);
+        await admitQueued(hqRoot, freshLanes, summary, deps, now);
+        await resumeAwaiting(hqRoot, freshLanes, freshQuestions, summary, deps);
+    });
     if (!deps.dryRun && summary.errors.length === 0) {
         try {
             writeHeartbeatFile(hqRoot, summary, nowIso);
@@ -882,18 +929,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,
@@ -978,7 +1051,8 @@ async function admitQueued(hqRoot, lanes, summary, deps, now) {
         .filter((lane) => lane.state === "queued" &&
         lane.pickup_validation_pending !== true &&
         laneRunsHere(lane, deps.host))
-        .sort(compareQueueOrder);
+        .filter((lane) => !hasFreshAdmissionReservation(lane, now.getTime()))
+        .sort(compareLaneQueueOrder);
     if (localQueued.length === 0)
         return;
     const config = loadLanesConfig(hqRoot);
@@ -1003,31 +1077,37 @@ async function admitQueued(hqRoot, lanes, summary, deps, now) {
     });
     const spawnFn = deps.spawn ??
         ((root, lane) => spawnLaneWorker(root, lane, deps.spawnLaneDeps));
-    const running = lanes.filter((lane) => lane.state === "running");
+    const running = lanes.filter((lane) => (lane.state === "running" ||
+        hasFreshAdmissionReservation(lane, now.getTime()) ||
+        hasActivePendingResume(lane, now.getTime())) &&
+        laneRunsHere(lane, deps.host));
     const starvation = decision.admit && decision.reason === "starvation_bound";
-    const candidates = starvation ? localQueued.slice(0, 1) : localQueued;
     const spawned = [];
     if (!decision.admit) {
+        for (const lane of localQueued) {
+            let profileMaxConcurrent;
+            if (lane.worker_profile !== undefined) {
+                try {
+                    profileMaxConcurrent = loadWorkerProfile(hqRoot, lane.worker_profile).meta.max_concurrent;
+                }
+                catch (err) {
+                    markDirty(summary, {
+                        kind: "lane",
+                        id: lane.lane_id,
+                        why: `profile admission failed: ${err instanceof Error ? err.message : String(err)}`,
+                    });
+                    continue;
+                }
+            }
+            const capReason = laneAdmissionCapReason(running, lane, config, deps.host, profileMaxConcurrent, now.getTime());
+            writeQueueReason(hqRoot, lane, capReason ?? "throttle", deps.dryRun);
+        }
         if (!deps.dryRun && throttleState !== "unreadable") {
             writeThrottleState(filePath, applyThrottleDecision(throttleState, decision, nowMs), throttleDeps);
         }
         return;
     }
-    for (const lane of candidates) {
-        const provider = lane.provider;
-        const providerCfg = config.providers[provider];
-        const providerRunning = running.filter((row) => row.provider === provider).length +
-            spawned.filter((row) => row.provider === provider).length;
-        if (providerRunning >= providerCfg.max_running && !starvation)
-            continue;
-        if (lane.account) {
-            const accountRunning = running.filter((row) => row.provider === provider && row.account === lane.account).length +
-                spawned.filter((row) => row.provider === provider && row.account === lane.account).length;
-            if (accountRunning >= accountMaxRunning(providerCfg, lane.account) &&
-                !starvation) {
-                continue;
-            }
-        }
+    for (const lane of localQueued) {
         let profileMaxConcurrent;
         if (lane.worker_profile !== undefined) {
             try {
@@ -1042,11 +1122,22 @@ async function admitQueued(hqRoot, lanes, summary, deps, now) {
                 continue;
             }
         }
-        if (profileMaxConcurrent !== undefined) {
-            const profileRunning = running.filter((row) => row.worker_profile === lane.worker_profile).length +
-                spawned.filter((row) => row.worker_profile === lane.worker_profile).length;
-            if (profileRunning >= profileMaxConcurrent)
-                continue;
+        const projected = [...running, ...spawned];
+        const alternateAccount = availableBalancedAccount(hqRoot, lane, projected, config, deps.host, profileMaxConcurrent, now.getTime());
+        const admittedLane = alternateAccount !== undefined
+            ? writeAdmissionAccount(hqRoot, lane, alternateAccount, deps.dryRun)
+            : lane;
+        const baseCap = laneAdmissionCapReason(running, admittedLane, config, deps.host, profileMaxConcurrent, now.getTime());
+        const currentCap = laneAdmissionCapReason([...running, ...spawned], admittedLane, config, deps.host, profileMaxConcurrent, now.getTime());
+        let blockedBy;
+        if (currentCap !== undefined) {
+            blockedBy = baseCap ?? "queue_position";
+        }
+        if (!blockedBy && !decision.admit)
+            blockedBy = "throttle";
+        if (blockedBy) {
+            writeQueueReason(hqRoot, admittedLane, blockedBy, deps.dryRun);
+            continue;
         }
         try {
             if (deps.dryRun) {
@@ -1056,12 +1147,12 @@ async function admitQueued(hqRoot, lanes, summary, deps, now) {
                     to: "running",
                     reason: decision.reason,
                 });
-                spawned.push({ ...lane, state: "running" });
+                spawned.push({ ...admittedLane, state: "running" });
                 if (starvation)
                     break;
                 continue;
             }
-            const started = spawnFn(hqRoot, lane);
+            const started = spawnFn(hqRoot, admittedLane);
             if (decision.reason === "starvation_bound") {
                 casLaneIf(hqRoot, lane.lane_id, (current) => current.admitted_reason !== "starvation_bound", (current) => ({ ...current, admitted_reason: "starvation_bound" }), false);
             }
@@ -1100,25 +1191,73 @@ async function admitQueued(hqRoot, lanes, summary, deps, now) {
     }
 }
 async function resumeAwaiting(hqRoot, lanes, questions, summary, deps) {
-    const spawnFn = deps.spawn ??
-        ((root, lane) => spawnLaneWorker(root, lane, deps.spawnLaneDeps));
+    const config = loadLanesConfig(hqRoot);
     const awaiting = lanes.filter((lane) => lane.state === "awaiting_input" && laneRunsHere(lane, deps.host));
+    if (awaiting.length === 0)
+        return;
+    const throttleDeps = deps.throttleDeps ?? defaultThrottleDeps(deps.env ?? process.env);
+    let throttleDecision;
+    if (deps.dryRun) {
+        const loaded = readThrottleState(throttleStatePath(hqRoot), throttleDeps);
+        const state = loaded === "missing" ? emptyThrottleState() : loaded;
+        throttleDecision = evaluateThrottle({
+            busy: await resolveCpuBusyFraction(throttleDeps),
+            availableMemMb: readAvailableMemMb(throttleDeps),
+            cpuCheckEnabled: isCpuCheckEnabled(throttleDeps.env),
+            state,
+            throttle: config.throttle,
+            nowMs: deps.now().getTime(),
+        });
+    }
+    else {
+        const throttle = await decideAdmission(hqRoot, config.throttle, throttleDeps);
+        throttleDecision = throttle.decision;
+    }
+    if (!throttleDecision.admit)
+        return;
+    const spawnFn = deps.spawn ?? ((root, lane) => spawnLaneWorker(root, lane, deps.spawnLaneDeps));
+    const nowMs = deps.now().getTime();
+    const capacityLanes = lanes.map((lane) => {
+        try {
+            return readLane(hqRoot, lane.lane_id);
+        }
+        catch {
+            return lane;
+        }
+    });
+    const running = capacityLanes.filter((lane) => (lane.state === "running" ||
+        hasFreshAdmissionReservation(lane, nowMs) ||
+        hasActivePendingResume(lane, nowMs)) &&
+        laneRunsHere(lane, deps.host));
     for (const lane of awaiting) {
+        const current = readLane(hqRoot, lane.lane_id);
+        if (current.state !== "awaiting_input")
+            continue;
         const pending = questions.filter((q) => q.origin.id === lane.lane_id && q.status === "pending");
         const answered = questions.filter((q) => q.origin.id === lane.lane_id && q.status === "answered");
         if (pending.length > 0 || answered.length === 0)
             continue;
         try {
+            let profileMaxConcurrent;
+            if (current.worker_profile !== undefined) {
+                profileMaxConcurrent = loadWorkerProfile(hqRoot, current.worker_profile).meta.max_concurrent;
+            }
+            if (laneAdmissionCapReason(running, current, config, deps.host, profileMaxConcurrent, nowMs) !== undefined) {
+                continue;
+            }
             if (deps.dryRun) {
                 summary.resumed.push({
                     id: lane.lane_id,
                     from: "awaiting_input",
                     to: "running",
                 });
+                running.push({ ...current, state: "running" });
                 continue;
             }
             writeAnsweredQuestions(hqRoot, lane, questions);
             const started = spawnFn(hqRoot, lane);
+            if (started.state === "running")
+                running.push(started);
             summary.resumed.push({
                 id: started.lane_id,
                 from: "awaiting_input",

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;