agent-relay-runner 0.91.4 → 0.92.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-runner",
-  "version": "0.91.4",
+  "version": "0.92.0",
   "description": "Unified provider lifecycle runner for Agent Relay",
   "type": "module",
   "bin": {
@@ -20,7 +20,7 @@
     "directory": "runner"
   },
   "dependencies": {
-    "agent-relay-sdk": "0.2.71"
+    "agent-relay-sdk": "0.2.72"
   },
   "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.91.4",
+  "version": "0.92.0",
   "agentRelayContracts": {
     "providerPluginProtocol": 1
   }

package/src/adapters/claude.ts

@@ -12,7 +12,8 @@ import type { SessionEvent } from "../session-insights";
 import { prepareClaudeProfileHome, profileUsesClaudeHostProviderGlobals } from "../profile-home";
 import { assembleLaunch, materializeLaunchAssembly, sessionStatusLineSettingsArgs } from "../launch-assembly";
 import { claudeProviderMessageText } from "./claude-delivery";
-import { buildRateLimitProviderState, gatedClaudeRateLimitStatus, parseClaudeRateLimitPane } from "../rate-limit";
+import { buildRateLimitProviderState, parseClaudeRateLimitPane } from "../rate-limit";
+import { evaluateClaudePromptGatePane, initialClaudePromptGatePaneState, type ClaudePromptGatePaneState } from "../claude-prompt-gates";
 
 export class ClaudeAdapter implements ProviderAdapter {
   readonly provider = "claude";
@@ -24,10 +25,7 @@ export class ClaudeAdapter implements ProviderAdapter {
   private tmuxWatcher?: Timer;
   private turnWatcher?: Timer;
   private modelUnavailableReported = false;
-  // #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;
+  private promptGatePaneState: ClaudePromptGatePaneState = initialClaudePromptGatePaneState();
 
   onStatusChange(cb: (status: ProviderStatusUpdate) => void): void {
     this.statusCb = cb;
@@ -309,6 +307,7 @@ export class ClaudeAdapter implements ProviderAdapter {
   private async spawnHeadless(config: RunnerSpawnConfig, spawnArgs: SpawnArgs): Promise<ManagedProcess> {
     const { sessionName, socketName, args: tmuxArgs } = this.buildTmuxArgs(config, spawnArgs);
     this.modelUnavailableReported = false;
+    this.promptGatePaneState = initialClaudePromptGatePaneState();
 
     Bun.spawnSync(tmuxCommand(socketName, "kill-session", "-t", sessionName), {
       stdin: "ignore", stdout: "ignore", stderr: "ignore",
@@ -370,30 +369,27 @@ export class ClaudeAdapter implements ProviderAdapter {
         this.statusCb(status);
         return;
       }
-      // #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);
+      // #663: prompt-gate fallback. Known gates should be prevented before launch;
+      // this catches missed/new blocking panes with the same #655 debounce + busy
+      // guard used for rate-limit holds.
+      const promptGate = evaluateClaudePromptGatePane(pane, this.promptGatePaneState, {
+        sessionName,
+        busy: claudePaneIsBusy(pane),
+      });
+      this.promptGatePaneState = promptGate.state;
+      if (promptGate.action) {
+        this.sendPromptGateKeystroke(sessionName, promptGate.action.keystroke, socketName);
+        if (promptGate.status) this.statusCb(promptGate.status);
       }
     }, 2000);
   }
 
-  // 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 {
+  // Best-effort: a failed auto-dismiss must not wedge the pane watcher.
+  private sendPromptGateKeystroke(sessionName: string, keystroke: string, socketName?: string): void {
     try {
-      Bun.spawnSync(tmuxCommand(socketName, "send-keys", "-t", sessionName, "Escape"), { stdin: "ignore", stdout: "ignore", stderr: "ignore" });
+      Bun.spawnSync(tmuxCommand(socketName, "send-keys", "-t", sessionName, keystroke), { stdin: "ignore", stdout: "ignore", stderr: "ignore" });
     } catch {
-      // ignore — the hold still publishes; worst case the modal lingers until the next tick.
+      // ignore; the timeline/status still publishes, and the next watcher tick can observe whether the pane moved.
     }
   }
 

package/src/adapters/codex.ts

@@ -101,7 +101,29 @@ export class CodexAdapter implements ProviderAdapter {
     const client = process.meta?.client as CodexAppClient | undefined;
     if (!client?.isConnected()) return "unknown";
     const threadId = typeof process.meta?.threadId === "string" ? process.meta.threadId : "";
-    if (!this.activeTurnId) return "idle";
+    // #651: when no local activeTurnId, don't short-circuit to idle — query the app-server.
+    // turn/started can arrive after processing begins (or be missed entirely); a stale-idle
+    // probe would make a busy agent appear idle to the coordinator. Same fallback as #653's
+    // ensureMainTurnActive path, but for the pull (probe) direction, not the push (event) one.
+    if (!this.activeTurnId) {
+      if (!threadId) return "idle";
+      try {
+        const read = await client.threadRead(threadId, true);
+        const thread = isRecord(read.thread) ? read.thread : undefined;
+        const turns = Array.isArray(thread?.turns) ? thread.turns : [];
+        const inProgressTurn = turns.find((t) => isRecord(t) && stringValue(t.status) === "inProgress");
+        if (inProgressTurn) {
+          // Synthesize the active turn (same path as ensureMainTurnActive on item events).
+          this.ensureMainTurnActive(stringValue(inProgressTurn.id));
+          return "busy";
+        }
+        const threadStatus = statusType(thread?.status);
+        if (threadStatus === "active") return "busy";
+        return "idle";
+      } catch {
+        return "unknown";
+      }
+    }
     if (!threadId) return "busy";
     try {
       const read = await client.threadRead(threadId, true);

package/src/claude-prompt-gates.ts

@@ -0,0 +1,268 @@
+import { resolve } from "node:path";
+import { isRecord } from "agent-relay-sdk";
+import type { ProviderStatusUpdate, RunnerSpawnConfig } from "./adapter";
+import { buildRateLimitProviderState, parseClaudeRateLimitPane } from "./rate-limit";
+
+export interface ClaudeConfigPromptGatePrevention {
+  id: string;
+  description: string;
+  apply(seed: Record<string, unknown>, context: { host?: Record<string, unknown>; config: RunnerSpawnConfig }): void;
+}
+
+export interface ClaudeLaunchPromptGatePrevention {
+  id: string;
+  description: string;
+  apply(config: RunnerSpawnConfig): { strictMcpConfig?: boolean };
+}
+
+type PaneGateMatch = { message?: string; resetAt?: number; kind?: "usage_limit" | "transient_overload"; errorType?: string };
+
+interface ClaudePanePromptGate {
+  id: string;
+  label: string;
+  policy: string;
+  keystroke: string;
+  minDetections: number;
+  match(text: string, nowMs?: number): PaneGateMatch | null;
+  providerState?(match: PaneGateMatch, context: ClaudePromptGatePaneContext): Record<string, unknown>;
+}
+
+export interface ClaudePromptGatePaneState {
+  currentGateId?: string;
+  consecutiveDetections: number;
+  handledGateId?: string;
+}
+
+export interface ClaudePromptGatePaneContext {
+  sessionName?: string;
+  busy?: boolean;
+  nowMs?: number;
+}
+
+export interface ClaudePromptGateAction {
+  gateId: string;
+  label: string;
+  policy: string;
+  keystroke: string;
+  source: "claude-pane";
+}
+
+export interface ClaudePromptGatePaneResult {
+  action?: ClaudePromptGateAction;
+  status?: ProviderStatusUpdate;
+  state: ClaudePromptGatePaneState;
+}
+
+export const claudeConfigPromptGatePreventions: ClaudeConfigPromptGatePrevention[] = [
+  {
+    id: "first-run-onboarding",
+    description: "Pre-accept Claude Code's first-run onboarding gate.",
+    apply(seed, { host }) {
+      seed.hasCompletedOnboarding = true;
+      if (typeof host?.lastOnboardingVersion === "string") seed.lastOnboardingVersion = host.lastOnboardingVersion;
+    },
+  },
+  {
+    id: "theme-selection",
+    description: "Pre-seed a theme so the first-run theme picker does not render.",
+    apply(seed, { host }) {
+      seed.theme = typeof host?.theme === "string" ? host.theme : "dark";
+    },
+  },
+  {
+    id: "bypass-permissions-mode",
+    description: "Pre-accept Claude's open-approval bypass-permissions modal.",
+    apply(seed, { config }) {
+      if (config.approvalMode === "open") seed.bypassPermissionsModeAccepted = true;
+    },
+  },
+  {
+    id: "workspace-trust",
+    description: "Trust the managed spawn cwd and clear project onboarding.",
+    apply(seed, { config }) {
+      if (!config.cwd) return;
+      seed.projects = {
+        ...(isRecord(seed.projects) ? seed.projects : {}),
+        [resolve(config.cwd)]: { hasTrustDialogAccepted: true, hasCompletedProjectOnboarding: true },
+      };
+    },
+  },
+];
+
+export const claudeLaunchPromptGatePreventions: ClaudeLaunchPromptGatePrevention[] = [
+  {
+    id: "project-mcp-discovery",
+    description: "Use strict controlled MCP config so Claude never prompts for ambient project .mcp.json servers.",
+    apply() {
+      return { strictMcpConfig: true };
+    },
+  },
+];
+
+const panePromptGates: ClaudePanePromptGate[] = [
+  {
+    id: "usage-limit",
+    label: "Usage limit",
+    policy: "wait-for-reset",
+    keystroke: "Escape",
+    minDetections: 2,
+    match: (text, nowMs) => parseClaudeRateLimitPane(text, nowMs),
+    providerState(match, context) {
+      return buildRateLimitProviderState({
+        errorType: match.errorType ?? "session_limit",
+        kind: match.kind ?? "usage_limit",
+        ...(match.resetAt ? { resetAt: match.resetAt } : {}),
+        message: match.message,
+        source: context.sessionName ? `claude-pane:${context.sessionName}` : "claude-pane",
+      });
+    },
+  },
+  {
+    id: "workspace-trust",
+    label: "Workspace trust",
+    policy: "accept-trusted-workspace",
+    keystroke: "Enter",
+    minDetections: 2,
+    match: (text) => /do you trust (?:the files in )?(?:this folder|this project|this directory)/i.test(text)
+      && /\b(?:yes|proceed|trust|continue)\b/i.test(text)
+      ? { message: lineMatching(text, /do you trust/i) }
+      : null,
+  },
+  {
+    id: "bypass-permissions-mode",
+    label: "Bypass permissions mode",
+    policy: "accept-configured-open-approval",
+    keystroke: "Enter",
+    minDetections: 2,
+    match: (text) => /bypass permissions mode/i.test(text) && /\b(?:accept|proceed|continue|yes)\b/i.test(text)
+      ? { message: lineMatching(text, /bypass permissions mode/i) }
+      : null,
+  },
+  {
+    id: "project-mcp-discovery",
+    label: "Project MCP discovery",
+    policy: "reject-ambient-project-mcp",
+    keystroke: "Escape",
+    minDetections: 2,
+    match: (text) => /\bnew MCP servers? found\b/i.test(text) && /\b(?:select|enable|servers?)\b/i.test(text)
+      ? { message: lineMatching(text, /new MCP servers? found/i) }
+      : null,
+  },
+  {
+    id: "theme-selection",
+    label: "Theme selection",
+    policy: "accept-default-theme",
+    keystroke: "Enter",
+    minDetections: 2,
+    match: (text) => /choose (?:the )?(?:text style|theme).*Claude Code/i.test(text) && /\b(?:dark|light) mode\b/i.test(text)
+      ? { message: lineMatching(text, /choose/i) }
+      : null,
+  },
+  {
+    id: "first-run-onboarding",
+    label: "First-run onboarding",
+    policy: "accept-onboarding",
+    keystroke: "Enter",
+    minDetections: 2,
+    match: (text) => /welcome to Claude Code/i.test(text) && /\b(?:let'?s get started|continue|get started)\b/i.test(text)
+      ? { message: lineMatching(text, /welcome to Claude Code/i) }
+      : null,
+  },
+];
+
+export function applyClaudeConfigPromptGatePreventions(
+  seed: Record<string, unknown>,
+  host: Record<string, unknown> | undefined,
+  config: RunnerSpawnConfig,
+): Record<string, unknown> {
+  const next = { ...seed };
+  for (const prevention of claudeConfigPromptGatePreventions) prevention.apply(next, { host, config });
+  return next;
+}
+
+export function claudeLaunchPromptGateSettings(config: RunnerSpawnConfig): { strictMcpConfig: boolean } {
+  return {
+    strictMcpConfig: claudeLaunchPromptGatePreventions.some((prevention) => prevention.apply(config).strictMcpConfig === true),
+  };
+}
+
+export function initialClaudePromptGatePaneState(): ClaudePromptGatePaneState {
+  return { consecutiveDetections: 0 };
+}
+
+export function evaluateClaudePromptGatePane(
+  text: string,
+  state: ClaudePromptGatePaneState,
+  context: ClaudePromptGatePaneContext = {},
+): ClaudePromptGatePaneResult {
+  const detected = firstDetectedPaneGate(text, context.nowMs);
+  if (!detected) return { state: initialClaudePromptGatePaneState() };
+  if (context.busy) {
+    return { state: { ...state, currentGateId: undefined, consecutiveDetections: 0 } };
+  }
+  if (state.handledGateId === detected.entry.id) {
+    return { state };
+  }
+
+  const consecutiveDetections = state.currentGateId === detected.entry.id ? state.consecutiveDetections + 1 : 1;
+  const nextState: ClaudePromptGatePaneState = {
+    currentGateId: detected.entry.id,
+    consecutiveDetections,
+    ...(state.handledGateId ? { handledGateId: state.handledGateId } : {}),
+  };
+  if (consecutiveDetections < detected.entry.minDetections) return { state: nextState };
+
+  const action: ClaudePromptGateAction = {
+    gateId: detected.entry.id,
+    label: detected.entry.label,
+    policy: detected.entry.policy,
+    keystroke: detected.entry.keystroke,
+    source: "claude-pane",
+  };
+  return {
+    action,
+    status: promptGateStatus(detected.entry, detected.match, action, context),
+    state: { ...nextState, handledGateId: detected.entry.id },
+  };
+}
+
+function firstDetectedPaneGate(text: string, nowMs?: number): { entry: ClaudePanePromptGate; match: PaneGateMatch } | null {
+  for (const entry of panePromptGates) {
+    const match = entry.match(text, nowMs);
+    if (match) return { entry, match };
+  }
+  return null;
+}
+
+function promptGateStatus(
+  entry: ClaudePanePromptGate,
+  match: PaneGateMatch,
+  action: ClaudePromptGateAction,
+  context: ClaudePromptGatePaneContext,
+): ProviderStatusUpdate {
+  const metadata = {
+    eventType: "claude.prompt_gate.auto_handled",
+    gateId: action.gateId,
+    policy: action.policy,
+    keystroke: action.keystroke,
+    source: action.source,
+    ...(context.sessionName ? { sessionName: context.sessionName } : {}),
+  };
+  return {
+    status: "idle",
+    clear: ["subagent"],
+    ...(entry.providerState ? { providerState: entry.providerState(match, context) } : {}),
+    timeline: {
+      status: "claude.prompt_gate.auto_handled",
+      id: `claude-prompt-gate-${entry.id}-${Date.now()}`,
+      timestamp: Date.now(),
+      title: "Claude prompt gate auto-handled",
+      body: match.message ?? `${entry.label} dismissed with ${entry.keystroke}`,
+      metadata,
+    },
+  };
+}
+
+function lineMatching(text: string, pattern: RegExp): string | undefined {
+  return text.split(/\r?\n/).map((line) => line.trim()).find((line) => pattern.test(line));
+}

package/src/launch-assembly.ts

@@ -13,6 +13,7 @@ import {
   profileUsesClaudeHostProviderGlobals,
   providerHomePathFor,
 } from "./profile-home";
+import { claudeLaunchPromptGateSettings } from "./claude-prompt-gates";
 import {
   materializeResolvedAssets,
   resolveClaudeProjectSkills,
@@ -280,16 +281,10 @@ function assembleClaude(config: RunnerSpawnConfig, providerConfig: ProviderConfi
     : {};
   const declaredMcp = { ...projectMcp, ...provisionedMcp, ...sharedMcp };
 
-  // #662 — EVERY managed Claude launch is --strict-mcp-config, not just vanilla. A managed
-  // agent runs headless (no human at the keyboard), so Claude's blocking "N new MCP servers
-  // found in this project — select to enable" modal (raised on UNDECIDED cwd `.mcp.json`
-  // servers) wedges the session forever, burning quota. Relay owns MCP: everything relay
-  // decides should load is injected via --mcp-config, which strict PRESERVES; strict only
-  // blocks what relay DIDN'T inject — above all the cwd project `.mcp.json` (the modal's
-  // source), which stays excluded. The relay plugin (monitor + turn hooks) loads via
-  // --plugin-dir and ships no MCP server, so it is untouched. Was `vanilla`-only, which left
-  // host/minimal/isolated bases exposed to the modal wedge.
-  const strictMcp = true;
+  // #662/#663 — strict controlled MCP is a Claude prompt-gate prevention entry, not a
+  // launch-assembly special case. It prevents the blocking "N new MCP servers found in
+  // this project" modal while preserving every relay-declared server in --mcp-config.
+  const strictMcp = claudeLaunchPromptGateSettings(config).strictMcpConfig;
 
   // #662 follow-up — strict drops ALL on-disk config, including the host user-scope
   // `~/.claude.json` MCP that a host-base agent loaded ambiently before strict. That

package/src/profile-home.ts

@@ -6,6 +6,7 @@ import type { ProvisioningMcpServer } from "agent-relay-sdk";
 import { profileAllowsRelayFeature, type RunnerSpawnConfig } from "./adapter";
 import { CLAUDE_RELAY_MANUAL } from "./relay-instructions";
 import { providerHomeRootFromEnv } from "./config";
+import { applyClaudeConfigPromptGatePreventions } from "./claude-prompt-gates";
 
 type ProviderHome = {
   path: string;
@@ -101,20 +102,7 @@ function seedClaudeConfigIfMissing(claudeHome: string, config: RunnerSpawnConfig
   const path = join(claudeHome, ".claude.json");
   if (existsSync(path)) return;
   const host = readHostClaudeConfig();
-  const seed: Record<string, unknown> = {
-    hasCompletedOnboarding: true,
-    theme: typeof host?.theme === "string" ? host.theme : "dark",
-  };
-  if (typeof host?.lastOnboardingVersion === "string") seed.lastOnboardingVersion = host.lastOnboardingVersion;
-  // Open approval = headless launch adds --dangerously-skip-permissions, which has
-  // its OWN first-run gate ("Bypass Permissions mode" accept/exit). Pre-accept it,
-  // or the agent stalls there exactly like the onboarding/trust gates.
-  if (config.approvalMode === "open") seed.bypassPermissionsModeAccepted = true;
-  if (config.cwd) {
-    seed.projects = {
-      [resolve(config.cwd)]: { hasTrustDialogAccepted: true, hasCompletedProjectOnboarding: true },
-    };
-  }
+  const seed = applyClaudeConfigPromptGatePreventions({}, host, config);
   writeFileSync(path, JSON.stringify(seed, null, 2), { mode: 0o600 });
 }
 

package/src/rate-limit.ts

@@ -1,5 +1,4 @@
 // #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.
@@ -126,38 +125,6 @@ function parseClaudeTransientOverloadPane(text: string): PaneRateLimit | 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: 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",
-      }),
-    },
-    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;