agent-relay-runner 0.39.0 → 0.41.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-runner",
-  "version": "0.39.0",
+  "version": "0.41.0",
   "description": "Unified provider lifecycle runner for Agent Relay",
   "type": "module",
   "bin": {
@@ -20,7 +20,7 @@
     "directory": "runner"
   },
   "dependencies": {
-    "agent-relay-sdk": "0.2.24"
+    "agent-relay-sdk": "0.2.26"
   },
   "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.39.0",
+  "version": "0.41.0",
   "agentRelayContracts": {
     "providerPluginProtocol": 1
   }

package/src/adapter.ts

@@ -36,13 +36,17 @@ export type ProviderStatusUpdate = SemanticStatus | ProviderStatusEvent;
  * same lane Claude's transcript capture uses. Provider-independent boundary.
  */
 export interface ProviderSessionEvent {
-  type: "prompt" | "response" | "reasoning" | "tool";
+  type: "prompt" | "response" | "narration" | "reasoning" | "tool";
   body: string;
   origin?: "chat" | "terminal" | "provider";
   turnId?: string;
   label?: string;
   status?: "running" | "completed" | "failed";
   streaming?: boolean;
+  /** Stable provider-side step id (Codex app-server item id). Carried into
+   * MessageSessionMeta.stepId so the server upserts the step's row in place instead of
+   * appending a duplicate (a tool's running→completed, a streamed reasoning row). */
+  stepId?: string;
 }
 
 export interface ProviderConfig {
@@ -132,7 +136,8 @@ export interface ProviderAdapter {
   provider: string;
   spawn(config: RunnerSpawnConfig): Promise<ManagedProcess>;
   shutdown(process: ManagedProcess, opts: { graceful: boolean; timeoutMs: number }): Promise<void>;
-  compact?(process: ManagedProcess): Promise<Record<string, unknown> | void>;
+  compact?(process: ManagedProcess, opts?: { instructions?: string }): Promise<Record<string, unknown> | void>;
+  compactSupportsInstructions?: boolean;
   clearContext?(process: ManagedProcess): Promise<Record<string, unknown> | void>;
   // Normalize the session so far into the provider-agnostic SessionEvent stream the
   // Insights context-ratio signal (#183/#184) reduces. Called by the runner's
@@ -143,6 +148,10 @@ export interface ProviderAdapter {
   // ignore it and return their accumulated log. Return null when there is nothing to
   // measure. Best-effort: may be omitted by providers without a session view yet.
   collectSessionEvents?(process: ManagedProcess, ctx: { transcriptPath?: string }): Promise<SessionEvent[] | null>;
+  // Full searchable transcript/archive source for destructive boundaries. The runner
+  // slices the returned stream by cursor, so adapters should return the session-so-far
+  // view when they have one.
+  collectSessionArchiveSegment?(process: ManagedProcess, ctx: { transcriptPath?: string }): Promise<string | null>;
   // Interrupt the in-flight turn without ending the session (ESC for Claude's
   // tmux pane, turn/interrupt for the Codex app-server). Provider-independent at
   // the runner boundary; each adapter does what its provider actually supports.
@@ -181,7 +190,7 @@ export function profileAllowsRelayFeature(config: RunnerSpawnConfig, feature: ke
   return config.agentProfile?.relay?.[feature] !== false;
 }
 
-export const RELAY_CONTEXT = `[agent-relay] You are connected to Agent Relay, a real-time message bus between agents and users. When you receive a relay message: read it, do what it asks, and reply through the relay when a text response is needed. Use agent-relay /react <messageId> <emoji> for lightweight acknowledgement or approval. If Relay MCP tools are available, prefer relay_reply, relay_get_message, relay_get_thread, relay_send_message, relay_upload_artifact, relay_attach_artifact, relay_agent_status, relay_find_agents, relay_spawn_agent, and relay_shutdown_agent. You never need to know or pass your own agent id — relay fills it from your token; use relay_whoami only if you need to reason about yourself. relay_spawn_targets / relay_spawn_agent / relay_shutdown_agent only appear if your profile grants spawning (a live-children quota); when present, call relay_spawn_targets FIRST for the live host/provider/model matrix + your quota, then stand up long-living child agents and shut down your own — find them later with relay_find_agents spawnedBy:me. CLI fallback: agent-relay /reply <messageId> --stdin < response.md; if a delivered message says it was truncated, fetch the full body with: agent-relay get-message <messageId>. For command details, run: agent-relay /guide`;
+export const RELAY_CONTEXT = `[agent-relay] You are connected to Agent Relay, a real-time message bus between agents and users. When you receive a relay message: read it, do what it asks, and reply through the relay when a text response is needed. Use agent-relay /react <messageId> <emoji> for lightweight acknowledgement or approval. If Relay MCP tools are available, prefer relay_reply, relay_get_message, relay_get_thread, relay_send_message, relay_upload_artifact, relay_attach_artifact, relay_agent_status, relay_find_agents, relay_compact_and_resume, relay_recall, relay_spawn_agent, and relay_shutdown_agent. You never need to know or pass your own agent id — relay fills it from your token; use relay_whoami only if you need to reason about yourself. relay_compact_and_resume is for clean-seam self-resume after a context advisory: pass workingState and optional ruledOut; Relay owns the objective envelope. relay_recall searches your own archived pre-compaction segments by keyword when a discarded detail is needed. relay_spawn_targets / relay_spawn_agent / relay_shutdown_agent only appear if your profile grants spawning (a live-children quota); when present, call relay_spawn_targets FIRST for the live host/provider/model matrix + your quota, then stand up long-living child agents and shut down your own — find them later with relay_find_agents spawnedBy:me. CLI fallback: agent-relay /reply <messageId> --stdin < response.md; if a delivered message says it was truncated, fetch the full body with: agent-relay get-message <messageId>. For command details, run: agent-relay /guide`;
 
 // #306 — deliver the FULL message body by default. Only a pathological body beyond this
 // high cap truncates (with a get-message hint) so it can't nuke an agent's context; the 99%

package/src/adapters/claude.ts

@@ -15,6 +15,7 @@ import { claudeProviderMessageText } from "./claude-delivery";
 
 export class ClaudeAdapter implements ProviderAdapter {
   readonly provider = "claude";
+  readonly compactSupportsInstructions = true;
   // #352: initial prompt is seeded as Claude's positional launch arg (buildSpawnArgs) — reliable,
   // no send-keys/onboarding race; tells the runner to skip the redundant post-launch delivery.
   readonly seedsInitialPromptAtLaunch = true;
@@ -55,12 +56,13 @@ export class ClaudeAdapter implements ProviderAdapter {
     await terminateSingleProcess(process, opts);
   }
 
-  async compact(process: ManagedProcess): Promise<Record<string, unknown>> {
+  async compact(process: ManagedProcess, opts?: { instructions?: string }): Promise<Record<string, unknown>> {
     const session = process.meta?.tmuxSession as string | undefined;
     const socket = process.meta?.tmuxSocket as string | undefined;
     if (!session || !tmuxHasSession(session, socket)) throw new Error("no active tmux session for compact");
-    await submitTextToTmux(session, "/compact", socket);
-    return { method: "tmux-inject", command: "/compact" };
+    const command = opts?.instructions ? `/compact ${opts.instructions}` : "/compact";
+    await submitTextToTmux(session, command, socket);
+    return { method: "tmux-inject", command };
   }
 
   async clearContext(process: ManagedProcess): Promise<Record<string, unknown>> {
@@ -84,6 +86,15 @@ export class ClaudeAdapter implements ProviderAdapter {
     return collectClaudeSessionEvents(jsonl);
   }
 
+  async collectSessionArchiveSegment(_process: ManagedProcess, ctx: { transcriptPath?: string }): Promise<string | null> {
+    if (!ctx.transcriptPath) return null;
+    try {
+      return await readFile(ctx.transcriptPath, "utf8");
+    } catch {
+      return null;
+    }
+  }
+
   async interrupt(process: ManagedProcess): Promise<Record<string, unknown>> {
     const session = process.meta?.tmuxSession as string | undefined;
     const socket = process.meta?.tmuxSocket as string | undefined;

package/src/adapters/codex.ts

@@ -476,11 +476,18 @@ export class CodexAdapter implements ProviderAdapter {
     const type = stringValue(item.type);
     const turnId = this.activeTurnId;
     const itemId = codexItemId(item);
+    // A completed non-reasoning item ends the reasoning segment that preceded it — flush the
+    // buffered reasoning first so it lands in transcript order, ahead of this tool/message.
+    if (type !== "reasoning") this.flushBufferedReasoning();
     if (type === "agentMessage") {
       const text = (stringValue(item.text) ?? (itemId ? this.itemTextBuffers.get(itemId) : undefined))?.trim();
       if (text) {
         this.turnMessages.push(text);
         this.recordInsightEvent({ type: "turn" }); // a substantive assistant turn
+        // Stream the assistant text into the trace as narration (Claude parity). The closing
+        // response bubble at turn end repeats the final block; the dashboard suppresses the
+        // matching narration so it isn't shown twice.
+        this.sessionEventCb({ type: "narration", origin: "provider", body: text, ...(turnId ? { turnId } : {}) });
       }
       if (itemId) this.itemTextBuffers.delete(itemId);
       if (itemId) this.itemTextBufferTypes.delete(itemId);
@@ -495,23 +502,43 @@ export class CodexAdapter implements ProviderAdapter {
       return;
     }
     if (type === "reasoning") {
-      const buffered = itemId ? this.itemTextBuffers.get(itemId) : undefined;
-      const text = (codexReasoningText(item) || buffered || "").trim();
-      if (text) this.sessionEventCb({ type: "reasoning", origin: "provider", body: text, ...(turnId ? { turnId } : {}) });
-      if (itemId) this.itemTextBuffers.delete(itemId);
-      if (itemId) this.itemTextBufferTypes.delete(itemId);
+      // Codex has no reliable reasoning item/completed carrying text — the stream IS the deltas.
+      // Keep the longer of (accumulated deltas, item.content) in the buffer and emit at the next
+      // boundary (next item / turn end), the same coarse signal the Claude reasoning tail uses.
+      const fromItem = codexReasoningText(item);
+      if (itemId && fromItem) {
+        const existing = this.itemTextBuffers.get(itemId) ?? "";
+        if (fromItem.length >= existing.length) this.itemTextBuffers.set(itemId, fromItem);
+        this.itemTextBufferTypes.set(itemId, "reasoning");
+      }
       return;
     }
     const tool = codexToolSummary(type, item);
     if (tool) {
       this.recordInsightEvent({ type: "tool", name: codexInsightToolName(type, item) });
       if (codexItemFailed(item)) this.recordInsightEvent({ type: "tool_error" });
-      this.sessionEventCb({ type: "tool", origin: "provider", body: tool.body, label: tool.label, status: "completed", ...(turnId ? { turnId } : {}) });
+      // stepId = the app-server item id: the server upserts the running step emitted on
+      // item/started into this completed state IN PLACE, so the tool persists as ONE row.
+      this.sessionEventCb({ type: "tool", origin: "provider", body: tool.body, label: tool.label, status: "completed", ...(turnId ? { turnId } : {}), ...(itemId ? { stepId: itemId } : {}) });
     }
     if (itemId) this.itemTextBuffers.delete(itemId);
     if (itemId) this.itemTextBufferTypes.delete(itemId);
   }
 
+  // Emit any buffered reasoning as discrete trace blocks (appended, in transcript order). Codex
+  // streams reasoning as deltas with no reliable completion event, so we flush coarsely at item
+  // and turn boundaries — the signal the Claude reasoning tail uses — never a codex-only timer.
+  private flushBufferedReasoning(): void {
+    const turnId = this.activeTurnId;
+    for (const [itemId, text] of [...this.itemTextBuffers.entries()]) {
+      if (this.itemTextBufferTypes.get(itemId) !== "reasoning") continue;
+      this.itemTextBuffers.delete(itemId);
+      this.itemTextBufferTypes.delete(itemId);
+      const body = text.trim();
+      if (body) this.sessionEventCb({ type: "reasoning", origin: "provider", body, ...(turnId ? { turnId } : {}) });
+    }
+  }
+
   // #183/#184: append to the session-event log with a soft cap. On overflow we drop the
   // oldest half; the runner detects the resulting length shrink and resets its segment
   // cursor (worst case: one slightly-truncated datapoint on a pathologically long session).
@@ -537,8 +564,11 @@ export class CodexAdapter implements ProviderAdapter {
     const turnId = this.activeTurnId;
 
     if (method.includes("/started") || method.includes(".started")) {
+      // A new item starting ends the prior reasoning segment — flush it ahead of this step.
+      this.flushBufferedReasoning();
       const tool = codexToolSummary(type, item ?? params ?? {});
-      if (tool) this.sessionEventCb({ type: "tool", origin: "provider", body: tool.body, label: tool.label, status: "running", streaming: true, ...(turnId ? { turnId } : {}) });
+      // stepId = item id so the server upserts this running step → completed IN PLACE (one row).
+      if (tool) this.sessionEventCb({ type: "tool", origin: "provider", body: tool.body, label: tool.label, status: "running", streaming: true, ...(turnId ? { turnId } : {}), ...(itemId ? { stepId: itemId } : {}) });
       return;
     }
 
@@ -570,6 +600,7 @@ export class CodexAdapter implements ProviderAdapter {
   }
 
   private finishMainTurn(): void {
+    this.flushBufferedReasoning(); // surface any trailing reasoning before the closing response
     this.flushTurnResponse();
     const turnId = this.activeTurnId;
     this.activeTurnId = undefined;

package/src/runner.ts

@@ -231,6 +231,8 @@ export class AgentRunner {
   // (transcript rotated, Codex buffer trimmed) resets the cursor.
   private insightsObserved = 0;
   private insightsCursorKey = "";
+  private archiveObservedChars = 0;
+  private archiveCursorKey = "";
   // Memoized repo-name project id for insight observations (resolved once; involves a
   // git toplevel lookup for direct agents). Aggregates by repo, not per-session worktree.
   private insightProjectName?: string;
@@ -251,6 +253,12 @@ export class AgentRunner {
   // its final response. Set when a provider-turn starts, cleared when it ends.
   private currentTurnId?: string;
   private currentTurnStartedAt?: number;
+  // True while a turn that was already in flight is being compacted. Claude's PostCompact
+  // hook posts a single `idle`, but a mid-turn compaction RESUMES the turn afterward — so
+  // treating that idle as a turn end (flip idle, kill the reasoning tail) makes chat go dark
+  // until the next prompt. Set when `compacting` arrives with a turn running; cleared on the
+  // genuine end (a plain idle with no compaction timeline).
+  private compactionMidTurn = false;
   // Prompt-echo dedup: a short, time-bounded queue of prompts the runner itself
   // injected (chat box or initial prompt) that are still awaiting their matching
   // UserPromptSubmit echo. A single slot dropped earlier entries when several prompts
@@ -731,7 +739,9 @@ export class AgentRunner {
       else if (type === "agent.reconnect") this.publishStatus();
       else if (type === "agent.compact") {
         if (!this.options.adapter.compact || !this.process) throw new Error("provider does not support compact");
-        providerResult = await this.options.adapter.compact(this.process);
+        providerResult = await this.options.adapter.compact(this.process, {
+          instructions: typeof params.instructions === "string" ? params.instructions : undefined,
+        });
       } 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);
@@ -762,7 +772,11 @@ export class AgentRunner {
     } finally {
       this.claims.finishClaim("command", commandId);
       if (exitAfterCommand) {
-        await this.http.deleteAgent(this.agentId).catch(() => {});
+        if (params.preserveRegistration === true) {
+          await this.http.setStatus(this.agentId, "offline", this.options.instanceId).catch(() => {});
+        } else {
+          await this.http.deleteAgent(this.agentId).catch(() => {});
+        }
         if (this.options.exitProcessOnShutdown !== false) {
           setTimeout(() => void this.stop().catch((error) => {
             logger.error("lifecycle", `stop after command failed: ${error}`);
@@ -1112,10 +1126,28 @@ export class AgentRunner {
     } else if (status === "idle" || status === "busy") {
       this.terminalFailure = undefined;
     }
+    // Compaction lifecycle (Claude PreCompact→`compacting` busy / PostCompact→`compacted`
+    // idle). A `compacted` idle for a turn that predated compaction is a hook artifact — the
+    // turn resumes — so it must NOT end the turn. Discriminate on whether a turn was running,
+    // captured BEFORE the busy logic below mints a currentTurnId (it does for /compact at idle).
+    const timelineStatus = typeof update !== "string" ? update.timeline?.status : undefined;
+    if (timelineStatus === "compacting") {
+      this.compactionMidTurn = this.currentTurnId !== undefined;
+    } else if (timelineStatus === "compacted") {
+      this.publishCompactionNotice();
+      if (this.compactionMidTurn) {
+        // Keep the turn (and its live reasoning tail) alive; the genuine Stop hook ends it.
+        // pendingTimelineEvent (the marker) was set above and is consumed by publishStatus.
+        this.sessionLog(`compaction completed mid-turn (turn ${this.currentTurnId ?? "?"}) — staying busy`);
+        this.publishStatus();
+        return;
+      }
+    }
     if (status === "busy" && reason === "provider-turn") {
       if (!this.currentTurnId) {
         this.currentTurnId = typeof update !== "string" && update.id ? update.id : crypto.randomUUID();
         this.currentTurnStartedAt = Date.now();
+        this.compactionMidTurn = false;
         this.sessionLog(`turn started (turn ${this.currentTurnId})`);
       }
       this.armBusyReconciler();
@@ -1123,6 +1155,7 @@ export class AgentRunner {
       if (this.currentTurnId) this.sessionLog(`turn ended via provider idle (turn ${this.currentTurnId})`);
       this.currentTurnId = undefined;
       this.currentTurnStartedAt = undefined;
+      this.compactionMidTurn = false;
       this.disarmBusyReconciler();
       this.stopReasoningTail();
     }
@@ -1239,8 +1272,12 @@ export class AgentRunner {
     // retried until it lands. occurredAt is stamped now so a queued event reports when it
     // truly happened, not when the server finally accepted it. Routed through the fast-lane
     // sessionOutbox (#332) so a transient trace failure can't head-of-line block real messages.
+    // A stepId-bearing step (Codex tool running→completed, streamed reasoning/response) uses a
+    // STABLE idempotency key so the server upserts the row in place instead of appending a dup.
+    const stepId = input.session.stepId;
     this.sessionOutbox.enqueue({
       kind: "session-message",
+      ...(stepId ? { idempotencyKey: `session-step:${input.from}:${input.session.turnId ?? ""}:${stepId}` } : {}),
       payload: {
         from: input.from,
         to: input.to,
@@ -1272,6 +1309,13 @@ export class AgentRunner {
         });
         return;
       }
+      if (record.kind === "continuation-archive") {
+        await this.http.recordContinuationArchive({
+          ...(record.payload as Parameters<RelayHttpClient["recordContinuationArchive"]>[0]),
+          occurredAt: record.occurredAt,
+        });
+        return;
+      }
       if (record.kind === "mcp-tool-call") {
         await this.deliverBufferedMcpCall(record);
         return;
@@ -1405,11 +1449,14 @@ export class AgentRunner {
       this.publishFinalizing(reason);
       try {
         await Promise.race([
-          this.captureContextRatio(reason, opts),
+          Promise.all([
+            this.captureContextRatio(reason, opts),
+            this.captureContinuationArchive(reason, opts),
+          ]).then(() => undefined),
           new Promise<void>((resolve) => setTimeout(resolve, PRE_DESTROY_TIMEOUT_MS)),
         ]);
       } catch (error) {
-        this.sessionLog(`insights: pre-destroy capture failed: ${errMessage(error)}`);
+        this.sessionLog(`pre-destroy capture failed: ${errMessage(error)}`);
       }
       // For exit-bound transitions the runner won't be alive afterward to drain the durable
       // outbox, so block (bounded) on delivering what capture just enqueued. This runs before
@@ -1449,6 +1496,30 @@ export class AgentRunner {
     return (this.insightProjectName ??= resolveProjectName(this.options.cwd, this.options.workspace));
   }
 
+  private async captureContinuationArchive(reason: SessionDestroyReason, opts?: { transcriptPath?: string }): Promise<void> {
+    const adapter = this.options.adapter;
+    if (!adapter.collectSessionArchiveSegment || !this.process) return;
+    const transcriptPath = opts?.transcriptPath ?? this.lastTranscriptPath;
+    const archive = await adapter.collectSessionArchiveSegment(this.process, { transcriptPath });
+    if (!archive) return;
+    const key = transcriptPath ?? `session:${this.providerSessionId}`;
+    if (key !== this.archiveCursorKey || archive.length < this.archiveObservedChars) {
+      this.archiveCursorKey = key;
+      this.archiveObservedChars = 0;
+    }
+    const segment = archive.slice(this.archiveObservedChars).trim();
+    this.archiveObservedChars = archive.length;
+    if (!segment) return;
+    this.outbox.enqueue({
+      kind: "continuation-archive",
+      payload: {
+        agentId: this.agentId,
+        segment,
+      },
+    });
+    this.sessionLog(`continuation archive queued (${segment.length} chars, ${reason})`);
+  }
+
   private async captureContextRatio(reason: SessionDestroyReason, opts?: { transcriptPath?: string }): Promise<void> {
     const adapter = this.options.adapter;
     if (!adapter.collectSessionEvents || !this.process) return;
@@ -1534,6 +1605,7 @@ export class AgentRunner {
         ...(event.label ? { label: event.label } : {}),
         ...(event.status ? { status: event.status } : {}),
         ...(event.streaming !== undefined ? { streaming: event.streaming } : {}),
+        ...(event.stepId ? { stepId: event.stepId } : {}),
       },
     });
   }
@@ -1617,6 +1689,7 @@ export class AgentRunner {
     this.sessionLog(`force-clearing stuck provider-turn (${reason})`);
     this.claims.clearWorkKind("provider-turn");
     this.currentTurnId = undefined;
+    this.compactionMidTurn = false;
     this.publishStatus();
   }
 
@@ -1697,6 +1770,18 @@ export class AgentRunner {
     this.reasoningTail = undefined;
   }
 
+  // Mirror a discreet, durable "context compacted" marker into chat via the existing
+  // session-mirror lane (not a parallel channel). `notice` renders as an inline timeline
+  // marker (never a bubble) and survives reload, unlike the ephemeral timeline-status one.
+  private publishCompactionNotice(): void {
+    this.publishSessionEvent({
+      from: this.agentId,
+      to: "user",
+      body: "🗜 Context compacted",
+      session: { type: "notice", origin: "provider", label: "compacted", ...(this.currentTurnId ? { turnId: this.currentTurnId } : {}) },
+    });
+  }
+
   private publishStatus(): void {
     this.claims.expire();
     const status = this.claims.currentStatus();
@@ -2023,7 +2108,7 @@ export class AgentRunner {
     const meta: Record<string, unknown> = {
       providerCapabilities: runtimeProviderCapabilities(
         this.options,
-        context ? { source: context.source, confidence: context.confidence } : undefined,
+        context,
         probeModel,
       ),
       ...(terminalSession ? { tmuxSession: terminalSession } : {}),
@@ -2276,7 +2361,7 @@ interface ProbeModelInfo {
   effort?: string;
 }
 
-function runtimeProviderCapabilities(options: RunnerOptions, contextStats?: { source: "api" | "statusline" | "hook" | "estimate"; confidence: "exact" | "reported" | "estimated" }, probeModel?: ProbeModelInfo): ProviderCapabilities {
+function runtimeProviderCapabilities(options: RunnerOptions, contextState?: ContextState, probeModel?: ProbeModelInfo): ProviderCapabilities {
   const model = options.model ?? probeModel?.model;
   const effort = options.effort ?? probeModel?.effort;
   const modelSource = options.model ? "runtime" as const : probeModel?.model ? "provider" as const : "runtime" as const;
@@ -2306,7 +2391,7 @@ function runtimeProviderCapabilities(options: RunnerOptions, contextStats?: { so
       confidence: "reported",
       lastUpdatedAt: options.startedAt,
     },
-    ...runtimeProviderContextCapabilities(options, contextStats),
+    ...runtimeProviderContextCapabilities(options, contextState),
     ...runtimeProviderTerminalCapabilities(options),
     liveSession: {
       capture: true,
@@ -2375,14 +2460,22 @@ function appliedAgentProfileMetadata(provider: string, profile: AgentProfile): R
   };
 }
 
-function runtimeProviderContextCapabilities(options: RunnerOptions, contextStats?: { source: "api" | "statusline" | "hook" | "estimate"; confidence: "exact" | "reported" | "estimated" }): Pick<ProviderCapabilities, "context"> {
-  const context: NonNullable<ProviderCapabilities["context"]> = {};
-  if (contextStats) context.stats = contextStats;
-  if (options.provider === "codex" || (options.provider === "claude" && options.headless)) {
+function runtimeProviderContextCapabilities(options: RunnerOptions, contextState?: ContextState): Pick<ProviderCapabilities, "context"> {
+  const context: NonNullable<ProviderCapabilities["context"]> = { resume: "none" };
+  const supportsManagedContext = options.provider === "codex" || (options.provider === "claude" && options.headless);
+  if (contextState) {
+    context.stats = { source: contextState.source, confidence: contextState.confidence };
+    if (typeof contextState.tokensMax === "number" && Number.isFinite(contextState.tokensMax)) {
+      context.windowTokens = contextState.tokensMax;
+    }
+  }
+  if (supportsManagedContext) {
     context.compact = true;
     context.clear = true;
   }
   context.inject = true;
+  if (supportsManagedContext && options.adapter.compact && options.adapter.compactSupportsInstructions) context.resume = "native";
+  else if (supportsManagedContext && options.adapter.clearContext) context.resume = "clear-inject";
   return Object.keys(context).length ? { context } : {};
 }