agent-relay-runner 0.88.0 → 0.88.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-runner",
-  "version": "0.88.0",
+  "version": "0.88.2",
   "description": "Unified provider lifecycle runner for Agent Relay",
   "type": "module",
   "bin": {
@@ -20,7 +20,7 @@
     "directory": "runner"
   },
   "dependencies": {
-    "agent-relay-sdk": "0.2.66"
+    "agent-relay-sdk": "0.2.67"
   },
   "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.88.0",
+  "version": "0.88.2",
   "agentRelayContracts": {
     "providerPluginProtocol": 1
   }

package/src/adapters/claude.ts

@@ -12,7 +12,7 @@ import type { SessionEvent } from "../session-insights";
 import { prepareClaudeProfileHome, profileUsesHostProviderGlobals } from "../profile-home";
 import { assembleLaunch, materializeLaunchAssembly, sessionStatusLineSettingsArgs } from "../launch-assembly";
 import { claudeProviderMessageText } from "./claude-delivery";
-import { buildRateLimitProviderState, parseClaudeRateLimitPane } from "../rate-limit";
+import { buildRateLimitProviderState, gatedClaudeRateLimitStatus, parseClaudeRateLimitPane } from "../rate-limit";
 
 export class ClaudeAdapter implements ProviderAdapter {
   readonly provider = "claude";
@@ -27,6 +27,7 @@ export class ClaudeAdapter implements ProviderAdapter {
   // #286: true while a usage-limit modal is being held, so the pane watcher dismisses
   // it + emits the hold once (not every 2s tick). Cleared when the modal leaves the pane.
   private rateLimitReported = false;
+  private rateLimitPaneDetections = 0;
 
   onStatusChange(cb: (status: ProviderStatusUpdate) => void): void {
     this.statusCb = cb;
@@ -369,25 +370,24 @@ export class ClaudeAdapter implements ProviderAdapter {
         this.statusCb(status);
         return;
       }
-      // #286: the subscription usage-limit modal fires no hook, so detect it from the
-      // pane. Dismiss it (Escape = "wait", which just stops the turn) so the agent
-      // returns to a clean prompt the resume `continue` can land on, then hold it.
-      const rateLimit = claudeRateLimitStatus(pane, sessionName);
-      if (rateLimit) {
-        if (!this.rateLimitReported) {
-          this.rateLimitReported = true;
-          this.dismissRateLimitModal(sessionName, socketName);
-          this.statusCb(rateLimit);
-        }
-      } else if (this.rateLimitReported) {
-        // Modal gone (dismissed, or a real turn resumed) — re-arm for the next limit.
-        this.rateLimitReported = false;
+      // #286/#655: the subscription usage-limit modal fires no hook, so detect it
+      // from the pane. Act only after consecutive non-busy detections; a live turn
+      // mentioning quota/reset text must not be escaped or held.
+      const rateLimit = gatedClaudeRateLimitStatus(pane, {
+        consecutiveDetections: this.rateLimitPaneDetections,
+        reported: this.rateLimitReported,
+      }, { sessionName, busy: claudePaneIsBusy(pane) });
+      this.rateLimitPaneDetections = rateLimit.state.consecutiveDetections;
+      this.rateLimitReported = rateLimit.state.reported;
+      if (rateLimit.status) {
+        this.dismissRateLimitModal(sessionName, socketName);
+        this.statusCb(rateLimit.status);
       }
     }, 2000);
   }
 
-  // Send Escape to dismiss the usage-limit modal — the "wait" choice, which stops the
-  // turn (per the CC TUI) and returns the agent to a normal idle prompt. Best-effort:
+  // Send Escape to dismiss the confirmed usage-limit modal — the "wait" choice,
+  // which returns the agent to a normal idle prompt. Best-effort:
   // a failed send-keys must never wedge the pane watcher.
   private dismissRateLimitModal(sessionName: string, socketName?: string): void {
     try {

package/src/claude-quota-harvest.ts

@@ -5,17 +5,21 @@ import { DEFAULT_PROVIDER_QUOTA_CONFIG, normalizeProviderQuotaConfig, resolveCla
 
 const PASSIVE_QUOTA_CONFIG_REFRESH_MS = 60_000;
 const PASSIVE_QUOTA_SAMPLE_STALE_MS = 10 * 60_000;
+const PASSIVE_QUOTA_LEASE_MAX_TTL_MS = 10 * 60_000;
+const PASSIVE_QUOTA_LEASE_PADDING_MS = 60_000;
 
 interface ClaudeQuotaHarvestOptions {
   agentId: string;
   provider: string;
-  http: () => Pick<RelayHttpClient, "getProviderQuotaConfig" | "upsertProviderQuota">;
+  http: () => Pick<RelayHttpClient, "acquireProviderQuotaPublisherLease" | "getProviderQuotaConfig" | "upsertProviderQuota">;
 }
 
 export class ClaudeQuotaHarvest {
   private config = { ...DEFAULT_PROVIDER_QUOTA_CONFIG };
   private configRefreshAt = 0;
   private lastReportAt?: number;
+  private lease?: { accountKey: string; leaseToken: string; expiresAt: number };
+  private nextLeaseAttemptAt?: number;
 
   constructor(private readonly options: ClaudeQuotaHarvestOptions) {}
 
@@ -30,6 +34,7 @@ export class ClaudeQuotaHarvest {
     if (this.lastReportAt !== undefined && now - this.lastReportAt < config.pollIntervalMs) return;
     const identity = await resolveClaudeStatuslineQuotaIdentity({ env: process.env });
     if (!identity) return;
+    if (!await this.ensurePublisherLease(identity.accountKey, config.pollIntervalMs, now)) return;
     await this.options.http().upsertProviderQuota({
       provider: "claude",
       accountKey: identity.accountKey,
@@ -55,6 +60,27 @@ export class ClaudeQuotaHarvest {
     }
     return this.config;
   }
+
+  private async ensurePublisherLease(accountKey: string, pollIntervalMs: number, now: number): Promise<boolean> {
+    if (this.lease?.accountKey === accountKey && this.lease.expiresAt > now) return true;
+    if (this.nextLeaseAttemptAt !== undefined && now < this.nextLeaseAttemptAt) return false;
+    const leaseToken = this.lease?.accountKey === accountKey ? this.lease.leaseToken : undefined;
+    const result = await this.options.http().acquireProviderQuotaPublisherLease({
+      provider: "claude",
+      accountKey,
+      sourceAgentId: this.options.agentId,
+      ...(leaseToken ? { leaseToken } : {}),
+      ttlMs: Math.min(PASSIVE_QUOTA_LEASE_MAX_TTL_MS, pollIntervalMs + PASSIVE_QUOTA_LEASE_PADDING_MS),
+    });
+    if (!result.acquired || !result.lease) {
+      this.lease = undefined;
+      this.nextLeaseAttemptAt = now + Math.min(result.retryAfterMs ?? pollIntervalMs, pollIntervalMs);
+      return false;
+    }
+    this.lease = { accountKey, leaseToken: result.lease.leaseToken, expiresAt: result.lease.expiresAt };
+    this.nextLeaseAttemptAt = undefined;
+    return true;
+  }
 }
 
 function freshQuotaFromProbeMetrics(metrics: NonNullable<ReturnType<typeof readRunnerContextProbeState>>, now: number): QuotaState | undefined {

package/src/rate-limit.ts

@@ -1,4 +1,5 @@
 // #286 — shared rate-limit hold construction + Claude pane detection.
+import type { ProviderStatusUpdate } from "./adapter";
 //
 // Two detection arms feed the SAME provider-neutral `blocked` hold:
 //   1. The StopFailure hook (clean API-error turn-end: API-429/auth/billing) → control-server.
@@ -94,6 +95,37 @@ export function parseClaudeRateLimitPane(text: string, nowMs: number = Date.now(
   return null;
 }
 
+export interface ClaudeRateLimitPaneGateState {
+  consecutiveDetections: number;
+  reported: boolean;
+}
+
+export function gatedClaudeRateLimitStatus(
+  text: string,
+  state: ClaudeRateLimitPaneGateState,
+  options: { sessionName?: string; busy?: boolean } = {},
+): { status: ProviderStatusUpdate | null; state: ClaudeRateLimitPaneGateState } {
+  const parsed = parseClaudeRateLimitPane(text);
+  if (!parsed) return { status: null, state: { consecutiveDetections: 0, reported: false } };
+  if (options.busy) return { status: null, state: { consecutiveDetections: 0, reported: state.reported } };
+  const nextState = { consecutiveDetections: state.consecutiveDetections + 1, reported: state.reported };
+  if (nextState.reported || nextState.consecutiveDetections < 2) return { status: null, state: nextState };
+  nextState.reported = true;
+  return {
+    status: {
+      status: "idle",
+      clear: ["subagent"],
+      providerState: buildRateLimitProviderState({
+        errorType: "session_limit",
+        ...(parsed.resetAt ? { resetAt: parsed.resetAt } : {}),
+        message: parsed.message,
+        source: options.sessionName ? `claude-pane:${options.sessionName}` : "claude-pane",
+      }),
+    },
+    state: nextState,
+  };
+}
+
 // The clean limit line containing the match offset, stripped of box-drawing chrome.
 function limitLineAt(text: string, index: number): string {
   const start = text.lastIndexOf("\n", index) + 1;

package/src/runner-core.ts

@@ -264,6 +264,7 @@ export class AgentRunner {
   // providerState; it clears when a new turn starts (the relay's resume message
   // wakes one) so the blocked badge lifts on its own.
   private rateLimitHold?: Record<string, unknown>;
+  private pendingRateLimitHold?: Record<string, unknown>;
   // Reasoning tailer (item 5): streams the in-flight turn's reasoning/tool steps
   // from the Claude transcript into chat as discreet session events.
   private reasoningTail?: ReasoningTailState;
@@ -1150,16 +1151,28 @@ export class AgentRunner {
         ...(update.timeline.metadata ? { metadata: update.timeline.metadata } : {}),
       };
     }
+    let deferredRateLimitHold = false;
     if (typeof update !== "string" && update.providerState) {
-      const ps = update.providerState as { state?: unknown; reason?: unknown };
-      this.providerBlocked = ps.state === "blocked";
+      const ps = update.providerState as { state?: unknown; reason?: unknown; source?: unknown };
       // A rate-limit hold persists across the idle the turn ends on; any other
       // providerState supersedes it (clears a stale hold).
       if (ps.state === "blocked" && ps.reason === "rate_limit") {
-        const fresh = !this.rateLimitHold;
-        this.rateLimitHold = update.providerState;
-        if (fresh) this.publishRateLimitNotice(update.providerState);
+        const paneRateLimitHold = typeof ps.source === "string" && ps.source.startsWith("claude-pane");
+        if (status === "idle" && reason === "provider-turn" && paneRateLimitHold && this.claims.activeWork().some((work) => work.kind === "provider-turn")) {
+          this.pendingRateLimitHold = update.providerState;
+          this.providerBlocked = false;
+          deferredRateLimitHold = true;
+          this.sessionLog(`rate-limit hold deferred until active turn finishes (turn ${this.currentTurnId ?? "?"})`);
+        } else {
+          this.providerBlocked = true;
+          this.pendingRateLimitHold = undefined;
+          const fresh = !this.rateLimitHold;
+          this.rateLimitHold = update.providerState;
+          if (fresh) this.publishRateLimitNotice(update.providerState);
+        }
       } else {
+        this.providerBlocked = ps.state === "blocked";
+        this.pendingRateLimitHold = undefined;
         this.rateLimitHold = undefined;
       }
     } else if (status === "idle") {
@@ -1167,6 +1180,13 @@ export class AgentRunner {
     }
     // Forward progress (a real turn) lifts the hold so the blocked badge clears.
     if (status === "busy") this.rateLimitHold = undefined;
+    if (deferredRateLimitHold) {
+      if (typeof update !== "string") {
+        for (const kind of update.clear ?? []) this.claims.clearWorkKind(kind);
+      }
+      this.publishStatus();
+      return;
+    }
     if (typeof update !== "string" && status === "error") {
       const terminalReason = typeof update.metadata?.terminalFailureReason === "string"
         ? update.metadata.terminalFailureReason
@@ -1253,6 +1273,14 @@ export class AgentRunner {
     if (status === "idle" && this.pendingInitialPrompt && !this.deliveringInitialPrompt) {
       void this.attemptInitialPromptDelivery(this.pendingInitialPrompt, INITIAL_PROMPT_RETRY_READY_TIMEOUT_MS);
     }
+    if (status === "idle" && this.pendingRateLimitHold && !this.claims.activeWork().some((work) => work.kind === "provider-turn")) {
+      const hold = this.pendingRateLimitHold;
+      this.pendingRateLimitHold = undefined;
+      this.providerBlocked = true;
+      const fresh = !this.rateLimitHold;
+      this.rateLimitHold = hold;
+      if (fresh) this.publishRateLimitNotice(hold);
+    }
     this.publishStatus();
   }