agent-relay-runner 0.62.3 → 0.63.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-runner",
-  "version": "0.62.3",
+  "version": "0.63.1",
   "description": "Unified provider lifecycle runner for Agent Relay",
   "type": "module",
   "bin": {
@@ -20,7 +20,7 @@
     "directory": "runner"
   },
   "dependencies": {
-    "agent-relay-sdk": "0.2.40"
+    "agent-relay-sdk": "0.2.42"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/plugins/claude/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "agent-relay-runner",
   "description": "Thin Agent Relay runner bridge for Claude Code",
-  "version": "0.62.3",
+  "version": "0.63.1",
   "agentRelayContracts": {
     "providerPluginProtocol": 1
   }

package/src/adapter.ts

@@ -1,6 +1,7 @@
 import type { AgentProfile, Message } from "agent-relay-sdk";
 import { isRecord } from "agent-relay-sdk";
 import type { SessionEvent } from "./session-insights";
+import { messageBodyMaxCharsFromEnv } from "./config";
 
 export type SemanticStatus = "idle" | "busy" | "offline" | "error";
 type ProviderWorkKind = "provider-turn" | "subagent";
@@ -202,7 +203,7 @@ export const DEFAULT_PROVIDER_MESSAGE_BODY_MAX_CHARS = 24_000;
 // Resolve the delivered-body cap. Deployment-dependent (the right ceiling tracks the host's
 // context budget), so it's overridable via env — set on the orchestrator/host that spawns runners.
 export function providerMessageBodyMaxChars(): number {
-  const raw = process.env.AGENT_RELAY_MESSAGE_BODY_MAX_CHARS;
+  const raw = messageBodyMaxCharsFromEnv();
   if (raw !== undefined) {
     const parsed = Number.parseInt(raw.trim(), 10);
     if (Number.isFinite(parsed) && parsed > 0) return parsed;

package/src/attachment-cache.ts

@@ -4,6 +4,7 @@ import { basename, join } from "node:path";
 import type { Artifact, Message } from "agent-relay-sdk";
 import { errMessage, isRecord } from "agent-relay-sdk";
 import { sanitizeFsName } from "agent-relay-sdk/fs-name";
+import { attachmentCacheDirFromEnv } from "./config";
 
 const DEFAULT_CACHE_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
 
@@ -34,11 +35,11 @@ function attachmentRefs(message: Message): Record<string, unknown>[] {
   return refs.filter(isRecord);
 }
 
-function attachmentCacheRoot(agentId: string, rootDir = process.env.AGENT_RELAY_ATTACHMENT_CACHE_DIR): string {
+function attachmentCacheRoot(agentId: string, rootDir = attachmentCacheDirFromEnv()): string {
   return join(attachmentCacheBase(rootDir), safePathPart(agentId));
 }
 
-function attachmentCacheBase(rootDir = process.env.AGENT_RELAY_ATTACHMENT_CACHE_DIR): string {
+function attachmentCacheBase(rootDir = attachmentCacheDirFromEnv()): string {
   return rootDir || join(homedir(), ".agent-relay", "attachments");
 }
 
@@ -147,7 +148,7 @@ function withCacheError(ref: Record<string, unknown>, error: unknown): Record<st
 
 export function pruneAttachmentCache(
   agentId: string,
-  rootDir = process.env.AGENT_RELAY_ATTACHMENT_CACHE_DIR,
+  rootDir = attachmentCacheDirFromEnv(),
   maxAgeMs = DEFAULT_CACHE_MAX_AGE_MS,
   now = Date.now(),
 ): void {

package/src/busy-reconciler.ts

@@ -0,0 +1,84 @@
+type ProviderActivity = "busy" | "idle" | "unknown";
+
+const BUSY_RECONCILE_POLL_MS = 4_000;
+const BUSY_RECONCILE_IDLE_CONFIRM = 8;
+const BUSY_RECONCILE_IDLE_CONFIRM_NO_BUSY = 15;
+const INTERRUPT_RECONCILE_DELAY_MS = 1_500;
+
+interface BusyReconcilerDeps {
+  isStopped(): boolean;
+  hasProcess(): boolean;
+  currentStatus(): "idle" | "busy" | "offline" | "error";
+  isProviderBlocked(): boolean;
+  hasProviderTurn(): boolean;
+  canProbeActivity(): boolean;
+  probeActivity(): Promise<ProviderActivity> | undefined;
+  clearProviderTurn(reason: string): void;
+  sessionDebug(message: string): void;
+}
+
+export class BusyReconciler {
+  private idleStreak = 0;
+  private timer?: ReturnType<typeof setInterval>;
+  private sawBusy = false;
+
+  constructor(private readonly deps: BusyReconcilerDeps) {}
+
+  arm(): void {
+    if (this.timer || !this.deps.canProbeActivity()) return;
+    this.idleStreak = 0;
+    this.sawBusy = false;
+    this.timer = setInterval(() => { void this.run(); }, BUSY_RECONCILE_POLL_MS);
+  }
+
+  disarm(): void {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = undefined;
+    this.idleStreak = 0;
+    this.sawBusy = false;
+  }
+
+  scheduleInterruptReconcile(): void {
+    setTimeout(() => {
+      if (this.deps.isStopped() || !this.deps.hasProcess()) return;
+      void (async () => {
+        if (this.deps.currentStatus() !== "busy" || this.deps.isProviderBlocked()) return;
+        const probe = this.deps.probeActivity();
+        let activity: ProviderActivity = "unknown";
+        try { if (probe) activity = await probe; } catch { return; }
+        this.deps.sessionDebug(`post-interrupt reconcile probe=${activity}`);
+        if (activity === "idle") this.deps.clearProviderTurn("post-interrupt");
+      })();
+    }, INTERRUPT_RECONCILE_DELAY_MS);
+  }
+
+  private async run(): Promise<void> {
+    const probe = this.deps.probeActivity();
+    if (this.deps.isStopped() || !this.deps.hasProcess() || !probe) {
+      this.disarm();
+      return;
+    }
+    if (this.deps.currentStatus() !== "busy" || this.deps.isProviderBlocked()) {
+      this.idleStreak = 0;
+      return;
+    }
+    if (!this.deps.hasProviderTurn()) {
+      this.disarm();
+      return;
+    }
+    let activity: ProviderActivity;
+    try { activity = await probe; } catch { return; }
+    if (activity === "busy") this.sawBusy = true;
+    if (activity !== "idle") {
+      this.idleStreak = 0;
+      this.deps.sessionDebug(`reconcile probe=${activity} sawBusy=${this.sawBusy} streak=${this.idleStreak}`);
+      return;
+    }
+    this.idleStreak += 1;
+    const confirm = this.sawBusy ? BUSY_RECONCILE_IDLE_CONFIRM : BUSY_RECONCILE_IDLE_CONFIRM_NO_BUSY;
+    this.deps.sessionDebug(`reconcile probe=idle sawBusy=${this.sawBusy} streak=${this.idleStreak}/${confirm}`);
+    if (this.idleStreak < confirm) return;
+    this.disarm();
+    this.deps.clearProviderTurn(this.sawBusy ? "backstop reconciler" : "backstop reconciler (no-busy-observed)");
+  }
+}

package/src/config.ts

@@ -1,11 +1,26 @@
 import { execFileSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir, hostname } from "node:os";
-import { join, resolve } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { DEFAULT_RELAY_URL, RELAY_TOKEN_HEADER, errMessage, stringValue } from "agent-relay-sdk";
 import type { SettingEntry, WorkspaceMetadata } from "agent-relay-sdk";
 import { sanitizeFsName } from "agent-relay-sdk/fs-name";
-import type { ProviderConfig } from "./adapter";
+
+interface ProviderConfig {
+  command: string;
+  defaultArgs: string[];
+  env: Record<string, string>;
+  pluginDirs: string[];
+  defaultCapabilities: string[];
+  defaultApprovalMode: string;
+  defaultTags: string[];
+  chatCaptureMode: "final" | "full";
+  reasoningCapture?: boolean;
+  headless: {
+    tmuxPrefix: string;
+    shutdownTimeoutMs: number;
+  };
+}
 
 interface GlobalRunnerConfig {
   relayUrl: string;
@@ -17,7 +32,7 @@ interface LoadedProviderConfig extends ProviderConfig {
   path: string;
 }
 
-function agentRelayHome(): string {
+export function agentRelayHome(): string {
   return process.env.AGENT_RELAY_HOME || join(homedir(), ".agent-relay");
 }
 
@@ -48,12 +63,135 @@ export function loadGlobalConfig(home = agentRelayHome()): GlobalRunnerConfig {
   const path = join(home, "config.json");
   const parsed = readJson(path);
   return {
-    relayUrl: stringValue(parsed.relayUrl) ?? process.env.AGENT_RELAY_URL ?? DEFAULT_RELAY_URL,
-    token: stringValue(parsed.token) ?? process.env.AGENT_RELAY_TOKEN,
+    relayUrl: stringValue(parsed.relayUrl) ?? relayUrlFromEnv() ?? DEFAULT_RELAY_URL,
+    token: stringValue(parsed.token) ?? relayTokenFromEnv(),
     defaultCwd: stringValue(parsed.defaultCwd) ?? process.cwd(),
   };
 }
 
+function relayUrlFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_URL;
+}
+
+export function relayTokenFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_TOKEN;
+}
+
+export function runtimeTokenProfileFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_TOKEN_PROFILE;
+}
+
+export function runtimeTokenJtiFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_TOKEN_JTI;
+}
+
+export function runtimeTokenExpiresAtFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_TOKEN_EXPIRES_AT;
+}
+
+export function agentProfileNameFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_AGENT_PROFILE;
+}
+
+export function agentProfileJsonFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_AGENT_PROFILE_JSON;
+}
+
+export function workspaceJsonFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_WORKSPACE_JSON;
+}
+
+export function tmuxSessionFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_TMUX_SESSION;
+}
+
+export function policyNameFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_POLICY;
+}
+
+export function spawnRequestIdFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_SPAWN_REQUEST_ID;
+}
+
+export function automationIdFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_AUTOMATION_ID;
+}
+
+export function automationRunIdFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_AUTOMATION_RUN_ID;
+}
+
+export function lifecycleFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_LIFECYCLE;
+}
+
+export function sessionDebugEnabled(): boolean {
+  return process.env.AGENT_RELAY_SESSION_DEBUG === "1";
+}
+
+export function logLevelFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_LOG_LEVEL;
+}
+
+export function mcpProxyEnabledFromEnv(): boolean {
+  return !["0", "false", "off"].includes((process.env.AGENT_RELAY_MCP_PROXY ?? "").trim().toLowerCase());
+}
+
+export function runnerInfoFileFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_RUNNER_INFO_FILE;
+}
+
+export function runnerOutboxDirFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_RUNNER_OUTBOX_DIR;
+}
+
+export function runnerOutboxDirWithInfoFallback(): string | undefined {
+  const dir = runnerOutboxDirFromEnv();
+  if (dir) return dir;
+  const infoFile = runnerInfoFileFromEnv();
+  return infoFile ? join(dirname(infoFile), "outbox") : undefined;
+}
+
+export function capsFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_CAPS;
+}
+
+export function tagsFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_TAGS;
+}
+
+export function workspaceModeFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_WORKSPACE_MODE;
+}
+
+export function orchestratorBaseDirFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_ORCHESTRATOR_BASE_DIR;
+}
+
+export function runnerLogFileFromEnv(): string | undefined {
+  return typeof process.env.AGENT_RELAY_LOG_FILE === "string" ? process.env.AGENT_RELAY_LOG_FILE : undefined;
+}
+
+export function orchestratorUrlFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_ORCHESTRATOR_URL;
+}
+
+export function contextStateDirFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_CONTEXT_STATE_DIR;
+}
+
+export function attachmentCacheDirFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_ATTACHMENT_CACHE_DIR;
+}
+
+export function providerHomeRootFromEnv(): string {
+  return process.env.AGENT_RELAY_PROVIDER_HOME_ROOT || join(homedir(), ".agent-relay", "provider-homes");
+}
+
+export function messageBodyMaxCharsFromEnv(): string | undefined {
+  return process.env.AGENT_RELAY_MESSAGE_BODY_MAX_CHARS;
+}
+
 export function loadProviderConfig(provider: string, home = agentRelayHome()): LoadedProviderConfig {
   const path = join(providersDir(home), `${provider}.json`);
   const raw = readJson(path);

package/src/index.ts

@@ -3,7 +3,24 @@ import { hostname } from "node:os";
 import { basename } from "node:path";
 import { isatty } from "node:tty";
 import { AgentRunner } from "./runner";
-import { loadGlobalConfig, loadProviderConfigFromRelay, resolveCwd, runnerId } from "./config";
+import {
+  agentProfileJsonFromEnv,
+  agentProfileNameFromEnv,
+  automationIdFromEnv,
+  automationRunIdFromEnv,
+  lifecycleFromEnv,
+  loadGlobalConfig,
+  loadProviderConfigFromRelay,
+  policyNameFromEnv,
+  resolveCwd,
+  runnerId,
+  runtimeTokenExpiresAtFromEnv,
+  runtimeTokenJtiFromEnv,
+  runtimeTokenProfileFromEnv,
+  spawnRequestIdFromEnv,
+  tmuxSessionFromEnv,
+  workspaceJsonFromEnv,
+} from "./config";
 import { createProviderAdapter } from "./providers";
 import { VERSION } from "./version";
 import type { AgentProfile, SpawnProvider, WorkspaceMetadata } from "agent-relay-sdk";
@@ -49,9 +66,9 @@ export async function main(argv = process.argv): Promise<void> {
     interactive: opts.interactive,
     relayUrl,
     token: opts.token ?? globalConfig.token,
-    runtimeTokenProfile: process.env.AGENT_RELAY_TOKEN_PROFILE,
-    runtimeTokenJti: process.env.AGENT_RELAY_TOKEN_JTI,
-    runtimeTokenExpiresAt: parseTokenExpiresAt(process.env.AGENT_RELAY_TOKEN_EXPIRES_AT),
+    runtimeTokenProfile: runtimeTokenProfileFromEnv(),
+    runtimeTokenJti: runtimeTokenJtiFromEnv(),
+    runtimeTokenExpiresAt: parseTokenExpiresAt(runtimeTokenExpiresAtFromEnv()),
     provider: opts.provider,
     cwd,
     runnerId: id,
@@ -84,20 +101,20 @@ export async function main(argv = process.argv): Promise<void> {
     approvalMode,
     label: opts.label,
     rig: opts.rig,
-    profile: opts.profile ?? process.env.AGENT_RELAY_AGENT_PROFILE,
-    agentProfile: parseAgentProfileEnv(process.env.AGENT_RELAY_AGENT_PROFILE_JSON),
-    workspace: parseWorkspaceEnv(process.env.AGENT_RELAY_WORKSPACE_JSON),
+    profile: opts.profile ?? agentProfileNameFromEnv(),
+    agentProfile: parseAgentProfileEnv(agentProfileJsonFromEnv()),
+    workspace: parseWorkspaceEnv(workspaceJsonFromEnv()),
     prompt: opts.prompt,
     systemPromptAppend: opts.systemPromptAppend,
-    tmuxSession: process.env.AGENT_RELAY_TMUX_SESSION,
+    tmuxSession: tmuxSessionFromEnv(),
     tags: opts.tags,
     capabilities: opts.caps,
     providerArgs: opts.providerArgs,
-    policyName: process.env.AGENT_RELAY_POLICY,
-    spawnRequestId: process.env.AGENT_RELAY_SPAWN_REQUEST_ID,
-    automationId: process.env.AGENT_RELAY_AUTOMATION_ID,
-    automationRunId: process.env.AGENT_RELAY_AUTOMATION_RUN_ID,
-    lifecycle: normalizeAgentLifecycle(process.env.AGENT_RELAY_LIFECYCLE) ?? "persistent",
+    policyName: policyNameFromEnv(),
+    spawnRequestId: spawnRequestIdFromEnv(),
+    automationId: automationIdFromEnv(),
+    automationRunId: automationRunIdFromEnv(),
+    lifecycle: normalizeAgentLifecycle(lifecycleFromEnv()) ?? "persistent",
     startedAt: Date.now(),
     providerConfig,
     adapter,

package/src/logger.ts

@@ -1,6 +1,7 @@
 import { appendFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { sanitizeFsName } from "agent-relay-sdk/fs-name";
+import { logLevelFromEnv } from "./config";
 
 // Phase 1 observability (#198): one leveled, runtime-togglable logger for the
 // Runner and the provider adapters below it. Replaces the ad-hoc scatter of
@@ -47,7 +48,7 @@ export class Logger {
   private logDir: string;
 
   constructor(config: LoggerConfig = {}) {
-    this.level = config.level ?? parseLogLevel(process.env.AGENT_RELAY_LOG_LEVEL) ?? "info";
+    this.level = config.level ?? parseLogLevel(logLevelFromEnv()) ?? "info";
     this.agentId = config.agentId ?? "runner";
     this.headless = config.headless ?? false;
     this.logDir = config.logDir ?? join(process.env.HOME || ".", ".agent-relay", "logs");

package/src/mcp-outbox.ts

@@ -0,0 +1,86 @@
+import type { SendMessageInput } from "agent-relay-sdk";
+import type { RelayHttpClient } from "agent-relay-sdk";
+import { relayMcpEndpoint } from "./relay-mcp";
+import type { OutboxRecord } from "./outbox";
+import { deliverContinuationArchiveRecord } from "./continuation-archive";
+import { logger } from "./logger";
+import { isHttpAuthError, isHttpStatusError } from "./runner-helpers";
+
+interface RunnerOutboxDelivery {
+  record: OutboxRecord;
+  http: RelayHttpClient;
+  relayUrl: string;
+  token?: string;
+  updatePayload(seq: number, payload: unknown): void;
+  sessionLog(message: string): void;
+  recoverRuntimeTokenAfterAuthFailure(source: string): void;
+}
+
+export async function deliverRunnerOutboxEvent(input: RunnerOutboxDelivery): Promise<void> {
+  const { record, http } = input;
+  try {
+    if (record.kind === "session-message") {
+      await http.sendMessage({
+        ...(record.payload as SendMessageInput),
+        occurredAt: record.occurredAt,
+        idempotencyKey: record.idempotencyKey,
+      });
+      return;
+    }
+    if (record.kind === "insight") {
+      await http.recordInsightObservation({
+        ...(record.payload as Parameters<RelayHttpClient["recordInsightObservation"]>[0]),
+        occurredAt: record.occurredAt,
+      });
+      return;
+    }
+    if (record.kind === "continuation-archive") {
+      await deliverContinuationArchiveRecord({
+        record,
+        http,
+        updatePayload: input.updatePayload,
+        sessionLog: input.sessionLog,
+      });
+      return;
+    }
+    if (record.kind === "mcp-tool-call") {
+      await deliverBufferedMcpCall(input);
+      return;
+    }
+    logger.warn("outbox", `dropping event with unknown kind: ${record.kind}`);
+  } catch (error) {
+    if (isHttpStatusError(error, 409)) return;
+    if (isHttpAuthError(error)) input.recoverRuntimeTokenAfterAuthFailure("outbox");
+    throw error;
+  }
+}
+
+export async function deliverBufferedMcpCall(input: {
+  record: OutboxRecord;
+  relayUrl: string;
+  token?: string;
+  recoverRuntimeTokenAfterAuthFailure(source: string): void;
+}): Promise<void> {
+  const payload = input.record.payload as { tool: string; arguments: Record<string, unknown> };
+  const headers: Record<string, string> = { "content-type": "application/json" };
+  if (input.token) headers.authorization = `Bearer ${input.token}`;
+  const response = await fetch(relayMcpEndpoint(input.relayUrl), {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/call", params: { name: payload.tool, arguments: payload.arguments } }),
+  });
+  if (response.status === 401 || response.status === 403) {
+    input.recoverRuntimeTokenAfterAuthFailure("mcp-outbox");
+    throw new Error(`relay rejected buffered ${payload.tool} with ${response.status}`);
+  }
+  if (response.status >= 500) throw new Error(`relay ${response.status} on buffered ${payload.tool}`);
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    logger.warn("mcp-outbox", `buffered ${payload.tool} permanently rejected (${response.status}); dropping: ${body.slice(0, 200)}`);
+    return;
+  }
+  const json = await response.json().catch(() => null) as { error?: { message?: string } } | null;
+  if (json?.error) {
+    logger.warn("mcp-outbox", `buffered ${payload.tool} returned a tool error; dropping: ${json.error.message ?? "(no detail)"}`);
+  }
+}

package/src/outbox.ts

@@ -5,6 +5,7 @@ import { tmpdir } from "node:os";
 import { sanitizeFsName } from "agent-relay-sdk/fs-name";
 import { errMessage } from "agent-relay-sdk";
 import { logger } from "./logger";
+import { runnerOutboxDirFromEnv } from "./config";
 
 // Phase 2 (#196) — the "nothing is ever lost" half. Runner→server events that used to be
 // fire-and-forget over HTTP (session turns, reasoning/tool traces, prompt echoes, insights,
@@ -112,7 +113,7 @@ export class Outbox {
     this.maxBackoffMs = options.maxBackoffMs ?? DEFAULTS.maxBackoffMs;
     this.pollMs = options.pollMs ?? DEFAULTS.pollMs;
 
-    const dir = options.dir ?? process.env.AGENT_RELAY_RUNNER_OUTBOX_DIR ?? join(tmpdir(), "agent-relay-outbox");
+    const dir = options.dir ?? runnerOutboxDirFromEnv() ?? join(tmpdir(), "agent-relay-outbox");
     this.path = options.dir === ":memory:" ? ":memory:" : join(dir, `outbox-${safeName(this.agentId)}.sqlite`);
     if (this.path !== ":memory:") mkdirSync(dirname(this.path), { recursive: true });
 

package/src/profile-home.ts

@@ -4,6 +4,7 @@ import { join, resolve } from "node:path";
 import { sanitizeFsName } from "agent-relay-sdk/fs-name";
 import { profileAllowsRelayFeature, type RunnerSpawnConfig } from "./adapter";
 import { CLAUDE_RELAY_MANUAL } from "./relay-instructions";
+import { providerHomeRootFromEnv } from "./config";
 
 type ProviderHome = {
   path: string;
@@ -105,7 +106,7 @@ function readHostClaudeConfig(): Record<string, unknown> | undefined {
 }
 
 function providerHomePath(provider: "claude" | "codex", config: RunnerSpawnConfig): string {
-  const root = process.env.AGENT_RELAY_PROVIDER_HOME_ROOT || join(homedir(), ".agent-relay", "provider-homes");
+  const root = providerHomeRootFromEnv();
   const profileName = sanitizePathPart(config.agentProfile?.name || config.profile || "profile");
   const instance = sanitizePathPart(config.instanceId || config.runnerId);
   return join(root, provider, profileName, instance);

package/src/rate-limit.ts

@@ -14,7 +14,7 @@ export const RATE_LIMIT_BLOCK_REASON = "rate_limit";
 // fall back to the resume sweep's poll window.
 const MAX_RESET_AHEAD_MS = 7 * 24 * 60 * 60 * 1000;
 
-export interface RateLimitHoldInput {
+interface RateLimitHoldInput {
   errorType?: string;
   /** Unix ms the limit window resets, when known. */
   resetAt?: number;
@@ -58,7 +58,7 @@ const LIMIT_PHRASE_RE = /(?:hit (?:your|the)\s*(?:[\w-]+\s+)*limit|usage limit|\
 const RESET_AT_RE = /\bresets?\b(?:\s+at)?\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)?\s*(?:\(([^)]+)\))?/i;
 const TRY_AGAIN_RE = /\btry again in\s+(\d+)\s*(second|minute|hour|day)s?/i;
 
-export interface PaneRateLimit {
+interface PaneRateLimit {
   /** The matched limit line, for the chat notice / observability. */
   message: string;
   /** Unix ms reset, when parseable from the pane (else undefined → resume falls back to poll). */