@indigoai-us/hq-cli 5.345.125 → 5.345.127

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## [Unreleased]
 
+## [5.345.127] — 2026-10-14
+
+## [5.345.126] — 2026-10-14
+- Claude quota holds are off. A Claude 429 still moves that lane to another account, but it no longer blocks the account for other lanes, and any stored Claude hold is ignored. Set `HQ_LANES_CLAUDE_QUOTA_HOLDS=1` to turn the old behavior back on. Codex and Grok holds are unchanged.
+- Remote Control lanes on the default Claude account now use your normal Claude login too. 5.345.125 fixed this for regular lanes only.
+
+- `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`

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

@@ -27,6 +27,16 @@
  */
 import type { LaneProvider } from "./types.js";
 export declare const QUOTA_STATE_REL: string;
+/**
+ * Claude quota holds are off. Removed by owner directive on 2026-10-14: a
+ * false weekly-limit 429 held every Claude lane for days while the account
+ * still had capacity. A Claude 429 still fails that lane over to another
+ * account; it never blocks the account for later lanes, and stored Claude
+ * holds are ignored on read. `HQ_LANES_CLAUDE_QUOTA_HOLDS=1` turns the old
+ * behavior back on; the test suite sets it to keep the hold machinery covered.
+ */
+export declare const CLAUDE_QUOTA_HOLDS_ENV = "HQ_LANES_CLAUDE_QUOTA_HOLDS";
+export declare function providerHasQuotaHolds(provider: LaneProvider): boolean;
 export declare const QUOTA_SCHEMA_VERSION = "hq-lanes-quota.v1";
 export interface ModelQuota {
     quota_reset_at?: string;

package/dist/lib/lanes/quota.js

@@ -29,6 +29,20 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { withLaneRecordFileLock } from "./store.js";
 export const QUOTA_STATE_REL = path.join("personal", "lanes", "quota.json");
+/**
+ * Claude quota holds are off. Removed by owner directive on 2026-10-14: a
+ * false weekly-limit 429 held every Claude lane for days while the account
+ * still had capacity. A Claude 429 still fails that lane over to another
+ * account; it never blocks the account for later lanes, and stored Claude
+ * holds are ignored on read. `HQ_LANES_CLAUDE_QUOTA_HOLDS=1` turns the old
+ * behavior back on; the test suite sets it to keep the hold machinery covered.
+ */
+export const CLAUDE_QUOTA_HOLDS_ENV = "HQ_LANES_CLAUDE_QUOTA_HOLDS";
+export function providerHasQuotaHolds(provider) {
+    if (provider !== "claude")
+        return true;
+    return process.env[CLAUDE_QUOTA_HOLDS_ENV] === "1";
+}
 export const QUOTA_SCHEMA_VERSION = "hq-lanes-quota.v1";
 /** A provider reset further away than this needs a second 429 before it holds. */
 export const QUOTA_CONFIRM_HORIZON_MS = 24 * 60 * 60 * 1000;
@@ -99,6 +113,8 @@ export function loadQuotaState(hqRoot) {
     const providers = {};
     const rawProviders = isPlainObject(parsed.providers) ? parsed.providers : {};
     for (const provider of ["claude", "codex", "grok"]) {
+        if (!providerHasQuotaHolds(provider))
+            continue;
         const rawAccounts = rawProviders[provider];
         if (!isPlainObject(rawAccounts))
             continue;
@@ -480,6 +496,8 @@ function gateFarReset(current, signal, options) {
     };
 }
 export function recordAccountQuota(hqRoot, provider, accountId, incoming, options) {
+    if (!providerHasQuotaHolds(provider))
+        return loadQuotaState(hqRoot);
     return withLaneRecordFileLock(quotaStatePath(hqRoot), () => {
         const state = loadQuotaState(hqRoot);
         const accounts = state.providers[provider] ?? {};
@@ -631,6 +649,8 @@ function resetStillAhead(iso, now) {
  * no expiry. A past reset does not block.
  */
 export function quotaBlockFor(state, provider, accountId, model, now) {
+    if (!providerHasQuotaHolds(provider))
+        return { blocked: false };
     const account = state.providers[provider]?.[accountId];
     if (!account)
         return { blocked: false };

package/dist/lib/lanes/remote-control-lane.js

@@ -12,14 +12,21 @@ import { fileURLToPath } from "node:url";
 import { stripVTControlCharacters } from "node:util";
 import { daemonPaths, ensurePrivateDir } from "../daemon/paths.js";
 import { isOwnedPoolForwarder, poolHostsFile, readRemoteControlPoolsConfig } from "../daemon/remote-control-pools.js";
-import { accountStatus } from "./accounts.js";
+import { accountStatus, isDefaultProviderHome } from "./accounts.js";
 import { effectiveAccountHome } from "./account-home.js";
 import { LanesError } from "./errors.js";
 import { defaultProbe } from "./models.js";
 import { encodeClaudeProjectDir } from "./move-account.js";
 /** Keep every credential and network route tied to the selected pool. */
 export function configureRemoteControlChildEnv(env, launch) {
-    env.CLAUDE_CONFIG_DIR = launch.accountHome;
+    // The default home runs with CLAUDE_CONFIG_DIR unset so it reads the same
+    // Keychain login as the user's own sessions (see isDefaultProviderHome).
+    if (isDefaultProviderHome("claude", launch.accountHome)) {
+        delete env.CLAUDE_CONFIG_DIR;
+    }
+    else {
+        env.CLAUDE_CONFIG_DIR = launch.accountHome;
+    }
     env.NODE_EXTRA_CA_CERTS = launch.caPath;
     env.IS_SANDBOX = "1";
     for (const key of Object.keys(env)) {
@@ -197,7 +204,7 @@ async function runInside(args) {
             if (fs.existsSync(envelopePath)) {
                 // The id was passed to Claude; verify the provider really persisted it
                 // before reporting it to the lane watcher as a resumable session.
-                const transcript = path.join(process.env.CLAUDE_CONFIG_DIR || "", "projects", encodeClaudeProjectDir(process.cwd()), `${sessionId}.jsonl`);
+                const transcript = path.join(process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude"), "projects", encodeClaudeProjectDir(process.cwd()), `${sessionId}.jsonl`);
                 for (let attempt = 0; attempt < 20 && !fs.existsSync(transcript); attempt++) {
                     await new Promise((resolve) => setTimeout(resolve, 500));
                 }

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

@@ -172,6 +172,7 @@ function relinkFromAnyProject(input, targetHome, 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);
@@ -183,12 +184,30 @@ function relinkFromAnyProject(input, targetHome, searched) {
             if (isFile(candidate))
                 found.push(candidate);
         }
-        if (found.length === 0)
-            continue;
         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 });
         }
-        const source = found[0];
+        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);
@@ -212,7 +231,6 @@ function relinkFromAnyProject(input, targetHome, searched) {
             found_outside_cwd: true,
         };
     }
-    throw missingTranscript(input, searched, scanned);
 }
 function copyVerifiedTranscript(input, sourceHome, targetHome, searched) {
     let copied;

package/package.json

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