@indigoai-us/hq-cli 5.345.124 → 5.345.126

package/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 ## [Unreleased]
 
+## [5.345.126] — 2026-10-14
+- `hq lanes` resume no longer picks a stale transcript when the same session exists in more than one account home. It uses the copy from the home the lane last ran in, and otherwise refuses with `provider_transcript_ambiguous` naming the homes.
+
+## [5.345.125] — 2026-10-14
+- `hq lanes` no longer sets `CLAUDE_CONFIG_DIR` for a Claude account whose
+  home is the default `~/.claude`, so lane workers, `claude auth status`
+  probes, and `hq lanes accounts login` read the same keychain credential as
+  the interactive `claude` session. `hq lanes accounts list` now reports each
+  Claude account's email and org, the interactive login, and
+  `credential_matches_interactive` with a warning when they differ.
+- A single provider 429 now holds an account for `quota_default_hold_ms`
+  (15 minutes by default) instead of the provider's multi-day reset. The
+  provider's reset is kept as `provider_reset_at` and becomes the hold only
+  when a fresh probe is refused again before it. The structured `resetsAt`
+  on a Claude result is used when present, and "resets Oct 16 at 1am
+  (America/Denver)" style messages (the `at` form and IANA zones) parse
+  correctly. Quota refusals name the account's email and org and print the
+  `hq lanes accounts clear-quota` command.
+- `hq lanes` resumes a lane that ran in a worktree. Spawn records the
+  directory each run started in and resumes there, and when a Claude
+  transcript is not under the expected project directory, the resume scans
+  every project directory in each account home before refusing. A truly
+  missing transcript still fails, and the error lists the directories scanned.
+- Lead autopilot no longer starts worker lanes on codex with a fixed
+  `gpt-6-luna` model. The worker follows the same engine choice as
+  `hq lanes create` (the lead lane's provider, then the harness markers) and
+  that provider's default model and effort.
+
 ## [5.345.124] — 2026-10-14
 - Lanes no longer stop every lane on an account for days after a single weekly-limit 429. Reset times such as "resets Oct 16 at 1am (America/Denver)" are now read with their time and timezone. A reset more than a day away first gets only a short hold, and the full hold applies only if the next lane after that also gets a 429. When a hold is set, the lane's senior gets a message with the provider's text and `hq lanes accounts clear-quota <provider> <account>`.
 

package/dist/commands/lanes-accounts.js

@@ -4,7 +4,7 @@ import { buildOutpostBalanceMoveCommand, dispatchErrorMessage } from "../lib/lan
 import { BALANCE_MOVABLE_STATES, accountLoadsForReport, planClaudeBalanceMoves, selectClaudeAccount } from "../lib/lanes/claude-balance.js";
 import { CompanySelectionError } from "../utils/company-selection-error.js";
 import { effectiveAccountHome } from "../lib/lanes/account-home.js";
-import { AccountResolutionError, DEFAULT_ACCOUNT_HOMES, LANE_PROVIDERS, PROVIDER_HOME_ENV, accountStatus, canonicalizeHome, installDrainHook, isLanesError, listAccountStatuses, loadLanesConfig, parseLaneProvider, readLane, writeLanesConfig } from "../lib/lanes/index.js";
+import { AccountResolutionError, DEFAULT_ACCOUNT_HOMES, LANE_PROVIDERS, accountStatus, canonicalizeHome, claudeIdentityDiffers, installDrainHook, isLanesError, listAccountStatuses, loadLanesConfig, parseLaneProvider, probeInteractiveClaudeIdentity, readLane, withProviderHomeEnv, writeLanesConfig } from "../lib/lanes/index.js";
 import { assertUniqueAccountHomes, providerCompactAfterMs } from "../lib/lanes/config.js";
 import { resolveLaneEffort } from "../lib/lanes/effort.js";
 import { LanesError } from "../lib/lanes/errors.js";
@@ -113,9 +113,16 @@ export function createLaneAccountsHandlers(deps) {
         // model and effort are what a spawn on each account would start from
         // (spec: --model/--effort, then the account, then the provider).
         const quota = loadQuotaState(hqRoot);
+        // The login the interactive `claude` uses (no CLAUDE_CONFIG_DIR), so a
+        // lane account that resolves to a different keychain credential is
+        // visible here instead of only as a 429 on the wrong subscription.
+        const interactiveIdentity = providers.includes("claude") && ctx.probeProvider
+            ? probeInteractiveClaudeIdentity(ctx.probeProvider, ctx.env)
+            : null;
         const accounts = providers.flatMap((provider) => listAccountStatuses(provider, config, {
             existsSync: ctx.existsSync,
             hostname: ctx.hostname(),
+            homedir: ctx.homedir,
             probe: ctx.probeProvider,
             env: ctx.env,
         }).map((status) => {
@@ -129,6 +136,9 @@ export function createLaneAccountsHandlers(deps) {
                 providerEffort: config.providers[provider].effort,
                 model,
             });
+            const differs = provider === "claude"
+                ? claudeIdentityDiffers(status.identity, interactiveIdentity)
+                : null;
             return {
                 ...status,
                 effective_home: status.home,
@@ -136,6 +146,13 @@ export function createLaneAccountsHandlers(deps) {
                     error: "home_missing",
                     fix_command: `hq lanes accounts set-home ${provider} ${status.id} <host-home>`,
                 } : {}),
+                ...(provider === "claude" ? {
+                    identity: status.identity ?? null,
+                    credential_matches_interactive: differs === null ? null : !differs,
+                    ...(differs === true ? {
+                        warning: `Lane credential ${status.identity?.email ?? status.identity?.org_id ?? "(unknown)"} differs from the interactive claude login ${interactiveIdentity?.email ?? interactiveIdentity?.org_id ?? "(unknown)"}; lanes on this account bill that other subscription`,
+                    } : {}),
+                } : {}),
                 model: accountCfg?.model ?? null,
                 effort: accountCfg?.effort ?? null,
                 effective_model: model ?? null,
@@ -154,6 +171,7 @@ export function createLaneAccountsHandlers(deps) {
             ok: true,
             action: "accounts.list",
             providers: providerDefaults,
+            ...(providers.includes("claude") ? { interactive_identity: interactiveIdentity } : {}),
             accounts,
         });
     }
@@ -387,15 +405,16 @@ export function createLaneAccountsHandlers(deps) {
             });
         const copied = defaultHome !== home ? copyHookRails(defaultHome, home) : railsPresent(home);
         installDrainHook(provider, home);
-        const envVar = PROVIDER_HOME_ENV[provider];
         const login = VENDOR_LOGIN[provider];
         const loginArgs = provider === "codex" && opts.deviceAuth
             ? [...login.args, "--device-auth"]
             : login.args;
+        // Same rule as the worker spawn: the default Claude home logs in with
+        // CLAUDE_CONFIG_DIR unset so the credential matches the interactive one.
         const result = await ctx.spawnLogin({
             command: login.command,
             args: loginArgs,
-            env: { ...ctx.env, [envVar]: home },
+            env: withProviderHomeEnv(ctx.env, provider, home, ctx.homedir),
             cwd: home,
         });
         if (result.status !== 0) {

package/dist/commands/lanes.js

@@ -2331,6 +2331,27 @@ function orchestratorEngine(hqRoot, senior, ctx) {
         return "claude";
     return undefined;
 }
+/**
+ * Starts the worker lane a lead autopilot fill-grant wake asks for. Provider,
+ * model and effort are left to `runCreate`, so the worker follows the
+ * orchestrator engine (the lead lane provider, then the harness markers) and
+ * that provider default model, and fails with `provider_required` when no
+ * engine is known. There is no hard-coded engine.
+ */
+function autopilotWorkerStarter(ctx) {
+    return async ({ lead, story }) => {
+        const workerCtx = { ...ctx, env: { ...ctx.env, HQ_LANE_ID: lead.lane_id } };
+        const started = await runCreate(workerCtx, {
+            company: lead.company?.slug,
+            project: lead.project_id,
+            story: story.id,
+            briefFile: story.briefPath,
+            senior: "lane:" + lead.lane_id,
+            quiet: true,
+        });
+        return { lane_id: started.lane_id };
+    };
+}
 function defaultSenior(ctx) {
     const parent = ctx.env.HQ_PARENT_SESSION_ID?.trim();
     if (parent)
@@ -7389,7 +7410,7 @@ async function prepareAccountMove(ctx, lane, input) {
     });
     const block = quotaBlockFor(loadQuotaState(hqRoot), lane.provider, target, model, now);
     if (block.blocked) {
-        throw new LanesError("account_quota_held", `Account ${target} for ${lane.provider} is held${block.quota_reset_at ? ` until ${block.quota_reset_at}` : ""}${block.marker ? ` (${block.marker})` : ""}`, { provider: lane.provider, account: target, quota_reset_at: block.quota_reset_at ?? null, marker: block.marker ?? null, model: model ?? null });
+        throw new LanesError("account_quota_held", `Account ${target} for ${lane.provider} is held${block.quota_reset_at ? ` until ${block.quota_reset_at}` : ""}${block.marker ? ` (${block.marker})` : ""}. Clear the hold with: hq lanes accounts clear-quota ${lane.provider} ${target}`, { provider: lane.provider, account: target, quota_reset_at: block.quota_reset_at ?? null, marker: block.marker ?? null, model: model ?? null, clear_command: `hq lanes accounts clear-quota ${lane.provider} ${target}` });
     }
     if (model !== undefined) {
         validateLaneModel(lane.provider, model, targetHome, {
@@ -7407,7 +7428,7 @@ async function prepareAccountMove(ctx, lane, input) {
     const copy = ensureSessionHome({
         provider: lane.provider,
         sessionId,
-        cwd: hqRoot,
+        cwd: lane.working_directory_at_spawn ?? hqRoot,
         targetHome,
         registeredHomes: Object.values(providerCfg.accounts).map((account) => effectiveAccountHome(account, ctx.hostname()).home),
         providerHomeAtSpawn: lane.provider_home_at_spawn ?? sourceHome,
@@ -9399,21 +9420,7 @@ async function runReconcile(ctx, opts, recoverQueuedMessages) {
             dryRun: Boolean(opts.dryRun),
             readFlag: readLanesRegistryFlag,
             keepAliveResumedLeads: new Set(summary.resumed.filter((entry) => entry.reason === "keep_alive").map((entry) => entry.id)),
-            startWorker: async ({ lead, story }) => {
-                const workerCtx = { ...ctx, env: { ...ctx.env, HQ_LANE_ID: lead.lane_id } };
-                const started = await runCreate(workerCtx, {
-                    company: lead.company?.slug,
-                    project: lead.project_id,
-                    story: story.id,
-                    briefFile: story.briefPath,
-                    provider: "codex",
-                    model: "gpt-6-luna",
-                    effort: "high",
-                    senior: `lane:${lead.lane_id}`,
-                    quiet: true,
-                });
-                return { lane_id: started.lane_id };
-            },
+            startWorker: autopilotWorkerStarter(ctx),
         });
     }
     catch (error) {
@@ -10446,21 +10453,7 @@ export function registerLanesCommand(parent, deps = {}) {
             now: ctx.now(),
             dryRun: Boolean(opts.dryRun),
             readFlag: readLanesRegistryFlag,
-            startWorker: async ({ lead, story }) => {
-                const workerCtx = { ...ctx, env: { ...ctx.env, HQ_LANE_ID: lead.lane_id } };
-                const started = await runCreate(workerCtx, {
-                    company: lead.company?.slug,
-                    project: lead.project_id,
-                    story: story.id,
-                    briefFile: story.briefPath,
-                    provider: "codex",
-                    model: "gpt-6-luna",
-                    effort: "high",
-                    senior: `lane:${lead.lane_id}`,
-                    quiet: true,
-                });
-                return { lane_id: started.lane_id };
-            },
+            startWorker: autopilotWorkerStarter(ctx),
         });
         printJson(result);
     }));

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

@@ -10,6 +10,45 @@
 import { type LaneRecord, type LaneProvider } from "./types.js";
 import type { LanesConfig } from "./types.js";
 export declare const PROVIDER_HOME_ENV: Record<LaneProvider, string>;
+/**
+ * Claude Code keys its OS keychain credential by `CLAUDE_CONFIG_DIR`: with
+ * the variable unset it reads the plain `Claude Code-credentials` item, and
+ * with it set, even to the default `~/.claude`, it reads a hash-suffixed item
+ * for that path. Setting the variable for the default home therefore makes a
+ * lane use a different login than the interactive session (incident
+ * 2026-10-13). A Claude account whose home is the default is launched with
+ * the variable unset instead.
+ */
+export declare function isDefaultProviderHome(provider: LaneProvider, home: string, homedir?: () => string): boolean;
+/**
+ * Return a copy of `base` with the provider home variable set to `home`,
+ * or, for a Claude account on the default home, with the variable removed
+ * so the worker and the interactive session share one credential.
+ */
+export declare function withProviderHomeEnv(base: NodeJS.ProcessEnv, provider: LaneProvider, home: string, homedir?: () => string): NodeJS.ProcessEnv;
+/** Who `claude auth status` says a home is logged in as. Never a token. */
+export interface ClaudeIdentity {
+    email: string | null;
+    org_id: string | null;
+    org_name: string | null;
+    subscription_type: string | null;
+}
+/**
+ * Email and org from a `claude auth status` JSON payload. Only identity
+ * fields are kept; everything else in the payload is dropped.
+ */
+export declare function claudeIdentityFromProbe(result: AccountStatusProbeResult): ClaudeIdentity | null;
+/** "me@example.com (Acme)" label for hold and failover messages. */
+export declare function describeClaudeIdentity(identity: ClaudeIdentity | undefined | null): string | null;
+/**
+ * The identity the interactive session uses: `claude auth status` with no
+ * `CLAUDE_CONFIG_DIR`. Null when the probe fails or names nobody.
+ */
+export declare function probeInteractiveClaudeIdentity(probe: NonNullable<AccountDeps["probe"]>, base?: NodeJS.ProcessEnv): ClaudeIdentity | null;
+/** True when both identities are known and name different logins; null when unknown. */
+export declare function claudeIdentityDiffers(a: ClaudeIdentity | undefined | null, b: ClaudeIdentity | undefined | null): boolean | null;
+/** The operator command that lifts a recorded quota hold. */
+export declare function clearQuotaCommand(provider: LaneProvider, accountId: string): string;
 export declare const AUTH_JSON_NAME = "auth.json";
 export declare const CLAUDE_CREDENTIALS_NAME = ".credentials.json";
 /**
@@ -28,6 +67,7 @@ export interface AccountStatusProbeResult {
 export interface AccountDeps {
     existsSync: (p: string) => boolean;
     hostname?: string;
+    homedir?: () => string;
     /** Provider status output is parsed for a boolean only; it is never printed. */
     probe?: (command: string, args: string[], env: NodeJS.ProcessEnv) => AccountStatusProbeResult;
     env?: NodeJS.ProcessEnv;
@@ -64,6 +104,8 @@ export interface AccountStatus {
     id: string;
     home: string;
     home_source?: "host" | "default";
+    /** Email and org from the provider status command, when it was consulted. */
+    identity?: ClaudeIdentity;
     enabled: boolean;
     disabled_reason?: string;
     /** Present in personal/lanes/config.json. */
@@ -112,6 +154,10 @@ export declare function resolveAccount(provider: LaneProvider, requestedId: stri
 export declare function authJsonPath(home: string): string;
 export declare function accountStatus(provider: LaneProvider, accountId: string, config: LanesConfig, deps?: AccountDeps): AccountStatus;
 export declare function listAccountStatuses(provider: LaneProvider, config: LanesConfig, deps?: AccountDeps): AccountStatus[];
-/** Environment assignment the worker process should receive. */
-export declare function accountEnv(resolved: ResolvedAccount): Record<string, string>;
+/**
+ * Environment assignment the worker process should receive. Empty for a
+ * Claude account on the default home, which runs with the variable unset
+ * (see isDefaultProviderHome).
+ */
+export declare function accountEnv(resolved: ResolvedAccount, homedir?: () => string): Record<string, string>;
 //# sourceMappingURL=accounts.d.ts.map

package/dist/lib/lanes/accounts.js

@@ -8,11 +8,12 @@
  * module never reads, prints, copies, or hashes credential files.
  */
 import * as fs from "node:fs";
+import * as os from "node:os";
 import { effectiveAccountHome } from "./account-home.js";
 import * as path from "node:path";
 import { AccountResolutionError } from "./errors.js";
 import { isTerminalLaneState } from "./types.js";
-import { accountMaxRunning } from "./config.js";
+import { DEFAULT_ACCOUNT_HOMES, accountMaxRunning, canonicalizeHome } from "./config.js";
 import { listLaneIds, readLane } from "./store.js";
 import { loadQuotaState, quotaBlockFor } from "./quota.js";
 export const PROVIDER_HOME_ENV = {
@@ -20,6 +21,112 @@ export const PROVIDER_HOME_ENV = {
     codex: "CODEX_HOME",
     grok: "GROK_HOME",
 };
+/**
+ * Claude Code keys its OS keychain credential by `CLAUDE_CONFIG_DIR`: with
+ * the variable unset it reads the plain `Claude Code-credentials` item, and
+ * with it set, even to the default `~/.claude`, it reads a hash-suffixed item
+ * for that path. Setting the variable for the default home therefore makes a
+ * lane use a different login than the interactive session (incident
+ * 2026-10-13). A Claude account whose home is the default is launched with
+ * the variable unset instead.
+ */
+export function isDefaultProviderHome(provider, home, homedir = () => os.homedir()) {
+    const deps = {
+        homedir,
+        realpathSync: (p) => fs.realpathSync(p),
+        existsSync: (p) => fs.existsSync(p),
+    };
+    try {
+        return canonicalizeHome(home, deps) === canonicalizeHome(DEFAULT_ACCOUNT_HOMES[provider], deps);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Return a copy of `base` with the provider home variable set to `home`,
+ * or, for a Claude account on the default home, with the variable removed
+ * so the worker and the interactive session share one credential.
+ */
+export function withProviderHomeEnv(base, provider, home, homedir) {
+    const next = { ...base };
+    const envVar = PROVIDER_HOME_ENV[provider];
+    if (provider === "claude" && isDefaultProviderHome(provider, home, homedir)) {
+        delete next[envVar];
+    }
+    else {
+        next[envVar] = home;
+    }
+    return next;
+}
+function optionalString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+/**
+ * Email and org from a `claude auth status` JSON payload. Only identity
+ * fields are kept; everything else in the payload is dropped.
+ */
+export function claudeIdentityFromProbe(result) {
+    const text = result.stdout.trim();
+    if (!text.startsWith("{"))
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+        return null;
+    const rec = parsed;
+    const identity = {
+        email: optionalString(rec.email),
+        org_id: optionalString(rec.orgId),
+        org_name: optionalString(rec.orgName),
+        subscription_type: optionalString(rec.subscriptionType),
+    };
+    if (!identity.email && !identity.org_id && !identity.org_name)
+        return null;
+    return identity;
+}
+/** "me@example.com (Acme)" label for hold and failover messages. */
+export function describeClaudeIdentity(identity) {
+    if (!identity)
+        return null;
+    const org = identity.org_name ?? identity.org_id;
+    if (identity.email && org)
+        return `${identity.email} (${org})`;
+    return identity.email ?? org;
+}
+/**
+ * The identity the interactive session uses: `claude auth status` with no
+ * `CLAUDE_CONFIG_DIR`. Null when the probe fails or names nobody.
+ */
+export function probeInteractiveClaudeIdentity(probe, base = process.env) {
+    const bare = { ...base };
+    delete bare[PROVIDER_HOME_ENV.claude];
+    try {
+        return claudeIdentityFromProbe(probe("claude", ["auth", "status"], bare));
+    }
+    catch {
+        return null;
+    }
+}
+/** True when both identities are known and name different logins; null when unknown. */
+export function claudeIdentityDiffers(a, b) {
+    if (!a || !b)
+        return null;
+    if (a.email && b.email)
+        return a.email.toLowerCase() !== b.email.toLowerCase();
+    if (a.org_id && b.org_id)
+        return a.org_id !== b.org_id;
+    return null;
+}
+/** The operator command that lifts a recorded quota hold. */
+export function clearQuotaCommand(provider, accountId) {
+    return `hq lanes accounts clear-quota ${provider} ${accountId}`;
+}
 export const AUTH_JSON_NAME = "auth.json";
 export const CLAUDE_CREDENTIALS_NAME = ".credentials.json";
 /**
@@ -161,23 +268,34 @@ function modelForAccount(provider, accountId, config, ctx) {
         return providerModel.trim();
     return undefined;
 }
-function throwIfQuotaBlocked(block, provider, accountId) {
+/** "account "a" (me@example.com (Acme))" when the identity is known. */
+function accountLabel(accountId, identity) {
+    const who = describeClaudeIdentity(identity);
+    return `Account ${JSON.stringify(accountId)}${who ? ` (${who})` : ""}`;
+}
+function throwIfQuotaBlocked(block, provider, accountId, identity) {
     if (!block.blocked || !block.reason)
         return;
     const model = block.model ?? "(no model)";
+    const label = accountLabel(accountId, identity);
+    const identityFields = identity ? { identity } : {};
     if (block.reason === "account_model_unavailable") {
-        throw new AccountResolutionError("account_model_unavailable", `Account ${JSON.stringify(accountId)} cannot run model ${model}: ${block.marker ?? "needs credits"}`, {
+        throw new AccountResolutionError("account_model_unavailable", `${label} cannot run model ${model}: ${block.marker ?? "needs credits"}`, {
             provider,
             account: accountId,
             model: block.model ?? null,
             marker: block.marker ?? null,
+            ...identityFields,
         });
     }
-    throw new AccountResolutionError("account_quota_exhausted", `Account ${JSON.stringify(accountId)} is out of quota${block.quota_reset_at ? ` until ${block.quota_reset_at}` : ""} for model ${model}`, {
+    const clear = clearQuotaCommand(provider, accountId);
+    throw new AccountResolutionError("account_quota_exhausted", `${label} is out of quota${block.quota_reset_at ? ` until ${block.quota_reset_at}` : ""} for model ${model}. Clear the hold with: ${clear}`, {
         provider,
         account: accountId,
         model: block.model ?? null,
         quota_reset_at: block.quota_reset_at ?? null,
+        clear_command: clear,
+        ...identityFields,
     });
 }
 function boundAccount(provider, id, account, hostname) {
@@ -205,15 +323,19 @@ export function selectBalancedAccount(provider, config, ctx = {}) {
         throw new AccountResolutionError("no_enabled_account", `No enabled account for provider ${provider}`, { provider, ineligible: "none_enabled" });
     }
     const proven = [];
+    const identities = new Map();
     for (const id of enabled) {
         const status = accountStatus(provider, id, config, {
             existsSync,
             ...(ctx.accountDeps?.probe ? { probe: ctx.accountDeps.probe } : {}),
             ...(ctx.accountDeps?.env ? { env: ctx.accountDeps.env } : {}),
+            ...(ctx.accountDeps?.homedir ? { homedir: ctx.accountDeps.homedir } : {}),
             ...(ctx.hostname !== undefined ? { hostname: ctx.hostname } : {}),
         });
         if (status.logged_in === true)
             proven.push(id);
+        if (status.identity)
+            identities.set(id, status.identity);
     }
     if (proven.length === 0) {
         throw new AccountResolutionError("no_enabled_account", `No logged-in account for provider ${provider}`, { provider, ineligible: "none_logged_in", enabled });
@@ -247,17 +369,25 @@ export function selectBalancedAccount(provider, config, ctx = {}) {
                 account: id,
                 reason: block.reason,
                 quota_reset_at: block.quota_reset_at ?? null,
+                identity: identities.get(id) ?? null,
+                clear_command: clearQuotaCommand(provider, id),
             }));
-            throw new AccountResolutionError("account_quota_exhausted", `All logged-in accounts for ${provider} are quota-limited for the selected model`, {
+            const held = blocked
+                .filter(({ block }) => block.reason === "account_quota_exhausted")
+                .map(({ id, block }) => `${accountLabel(id, identities.get(id))}${block.quota_reset_at ? ` until ${block.quota_reset_at}` : ""}; clear with: ${clearQuotaCommand(provider, id)}`)
+                .join("; ");
+            throw new AccountResolutionError("account_quota_exhausted", `All logged-in accounts for ${provider} are quota-limited for the selected model. ${held}`, {
                 provider,
                 account: earliest.id,
                 model: earliest.block.model ?? null,
                 quota_reset_at: resetTimes[0] ?? null,
                 account_reasons: resetsByAccount,
+                ...(identities.get(earliest.id) ? { identity: identities.get(earliest.id) } : {}),
+                clear_command: clearQuotaCommand(provider, earliest.id),
             });
         }
         const sample = proven[0];
-        throwIfQuotaBlocked(blocked[0].block, provider, sample);
+        throwIfQuotaBlocked(blocked[0].block, provider, sample, identities.get(sample));
     }
     const underCap = runnable.filter((id) => {
         const cap = accountMaxRunning(providerCfg, id);
@@ -298,6 +428,16 @@ export function resolveAccount(provider, requestedId, config, ctx = {}) {
         if (ctx.hqRoot !== undefined) {
             const now = ctx.now ?? new Date();
             const block = quotaBlockFor(loadQuotaState(ctx.hqRoot), provider, requestedId, modelForAccount(provider, requestedId, config, ctx), now);
+            if (block.blocked && provider === "claude" && ctx.accountDeps?.probe) {
+                const status = accountStatus(provider, requestedId, config, {
+                    existsSync: ctx.existsSync ?? ((p) => fs.existsSync(p)),
+                    probe: ctx.accountDeps.probe,
+                    ...(ctx.accountDeps.env ? { env: ctx.accountDeps.env } : {}),
+                    ...(ctx.accountDeps.homedir ? { homedir: ctx.accountDeps.homedir } : {}),
+                    ...(ctx.hostname !== undefined ? { hostname: ctx.hostname } : {}),
+                });
+                throwIfQuotaBlocked(block, provider, requestedId, status.identity);
+            }
             throwIfQuotaBlocked(block, provider, requestedId);
         }
         return boundAccount(provider, requestedId, account, ctx.hostname);
@@ -328,14 +468,16 @@ export function accountStatus(provider, accountId, config, deps = defaultAccount
     const present = homeExists && hasCredentialFile(provider, effective.home, deps.existsSync);
     let auth_state = homeExists ? authStateFor(provider, present) : "home_missing";
     let logged_in = homeExists ? loggedInFromAuthState(auth_state) : false;
+    let identity;
     if (homeExists && !present && provider === "claude" && deps.probe !== undefined) {
         try {
-            const result = deps.probe("claude", ["auth", "status"], { ...(deps.env ?? process.env), CLAUDE_CONFIG_DIR: effective.home });
+            const result = deps.probe("claude", ["auth", "status"], withProviderHomeEnv(deps.env ?? process.env, "claude", effective.home, deps.homedir));
             const providerStatus = claudeLoginStatus(result);
             if (providerStatus !== null) {
                 auth_state = "status";
                 logged_in = providerStatus;
             }
+            identity = claudeIdentityFromProbe(result) ?? undefined;
         }
         catch {
             process.stderr.write(`hq lanes: Claude auth status probe failed for account ${accountId}\n`);
@@ -352,6 +494,8 @@ export function accountStatus(provider, accountId, config, deps = defaultAccount
         auth_state,
         envVar,
     };
+    if (identity)
+        status.identity = identity;
     if (account.disabled_reason !== undefined) {
         status.disabled_reason = account.disabled_reason;
     }
@@ -381,8 +525,15 @@ function claudeLoginStatus(result) {
         return false;
     return null;
 }
-/** Environment assignment the worker process should receive. */
-export function accountEnv(resolved) {
+/**
+ * Environment assignment the worker process should receive. Empty for a
+ * Claude account on the default home, which runs with the variable unset
+ * (see isDefaultProviderHome).
+ */
+export function accountEnv(resolved, homedir) {
+    if (resolved.provider === "claude" && isDefaultProviderHome("claude", resolved.home, homedir)) {
+        return {};
+    }
     return { [resolved.envVar]: resolved.home };
 }
 //# sourceMappingURL=accounts.js.map

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

@@ -40,8 +40,8 @@ export { CPU_SAMPLE_MS, LANES_CPU_BUSY_OVERRIDE, LANES_CPU_CHECK, PROC_MEMINFO,
 export type { CpuTimes, ThrottleAdmitReason, ThrottleDecision, ThrottleDeferReason, ThrottleDeps, ThrottleState, } from "./throttle.js";
 export { effectiveAccountHome, } from "./account-home.js";
 export type { EffectiveAccountHome, } from "./account-home.js";
-export { AUTH_JSON_NAME, CLAUDE_CREDENTIALS_NAME, PROVIDER_CREDENTIAL_FILES, PROVIDER_HOME_ENV, accountEnv, accountStatus, authJsonPath, authStateFor, credentialPaths, hasCredentialFile, isCredentialProven, isLoggedOut, isOccupyingLaneState, lastStartedAt, listAccountStatuses, occupyingLaneCount, resolveAccount, runningLaneCount, selectBalancedAccount, } from "./accounts.js";
-export type { AccountResolveContext, AccountStatus, AuthState, ResolvedAccount, } from "./accounts.js";
+export { AUTH_JSON_NAME, CLAUDE_CREDENTIALS_NAME, PROVIDER_CREDENTIAL_FILES, PROVIDER_HOME_ENV, accountEnv, accountStatus, authJsonPath, authStateFor, claudeIdentityDiffers, claudeIdentityFromProbe, clearQuotaCommand, credentialPaths, describeClaudeIdentity, hasCredentialFile, isCredentialProven, isDefaultProviderHome, isLoggedOut, probeInteractiveClaudeIdentity, withProviderHomeEnv, isOccupyingLaneState, lastStartedAt, listAccountStatuses, occupyingLaneCount, resolveAccount, runningLaneCount, selectBalancedAccount, } from "./accounts.js";
+export type { AccountResolveContext, AccountStatus, AuthState, ClaudeIdentity, ResolvedAccount, } from "./accounts.js";
 export { LIVE_WITHIN_MS, LIVENESS_EVENT_KINDS, SILENT_LOST_MS, TURN_START_LOST_MS, buildLivenessIndexFromSpool, classifySessionLiveness, defaultLivenessDeps, defaultSpoolPath, ingestSpoolLine, listSessionLiveness, livenessIndexPath, loadLivenessIndex, readDaemonPresenceConnected, readLivenessIndex, rebuildLivenessIndex, sessionLiveness, } from "./liveness.js";
 export type { LivenessDeps, LivenessEventKind, LivenessIndex, SessionIndexEntry, } from "./liveness.js";
 export { DEAD_HOST_MS, MAX_AGED_ADVANCES, QUESTION_AGE_MS, RECONCILE_TIMER_NAME, RECONCILE_UNIT_NAME, wakeAnsweredLaneNow, agedAdvanceCount, currentHopStartedAtMs, isDeadlinePassed, laneRunsHere, readTimeoutDeadline, reconcileHeartbeatPath, resolveQuestionAudience, runReconcilePass, shouldAdvanceAudienceEnded, shouldAgeQuestion, timeoutPath, } from "./reconcile.js";

package/dist/lib/lanes/index.js

@@ -22,7 +22,7 @@ export { ENVELOPE_INVALID_REASON, decideEnvelopeRepair, emitMeshSoft, envelopeQu
 export { LANE_MESH_EVENTS, WIRE_EVENT_KINDS, createLaneMesh, emitLaneDecisionEvents, emitLaneProgressEvent, laneCanEmit, parseLaneMeshEvent, progressEventDue, toWireThreadEvent, } from "./mesh-events.js";
 export { CPU_SAMPLE_MS, LANES_CPU_BUSY_OVERRIDE, LANES_CPU_CHECK, PROC_MEMINFO, STARVATION_MAX_DEFERRALS, STARVATION_MAX_MS, VM_STAT_BIN, applyThrottleDecision, busyFractionFromDeltas, cpuTimesSnapshot, decideAdmission, defaultThrottleDeps, emptyThrottleState, evaluateThrottle, isCpuCheckEnabled, parseMemAvailableKb, parseVmStatAvailableMb, readAvailableMemMb, readThrottleState, resolveCpuBusyFraction, sampleCpuBusyFraction, starvationBoundReached, throttleStatePath, writeThrottleState, } from "./throttle.js";
 export { effectiveAccountHome, } from "./account-home.js";
-export { AUTH_JSON_NAME, CLAUDE_CREDENTIALS_NAME, PROVIDER_CREDENTIAL_FILES, PROVIDER_HOME_ENV, accountEnv, accountStatus, authJsonPath, authStateFor, credentialPaths, hasCredentialFile, isCredentialProven, isLoggedOut, isOccupyingLaneState, lastStartedAt, listAccountStatuses, occupyingLaneCount, resolveAccount, runningLaneCount, selectBalancedAccount, } from "./accounts.js";
+export { AUTH_JSON_NAME, CLAUDE_CREDENTIALS_NAME, PROVIDER_CREDENTIAL_FILES, PROVIDER_HOME_ENV, accountEnv, accountStatus, authJsonPath, authStateFor, claudeIdentityDiffers, claudeIdentityFromProbe, clearQuotaCommand, credentialPaths, describeClaudeIdentity, hasCredentialFile, isCredentialProven, isDefaultProviderHome, isLoggedOut, probeInteractiveClaudeIdentity, withProviderHomeEnv, isOccupyingLaneState, lastStartedAt, listAccountStatuses, occupyingLaneCount, resolveAccount, runningLaneCount, selectBalancedAccount, } from "./accounts.js";
 export { LIVE_WITHIN_MS, LIVENESS_EVENT_KINDS, SILENT_LOST_MS, TURN_START_LOST_MS, buildLivenessIndexFromSpool, classifySessionLiveness, defaultLivenessDeps, defaultSpoolPath, ingestSpoolLine, listSessionLiveness, livenessIndexPath, loadLivenessIndex, readDaemonPresenceConnected, readLivenessIndex, rebuildLivenessIndex, sessionLiveness, } from "./liveness.js";
 export { DEAD_HOST_MS, MAX_AGED_ADVANCES, QUESTION_AGE_MS, RECONCILE_TIMER_NAME, RECONCILE_UNIT_NAME, wakeAnsweredLaneNow, agedAdvanceCount, currentHopStartedAtMs, isDeadlinePassed, laneRunsHere, readTimeoutDeadline, reconcileHeartbeatPath, resolveQuestionAudience, runReconcilePass, shouldAdvanceAudienceEnded, shouldAgeQuestion, timeoutPath, } from "./reconcile.js";
 export { RECONCILE_TIMER_INTERVAL, defaultSystemdUserDir, installReconcileTimer, providerPathEnv, renderReconcileService, renderReconcileTimer, uninstallReconcileTimer, } from "./reconcile-install.js";

package/dist/lib/lanes/message-replay.js

@@ -1,5 +1,6 @@
 import { randomBytes } from "node:crypto";
 import * as fs from "node:fs";
+import * as os from "node:os";
 import * as path from "node:path";
 import { probeProviderCompactionsSince, providerTranscriptSize, } from "./compaction.js";
 import { LanesError } from "./errors.js";
@@ -55,7 +56,11 @@ export function writeMessageReplayState(filePath, state) {
 function safeProviderTranscriptPath(transcriptPath, provider, env) {
     if (provider === "grok")
         return transcriptPath;
-    const home = provider === "claude" ? env.CLAUDE_CONFIG_DIR : env.CODEX_HOME;
+    // A Claude worker on the default home runs with CLAUDE_CONFIG_DIR unset
+    // (accounts.ts isDefaultProviderHome); its transcripts live under ~/.claude.
+    const home = provider === "claude"
+        ? env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude")
+        : env.CODEX_HOME;
     if (!home) {
         throw new LanesError("message_replay_provider_home_missing", `Cannot validate ${provider} transcript without its provider home`);
     }

package/dist/lib/lanes/provider-rejection.d.ts

@@ -38,6 +38,8 @@ export interface ProviderRejection {
     event: "codex.turn.failed" | "claude.result.is_error" | "claude.result.login_failure" | "grok.error";
     /** Filesystem time when the provider output was appended, when read from worker.out. */
     output_at?: string;
+    /** The provider's structured reset (`resetsAt`), when the result carried one. */
+    resets_at?: unknown;
 }
 export declare function isProviderLoginFailure(failure: ProviderRejection | null): boolean;
 /**
@@ -56,12 +58,6 @@ export declare function retryableFromStatus(status: number | null): boolean;
  * read when it parses; otherwise the outer text is the message.
  */
 export declare function parseCodexTurnFailed(text: string): ProviderRejection | null;
-/**
- * Claude `-p --output-format json`: the last `type: "result"` object with
- * `is_error: true` and a numeric `api_error_status`, or the CLI's explicit
- * unauthenticated message. Other status-less errors keep the existing
- * classification because they may be quota text or a worker failure.
- */
 export declare function parseClaudeResultRejection(text: string): ProviderRejection | null;
 /**
  * Grok `--output-format json` prints one object. Measured 2026-09-22 (lane

package/dist/lib/lanes/provider-rejection.js

@@ -166,6 +166,23 @@ export function parseCodexTurnFailed(text) {
  * unauthenticated message. Other status-less errors keep the existing
  * classification because they may be quota text or a worker failure.
  */
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/** `resetsAt` on the result, or under `rate_limit_info` (directly or in the API error params). */
+function claudeStructuredReset(rec) {
+    const direct = rec.resets_at ?? rec.resetsAt;
+    if (direct !== undefined)
+        return direct;
+    for (const holder of [rec, rec.api_error_params, rec.apiErrorParams]) {
+        if (!isRecord(holder))
+            continue;
+        const info = holder.rate_limit_info ?? holder.rateLimitInfo;
+        if (isRecord(info) && info.resetsAt !== undefined)
+            return info.resetsAt;
+    }
+    return undefined;
+}
 export function parseClaudeResultRejection(text) {
     // The last `result` decides: a success or a status-less error there is
     // final (NOT_REJECTED), so the scan does not continue to earlier results.
@@ -182,6 +199,7 @@ export function parseClaudeResultRejection(text) {
         if (status === null && !loginFailure && !retryableProviderFailure(status, message)) {
             return NOT_REJECTED;
         }
+        const resetsAt = claudeStructuredReset(rec);
         return {
             reason: PROVIDER_REJECTED_REASON,
             provider: "claude",
@@ -192,6 +210,7 @@ export function parseClaudeResultRejection(text) {
             event: loginFailure && rec.is_error !== true
                 ? "claude.result.login_failure"
                 : "claude.result.is_error",
+            ...(resetsAt !== undefined ? { resets_at: resetsAt } : {}),
         };
     });
     return found === NOT_REJECTED ? null : found;

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

@@ -107,16 +107,20 @@ export declare function parseProviderResetTime(text: string, now: Date): string
  * `type: "result"` object. Nothing else from the payload is returned, and
  * this function does not log.
  */
-export declare function quotaFieldsFromOutput(text: string): {
+export interface QuotaResultFields {
     api_error_status: unknown;
     is_error: unknown;
     result: unknown;
-} | null;
-export declare function quotaSignalFromFields(fields: {
-    api_error_status: unknown;
-    is_error: unknown;
-    result: unknown;
-}, model: string | undefined, now: Date): QuotaSignal | null;
+    /**
+     * The provider's structured reset (`resetsAt`, epoch seconds or ISO) when
+     * the result carries one; it beats the wording in `result`.
+     */
+    resets_at?: unknown;
+}
+/** Epoch seconds, epoch milliseconds, or an ISO string, to ISO; null otherwise. */
+export declare function normalizeStructuredReset(value: unknown): string | null;
+export declare function quotaFieldsFromOutput(text: string): QuotaResultFields | null;
+export declare function quotaSignalFromFields(fields: QuotaResultFields, model: string | undefined, now: Date): QuotaSignal | null;
 export declare function readQuotaSignal(runDir: string, model: string | undefined, now: Date, workerOutOffset?: number): QuotaSignal | null;
 export interface RecordAccountQuotaOptions {
     /** When the 429 was observed. Enables the far-reset confirmation gate. */

package/dist/lib/lanes/quota.js

@@ -258,7 +258,7 @@ export function parseProviderResetTime(text, now) {
         }
         return null;
     }
-    const resetMatch = new RegExp(String.raw `\bresets\s+([A-Za-z]+)\s+(\d{1,2})(?:st|nd|rd|th)?(?:(?:,\s*(?:(\d{4})\s+)?|\s+at\s+)(\d{1,2})(?::(\d{2}))?\s*(am|pm))?(?:\s*${ZONE_PATTERN})?`, "i").exec(text);
+    const resetMatch = new RegExp(String.raw `\bresets\s+([A-Za-z]+)\s+(\d{1,2})(?:st|nd|rd|th)?(?:(?:,\s*(?:(\d{4})(?:,|\s+at)?\s+)?|\s+at\s+)(?:at\s+)?(\d{1,2})(?::(\d{2}))?\s*(am|pm))?(?:\s*${ZONE_PATTERN})?`, "i").exec(text);
     const codexMatch = /\btry\s+again\s+at\s+([A-Za-z]+)\s+(\d{1,2})(?:st|nd|rd|th)?,\s*(\d{4})\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)(?:\s*\((UTC)\))?/i.exec(text);
     const match = resetMatch ?? codexMatch;
     if (!match)
@@ -320,10 +320,47 @@ function isUsageLimitShape(text) {
     return /weekly limit|usage limit|rate limit|quota|usage credits|hit your .+ limit/i.test(text);
 }
 /**
- * Read only `api_error_status`, `is_error`, and `result` off the last
- * `type: "result"` object. Nothing else from the payload is returned, and
- * this function does not log.
+ * A structured reset from a result object: `resets_at` / `resetsAt` at the
+ * top level, or `rate_limit_info.resetsAt` directly or under
+ * `api_error_params` / `apiErrorParams`. Undefined when none is present.
  */
+function structuredResetFrom(rec) {
+    const direct = rec.resets_at ?? rec.resetsAt;
+    if (direct !== undefined)
+        return direct;
+    const holders = [rec, rec.api_error_params, rec.apiErrorParams];
+    for (const holder of holders) {
+        if (!isPlainObject(holder))
+            continue;
+        const info = holder.rate_limit_info ?? holder.rateLimitInfo;
+        if (isPlainObject(info) && info.resetsAt !== undefined)
+            return info.resetsAt;
+    }
+    return undefined;
+}
+/** Epoch seconds, epoch milliseconds, or an ISO string, to ISO; null otherwise. */
+export function normalizeStructuredReset(value) {
+    let ms;
+    if (typeof value === "number" && Number.isFinite(value)) {
+        ms = value < 1e12 ? value * 1000 : value;
+    }
+    else if (typeof value === "string" && value.trim().length > 0) {
+        const trimmed = value.trim();
+        if (/^\d+(?:\.\d+)?$/.test(trimmed)) {
+            const n = Number(trimmed);
+            ms = n < 1e12 ? n * 1000 : n;
+        }
+        else {
+            ms = Date.parse(trimmed);
+        }
+    }
+    else {
+        return null;
+    }
+    if (!Number.isFinite(ms) || ms <= 0)
+        return null;
+    return new Date(ms).toISOString();
+}
 export function quotaFieldsFromOutput(text) {
     const lines = text.split("\n");
     for (let i = lines.length - 1; i >= 0; i -= 1) {
@@ -339,10 +376,12 @@ export function quotaFieldsFromOutput(text) {
         }
         if (!isPlainObject(parsed) || parsed.type !== "result")
             continue;
+        const resets_at = structuredResetFrom(parsed);
         return {
             api_error_status: parsed.api_error_status,
             is_error: parsed.is_error,
             result: parsed.result,
+            ...(resets_at !== undefined ? { resets_at } : {}),
         };
     }
     return null;
@@ -362,7 +401,8 @@ export function quotaSignalFromFields(fields, model, now) {
             marker,
         };
     }
-    const quota_reset_at = text.length > 0 ? parseProviderResetTime(text, now) ?? undefined : undefined;
+    const structured = normalizeStructuredReset(fields.resets_at) ?? undefined;
+    const quota_reset_at = structured ?? (text.length > 0 ? parseProviderResetTime(text, now) ?? undefined : undefined);
     return {
         reason: "account_quota_exhausted",
         quota_reset_at,

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

@@ -12,6 +12,8 @@ export interface EnsureSessionHomeResult extends SessionCopyResult {
     source_home: string;
     transcript_path: string;
     homes_searched: string[];
+    /** Set when the transcript was found outside the expected project directory. */
+    found_outside_cwd?: true;
 }
 /**
  * Older Claude account homes can share a registered `account-N/.claude`

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

@@ -117,8 +117,120 @@ function uniqueHomes(homes) {
     }
     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 missingTranscript(input, homes, dirsScanned) {
+    return new LanesError("provider_transcript_missing", `Provider transcript for session ${input.sessionId} was not found. Homes searched: ${homes.join(", ")}. Directories scanned: ${dirsScanned.length > 0 ? dirsScanned.join(", ") : "none"}`, {
+        provider: input.provider,
+        session_id: input.sessionId,
+        homes_searched: homes,
+        directories_scanned: dirsScanned,
+    });
+}
+/**
+ * Every `<home>/projects/<dir>/` that could hold a claude transcript. A lane
+ * can record one cwd and have run in another (a worktree), so a resume looks
+ * in every project directory before refusing.
+ */
+function claudeProjectDirs(home) {
+    const root = path.join(home, "projects");
+    let entries;
+    try {
+        entries = fs.readdirSync(root, { withFileTypes: true });
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT" || code === "ENOTDIR")
+            return [];
+        throw new LanesError("provider_home_search_failed", `Could not search provider home ${home}: ${err instanceof Error ? err.message : String(err)}`, { provider: "claude", home });
+    }
+    return entries
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => path.join(root, entry.name))
+        .sort();
+}
+function isFile(target) {
+    try {
+        return fs.statSync(target).isFile();
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT" || code === "ENOTDIR")
+            return false;
+        throw err;
+    }
+}
+/**
+ * Last resort for a claude session that is not under the expected project
+ * directory in any home: scan every project directory of every searched home,
+ * then copy the transcript (and its sibling subagent directory) into the
+ * target home under the project directory for `input.cwd`, which is where
+ * `claude --resume` started in that cwd looks for it.
+ */
+function relinkFromAnyProject(input, targetHome, searched) {
+    const scanned = [];
+    if (input.provider !== "claude") {
+        for (const home of searched)
+            scanned.push(path.join(home, "sessions"));
+        throw missingTranscript(input, searched, scanned);
+    }
+    const matches = [];
+    for (const home of searched) {
+        const found = [];
+        const dirs = claudeProjectDirs(home);
+        if (dirs.length === 0)
+            scanned.push(path.join(home, "projects"));
+        for (const dir of dirs) {
+            scanned.push(dir);
+            const candidate = path.join(dir, `${input.sessionId}.jsonl`);
+            if (isFile(candidate))
+                found.push(candidate);
+        }
+        if (found.length > 1) {
+            throw new LanesError("provider_transcript_ambiguous", `Multiple claude 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, source: found[0] });
+    }
+    if (matches.length === 0)
+        throw missingTranscript(input, searched, scanned);
+    // The last-run home holds the newest copy; any other home may hold a stale
+    // copy from an earlier account move, so more than one is ambiguous.
+    const lastRunHome = input.providerHomeAtSpawn ? path.resolve(input.providerHomeAtSpawn) : undefined;
+    const chosen = matches.find((match) => match.home === lastRunHome) ??
+        (matches.length === 1 ? matches[0] : undefined);
+    if (chosen === undefined) {
+        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),
+        });
+    }
+    {
+        const home = chosen.home;
+        const source = chosen.source;
+        const targetDir = path.join(targetHome, "projects", encodeClaudeProjectDir(input.cwd));
+        const target = path.join(targetDir, `${input.sessionId}.jsonl`);
+        const subagents = path.join(path.dirname(source), input.sessionId);
+        const hasSubagents = statDirectory(subagents);
+        const plan = {
+            provider: "claude",
+            sources: [source],
+            targets: [target],
+            source_dir: hasSubagents ? subagents : null,
+            target_dir: hasSubagents ? path.join(targetDir, input.sessionId) : null,
+        };
+        const copied = copySessionFiles(plan);
+        if (!isFile(target)) {
+            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: home,
+            transcript_path: target,
+            homes_searched: searched,
+            found_outside_cwd: true,
+        };
+    }
 }
 function copyVerifiedTranscript(input, sourceHome, targetHome, searched) {
     let copied;
@@ -132,7 +244,7 @@ function copyVerifiedTranscript(input, sourceHome, targetHome, searched) {
     }
     catch (err) {
         if (err instanceof LanesError && err.error === "provider_session_missing") {
-            throw missingTranscript(input, searched);
+            return relinkFromAnyProject(input, targetHome, searched);
         }
         throw err;
     }
@@ -202,7 +314,7 @@ export function ensureSessionHome(input) {
             matches.push({ home, transcript: found[0] });
     }
     if (matches.length === 0)
-        throw missingTranscript(input, searched);
+        return relinkFromAnyProject(input, targetHome, 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,

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

@@ -255,7 +255,7 @@ export declare function buildProviderCommand(provider: LaneProvider, input: {
 export declare function workerEnv(base: NodeJS.ProcessEnv, resolved: {
     envVar: string;
     home: string;
-}, laneId: string, hqRoot: string, autoCompactTokens?: number, meshCompany?: LaneCompanyRef, workerPolicyDir?: string, registryWorker?: LaneRecord["registry_worker"]): NodeJS.ProcessEnv;
+}, laneId: string, hqRoot: string, autoCompactTokens?: number, meshCompany?: LaneCompanyRef, workerPolicyDir?: string, registryWorker?: LaneRecord["registry_worker"], homedir?: () => string): NodeJS.ProcessEnv;
 export declare const WORKER_POLICY_HOOK_CAPABILITY = "# hq-capability: worker-policy-dir v1";
 /** Grok does not run HQ hooks; Claude and Codex use the installed capability marker. */
 export declare function workerPolicyDeliveryMode(hqRoot: string, provider: LaneProvider): "hook" | "prompt";

package/dist/lib/lanes/spawn.js

@@ -13,7 +13,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import { configureRemoteControlChildEnv, prepareRemoteControlLane, remoteControlSelectionConfig } from "./remote-control-lane.js";
-import { PROVIDER_HOME_ENV, accountStatus, isLoggedOut, resolveAccount, selectBalancedAccount, } from "./accounts.js";
+import { PROVIDER_HOME_ENV, accountStatus, isDefaultProviderHome, isLoggedOut, resolveAccount, selectBalancedAccount, } from "./accounts.js";
 import { effectiveAccountHome } from "./account-home.js";
 import { buildHostCapacitySnapshot } from "./host-capacity.js";
 import { selectClaudeAccount } from "./claude-balance.js";
@@ -1661,7 +1661,7 @@ export function buildProviderCommand(provider, input) {
         args: appendFastModeFlags(parsed, appendEffortFlag(parsed, appendModelFlag(parsed, appendCodexWorkerPolicyDirFlag(parsed, appendProviderProfileFlags(parsed, args, input.profile), input.workerPolicyDir), input.model), input.effort), input.fastMode),
     };
 }
-export function workerEnv(base, resolved, laneId, hqRoot, autoCompactTokens, meshCompany, workerPolicyDir, registryWorker) {
+export function workerEnv(base, resolved, laneId, hqRoot, autoCompactTokens, meshCompany, workerPolicyDir, registryWorker, homedir) {
     const accepted = Object.values(PROVIDER_HOME_ENV);
     if (!accepted.includes(resolved.envVar)) {
         throw new LanesError("unknown_provider_home_env", `Unknown provider home variable ${JSON.stringify(resolved.envVar)}. Accepted: ${accepted.join(", ")}`, { accepted, value: resolved.envVar });
@@ -1672,7 +1672,16 @@ export function workerEnv(base, resolved, laneId, hqRoot, autoCompactTokens, mes
     delete env.HQ_POLICY_WORKER_DIR;
     delete env.HQ_LANE_APPROVAL_REQUIRED;
     delete env.HQ_LANE_HUMAN_CHECKPOINTS;
-    env[resolved.envVar] = resolved.home;
+    if (resolved.envVar === PROVIDER_HOME_ENV.claude &&
+        isDefaultProviderHome("claude", resolved.home, homedir)) {
+        // The default ~/.claude home runs with CLAUDE_CONFIG_DIR unset so the
+        // worker reads the same keychain credential as the interactive session
+        // (see isDefaultProviderHome). An inherited value is dropped too.
+        delete env[resolved.envVar];
+    }
+    else {
+        env[resolved.envVar] = resolved.home;
+    }
     delete env[CLAUDE_AUTO_COMPACT_ENV];
     if (resolved.envVar === PROVIDER_HOME_ENV.claude && autoCompactTokens !== undefined) {
         env[CLAUDE_AUTO_COMPACT_ENV] = String(autoCompactTokens);
@@ -2075,6 +2084,14 @@ export function readSpawnManifest(runDir) {
     }
     return out;
 }
+function isExistingDirectory(target) {
+    try {
+        return fs.statSync(target).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
 function laneLaunchResult(lane) {
     const { provider_home_at_spawn: _providerHomeAtSpawn, ...safe } = lane;
     return safe;
@@ -2327,6 +2344,17 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
             : existing;
         throw new LanesError("account_not_logged_in", `Account ${resolved.id} for ${lane.provider} is not logged in (no credential file)`, { provider: lane.provider, account: resolved.id, lane_id: lane.lane_id, lane: failed });
     }
+    // The worker starts here, and claude keys its transcript by this directory,
+    // so the transcript checks below use the same value. A resume reuses the
+    // directory the last run started in (a worktree for pipeline lanes) when it
+    // still exists.
+    const recordedWorkingDirectory = plan.mode === "resume" &&
+        typeof existing.working_directory_at_spawn === "string" &&
+        existing.working_directory_at_spawn.trim() !== "" &&
+        isExistingDirectory(existing.working_directory_at_spawn)
+        ? existing.working_directory_at_spawn
+        : undefined;
+    const workerCwd = deps.workingDirectory ?? pendingResume?.working_directory ?? recordedWorkingDirectory ?? hqRoot;
     if (existing.account !== resolved.id) {
         const source = existing.account
             ? config.providers[existing.provider].accounts[existing.account]
@@ -2335,12 +2363,22 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
             source &&
             existing.provider_session_id &&
             providerSupportsSessionResume(existing.provider)) {
-            copySessionFiles(planSessionCopy(existing.provider, {
-                sourceHome: existing.provider_home_at_spawn ?? effectiveAccountHome(source, hostname).home,
-                targetHome: resolved.home,
-                cwd: hqRoot,
-                sessionId: existing.provider_session_id,
-            }));
+            try {
+                copySessionFiles(planSessionCopy(existing.provider, {
+                    sourceHome: existing.provider_home_at_spawn ?? effectiveAccountHome(source, hostname).home,
+                    targetHome: resolved.home,
+                    cwd: workerCwd,
+                    sessionId: existing.provider_session_id,
+                }));
+            }
+            catch (err) {
+                // A resume below searches every home and project directory for the
+                // session, so a transcript under another cwd is handled there.
+                const resumeFollows = plan.mode === "resume" && existing.provider !== "grok";
+                if (!(resumeFollows && err instanceof LanesError && err.error === "provider_session_missing")) {
+                    throw err;
+                }
+            }
         }
     }
     if (plan.mode === "resume" && existing.provider !== "grok") {
@@ -2350,7 +2388,7 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
         ensureSessionHome({
             provider: existing.provider,
             sessionId: plan.session_id,
-            cwd: hqRoot,
+            cwd: workerCwd,
             targetHome,
             registeredHomes: Object.values(config.providers[existing.provider].accounts)
                 .map((account) => effectiveAccountHome(account, hostname).home),
@@ -2644,6 +2682,7 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
             pending_settings: undefined,
             account: resolved.id,
             provider_home_at_spawn: remoteControlHome ?? resolved.home,
+            working_directory_at_spawn: workerCwd,
             ...(model !== undefined ? { model } : {}),
             ...(model !== undefined
                 ? {
@@ -2789,7 +2828,7 @@ export function spawnLaneWorker(hqRoot, lane, deps = {}, launch = {}) {
     let watcherPid;
     try {
         noteCapacityAdvisory(lane, env);
-        workerPid = spawnTrackedWorker(spawnProcess, command.command, command.args, childEnv, deps.workingDirectory ?? pendingResume?.working_directory ?? hqRoot, path.join(logsDir, "worker.out"), path.join(logsDir, "worker.err"), path.join(logsDir, "worker-exit.json"));
+        workerPid = spawnTrackedWorker(spawnProcess, command.command, command.args, childEnv, workerCwd, path.join(logsDir, "worker.out"), path.join(logsDir, "worker.err"), path.join(logsDir, "worker-exit.json"));
         writePidRecord(path.join(runDir, "worker.pid"), {
             pid: workerPid,
             starttime: readProcStarttime(workerPid) ?? undefined,
@@ -3095,12 +3134,19 @@ export function spawnEnvelopeRepair(hqRoot, lane, input, deps = {}) {
             ? { resume: { session_id: sessionId, prompt: repairPrompt } }
             : { freshTurnPrompt: repairPrompt }),
     });
+    // The repair turn resumes the run's session, which claude keys by the
+    // directory that run started in.
+    const repairCwd = mode === "resume" &&
+        typeof lane.working_directory_at_spawn === "string" &&
+        isExistingDirectory(lane.working_directory_at_spawn)
+        ? lane.working_directory_at_spawn
+        : hqRoot;
     const workerOutOffset = fileSizeOrZero(path.join(logsDir, "worker.out"));
     const previous = readSpawnManifest(runDir);
     let workerPid;
     try {
         noteCapacityAdvisory(lane, env);
-        workerPid = spawnTrackedWorker(spawnProcess, command.command, command.args, childEnv, hqRoot, path.join(logsDir, "worker.out"), path.join(logsDir, "worker.err"), path.join(logsDir, "worker-exit.json"));
+        workerPid = spawnTrackedWorker(spawnProcess, command.command, command.args, childEnv, repairCwd, path.join(logsDir, "worker.out"), path.join(logsDir, "worker.err"), path.join(logsDir, "worker-exit.json"));
         writePidRecord(path.join(runDir, "worker.pid"), {
             pid: workerPid,
             starttime: readProcStarttime(workerPid) ?? undefined,

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

@@ -772,6 +772,11 @@ export interface LaneRecord {
     provider_session_id_absent?: string;
     /** Provider home used by the most recently spawned run, for transcript recovery. */
     provider_home_at_spawn?: string;
+    /**
+     * Working directory the most recently spawned run started in. Claude keys
+     * its transcript by this directory, so a later resume starts there too.
+     */
+    working_directory_at_spawn?: string;
     /** Set at spawn when this run continued a recorded session instead of starting fresh. */
     last_resume?: LaneResumeRecord;
     /** Last 50 lane worker starts after the initial start, including actor provenance. */

package/dist/lib/lanes/types.js

@@ -242,7 +242,7 @@ export const LANE_FIELD_WRITERS = {
     overdue: ["reconcile"], overdue_at: ["reconcile"], last_host_report_at: ["watcher", "spawn", "reconcile"], stalled: ["watcher"], stalled_at: ["watcher"], stalled_reason: ["watcher"],
     admitted_reason: ["command", "reconcile"], terminal_reason: ["command", "watcher", "spawn", "reconcile"], stop_history: ["command", "reconcile"], settings_history: ["command"], pending_settings: ["command", "spawn"], interrupted_at: ["command", "watcher", "reconcile", "spawn"], terminal_details: ["command", "spawn", "watcher", "reconcile"],
     quota_reset_at: ["watcher", "reconcile", "spawn", "command"], model_quota_marker: ["watcher", "reconcile"], outpost_command_id: ["command"],
-    provider_session_id: ["watcher", "command", "spawn"], provider_session_id_absent: ["watcher", "command"], provider_home_at_spawn: ["spawn"], last_resume: ["spawn"], resume_history: ["spawn", "watcher"], last_run_usage: ["watcher"], last_run_usage_at: ["watcher"], envelope_repair: ["watcher", "reconcile"], envelope_validation_errors: ["watcher"], last_progress_event_at: ["watcher"],
+    provider_session_id: ["watcher", "command", "spawn"], provider_session_id_absent: ["watcher", "command"], provider_home_at_spawn: ["spawn"], working_directory_at_spawn: ["spawn"], last_resume: ["spawn"], resume_history: ["spawn", "watcher"], last_run_usage: ["watcher"], last_run_usage_at: ["watcher"], envelope_repair: ["watcher", "reconcile"], envelope_validation_errors: ["watcher"], last_progress_event_at: ["watcher"],
 };
 function isPlainObject(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@indigoai-us/hq-cli",
-  "version": "5.345.124",
+  "version": "5.345.126",
   "description": "HQ by Indigo management CLI — modules and cloud sync",
   "main": "dist/index.js",
   "bin": {