@indigoai-us/hq-cli 5.345.155 → 5.345.159

package/dist/lib/lanes/claude-credential.js

@@ -0,0 +1,163 @@
+/**
+ * Expiry check for the Claude OAuth credential a lane worker will use.
+ *
+ * `hq lanes accounts list` used to report `logged_in: true` when a
+ * credential merely existed (a `.credentials.json` file, or `claude auth
+ * status` saying a keychain item is present). An expired access token still
+ * passed, and the lane exited seconds after start with an OAuth expiry
+ * error. This module reads the same credential the worker reads and reports
+ * whether its access token is still valid.
+ *
+ * The worker's credential is keyed by CLAUDE_CONFIG_DIR:
+ * - macOS: the login user's Keychain item `Claude Code-credentials` for the
+ *   default home (the worker runs with the variable unset), or the
+ *   hash-suffixed item for any other home; `<home>/.credentials.json` when no
+ *   Keychain item exists.
+ * - elsewhere: `<home>/.credentials.json`.
+ *
+ * An access token past its expiry is only reported expired when there is no
+ * refresh token, or the capacity collector has recorded the refresh token as
+ * revoked. Otherwise Claude Code renews the access token at startup, so the
+ * account is still usable.
+ *
+ * Only `claudeAiOauth.expiresAt` and the presence of the tokens are read.
+ * Token values are never returned, logged, or copied; the refresh token is
+ * only passed to the revoked check, which compares a fingerprint.
+ */
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { CLAUDE_KEYCHAIN_SERVICE, claudeKeychainServiceName, isRefreshTokenRevoked, } from "../capacity/collectors/claude-oauth.js";
+import { resolveLanesHqRoot } from "./hq-root.js";
+/** Revoked check against the capacity collector's marker file. Never throws. */
+export function defaultIsRefreshRevoked(refreshToken) {
+    try {
+        return isRefreshTokenRevoked(resolveLanesHqRoot(), refreshToken);
+    }
+    catch {
+        return false;
+    }
+}
+function safeUsername() {
+    try {
+        return os.userInfo().username || null;
+    }
+    catch {
+        return null;
+    }
+}
+export const CLAUDE_CREDENTIAL_SECURITY_TIMEOUT_MS = 5_000;
+/** `security find-generic-password` exit status when the item does not exist. */
+const SECURITY_ITEM_NOT_FOUND = 44;
+/** Keychain service the worker reads for this home. */
+export function laneClaudeKeychainService(target) {
+    return target.defaultHome ? CLAUDE_KEYCHAIN_SERVICE : claudeKeychainServiceName(target.home);
+}
+/** Classify a credential document. Returns only state and expiry. */
+export function claudeTokenStateFromDocument(text, nowMs, isRefreshRevoked = () => false) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return { state: "unknown", expires_at: null };
+    }
+    if (!isRecord(parsed))
+        return { state: "unknown", expires_at: null };
+    const oauth = parsed.claudeAiOauth;
+    if (!isRecord(oauth))
+        return { state: "missing", expires_at: null };
+    const token = typeof oauth.accessToken === "string" ? oauth.accessToken : oauth.access_token;
+    if (typeof token !== "string" || token.trim() === "")
+        return { state: "missing", expires_at: null };
+    const raw = oauth.expiresAt;
+    if (typeof raw !== "number" || !Number.isFinite(raw))
+        return { state: "valid", expires_at: null };
+    const ms = raw < 1e12 ? raw * 1000 : raw;
+    const date = new Date(ms);
+    const expires_at = Number.isNaN(date.getTime()) ? null : date.toISOString();
+    if (ms > nowMs)
+        return { state: "valid", expires_at };
+    // Past expiry. Claude Code renews the access token from the refresh token
+    // at startup, so this is only a dead sign-in when there is nothing to renew
+    // with or the refresh token is known to be revoked.
+    const refresh = typeof oauth.refreshToken === "string" ? oauth.refreshToken : oauth.refresh_token;
+    if (typeof refresh !== "string" || refresh.trim() === "")
+        return { state: "expired", expires_at };
+    let revoked = false;
+    try {
+        revoked = isRefreshRevoked(refresh);
+    }
+    catch {
+        revoked = false;
+    }
+    return { state: revoked ? "expired" : "valid", expires_at };
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function defaultSecurity(args) {
+    const result = spawnSync("security", [...args], {
+        encoding: "utf8",
+        timeout: CLAUDE_CREDENTIAL_SECURITY_TIMEOUT_MS,
+        stdio: ["ignore", "pipe", "ignore"],
+        maxBuffer: 8 * 1024 * 1024,
+    });
+    const timedOut = result.error?.code === "ETIMEDOUT";
+    return {
+        status: result.error ? null : result.status,
+        stdout: typeof result.stdout === "string" ? result.stdout : "",
+        timedOut,
+    };
+}
+export function createClaudeCredentialReader(deps = {}) {
+    const platform = deps.platform ?? process.platform;
+    const now = deps.now ?? (() => Date.now());
+    const security = deps.security ?? defaultSecurity;
+    const readFile = deps.readFile ?? ((file) => fs.readFileSync(file, "utf8"));
+    const isRefreshRevoked = deps.isRefreshRevoked ?? defaultIsRefreshRevoked;
+    const fromFile = (home) => {
+        let text;
+        try {
+            text = readFile(path.join(home, ".credentials.json"));
+        }
+        catch (err) {
+            const code = err?.code;
+            return { state: code === "ENOENT" ? "missing" : "unknown", expires_at: null, source: null };
+        }
+        return { ...claudeTokenStateFromDocument(text, now(), isRefreshRevoked), source: "file" };
+    };
+    return (target) => {
+        if (platform !== "darwin")
+            return fromFile(target.home);
+        const service = laneClaudeKeychainService(target);
+        let read;
+        try {
+            // Claude Code writes its item under the login user's account name. A
+            // second item with the same service and another account (MCP OAuth
+            // only) can exist, so ask for the user's item first, as the capacity
+            // collector does, and fall back to any item for the service.
+            const username = deps.username ?? safeUsername();
+            read = username
+                ? security(["find-generic-password", "-s", service, "-a", username, "-w"])
+                : { status: SECURITY_ITEM_NOT_FOUND, stdout: "", timedOut: false };
+            if (!read.timedOut && read.status === SECURITY_ITEM_NOT_FOUND) {
+                read = security(["find-generic-password", "-s", service, "-w"]);
+            }
+        }
+        catch {
+            return { state: "unknown", expires_at: null, source: null };
+        }
+        if (read.timedOut)
+            return { state: "unknown", expires_at: null, source: null };
+        if (read.status === SECURITY_ITEM_NOT_FOUND)
+            return fromFile(target.home);
+        if (read.status !== 0)
+            return { state: "unknown", expires_at: null, source: null };
+        return { ...claudeTokenStateFromDocument(read.stdout.replace(/\n$/, ""), now(), isRefreshRevoked), source: "keychain" };
+    };
+}
+/** Production reader: real Keychain on macOS, the credentials file elsewhere. */
+export const readLaneClaudeCredential = createClaudeCredentialReader();
+//# sourceMappingURL=claude-credential.js.map

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

@@ -79,6 +79,8 @@ export type RunCompactionFn = (input: {
 }) => CompactionCommandResult;
 /** Synchronous `/compact`. stdout is discarded; stderr goes to the run dir. */
 export declare const defaultRunCompaction: RunCompactionFn;
+/** Stderr line printed before a resume-time `/compact` starts. */
+export declare function compactionStartNotice(sessionId: string): string;
 export interface CompactLaneSessionInput {
     command: string;
     /** Full argv of `claude -p --resume <sid> "/compact" …`, built by buildProviderCommand. */

package/dist/lib/lanes/compaction.js

@@ -388,6 +388,12 @@ export const defaultRunCompaction = (input) => {
         fs.closeSync(errFd);
     }
 };
+/** Stderr line printed before a resume-time `/compact` starts. */
+export function compactionStartNotice(sessionId) {
+    const minutes = Math.round(COMPACTION_TIMEOUT_MS / 60_000);
+    return `hq lanes: compacting session ${sessionId} before resume; this can take up to ${minutes} minutes. ` +
+        `Re-run with --no-compact to skip it.\n`;
+}
 /**
  * Run `/compact` on the recorded session and report what happened. A failed
  * or ineffective compaction is recorded, not thrown: the resume that needed
@@ -398,6 +404,9 @@ export function compactLaneSession(input) {
     const locate = input.locateTranscript ?? findSessionTranscript;
     const started = input.now();
     const beforeProbe = probeCompactBoundaries(locate(input.accountHome, input.sessionId));
+    // `/compact` runs synchronously and can take minutes. Say so before it
+    // starts, so a resume that is waiting on it does not look hung.
+    process.stderr.write(compactionStartNotice(input.sessionId));
     const result = run({
         command: input.command,
         args: input.args,

package/dist/lib/lanes/config.js

@@ -186,6 +186,12 @@ function parseAccount(provider, id, raw, deps) {
         home: canonicalizeHome(raw.home, deps),
         enabled: raw.enabled,
     };
+    if (raw.company !== undefined) {
+        if (typeof raw.company !== "string" || raw.company.trim() === "" || raw.company.trim() !== raw.company) {
+            throw new LanesConfigError("invalid_config", `providers.${provider}.accounts.${id}.company must be a non-empty company slug or UID`, { provider, account: id });
+        }
+        account.company = raw.company;
+    }
     if (raw.hosts !== undefined) {
         const field = `providers.${provider}.accounts.${id}.hosts`;
         if (!isPlainObject(raw.hosts)) {

package/dist/lib/lanes/envelope-repair-dispatch.js

@@ -1,6 +1,7 @@
 import { spawnSync as nodeSpawnSync } from "node:child_process";
 import * as path from "node:path";
 import { LanesError } from "./errors.js";
+import { liveNodeBinary } from "./node-binary.js";
 const LANE_RUNNER_ENTRY_NAMES = new Set(["watcher-main", "worker-process", "remote-control-lane"]);
 /**
  * True for the detached lane runner scripts. They are not the hq CLI: running
@@ -42,7 +43,7 @@ export function spawnEnvelopeRepairViaCurrentCli(hqRoot, lane, input, deps = {})
         isLaneRunnerEntry(cliEntry)) {
         throw new LanesError("repair_cli_entry_invalid", "Lane watcher has no valid absolute hq CLI entrypoint for envelope repair", { lane_id: lane.lane_id });
     }
-    const result = run(process.execPath, [cliEntry, "lanes", "_spawn-envelope-repair"], {
+    const result = run(liveNodeBinary(), [cliEntry, "lanes", "_spawn-envelope-repair"], {
         encoding: "utf8",
         timeout: 120_000,
         input: JSON.stringify(request),

package/dist/lib/lanes/hooks-install.js

@@ -25,6 +25,7 @@ import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import { parse as parseToml, TomlError } from "smol-toml";
 import { LanesError } from "./errors.js";
+import { liveNodeBinary } from "./node-binary.js";
 import { parseLaneProvider } from "./types.js";
 export const DRAIN_HOOK_BASENAME = "hq-lanes-drain";
 export const DRAIN_HOOK_TIMEOUT_SECONDS = 30;
@@ -49,7 +50,7 @@ export const PROVIDER_REGISTRATION_KIND = {
 };
 export function drainHookCommand(_shPath, provider) {
     const providerEnv = provider === "grok" ? "HQ_LANE_PROVIDER=grok " : "";
-    return `${providerEnv}${shellQuote(process.execPath)} ${shellQuote(drainHookEntryPath())}`;
+    return `${providerEnv}${shellQuote(liveNodeBinary())} ${shellQuote(drainHookEntryPath())}`;
 }
 function legacyDrainHookCommand(shPath) {
     return `bash ${shPath}`;

package/dist/lib/lanes/host-capacity.d.ts

@@ -1,4 +1,5 @@
 import { type AuthState } from "./accounts.js";
+import type { ClaudeCredentialReader } from "./claude-credential.js";
 import { type QuotaState } from "./quota.js";
 import type { LaneHost, LaneProvider, LaneRecord, LanesConfig } from "./types.js";
 export interface HostCapacityAccount {
@@ -63,6 +64,7 @@ export declare function buildHostCapacitySnapshot(input: {
     hostname?: string;
     now: Date;
     quotaState?: QuotaState;
+    readClaudeCredential?: ClaudeCredentialReader;
 }): HostCapacitySnapshot;
 /** Reject malformed remote snapshots before they can influence host selection. */
 export declare function parseHostCapacitySnapshot(raw: unknown): HostCapacitySnapshot;

package/dist/lib/lanes/host-capacity.js

@@ -31,6 +31,7 @@ export function buildHostCapacitySnapshot(input) {
                 ...(input.probe !== undefined ? { probe: input.probe } : {}),
                 ...(input.env !== undefined ? { env: input.env } : {}),
                 ...(input.hostname !== undefined ? { hostname: input.hostname } : {}),
+                ...(input.readClaudeCredential !== undefined ? { readClaudeCredential: input.readClaudeCredential } : {}),
             });
             const accountLanes = providerLanes.filter((lane) => lane.account === id);
             const liveLanes = accountLanes.filter((lane) => lane.state === "running" || lane.state === "queued" || lane.state === "awaiting_input");

package/dist/lib/lanes/keep-alive.d.ts

@@ -30,7 +30,7 @@ export declare function queueLaneTerminalResume(current: LaneRecord, at: string,
     trigger?: "resume" | "watcher";
 }): LaneTerminalResumeResult;
 /** Persist a manager status miss and queue its one bounded follow-up turn. */
-export declare function queueManagerStatusGateResume(hqRoot: string, laneId: string, entry: Omit<ManagerStatusGateHistoryEntry, "event" | "resume_queued" | "resume_skipped_reason">, resumeText: string): LaneRecord;
+export declare function queueManagerStatusGateResume(hqRoot: string, laneId: string, entry: Omit<ManagerStatusGateHistoryEntry, "event" | "resume_queued" | "resume_skipped_reason">, resumeText: string, skip?: (current: LaneRecord) => boolean): LaneRecord;
 export declare const LEAD_LANE_KEEP_ALIVE_RESUME_TEXT = "Automatic keep-alive resume: your last turn ended with decision done and story_complete false. Continue the open work from where you stopped. End with done only when story_complete is true; if you are waiting, use hq lanes ask or stay in the loop.";
 export declare const LEAD_LANE_KEEP_ALIVE_BLOCKED_RESUME_TEXT = "You ended blocked with no pending question. Record the event you wait on in waiting_on, re-check each blocker, and continue the next unblocked story.";
 export declare const LEAD_LANE_KEEP_ALIVE_INTERRUPTED_RESUME_TEXT = "Automatic keep-alive resume: your previous turn was interrupted by a provider process exit. Check your last state before continuing. Continue the open work from where you stopped. End with done only when story_complete is true; if you are waiting, use hq lanes ask or stay in the loop.";

package/dist/lib/lanes/keep-alive.js

@@ -75,8 +75,10 @@ export function queueLaneTerminalResume(current, at, resumeText, options = {}) {
     };
 }
 /** Persist a manager status miss and queue its one bounded follow-up turn. */
-export function queueManagerStatusGateResume(hqRoot, laneId, entry, resumeText) {
+export function queueManagerStatusGateResume(hqRoot, laneId, entry, resumeText, skip = () => false) {
     return retryUpdateLane(hqRoot, laneId, "watcher", (current) => {
+        if (skip(current))
+            return current;
         const gate = current.status_gate;
         if (gate === undefined || gate.turn_id !== entry.turn_id)
             return current;

package/dist/lib/lanes/links.js

@@ -117,6 +117,9 @@ function resolvePointer(root, sid, role, options) {
     if (role === "child" && !safeId(child))
         throw new LaneLinkError("child_name_invalid", `Invalid child name: ${child ?? ""}`);
     const link = options.link ?? pointer.link;
+    if (role === "conductor" && link !== pointer.link) {
+        throw new LaneLinkError("link_role_invalid", "A conductor can only consume or wait on its own link");
+    }
     if (role === "child") {
         if (options.link !== undefined && !safeId(options.link))
             throw new LaneLinkError("link_invalid", "Invalid --link");
@@ -412,15 +415,18 @@ export async function runLaneLink(subcommand, options) {
     }
     if (subcommand === "inbox" || subcommand === "read") {
         const role = subcommand === "inbox" ? "child" : "conductor";
-        const resolved = role === "conductor" && options.link !== undefined
-            ? { link: options.link }
-            : resolvePointer(root, requireSid(), role, options);
+        // Preserve explicit-link validation errors before resolving ownership.
+        if (role === "conductor" && options.link !== undefined)
+            linkPath(root, options.link);
+        const resolved = resolvePointer(root, requireSid(), role, options);
         linkPath(root, resolved.link);
         const text = drainLinkQueue(queueDir(root, resolved.link, role === "child" ? resolved.child : undefined));
         return { output: { messages: text } };
     }
     if (subcommand === "wait") {
-        const resolved = options.link ? { link: options.link } : resolvePointer(root, requireSid(), "conductor", options);
+        if (options.link !== undefined)
+            linkPath(root, options.link);
+        const resolved = resolvePointer(root, requireSid(), "conductor", options);
         return await waitForReport(linkPath(root, resolved.link), options.timeout ?? 1800, options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms))));
     }
     if (subcommand === "list") {

package/dist/lib/lanes/loop.js

@@ -1002,6 +1002,21 @@ function appendJournal(runDir, value) {
     fs.mkdirSync(path.dirname(file), { recursive: true });
     fs.appendFileSync(file, `${JSON.stringify(value)}\n`, { mode: 0o600 });
 }
+/**
+ * Where a synthetic failed or blocked handoff goes. The phase worker may have
+ * written its own handoff to result_path already (for example one that failed
+ * validation). That file is the only copy of the worker's evidence, so it is
+ * never overwritten: the synthetic handoff is written beside it instead
+ * (`<name>.lane-failure.json`). With no worker file, result_path itself gets
+ * the synthetic handoff so the pipeline driver still sees the phase end.
+ */
+function syntheticHandoffPath(resultPath) {
+    if (!fs.existsSync(resultPath))
+        return resultPath;
+    const ext = path.extname(resultPath);
+    const base = ext ? resultPath.slice(0, -ext.length) : resultPath;
+    return `${base}.lane-failure${ext || ".json"}`;
+}
 function writeResultAt(runDir, activeFile, record, result, includeHandoffValidationError = true) {
     const localPath = path.join(resultsDir(runDir), resultName(record.envelope_id));
     atomicJson(localPath, result);
@@ -1025,7 +1040,7 @@ function writeResultAt(runDir, activeFile, record, result, includeHandoffValidat
                         back_pressure: { tests: "skip", lint: "skip", typecheck: "skip", build: "skip" },
                         context_for_next: [result.error ?? result.status, ...(result.question_id ? [`Decision question: ${result.question_id}`] : [])].join("\n"),
                     };
-                    atomicJson(path.resolve(externalPath), failure);
+                    atomicJson(syntheticHandoffPath(path.resolve(externalPath)), failure);
                 }
             }
             else

package/dist/lib/lanes/node-binary.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The Node binary to use for a child process started by a long-lived lane
+ * process (loop worker, watcher, drain hook registration).
+ *
+ * `process.execPath` is fixed when the process starts. A Node upgrade can
+ * remove that file while the process keeps running (Homebrew deletes the old
+ * Cellar directory), and every later child then fails to start. When the
+ * launch-time binary is gone:
+ *
+ * 1. For a Homebrew Cellar path (`<prefix>/Cellar/<formula>/<version>/bin/node`),
+ *    use the stable `<prefix>/bin/node` symlink when it exists. That points at
+ *    the upgraded install of the same prefix and does not depend on PATH or on
+ *    a version manager shim reading the child's cwd.
+ * 2. Otherwise fall back to `node` resolved through the child env PATH.
+ */
+export declare function liveNodeBinary(execPath?: string, exists?: (candidate: string) => boolean): string;
+//# sourceMappingURL=node-binary.d.ts.map

package/dist/lib/lanes/node-binary.js

@@ -0,0 +1,30 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+/**
+ * The Node binary to use for a child process started by a long-lived lane
+ * process (loop worker, watcher, drain hook registration).
+ *
+ * `process.execPath` is fixed when the process starts. A Node upgrade can
+ * remove that file while the process keeps running (Homebrew deletes the old
+ * Cellar directory), and every later child then fails to start. When the
+ * launch-time binary is gone:
+ *
+ * 1. For a Homebrew Cellar path (`<prefix>/Cellar/<formula>/<version>/bin/node`),
+ *    use the stable `<prefix>/bin/node` symlink when it exists. That points at
+ *    the upgraded install of the same prefix and does not depend on PATH or on
+ *    a version manager shim reading the child's cwd.
+ * 2. Otherwise fall back to `node` resolved through the child env PATH.
+ */
+export function liveNodeBinary(execPath = process.execPath, exists = fs.existsSync) {
+    if (exists(execPath))
+        return execPath;
+    const parts = execPath.split(path.sep);
+    const cellar = parts.lastIndexOf("Cellar");
+    if (cellar > 0) {
+        const prefixLink = path.join(parts.slice(0, cellar).join(path.sep) || path.sep, "bin", "node");
+        if (exists(prefixLink))
+            return prefixLink;
+    }
+    return "node";
+}
+//# sourceMappingURL=node-binary.js.map

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

@@ -27,7 +27,7 @@ export interface OutpostDispatchResult {
     stderr: string;
 }
 export interface OutpostLaneCommand {
-    action: "message" | "resume" | "stop" | "show" | "logs" | "grant" | "grant-target" | "reparent-target" | "approve-target" | "repair-company-target" | "blocked-escalation-target";
+    action: "message" | "resume" | "stop" | "show" | "logs" | "grant" | "grant-target" | "reparent-target" | "approve-target" | "repair-company-target" | "set-target" | "blocked-escalation-target";
     laneId: string;
     hqBinary?: string;
     text?: string;
@@ -46,6 +46,7 @@ export interface OutpostLaneCommand {
     profileRepinContext?: string;
     approvalContext?: string;
     senior?: string;
+    actor?: string;
     reason?: string;
     company?: string;
     compact?: boolean;

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

@@ -225,6 +225,7 @@ export function buildOutpostLaneCommand(input) {
         ["--approval-context", input.approvalContext],
         ["--failed-resume-context", input.failedResumeContext],
         ["--senior", input.senior],
+        ["--actor", input.actor],
         ["--reason", input.reason],
         ["--company", input.company],
         ["--message-id", input.messageId],

package/dist/lib/lanes/reconcile.js

@@ -5,6 +5,7 @@
  * compare-and-set. The per-lane watcher owns progress/terminal/silence of a
  * live process — this pass owns the transitions no single lane can own.
  */
+import { accountMatchesCompany } from "./account-company.js";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { parseUserYaml } from "../../utils/user-yaml-error.js";
@@ -724,6 +725,8 @@ function availableBalancedAccount(hqRoot, lane, occupying, config, host, profile
     for (const account of lane.admission_accounts) {
         if (account === lane.account)
             continue;
+        if (!accountMatchesCompany(config.providers[lane.provider].accounts[account], resolveLaneCompany(hqRoot, lane).company, config.providers[lane.provider].accounts))
+            continue;
         if (config.providers[lane.provider].accounts[account]?.enabled !== true)
             continue;
         const status = accountStatus(lane.provider, account, config, {
@@ -754,6 +757,7 @@ function availableBalancedAccount(hqRoot, lane, occupying, config, host, profile
 function writeAdmissionAccount(hqRoot, lane, account, dryRun) {
     return casLaneIf(hqRoot, lane.lane_id, (current) => current.state === "queued" &&
         current.account === lane.account &&
+        accountMatchesCompany(loadLanesConfig(hqRoot).providers[current.provider].accounts[account], resolveLaneCompany(hqRoot, current).company, loadLanesConfig(hqRoot).providers[current.provider].accounts) &&
         current.admission_accounts?.includes(account) === true, (current) => ({ ...current, account }), dryRun).record;
 }
 function casQuestionIf(hqRoot, questionId, shouldWrite, updater, dryRun) {

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

@@ -15,6 +15,7 @@ import { isOwnedPoolForwarder, poolHostsFile, readRemoteControlPoolsConfig } fro
 import { accountStatus, isDefaultProviderHome } from "./accounts.js";
 import { effectiveAccountHome } from "./account-home.js";
 import { LanesError } from "./errors.js";
+import { readLaneClaudeCredential } from "./claude-credential.js";
 import { defaultProbe } from "./models.js";
 import { encodeClaudeProjectDir } from "./move-account.js";
 /** Keep every credential and network route tied to the selected pool. */
@@ -117,6 +118,7 @@ export function prepareRemoteControlLane(input) {
     }
     const status = accountStatus("claude", "a", input.config, {
         hostname: input.hostname, existsSync: fs.existsSync, probe: defaultProbe, env: input.env,
+        readClaudeCredential: readLaneClaudeCredential,
     });
     if (!status.logged_in) {
         throw new LanesError("remote_control_login_missing", "Claude account a must be logged in for Remote Control", {});

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

@@ -8,6 +8,7 @@
  * mutable fields are re-read from the lane record (spec §5.4).
  */
 import { PROVIDER_HOME_ENV } from "./accounts.js";
+import { type ClaudeCredentialReader } from "./claude-credential.js";
 import { type RunCompactionFn } from "./compaction.js";
 import { type ResolvedEffort } from "./effort.js";
 import { type KnownModelsDeps } from "./models.js";
@@ -66,6 +67,8 @@ export type ProveDetachedFn = (pid: number) => DetachProof;
 export type KillProcessFn = (pid: number, signal?: NodeJS.Signals) => void;
 export interface SpawnLaneDeps {
     env?: NodeJS.ProcessEnv;
+    /** Claude credential expiry check; see spawnCredentialReader for the default. */
+    readClaudeCredential?: ClaudeCredentialReader;
     /** Builds the lane's fingerprint from the worker env. Defaults to laneStartFingerprint. */
     buildFingerprint?: (hqRoot: string, workerEnv: NodeJS.ProcessEnv) => string | null;
     /** Test seam for the default-off quota account failover registry gate. */