agent-relay-runner 0.91.1 → 0.91.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-runner",
-  "version": "0.91.1",
+  "version": "0.91.3",
   "description": "Unified provider lifecycle runner for Agent Relay",
   "type": "module",
   "bin": {

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

package/plugins/claude/hooks/stop-failure.sh

@@ -10,15 +10,27 @@ error="$(relay_json_string_field error_type "$payload")"
 [ -z "$error" ] && error="$(relay_json_string_field error "$payload")"
 reset_time="$(relay_json_number_field reset_time "$payload")"
 error_message="$(relay_json_string_field error_message "$payload")"
+[ -z "$error_message" ] && error_message="$(relay_json_string_field error_details "$payload")"
+[ -z "$error_message" ] && error_message="$(relay_json_string_field last_assistant_message "$payload")"
 
 # #286: a usage/rate-limit stall is transient and time-bounded — hold the agent
 # (providerState blocked) and auto-resume at reset, instead of silently going idle.
 # The disambiguator for billing_error is reset_time: a subscription rolling-window
 # limit carries one (and is auto-resumable); true credit exhaustion does not (fatal).
 case "$error" in
-  rate_limit|overloaded)
+  rate_limit|overloaded|server_error|api_error)
     relay_post_rate_limit "$error" "$reset_time" "$error_message"
     ;;
+  unknown)
+    case "$error_message" in
+      *"529"*|*"Overloaded"*|*"overloaded"*|*"temporar"*|*"server-side"*|*"server error"*)
+        relay_post_rate_limit "$error" "$reset_time" "$error_message"
+        ;;
+      *)
+        relay_post_status_clearing_subagents idle
+        ;;
+    esac
+    ;;
   billing_error)
     case "$reset_time" in
       ''|*[!0-9]*) relay_post_status_clearing_subagents error ;;

package/src/adapters/claude.ts

@@ -559,7 +559,7 @@ export function claudeRateLimitStatus(text: string, sessionName?: string): Provi
     status: "idle",
     clear: ["subagent"],
     providerState: buildRateLimitProviderState({
-      errorType: "session_limit",
+      errorType: parsed.errorType ?? "session_limit", kind: parsed.kind ?? "usage_limit",
       ...(parsed.resetAt ? { resetAt: parsed.resetAt } : {}),
       message: parsed.message,
       source: sessionName ? `claude-pane:${sessionName}` : "claude-pane",

package/src/config.ts

@@ -99,6 +99,11 @@ export function registrationTimeoutMsFromEnv(): number {
   return Number.isFinite(parsed) && parsed > 0 ? parsed : 60_000;
 }
 
+export function nativeSelfResumeTimeoutMsFromEnv(): number {
+  const parsed = Number(process.env.AGENT_RELAY_NATIVE_SELF_RESUME_TIMEOUT_MS);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 120_000;
+}
+
 export function agentProfileNameFromEnv(): string | undefined {
   return process.env.AGENT_RELAY_AGENT_PROFILE;
 }

package/src/native-self-resume.ts

@@ -0,0 +1,202 @@
+import { errMessage } from "agent-relay-sdk";
+import type { ProviderStatusEvent, SemanticStatus } from "./adapter";
+import { nativeSelfResumeTimeoutMsFromEnv } from "./config";
+
+interface RunnerTimelineEvent {
+  status: string;
+  id?: string;
+  timestamp: number;
+  title?: string;
+  body?: string;
+  icon?: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface NativeSelfResumeHandoff {
+  commandId: string;
+  generation?: number;
+  compactedAt?: number;
+  timer: ReturnType<typeof setTimeout>;
+  resolve: (result: Record<string, unknown>) => void;
+  reject: (error: Error) => void;
+  promise: Promise<Record<string, unknown>>;
+}
+
+export function isNativeSelfResumeCompact(type: string, params: Record<string, unknown>): boolean {
+  if (type !== "agent.compact") return false;
+  const selfResume = params.selfResume;
+  return Boolean(selfResume && typeof selfResume === "object" && !Array.isArray(selfResume) && (selfResume as Record<string, unknown>).mode === "native");
+}
+
+export class NativeSelfResumeTracker {
+  private current?: NativeSelfResumeHandoff;
+
+  get active(): NativeSelfResumeHandoff | undefined {
+    return this.current;
+  }
+
+  begin(commandId: string, params: Record<string, unknown>): NativeSelfResumeHandoff {
+    this.finish(this.current);
+    let resolve!: (result: Record<string, unknown>) => void;
+    let reject!: (error: Error) => void;
+    const promise = new Promise<Record<string, unknown>>((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    const selfResume = params.selfResume && typeof params.selfResume === "object" && !Array.isArray(params.selfResume)
+      ? params.selfResume as Record<string, unknown>
+      : undefined;
+    const generation = typeof selfResume?.generation === "number" ? selfResume.generation : undefined;
+    const timeoutMs = nativeSelfResumeTimeoutMsFromEnv();
+    const handoff: NativeSelfResumeHandoff = {
+      commandId,
+      generation,
+      promise,
+      resolve,
+      reject,
+      timer: setTimeout(() => {
+        if (this.current !== handoff) return;
+        this.current = undefined;
+        reject(new Error(`native self-resume timed out after ${Math.round(timeoutMs / 1000)}s`));
+      }, timeoutMs),
+    };
+    this.current = handoff;
+    return handoff;
+  }
+
+  finish(handoff?: NativeSelfResumeHandoff): void {
+    if (!handoff) return;
+    clearTimeout(handoff.timer);
+    if (this.current === handoff) this.current = undefined;
+  }
+
+  resolve(handoff: NativeSelfResumeHandoff, result: Record<string, unknown>): void {
+    this.finish(handoff);
+    handoff.resolve(result);
+  }
+
+  reject(handoff: NativeSelfResumeHandoff, error: Error): void {
+    this.finish(handoff);
+    handoff.reject(error);
+  }
+
+  noteCompacted(timestamp: number = Date.now()): void {
+    if (!this.current) return;
+    this.current.compactedAt = timestamp;
+  }
+}
+
+interface NativeSelfResumeRecoveryOptions {
+  handoff: NativeSelfResumeHandoff;
+  tracker: NativeSelfResumeTracker;
+  providerSessionId: string;
+  status: SemanticStatus;
+  diagnostics: Record<string, unknown>;
+  now: number;
+  publishTimeline(event: RunnerTimelineEvent): void;
+  setTerminalProviderExit(marker: Record<string, unknown>): void;
+  setProviderStatus(update: ProviderStatusEvent): void;
+  restartProvider(resumeId?: string): Promise<void>;
+  publishStatus(): void;
+  scheduleDrain(): void;
+}
+
+export async function recoverNativeSelfResumeExit(opts: NativeSelfResumeRecoveryOptions): Promise<void> {
+  const resumeId = typeof opts.diagnostics.claudeResumeId === "string" && opts.diagnostics.claudeResumeId.length > 0
+    ? opts.diagnostics.claudeResumeId
+    : undefined;
+  if (opts.handoff.compactedAt && resumeId) {
+    await recoverWithClaudeResume(opts, resumeId);
+    return;
+  }
+  await recoverWithFreshLaunch(opts, resumeId);
+}
+
+async function recoverWithClaudeResume(opts: NativeSelfResumeRecoveryOptions, resumeId: string): Promise<void> {
+  opts.publishTimeline({
+    status: "provider.restart_decision",
+    id: `provider-self-resume-relaunch-${opts.providerSessionId}-${opts.now}`,
+    timestamp: Date.now(),
+    title: "Self-resume relaunching",
+    body: `Claude exited during native self-resume; runner is relaunching with claude --resume ${resumeId}.`,
+    icon: "ti-refresh",
+    metadata: selfResumeMetadata(opts.handoff, opts.diagnostics, {
+      decision: "resume-native-self-resume",
+      reason: "self-resume-exit-after-compact",
+      claudeResumeId: resumeId,
+      compactedAt: opts.handoff.compactedAt,
+    }),
+  });
+  try {
+    await opts.restartProvider(resumeId);
+    opts.publishStatus();
+    opts.scheduleDrain();
+    opts.tracker.resolve(opts.handoff, { recovered: true, via: "claude-resume", claudeResumeId: resumeId });
+  } catch (error) {
+    const message = errMessage(error);
+    opts.setTerminalProviderExit(selfResumeMetadata(opts.handoff, opts.diagnostics, {
+      reason: "self-resume-relaunch-failed",
+      claudeResumeId: resumeId,
+      compactedAt: opts.handoff.compactedAt,
+      lastError: message,
+    }));
+    opts.setProviderStatus({
+      status: "offline",
+      reason: "provider-turn",
+      id: `provider-self-resume-relaunch-failed-${opts.providerSessionId}`,
+      clear: ["provider-turn", "subagent", "background-script"],
+    });
+    opts.tracker.reject(opts.handoff, new Error(`self-resume relaunch failed: ${message}`));
+  }
+}
+
+async function recoverWithFreshLaunch(opts: NativeSelfResumeRecoveryOptions, resumeId?: string): Promise<void> {
+  opts.publishTimeline({
+    status: "provider.restart_decision",
+    id: `provider-self-resume-fresh-launch-${opts.providerSessionId}-${opts.now}`,
+    timestamp: Date.now(),
+    title: "Self-resume fresh-launching",
+    body: "Claude exited during native self-resume before a compacted marker; runner is fresh-launching so Relay can inject the persisted continuation.",
+    icon: "ti-refresh",
+    metadata: selfResumeMetadata(opts.handoff, opts.diagnostics, {
+      decision: "fresh-launch-native-self-resume",
+      reason: "self-resume-exit-before-compact",
+      ...(resumeId ? { claudeResumeId: resumeId } : {}),
+    }),
+  });
+  try {
+    await opts.restartProvider();
+    opts.publishStatus();
+    opts.scheduleDrain();
+    opts.tracker.resolve(opts.handoff, {
+      recovered: true,
+      via: "fresh-launch",
+      ...(resumeId ? { claudeResumeId: resumeId } : {}),
+    });
+  } catch (error) {
+    const message = errMessage(error);
+    opts.setTerminalProviderExit(selfResumeMetadata(opts.handoff, opts.diagnostics, {
+      reason: "self-resume-fresh-launch-failed",
+      ...(resumeId ? { claudeResumeId: resumeId } : {}),
+      lastError: message,
+    }));
+    opts.setProviderStatus({
+      status: "offline",
+      reason: "provider-turn",
+      id: `provider-self-resume-fresh-launch-failed-${opts.providerSessionId}`,
+      clear: ["provider-turn", "subagent", "background-script"],
+    });
+    opts.tracker.reject(opts.handoff, new Error(`self-resume fresh launch failed: ${message}`));
+  }
+}
+
+function selfResumeMetadata(handoff: NativeSelfResumeHandoff, diagnostics: Record<string, unknown>, extra: Record<string, unknown>): Record<string, unknown> {
+  return {
+    eventType: "provider.restart_decision",
+    selfResume: true,
+    selfResumeCommandId: handoff.commandId,
+    selfResumeGeneration: handoff.generation ?? null,
+    ...extra,
+    ...diagnostics,
+  };
+}

package/src/rate-limit.ts

@@ -17,6 +17,7 @@ const MAX_RESET_AHEAD_MS = 7 * 24 * 60 * 60 * 1000;
 
 interface RateLimitHoldInput {
   errorType?: string;
+  kind?: "usage_limit" | "transient_overload";
   /** Unix ms the limit window resets, when known. */
   resetAt?: number;
   message?: string;
@@ -27,12 +28,18 @@ interface RateLimitHoldInput {
 export function buildRateLimitProviderState(input: RateLimitHoldInput): Record<string, unknown> {
   const now = Date.now();
   const resetAt = typeof input.resetAt === "number" && Number.isFinite(input.resetAt) ? input.resetAt : undefined;
-  const label = resetAt ? `usage limit · resets ${formatResetClock(resetAt)}` : "usage limit reached";
+  const kind = input.kind ?? rateLimitKindForError(input.errorType);
+  const label = kind === "transient_overload"
+    ? "provider overloaded"
+    : resetAt ? `usage limit · resets ${formatResetClock(resetAt)}` : "usage limit reached";
   return {
     state: "blocked",
     reason: RATE_LIMIT_BLOCK_REASON,
     label,
-    recommendedAction: "Holding until the usage window resets; agent-relay auto-resumes the agent.",
+    recommendedAction: kind === "transient_overload"
+      ? "Holding briefly for provider overload; agent-relay will retry with bounded backoff."
+      : "Holding until the usage window resets; agent-relay auto-resumes the agent.",
+    kind,
     source: input.source ?? "claude",
     errorType: input.errorType ?? RATE_LIMIT_BLOCK_REASON,
     enteredAt: now,
@@ -42,6 +49,10 @@ export function buildRateLimitProviderState(input: RateLimitHoldInput): Record<s
   };
 }
 
+function rateLimitKindForError(errorType: string | undefined): "usage_limit" | "transient_overload" {
+  return /^(overloaded|server_error|api_error|unknown|529|5\d\d)$/i.test(errorType ?? "") ? "transient_overload" : "usage_limit";
+}
+
 /** Host-local HH:MM for the chat notice / badge label (matches how the CLI shows "resets 3:45pm"). */
 function formatResetClock(resetAtMs: number): string {
   try {
@@ -64,6 +75,9 @@ interface PaneRateLimit {
   message: string;
   /** Unix ms reset, when parseable from the pane (else undefined → resume falls back to poll). */
   resetAt?: number;
+  /** Usage limits wait for reset; transient provider overloads retry quickly. */
+  kind?: "usage_limit" | "transient_overload";
+  errorType?: string;
 }
 
 /**
@@ -75,6 +89,8 @@ interface PaneRateLimit {
  */
 export function parseClaudeRateLimitPane(text: string, nowMs: number = Date.now()): PaneRateLimit | null {
   if (!text) return null;
+  const overload = parseClaudeTransientOverloadPane(text);
+  if (overload) return overload;
   const limit = LIMIT_PHRASE_RE.exec(text);
   if (!limit) return null;
   const message = limitLineAt(text, limit.index);
@@ -95,6 +111,21 @@ export function parseClaudeRateLimitPane(text: string, nowMs: number = Date.now(
   return null;
 }
 
+const TRANSIENT_API_ERROR_RE = /\bAPI Error:\s*((?:5\d\d)|529)\b[^\n]*(?:overload|server-side|temporar|try again|status\.claude\.com)?[^\n]*/i;
+const TRANSIENT_5XX_RE = /\b(?:5(?:00|02|03|04|20|29)|529)\b[^\n]*(?:overload|server-side|temporar|try again|status\.claude\.com)\b[^\n]*/i;
+
+function parseClaudeTransientOverloadPane(text: string): PaneRateLimit | null {
+  const match = TRANSIENT_API_ERROR_RE.exec(text) ?? TRANSIENT_5XX_RE.exec(text);
+  if (!match) return null;
+  const message = limitLineAt(text, match.index);
+  const code = match[1] ?? /\b(5\d\d|529)\b/.exec(match[0])?.[1];
+  return {
+    message: message || match[0].trim(),
+    kind: "transient_overload",
+    errorType: code === "529" ? "overloaded" : "server_error",
+  };
+}
+
 export interface ClaudeRateLimitPaneGateState {
   consecutiveDetections: number;
   reported: boolean;
@@ -116,7 +147,8 @@ export function gatedClaudeRateLimitStatus(
       status: "idle",
       clear: ["subagent"],
       providerState: buildRateLimitProviderState({
-        errorType: "session_limit",
+        errorType: parsed.errorType ?? "session_limit",
+        kind: parsed.kind ?? "usage_limit",
         ...(parsed.resetAt ? { resetAt: parsed.resetAt } : {}),
         message: parsed.message,
         source: options.sessionName ? `claude-pane:${options.sessionName}` : "claude-pane",

package/src/runner-core.ts

@@ -30,6 +30,7 @@ import { runnerLaunchInjectionSessionEvents, type RunnerRelayInjectionEvent } fr
 import { providerTerminalSession, providerTerminalSocket } from "./process-meta";
 import { capsFromEnv, logLevelFromEnv, mcpProxyEnabledFromEnv, orchestratorBaseDirFromEnv, orchestratorUrlFromEnv, registrationTimeoutMsFromEnv, runnerInfoFileFromEnv, runnerLogFileFromEnv, runnerOutboxDirWithInfoFallback, sessionDebugEnabled, tagsFromEnv, workspaceModeFromEnv } from "./config";
 import { boundaryReasonForCommand, PRE_DESTROY_TIMEOUT_MS, reasonExitsRunner, type LifecycleAction, type SessionDestroyReason } from "./session-destroy";
+import { isNativeSelfResumeCompact, NativeSelfResumeTracker, recoverNativeSelfResumeExit } from "./native-self-resume";
 import {
   appliedAgentProfileMetadata,
   commandTimeoutMs,
@@ -38,8 +39,8 @@ import {
   isContextState,
   isHttpAuthError,
   isHttpStatusError,
-  latestClaudeResumeIdFromLogFile,
   lifecycleCapabilities,
+  providerExitDiagnostics,
   providerStateFromActiveWork,
   registerWithinDeadline,
   relayBusUrl,
@@ -198,6 +199,7 @@ export class AgentRunner {
   // terminal `agent.exited` event with a #636 diagnosis instead of the death going silent. Cleared
   // on any genuine restart back to busy/idle.
   private terminalProviderExit?: Record<string, unknown>;
+  private nativeSelfResume = new NativeSelfResumeTracker();
   private exitCommandInProgress = false;
   private restartInProgress = false;
   // Set for the whole unexpected-exit restart, including the pre-restart backoff
@@ -521,7 +523,7 @@ export class AgentRunner {
     return mode === "isolated";
   }
 
-  private async spawnProvider(): Promise<ManagedProcess> {
+  private async spawnProvider(opts: { resumeId?: string; suppressPrompt?: boolean } = {}): Promise<ManagedProcess> {
     this.providerSessionId = crypto.randomUUID();
     this.lastTranscriptPath = undefined;
     const includeProviderGlobals = profileUsesHostProviderGlobals(this.options);
@@ -571,10 +573,10 @@ export class AgentRunner {
       ...(this.options.rig ? { rig: this.options.rig } : {}),
       ...(this.options.profile ? { profile: this.options.profile } : {}),
       ...(this.options.agentProfile ? { agentProfile: this.options.agentProfile } : {}),
-      ...(this.options.prompt ? { prompt: this.options.prompt } : {}),
+      ...(this.options.prompt && !opts.resumeId && !opts.suppressPrompt ? { prompt: this.options.prompt } : {}),
       ...(this.options.systemPromptAppend ? { systemPromptAppend: this.options.systemPromptAppend } : {}),
       ...(this.options.tmuxSession ? { tmuxSession: this.options.tmuxSession } : {}),
-      providerArgs: this.options.providerArgs,
+      providerArgs: opts.resumeId ? [...this.options.providerArgs, "--resume", opts.resumeId] : this.options.providerArgs,
       providerConfig: this.options.providerConfig,
       env,
       controlPort: this.control!.port,
@@ -588,7 +590,7 @@ export class AgentRunner {
         deliver: (messages) => this.control!.deliverToMonitor(messages),
       },
     };
-    const launchSeededPrompt = this.options.adapter.seedsInitialPromptAtLaunch ? this.options.prompt?.trim() : ""; if (launchSeededPrompt) this.recordInjectedPrompt(launchSeededPrompt);
+    const launchSeededPrompt = this.options.adapter.seedsInitialPromptAtLaunch && !opts.resumeId && !opts.suppressPrompt ? this.options.prompt?.trim() : ""; if (launchSeededPrompt) this.recordInjectedPrompt(launchSeededPrompt);
     const managedProcess = await this.options.adapter.spawn(config);
     const injectionEvents = runnerLaunchInjectionSessionEvents({ carried: this.options.relayInjectionEvents, provider: this.options.provider, config, providerConfig: this.options.providerConfig, agentId: this.agentId, providerSessionId: this.providerSessionId });
     for (const event of injectionEvents) {
@@ -744,6 +746,9 @@ export class AgentRunner {
 
     const exitAfterCommand = type === "agent.shutdown" || type === "agent.kill";
     if (exitAfterCommand) this.exitCommandInProgress = true;
+    const nativeSelfResume = isNativeSelfResumeCompact(type, params)
+      ? this.nativeSelfResume.begin(commandId, params)
+      : undefined;
     this.claims.startClaim("command", commandId);
     try {
       await this.updateCommand(commandId, "accepted");
@@ -767,6 +772,10 @@ export class AgentRunner {
         providerResult = await this.options.adapter.compact(this.process, {
           instructions: typeof params.instructions === "string" ? params.instructions : undefined,
         });
+        if (nativeSelfResume) {
+          const handoff = await nativeSelfResume.promise;
+          providerResult = { ...(providerResult ?? {}), nativeSelfResume: handoff };
+        }
       } else if (type === "agent.clearContext") {
         if (!this.options.adapter.clearContext || !this.process) throw new Error("provider does not support clearContext");
         providerResult = await this.options.adapter.clearContext(this.process);
@@ -793,6 +802,7 @@ export class AgentRunner {
         ...(providerResult ? { providerResult } : {}),
       });
     } catch (error) {
+      if (nativeSelfResume) this.nativeSelfResume.finish(nativeSelfResume);
       await this.updateCommand(commandId, "failed", undefined, errMessage(error)).catch(() => {});
     } finally {
       this.claims.finishClaim("command", commandId);
@@ -808,6 +818,7 @@ export class AgentRunner {
           }).finally(() => process.exit(0)), 10);
         }
       } else if (!this.stopped) {
+        if (nativeSelfResume) this.nativeSelfResume.finish(nativeSelfResume);
         this.lifecycleAction = undefined;
         this.publishStatus();
       }
@@ -904,7 +915,7 @@ export class AgentRunner {
     return attachmentText ? `${body}\n\n${attachmentText}` : body;
   }
 
-  private async restartProvider(): Promise<void> {
+  private async restartProvider(opts: { resumeId?: string; suppressPrompt?: boolean } = {}): Promise<void> {
     this.restartInProgress = true;
     try {
       if (this.process) {
@@ -918,7 +929,7 @@ export class AgentRunner {
       this.claims.clearWorkKind("subagent");
       this.claims.clearWorkKind("background-script");
       if (this.stopped) return;
-      this.process = await this.spawnProvider();
+      this.process = await this.spawnProvider(opts);
       this.processStartedAt = Date.now();
     } finally {
       this.restartInProgress = false;
@@ -956,7 +967,7 @@ export class AgentRunner {
       const recent = this.unexpectedExitTimes.filter((time) => now - time <= UNEXPECTED_EXIT_WINDOW_MS);
       recent.push(now);
       this.unexpectedExitTimes.splice(0, this.unexpectedExitTimes.length, ...recent);
-      const diagnostics = this.providerExitDiagnostics(status, runtimeMs);
+      const diagnostics = providerExitDiagnostics({ status, runtimeMs, processMeta: this.process?.meta, hasProcess: Boolean(this.process?.process), exitCommandInProgress: this.exitCommandInProgress, stopped: this.stopped, restartInProgress: this.restartInProgress, restartPending: this.restartPending, headless: this.options.headless, provider: this.options.provider, logFile: runnerLogFileFromEnv() });
 
       this.publishRunnerTimelineEvent({
         status: "provider.exit_detected",
@@ -971,6 +982,12 @@ export class AgentRunner {
         },
       });
 
+      const nativeSelfResume = this.nativeSelfResume.active;
+      if (nativeSelfResume && this.options.provider === "claude") {
+        await recoverNativeSelfResumeExit({ handoff: nativeSelfResume, tracker: this.nativeSelfResume, providerSessionId: this.providerSessionId, status, diagnostics, now, publishTimeline: (event) => this.publishRunnerTimelineEvent(event), setTerminalProviderExit: (marker) => { this.terminalProviderExit = marker; }, setProviderStatus: (update) => this.setProviderStatus(update), restartProvider: (resumeId) => this.restartProvider(resumeId ? { resumeId } : { suppressPrompt: true }), publishStatus: () => this.publishStatus(), scheduleDrain: () => this.scheduleDrain() });
+        return;
+      }
+
       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`);
@@ -1104,28 +1121,6 @@ export class AgentRunner {
     this.publishStatus();
   }
 
-  private providerExitDiagnostics(status: SemanticStatus, runtimeMs: number): Record<string, unknown> {
-    const tmuxSession = typeof this.process?.meta?.tmuxSession === "string" ? this.process.meta.tmuxSession : undefined;
-    const tmuxSocket = typeof this.process?.meta?.tmuxSocket === "string" ? this.process.meta.tmuxSocket : undefined;
-    const exitSource = tmuxSession ? "tmux-session-ended" : this.process?.process ? "process-exit" : "provider-status";
-    const logFile = runnerLogFileFromEnv();
-    const claudeResumeId = this.options.provider === "claude" && logFile ? latestClaudeResumeIdFromLogFile(logFile) : undefined;
-    return {
-      status,
-      runtimeMs: Number.isFinite(runtimeMs) ? runtimeMs : null,
-      exitSource,
-      exitCommandInProgress: this.exitCommandInProgress,
-      stopped: this.stopped,
-      restartInProgress: this.restartInProgress,
-      restartPending: this.restartPending,
-      headless: this.options.headless,
-      hasTerminalSession: Boolean(tmuxSession),
-      tmuxSession: tmuxSession ?? null,
-      tmuxSocket: tmuxSocket ?? null,
-      claudeResumeId: claudeResumeId ?? null,
-    };
-  }
-
   private async updateCommand(commandId: string, status: string, result?: Record<string, unknown>, error?: string): Promise<void> {
     await this.bus.updateCommand(commandId, { status, ...(result ? { result } : {}), ...(error ? { error } : {}) });
   }
@@ -1222,6 +1217,7 @@ export class AgentRunner {
     if (timelineStatus === "compacting") {
       this.compactionMidTurn = this.currentTurnId !== undefined;
     } else if (timelineStatus === "compacted") {
+      this.nativeSelfResume.noteCompacted(typeof update !== "string" && typeof update.timeline?.timestamp === "number" ? update.timeline.timestamp : Date.now());
       this.publishCompactionNotice();
       if (this.compactionMidTurn) {
         // Keep the turn (and its live reasoning tail) alive; the genuine Stop hook ends it.
@@ -1304,6 +1300,9 @@ export class AgentRunner {
       this.rateLimitHold = hold;
       if (fresh) this.publishRateLimitNotice(hold);
     }
+    if (status === "idle" && this.nativeSelfResume.active) {
+      this.nativeSelfResume.resolve(this.nativeSelfResume.active, { resumed: true, via: "provider-idle" });
+    }
     this.publishStatus();
   }
 

package/src/runner-helpers.ts

@@ -157,6 +157,39 @@ export function latestClaudeResumeIdFromLogFile(path: string): string | undefine
   }
 }
 
+export function providerExitDiagnostics(input: {
+  status: SemanticStatus;
+  runtimeMs: number;
+  processMeta?: Record<string, unknown>;
+  hasProcess: boolean;
+  exitCommandInProgress: boolean;
+  stopped: boolean;
+  restartInProgress: boolean;
+  restartPending: boolean;
+  headless: boolean;
+  provider: string;
+  logFile?: string;
+}): Record<string, unknown> {
+  const tmuxSession = typeof input.processMeta?.tmuxSession === "string" ? input.processMeta.tmuxSession : undefined;
+  const tmuxSocket = typeof input.processMeta?.tmuxSocket === "string" ? input.processMeta.tmuxSocket : undefined;
+  const exitSource = tmuxSession ? "tmux-session-ended" : input.hasProcess ? "process-exit" : "provider-status";
+  const claudeResumeId = input.provider === "claude" && input.logFile ? latestClaudeResumeIdFromLogFile(input.logFile) : undefined;
+  return {
+    status: input.status,
+    runtimeMs: Number.isFinite(input.runtimeMs) ? input.runtimeMs : null,
+    exitSource,
+    exitCommandInProgress: input.exitCommandInProgress,
+    stopped: input.stopped,
+    restartInProgress: input.restartInProgress,
+    restartPending: input.restartPending,
+    headless: input.headless,
+    hasTerminalSession: Boolean(tmuxSession),
+    tmuxSession: tmuxSession ?? null,
+    tmuxSocket: tmuxSocket ?? null,
+    claudeResumeId: claudeResumeId ?? null,
+  };
+}
+
 export function commandTimeoutMs(params: Record<string, unknown>, fallback = 10_000): number {
   const raw = params.timeoutMs;
   if (typeof raw !== "number" || !Number.isSafeInteger(raw) || raw <= 0) return fallback;