agent-relay-server 0.121.5 → 0.122.1

package/runner/src/attachment-cache.ts

@@ -0,0 +1,189 @@
+import { existsSync, mkdirSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
+import type { Artifact, Message } from "agent-relay-sdk";
+import { errMessage, isRecord } from "agent-relay-sdk";
+import { sanitizeFsName } from "agent-relay-sdk/fs-name";
+import { attachmentCacheDirFromEnv } from "./config";
+
+const DEFAULT_CACHE_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+
+interface AttachmentCacheClient {
+  downloadArtifact(id: string): Promise<{ stream: ReadableStream<Uint8Array>; meta: Artifact }>;
+}
+
+interface AttachmentCacheOptions {
+  agentId: string;
+  rootDir?: string;
+  maxAgeMs?: number;
+  now?: number;
+  onError?: (message: string) => void;
+}
+
+interface CachedAttachment {
+  path: string;
+  filename: string;
+  mediaType: string;
+  size: number;
+  digest: string;
+}
+
+function attachmentRefs(message: Message): Record<string, unknown>[] {
+  const payloadRefs = message.payload?.attachments;
+  const topLevelRefs = (message as Message & { attachments?: unknown }).attachments;
+  const refs = Array.isArray(payloadRefs) ? payloadRefs : Array.isArray(topLevelRefs) ? topLevelRefs : [];
+  return refs.filter(isRecord);
+}
+
+function attachmentCacheRoot(agentId: string, rootDir = attachmentCacheDirFromEnv()): string {
+  return join(attachmentCacheBase(rootDir), safePathPart(agentId));
+}
+
+function attachmentCacheBase(rootDir = attachmentCacheDirFromEnv()): string {
+  return rootDir || join(homedir(), ".agent-relay", "attachments");
+}
+
+export async function messagesWithCachedAttachments(
+  messages: Message[],
+  client: AttachmentCacheClient,
+  options: AttachmentCacheOptions,
+): Promise<Message[]> {
+  pruneAttachmentCache(options.agentId, options.rootDir, options.maxAgeMs ?? DEFAULT_CACHE_MAX_AGE_MS, options.now ?? Date.now());
+  const enriched: Message[] = [];
+  for (const message of messages) enriched.push(await messageWithCachedAttachments(message, client, options));
+  return enriched;
+}
+
+async function messageWithCachedAttachments(
+  message: Message,
+  client: AttachmentCacheClient,
+  options: AttachmentCacheOptions,
+): Promise<Message> {
+  const refs = attachmentRefs(message);
+  if (!refs.length) return message;
+  const nextRefs = [];
+  let changed = false;
+  for (const ref of refs) {
+    const artifactId = typeof ref.artifactId === "string" ? ref.artifactId.trim() : "";
+    if (!artifactId) {
+      nextRefs.push(ref);
+      continue;
+    }
+    try {
+      const cached = await cacheArtifact(client, artifactId, options);
+      nextRefs.push(withCacheMetadata(ref, cached));
+      changed = true;
+    } catch (error) {
+      options.onError?.(`attachment ${artifactId} cache failed: ${errMessage(error)}`);
+      nextRefs.push(withCacheError(ref, error));
+      changed = true;
+    }
+  }
+  if (!changed) return message;
+  return {
+    ...message,
+    payload: {
+      ...message.payload,
+      attachments: nextRefs,
+    },
+  };
+}
+
+async function cacheArtifact(client: AttachmentCacheClient, artifactId: string, options: AttachmentCacheOptions): Promise<CachedAttachment> {
+  const { stream, meta } = await client.downloadArtifact(artifactId);
+  const root = attachmentCacheRoot(options.agentId, options.rootDir);
+  mkdirSync(root, { recursive: true, mode: 0o700 });
+  const filename = safeFilename(meta.filename || artifactId);
+  const digestPart = safePathPart((meta.digest || meta.blobDigest || artifactId).replace(/^sha256:/, "")).slice(0, 24) || safePathPart(artifactId);
+  const path = join(root, `${digestPart}-${filename}`);
+  if (existsSync(path)) {
+    const stat = statSync(path);
+    if (stat.isFile() && stat.size === meta.size) {
+      return { path, filename, mediaType: meta.mediaType, size: meta.size, digest: meta.digest };
+    }
+  }
+  const bytes = new Uint8Array(await new Response(stream).arrayBuffer());
+  if (bytes.byteLength !== meta.size) throw new Error(`artifact size mismatch: expected ${meta.size}, got ${bytes.byteLength}`);
+  const temp = `${path}.${process.pid}.${Date.now()}.tmp`;
+  writeFileSync(temp, bytes, { mode: 0o600 });
+  rmSync(path, { force: true });
+  renameSync(temp, path);
+  return { path, filename, mediaType: meta.mediaType, size: meta.size, digest: meta.digest };
+}
+
+function withCacheMetadata(ref: Record<string, unknown>, cached: CachedAttachment): Record<string, unknown> {
+  const metadata = isRecord(ref.metadata) ? ref.metadata : {};
+  const agentRelay = isRecord(metadata.agentRelay) ? metadata.agentRelay : {};
+  return {
+    ...ref,
+    metadata: {
+      ...metadata,
+      agentRelay: {
+        ...agentRelay,
+        localPath: cached.path,
+        filename: cached.filename,
+        mediaType: cached.mediaType,
+        size: cached.size,
+        digest: cached.digest,
+        cachedAt: new Date().toISOString(),
+      },
+    },
+  };
+}
+
+function withCacheError(ref: Record<string, unknown>, error: unknown): Record<string, unknown> {
+  const metadata = isRecord(ref.metadata) ? ref.metadata : {};
+  const agentRelay = isRecord(metadata.agentRelay) ? metadata.agentRelay : {};
+  return {
+    ...ref,
+    metadata: {
+      ...metadata,
+      agentRelay: {
+        ...agentRelay,
+        cacheError: errMessage(error),
+      },
+    },
+  };
+}
+
+export function pruneAttachmentCache(
+  agentId: string,
+  rootDir = attachmentCacheDirFromEnv(),
+  maxAgeMs = DEFAULT_CACHE_MAX_AGE_MS,
+  now = Date.now(),
+): void {
+  const base = attachmentCacheBase(rootDir);
+  if (!existsSync(base)) return;
+  const roots = [attachmentCacheRoot(agentId, rootDir)];
+  for (const entry of readdirSync(base)) roots.push(join(base, entry));
+  for (const root of [...new Set(roots)]) pruneAttachmentCacheDir(root, maxAgeMs, now);
+}
+
+function pruneAttachmentCacheDir(root: string, maxAgeMs: number, now: number): void {
+  if (!existsSync(root)) return;
+  const entries = readdirSync(root);
+  for (const entry of entries) {
+    const path = join(root, entry);
+    try {
+      const stat = statSync(path);
+      if (!stat.isFile()) continue;
+      if (now - stat.mtimeMs > maxAgeMs) rmSync(path, { force: true });
+    } catch {
+      // Best-effort cache cleanup only.
+    }
+  }
+  try {
+    if (readdirSync(root).length === 0) rmSync(root, { recursive: true, force: true });
+  } catch {
+    // Best-effort cache cleanup only.
+  }
+}
+
+function safeFilename(value: string): string {
+  const name = safePathPart(basename(value));
+  return name || "artifact";
+}
+
+function safePathPart(value: string): string {
+  return sanitizeFsName(value, { replacement: "_", collapseReplacement: true, maxLen: 180 });
+}

package/runner/src/busy-reconciler.ts

@@ -0,0 +1,102 @@
+type ProviderActivity = "busy" | "idle" | "unknown";
+
+const BUSY_RECONCILE_POLL_MS = 4_000;
+const BUSY_RECONCILE_IDLE_CONFIRM = 8;
+const BUSY_RECONCILE_IDLE_CONFIRM_NO_BUSY = 15;
+const INTERRUPT_RECONCILE_DELAY_MS = 1_500;
+
+interface BusyReconcilerDeps {
+  isStopped(): boolean;
+  hasProcess(): boolean;
+  currentStatus(): "idle" | "busy" | "offline" | "error";
+  isProviderBlocked(): boolean;
+  hasProviderTurn(): boolean;
+  canProbeActivity(): boolean;
+  probeActivity(): Promise<ProviderActivity> | undefined;
+  // #769 P1-A: optional independent pane-busy read consulted ONLY at the force-clear
+  // moment. When it resolves true, a probe-`idle` must not clear the live turn.
+  probePaneBusy?(): Promise<boolean> | undefined;
+  clearProviderTurn(reason: string): void;
+  sessionDebug(message: string): void;
+}
+
+export class BusyReconciler {
+  private idleStreak = 0;
+  private timer?: ReturnType<typeof setInterval>;
+  private sawBusy = false;
+
+  constructor(private readonly deps: BusyReconcilerDeps) {}
+
+  arm(): void {
+    if (this.timer || !this.deps.canProbeActivity()) return;
+    this.idleStreak = 0;
+    this.sawBusy = false;
+    this.timer = setInterval(() => { void this.run(); }, BUSY_RECONCILE_POLL_MS);
+  }
+
+  disarm(): void {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = undefined;
+    this.idleStreak = 0;
+    this.sawBusy = false;
+  }
+
+  scheduleInterruptReconcile(): void {
+    setTimeout(() => {
+      if (this.deps.isStopped() || !this.deps.hasProcess()) return;
+      void (async () => {
+        if (this.deps.currentStatus() !== "busy" || this.deps.isProviderBlocked()) return;
+        const probe = this.deps.probeActivity();
+        let activity: ProviderActivity = "unknown";
+        try { if (probe) activity = await probe; } catch { return; }
+        this.deps.sessionDebug(`post-interrupt reconcile probe=${activity}`);
+        if (activity === "idle") this.deps.clearProviderTurn("post-interrupt");
+      })();
+    }, INTERRUPT_RECONCILE_DELAY_MS);
+  }
+
+  private async run(): Promise<void> {
+    const probe = this.deps.probeActivity();
+    if (this.deps.isStopped() || !this.deps.hasProcess() || !probe) {
+      this.disarm();
+      return;
+    }
+    if (this.deps.currentStatus() !== "busy" || this.deps.isProviderBlocked()) {
+      this.idleStreak = 0;
+      return;
+    }
+    if (!this.deps.hasProviderTurn()) {
+      this.disarm();
+      return;
+    }
+    let activity: ProviderActivity;
+    try { activity = await probe; } catch { return; }
+    if (activity === "busy") this.sawBusy = true;
+    if (activity !== "idle") {
+      this.idleStreak = 0;
+      this.deps.sessionDebug(`reconcile probe=${activity} sawBusy=${this.sawBusy} streak=${this.idleStreak}`);
+      return;
+    }
+    this.idleStreak += 1;
+    const confirm = this.sawBusy ? BUSY_RECONCILE_IDLE_CONFIRM : BUSY_RECONCILE_IDLE_CONFIRM_NO_BUSY;
+    this.deps.sessionDebug(`reconcile probe=idle sawBusy=${this.sawBusy} streak=${this.idleStreak}/${confirm}`);
+    if (this.idleStreak < confirm) return;
+    // #769 P1-A: before force-clearing, give an independent pane-busy read a veto.
+    // If the pane spinner still says busy, the probe-`idle` is untrustworthy (e.g. a
+    // connection retry wrote status:idle mid-turn) — hold the turn instead of clearing.
+    // Symmetric defense-in-depth: only clear when BOTH sources agree the turn is done.
+    const paneBusy = this.deps.probePaneBusy?.();
+    if (paneBusy) {
+      let stillBusy = false;
+      try { stillBusy = (await paneBusy) === true; } catch { stillBusy = false; }
+      if (stillBusy) {
+        this.idleStreak = 0;
+        this.sawBusy = true;
+        this.deps.sessionDebug("reconcile clear vetoed: pane still reads busy");
+        return;
+      }
+    }
+    this.disarm();
+    this.deps.clearProviderTurn(this.sawBusy ? "backstop reconciler" : "backstop reconciler (no-busy-observed)");
+  }
+}

package/runner/src/claim-tracker.ts

@@ -0,0 +1,140 @@
+type ClaimKind = "message" | "task" | "command";
+type RunnerWorkKind = "provider-turn" | "subagent" | "background-script";
+type RunnerBusyReason = RunnerWorkKind | ClaimKind;
+type RunnerSemanticStatus = "idle" | "busy" | "offline" | "error";
+
+interface ClaimRecord {
+  id: string;
+  kind: ClaimKind;
+  startedAt: number;
+  expiresAt?: number;
+}
+
+interface WorkRecord {
+  id: string;
+  kind: RunnerWorkKind;
+  label?: string;
+  role?: string;
+  parentId?: string;
+  metadata?: Record<string, unknown>;
+  // OS pids of the underlying process(es) this work tracks (#650). When present,
+  // a periodic liveness reconcile clears the record once every pid is dead — so a
+  // tracked process killed out-of-band (no exit event) can't strand the agent busy.
+  pids?: number[];
+  startedAt: number;
+}
+
+export class ClaimTracker {
+  private status: RunnerSemanticStatus = "idle";
+  private readonly claims = new Map<string, ClaimRecord>();
+  private readonly work = new Map<string, WorkRecord>();
+
+  setProviderBusy(busy: boolean): boolean {
+    return busy ? this.startWork("provider-turn", "provider-turn") : this.finishWork("provider-turn", "provider-turn");
+  }
+
+  startWork(kind: RunnerWorkKind, id: string = kind, details: Omit<Partial<WorkRecord>, "id" | "kind" | "startedAt"> = {}): boolean {
+    const before = this.currentStatus();
+    const key = `${kind}:${id}`;
+    const existing = this.work.get(key);
+    this.work.set(key, {
+      id,
+      kind,
+      label: details.label ?? existing?.label,
+      role: details.role ?? existing?.role,
+      parentId: details.parentId ?? existing?.parentId,
+      metadata: details.metadata ?? existing?.metadata,
+      pids: details.pids ?? existing?.pids,
+      startedAt: existing?.startedAt ?? Date.now(),
+    });
+    return before !== this.currentStatus();
+  }
+
+  finishWork(kind: RunnerWorkKind, id: string = kind): boolean {
+    const before = this.currentStatus();
+    this.work.delete(`${kind}:${id}`);
+    return before !== this.currentStatus();
+  }
+
+  clearWorkKind(kind: RunnerWorkKind): boolean {
+    const before = this.currentStatus();
+    for (const key of [...this.work.keys()]) {
+      if (key.startsWith(`${kind}:`)) this.work.delete(key);
+    }
+    return before !== this.currentStatus();
+  }
+
+  setTerminalStatus(status: "offline" | "error"): boolean {
+    const before = this.status;
+    this.status = status;
+    return before !== status;
+  }
+
+  clearTerminalStatus(): boolean {
+    const before = this.status;
+    this.status = "idle";
+    return before !== this.status;
+  }
+
+  startClaim(kind: ClaimKind, id: string, expiresAt?: number): boolean {
+    const before = this.currentStatus();
+    this.claims.set(`${kind}:${id}`, { kind, id, startedAt: Date.now(), expiresAt });
+    return before !== this.currentStatus();
+  }
+
+  finishClaim(kind: ClaimKind, id: string): boolean {
+    const before = this.currentStatus();
+    this.claims.delete(`${kind}:${id}`);
+    return before !== this.currentStatus();
+  }
+
+  expire(now = Date.now()): boolean {
+    const before = this.currentStatus();
+    for (const [key, claim] of this.claims) {
+      if (claim.expiresAt !== undefined && claim.expiresAt <= now) this.claims.delete(key);
+    }
+    return before !== this.currentStatus();
+  }
+
+  currentStatus(): RunnerSemanticStatus {
+    if (this.status === "offline" || this.status === "error") return this.status;
+    return this.work.size > 0 || this.claims.size > 0 ? "busy" : "idle";
+  }
+
+  reasons(): RunnerBusyReason[] {
+    const reasons = new Set<RunnerBusyReason>();
+    for (const item of this.work.values()) reasons.add(item.kind);
+    for (const claim of this.claims.values()) reasons.add(claim.kind);
+    return [...reasons];
+  }
+
+  activeWork(): WorkRecord[] {
+    return [...this.work.values()];
+  }
+
+  /** True iff any active work carries pids the liveness reconcile can check (#650). */
+  hasLivenessTrackedWork(): boolean {
+    for (const item of this.work.values()) {
+      if (item.pids && item.pids.length > 0) return true;
+    }
+    return false;
+  }
+
+  /**
+   * Reconcile pid-bearing work against actual process liveness (#650): drop any
+   * record whose tracked pids are ALL dead — its underlying process died out-of-band
+   * (killed/crashed/orphaned) with no exit event to clear the busy marker. Records
+   * with no pids are never touched (no liveness signal to act on). Returns the removed
+   * records so the caller can emit the matching completion/abort + republish status.
+   */
+  reconcileLiveness(isAlive: (pid: number) => boolean): WorkRecord[] {
+    const removed: WorkRecord[] = [];
+    for (const [key, item] of this.work) {
+      if (!item.pids || item.pids.length === 0) continue;
+      if (item.pids.some(isAlive)) continue;
+      this.work.delete(key);
+      removed.push(item);
+    }
+    return removed;
+  }
+}

package/runner/src/claude-prompt-gates.ts

@@ -0,0 +1,268 @@
+import { resolve } from "node:path";
+import { isRecord, type ProviderState } 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): ProviderState;
+}
+
+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));
+}