agent-relay-runner 0.119.0 → 0.119.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-runner",
-  "version": "0.119.0",
+  "version": "0.119.1",
   "description": "Unified provider lifecycle runner for Agent Relay",
   "type": "module",
   "bin": {
@@ -20,8 +20,8 @@
     "directory": "runner"
   },
   "dependencies": {
-    "agent-relay-providers": "0.104.1",
-    "agent-relay-sdk": "0.2.102",
+    "agent-relay-providers": "0.104.2",
+    "agent-relay-sdk": "0.2.103",
     "callmux": "0.23.0"
   },
   "devDependencies": {

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.119.0",
+  "version": "0.119.1",
   "agentRelayContracts": {
     "providerPluginProtocol": 1
   }

package/plugins/claude/claude-statusline-probe.cjs

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+"use strict";
+
+const { mkdirSync, renameSync, writeFileSync } = require("node:fs");
+const { tmpdir } = require("node:os");
+const { basename, dirname, join } = require("node:path");
+
+let input = "";
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", (chunk) => { input += chunk; });
+process.stdin.on("end", () => {
+  const metrics = parseClaudeStatusLineInput(input);
+  if (metrics) writeState(metrics);
+  process.stdout.write(`${standaloneOutput(metrics)}\n`);
+});
+
+function parseClaudeStatusLineInput(raw) {
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!isRecord(data) || !isRecord(data.context_window)) return null;
+  const context = data.context_window;
+  const timestamp = Date.now();
+  const contextPercent = numberValue(context.used_percentage);
+  const tokensMax = numberValue(context.context_window_size);
+  const usage = isRecord(context.current_usage) ? context.current_usage : undefined;
+  const tokensUsed = sumNumbers(
+    usage && usage.input_tokens,
+    usage && usage.cache_creation_input_tokens,
+    usage && usage.cache_read_input_tokens,
+  );
+  if (contextPercent === undefined && tokensUsed === undefined) return null;
+
+  const rateLimits = isRecord(data.rate_limits) ? data.rate_limits : undefined;
+  const fiveHour = isRecord(rateLimits && rateLimits.five_hour) ? rateLimits.five_hour : undefined;
+  const quotaWindows = quotaWindowsFromRateLimits(rateLimits);
+  const model = stringValue(data.model) || stringValue(process.env.CLAUDE_MODEL);
+  const effort = isRecord(data.effort) ? stringValue(data.effort.level) : stringValue(data.effort);
+  const resolvedEffort = effort || stringValue(process.env.CLAUDE_EFFORT) || stringValue(process.env.CLAUDE_CODE_EFFORT_LEVEL);
+
+  const metrics = {
+    agentId: stringValue(process.env.AGENT_RELAY_AGENT_ID) || stringValue(process.env.AGENT_RELAY_ID) || stringValue(data.session_id) || "unknown",
+    contextPercent: contextPercent !== undefined ? contextPercent : ((tokensUsed || 0) / (tokensMax || 1)) * 100,
+    source: "statusline",
+    confidence: "exact",
+    timestamp,
+  };
+  if (tokensUsed !== undefined) metrics.tokensUsed = tokensUsed;
+  if (tokensMax !== undefined) metrics.tokensMax = tokensMax;
+  const quotaUsed = numberValue(fiveHour && fiveHour.used_percentage);
+  if (quotaUsed !== undefined) metrics.quotaUsed = quotaUsed;
+  const quotaResetIn = secondsUntil(numberValue(fiveHour && fiveHour.resets_at), timestamp);
+  if (quotaResetIn !== undefined) metrics.quotaResetIn = quotaResetIn;
+  if (quotaWindows.length > 0) metrics.quotaWindows = quotaWindows;
+  if (model) metrics.model = model;
+  if (resolvedEffort) metrics.effort = resolvedEffort;
+  metrics.contextPercent = Math.max(0, Math.min(100, metrics.contextPercent));
+  return metrics;
+}
+
+function writeState(metrics) {
+  const file = join(process.env.AGENT_RELAY_CONTEXT_STATE_DIR || tmpdir(), `agent-relay-context-${safeStateId(metrics.agentId)}.json`);
+  mkdirSync(dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify(metrics, null, 2));
+  renameSync(tmp, file);
+}
+
+function quotaWindowsFromRateLimits(rateLimits) {
+  const windows = [];
+  for (const name of ["five_hour", "seven_day", "seven_day_sonnet", "seven_day_opus"]) {
+    const raw = isRecord(rateLimits && rateLimits[name]) ? rateLimits[name] : undefined;
+    const usedPercentage = numberValue(raw && raw.used_percentage);
+    if (usedPercentage === undefined) continue;
+    const window = { name, utilization: usedPercentage / 100, unit: "%" };
+    const resetsAt = epochSecondsToMs(numberValue(raw && raw.resets_at));
+    if (resetsAt !== undefined) window.resetsAt = resetsAt;
+    windows.push(window);
+  }
+  return windows;
+}
+
+function standaloneOutput(metrics) {
+  if (!metrics) return "agent-relay context: unavailable";
+  const pct = Math.round(metrics.contextPercent);
+  const tokens = metrics.tokensUsed && metrics.tokensMax ? ` ${formatTokens(metrics.tokensUsed)}/${formatTokens(metrics.tokensMax)}` : "";
+  return `agent-relay context: ${pct}%${tokens}`;
+}
+
+function formatTokens(tokens) {
+  if (tokens >= 1000000) return `${(tokens / 1000000).toFixed(1)}M`;
+  if (tokens >= 1000) return `${Math.round(tokens / 1000)}K`;
+  return String(tokens);
+}
+
+function safeStateId(agentId) {
+  const safe = basename(agentId).replace(/[^\w.-]/g, "-");
+  return safe || "unknown";
+}
+
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function stringValue(value) {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+function sumNumbers(...values) {
+  let total = 0;
+  let seen = false;
+  for (const value of values) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+      total += value;
+      seen = true;
+    }
+  }
+  return seen ? total : undefined;
+}
+
+function secondsUntil(epochSeconds, nowMs) {
+  return epochSeconds === undefined ? undefined : Math.max(0, Math.round(epochSeconds - nowMs / 1000));
+}
+
+function epochSecondsToMs(epochSeconds) {
+  return epochSeconds === undefined ? undefined : epochSeconds * 1000;
+}

package/plugins/claude/monitors/relay-monitor.provisioned.mjs

@@ -71,7 +71,7 @@ var claudeProviderManifest = {
     }
   },
   catalog: {
-    defaultModel: "sonnet-4.6",
+    defaultModel: "sonnet-5",
     models: [
       { alias: "fable-5", label: "Fable 5", providerModel: "claude-fable-5", efforts: CLAUDE_LOW_TO_XHIGH_MAX, defaultEffort: "medium", unavailable: "suspended by export-control directive, 2026-06-12", ...codeModel({ contextWindowTokens: CONTEXT_1M }) },
       { alias: "opus-4.8", label: "Opus 4.8", providerModel: "claude-opus-4-8", efforts: CLAUDE_LOW_TO_XHIGH_MAX, defaultEffort: "medium", ...codeModel({ contextWindowTokens: CONTEXT_200K }) },
@@ -80,8 +80,8 @@ var claudeProviderManifest = {
       { alias: "opus-4.7[1m]", label: "Opus 4.7 1M", providerModel: "claude-opus-4-7[1m]", efforts: CLAUDE_LOW_TO_XHIGH_MAX, defaultEffort: "medium", ...codeModel({ contextWindowTokens: CONTEXT_1M }) },
       { alias: "opus-4.6", label: "Opus 4.6", providerModel: "claude-opus-4-6", efforts: CLAUDE_LOW_TO_MAX, defaultEffort: "medium", ...codeModel({ contextWindowTokens: CONTEXT_200K }) },
       { alias: "opus-4.6[1m]", label: "Opus 4.6 1M", providerModel: "claude-opus-4-6[1m]", efforts: CLAUDE_LOW_TO_MAX, defaultEffort: "medium", ...codeModel({ contextWindowTokens: CONTEXT_1M }) },
-      { alias: "sonnet-4.6", label: "Sonnet 4.6", providerModel: "claude-sonnet-4-6", efforts: CLAUDE_LOW_TO_MAX, defaultEffort: "medium", ...codeModel({ contextWindowTokens: CONTEXT_200K }) },
-      { alias: "sonnet-4.6[1m]", label: "Sonnet 4.6 1M", providerModel: "claude-sonnet-4-6[1m]", efforts: CLAUDE_LOW_TO_MAX, defaultEffort: "medium", ...codeModel({ contextWindowTokens: CONTEXT_1M }) },
+      { alias: "sonnet-5", label: "Sonnet 5", providerModel: "claude-sonnet-5", efforts: CLAUDE_LOW_TO_XHIGH_MAX, defaultEffort: "medium", ...codeModel({ contextWindowTokens: CONTEXT_200K }) },
+      { alias: "sonnet-5[1m]", label: "Sonnet 5 1M", providerModel: "claude-sonnet-5[1m]", efforts: CLAUDE_LOW_TO_XHIGH_MAX, defaultEffort: "medium", ...codeModel({ contextWindowTokens: CONTEXT_1M }) },
       { alias: "haiku", label: "Haiku", providerModel: "haiku", efforts: [], ...codeModel() }
     ]
   },

package/src/launch-assembly.ts

@@ -1,6 +1,7 @@
 import { existsSync, readdirSync } from "node:fs";
 import { resolve, join } from "node:path";
 import type { AgentProfile, AgentProfileBase, ProvisioningMcpServer, SpawnProvider } from "agent-relay-sdk";
+import { shellQuote } from "agent-relay-sdk/shell-utils";
 import {
   profileAllowsRelayFeature,
   profileIsVanillaBase,
@@ -186,11 +187,15 @@ export function sessionStatusLineSettingsArgs(...argLists: string[][]): string[]
 
 function relayStatusLineSettings(): Record<string, unknown> {
   return {
-    statusLine: { type: "command", command: "agent-relay context-probe --wrap", refreshInterval: 30 },
+    statusLine: { type: "command", command: `node ${shellQuote(claudeStatusLineProbePath())}`, refreshInterval: 30 },
     showThinkingSummaries: true,
   };
 }
 
+function claudeStatusLineProbePath(): string {
+  return resolve(import.meta.dir, "../plugins/claude/claude-statusline-probe.cjs");
+}
+
 function claudeSettingsArgs(
   projectSettings: Record<string, unknown>,
   includeStatusLine: boolean,

package/src/runner-core.ts

@@ -125,6 +125,8 @@ const REACTIVE_TOKEN_RECOVERY_DEBOUNCE_MS = 10_000;
 const UNEXPECTED_EXIT_WINDOW_MS = 2 * 60 * 1000;
 const RAPID_EXIT_MS = 30 * 1000;
 const MAX_RAPID_UNEXPECTED_EXITS = 3;
+const UNDETERMINED_PROVIDER_EXIT_CONFIRM_MS = 1_500;
+const PROVIDER_EXIT_CONFIRM_POLL_MS = 250;
 // A UserPromptSubmit echo matching a runner-injected prompt within this window is
 // the same prompt arriving back from the provider — drop it to avoid a duplicate.
 const PROMPT_ECHO_DEDUP_MS = 30_000;
@@ -996,39 +998,67 @@ export class AgentRunner {
 
       if (this.shouldStopUnexpectedProviderExit(diagnostics)) {
         const hasResumeId = typeof diagnostics.claudeResumeId === "string" && diagnostics.claudeResumeId.length > 0;
-        logger.warn("lifecycle", `${this.options.provider} exited; leaving agent offline for manual recovery`);
-        this.publishRunnerTimelineEvent({
-          status: "provider.restart_decision",
-          id: `provider-restart-decision-${this.providerSessionId}-${now}`,
-          timestamp: Date.now(),
-          title: "Provider restart skipped",
-          body: hasResumeId
-            ? "Claude exited; runner will not auto-resume. Resume id captured for manual recovery."
-            : "Claude exited; runner will not restart automatically.",
-          icon: "ti-player-stop",
-          metadata: {
-            eventType: "provider.restart_decision",
-            decision: "stop-surface",
+        if (!hasResumeId) {
+          const recoveredStatus = await this.recoveredStatusAfterUndeterminedProviderExit();
+          if (recoveredStatus) {
+            logger.warn("lifecycle", `${this.options.provider} exit signal recovered as ${recoveredStatus}; suppressing terminal exit`);
+            this.publishRunnerTimelineEvent({
+              status: "provider.restart_decision",
+              id: `provider-restart-decision-${this.providerSessionId}-${now}`,
+              timestamp: Date.now(),
+              title: "Provider exit suppressed",
+              body: `${this.options.provider} reported ${recoveredStatus} during exit confirmation; runner kept the provider live.`,
+              icon: "ti-player-play",
+              metadata: {
+                eventType: "provider.restart_decision",
+                decision: "suppress-recovered",
+                reason: "undetermined-provider-exit-recovered",
+                recoveredStatus,
+                confirmWindowMs: UNDETERMINED_PROVIDER_EXIT_CONFIRM_MS,
+                ...diagnostics,
+              },
+            });
+            this.setProviderStatus(recoveredStatus);
+            return;
+          }
+        }
+        if (!hasResumeId && this.shouldRestartRecoverableProviderExit(diagnostics)) {
+          logger.warn("lifecycle", `${this.options.provider} exit signal is early/recoverable; allowing fresh restart`);
+        } else {
+          logger.warn("lifecycle", `${this.options.provider} exited; leaving agent offline for manual recovery`);
+          this.publishRunnerTimelineEvent({
+            status: "provider.restart_decision",
+            id: `provider-restart-decision-${this.providerSessionId}-${now}`,
+            timestamp: Date.now(),
+            title: "Provider restart skipped",
+            body: hasResumeId
+              ? "Claude exited; runner will not auto-resume. Resume id captured for manual recovery."
+              : "Claude exited; runner will not restart automatically.",
+            icon: "ti-player-stop",
+            metadata: {
+              eventType: "provider.restart_decision",
+              decision: "stop-surface",
+              reason: hasResumeId ? "claude-exit-manual-resume-available" : "claude-exit-manual-intervention-required",
+              ...diagnostics,
+            },
+          });
+          this.process = undefined;
+          // #633: the runner stays alive (manual-resume hold), so neither the orchestrator tmux-gone
+          // path nor the heartbeat reaper will ever fire. Stamp the terminal marker so the SAME offline
+          // status frame (published by setProviderStatus below) carries it; the server's bus status
+          // handler turns that edge into a terminal `agent.exited` event with a #636 diagnosis.
+          this.terminalProviderExit = {
             reason: hasResumeId ? "claude-exit-manual-resume-available" : "claude-exit-manual-intervention-required",
             ...diagnostics,
-          },
-        });
-        this.process = undefined;
-        // #633: the runner stays alive (manual-resume hold), so neither the orchestrator tmux-gone
-        // path nor the heartbeat reaper will ever fire. Stamp the terminal marker so the SAME offline
-        // status frame (published by setProviderStatus below) carries it; the server's bus status
-        // handler turns that edge into a terminal `agent.exited` event with a #636 diagnosis.
-        this.terminalProviderExit = {
-          reason: hasResumeId ? "claude-exit-manual-resume-available" : "claude-exit-manual-intervention-required",
-          ...diagnostics,
-        };
-        this.setProviderStatus({
-          status,
-          reason: "provider-turn",
-          id: `provider-exit-${this.providerSessionId}`,
-          clear: ["provider-turn", "subagent", "background-script"],
-        });
-        return;
+          };
+          this.setProviderStatus({
+            status,
+            reason: "provider-turn",
+            id: `provider-exit-${this.providerSessionId}`,
+            clear: ["provider-turn", "subagent", "background-script"],
+          });
+          return;
+        }
       }
 
       if (runtimeMs < RAPID_EXIT_MS && recent.length > MAX_RAPID_UNEXPECTED_EXITS) {
@@ -1094,6 +1124,28 @@ export class AgentRunner {
     return getManifest(this.options.provider)?.launch?.managedPolicyPrompt?.alwaysOn === "append-system-prompt" && diagnostics.exitCommandInProgress !== true;
   }
 
+  private shouldRestartRecoverableProviderExit(diagnostics: Record<string, unknown>): boolean {
+    return diagnostics.exitSource === "tmux-session-ended"
+      && typeof diagnostics.runtimeMs === "number"
+      && diagnostics.runtimeMs >= 0
+      && diagnostics.runtimeMs < RAPID_EXIT_MS;
+  }
+
+  private async recoveredStatusAfterUndeterminedProviderExit(): Promise<"busy" | "idle" | undefined> {
+    if (!this.process || !this.options.adapter.probeActivity) return undefined;
+    const deadline = Date.now() + UNDETERMINED_PROVIDER_EXIT_CONFIRM_MS;
+    do {
+      const activity = await this.options.adapter.probeActivity(this.process).catch((error) => {
+        this.sessionLog(`provider-exit confirmation probe failed: ${errMessage(error)}`);
+        return "unknown" as const;
+      });
+      if (activity === "busy" || activity === "idle") return activity;
+      if (Date.now() >= deadline) return undefined;
+      await Bun.sleep(PROVIDER_EXIT_CONFIRM_POLL_MS);
+    } while (!this.stopped && !this.exitCommandInProgress);
+    return undefined;
+  }
+
   private async shutdownProvider(hard: boolean, timeoutMs = this.options.providerConfig.headless.shutdownTimeoutMs): Promise<void> {
     this.lifecycleAction = hard ? "killing" : "shutting-down";
     this.publishStatus();