agent-relay-server 0.121.5 → 0.122.0

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

@@ -3,922 +3,8 @@
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-// sdk/src/types/constants.ts
-var DEFAULT_RELAY_PORT = 4850;
-var DEFAULT_RELAY_URL = `http://127.0.0.1:${DEFAULT_RELAY_PORT}`;
-// providers/registry.ts
-var PROVIDER_ID_RE = /^[a-z][a-z0-9-]*$/;
-var manifests = new Map;
-function registerProvider(manifest) {
-  if (!PROVIDER_ID_RE.test(manifest.id)) {
-    throw new Error(`invalid provider id: ${manifest.id}`);
-  }
-  if (!manifest.label.trim()) {
-    throw new Error(`provider ${manifest.id} is missing a label`);
-  }
-  if (!manifest.icon.trim()) {
-    throw new Error(`provider ${manifest.id} is missing an icon`);
-  }
-  if (manifests.has(manifest.id)) {
-    throw new Error(`provider already registered: ${manifest.id}`);
-  }
-  manifests.set(manifest.id, manifest);
-}
-function getAllManifests() {
-  return [...manifests.values()];
-}
-var accountKeyAliasResolvers = new Map;
-
-// providers/claude.ts
-var CLAUDE_LOW_TO_MAX = ["low", "medium", "high", "max"];
-var CLAUDE_LOW_TO_XHIGH_MAX = ["low", "medium", "high", "xhigh", "max"];
-var CONTEXT_200K = { value: 200000, source: "catalog", confidence: "declared" };
-var CONTEXT_1M = { value: 1e6, source: "catalog", confidence: "declared" };
-var CODE_MODEL_CAPABILITIES = {
-  modalities: {
-    input: { text: true, image: true },
-    output: { text: true }
-  },
-  tools: {
-    code: true,
-    review: true,
-    debug: true,
-    refactor: true
-  },
-  source: "catalog",
-  confidence: "declared"
-};
-var quotaWindows = [
-  { name: "five_hour", unit: "%", reset: true },
-  { name: "seven_day", unit: "%", reset: true }
-];
-function codeModel(limits) {
-  return {
-    ...limits ? { limits } : {},
-    capabilities: CODE_MODEL_CAPABILITIES
-  };
-}
-var claudeProviderManifest = {
-  id: "claude",
-  label: "Claude",
-  icon: "\uD83D\uDFE0",
-  launch: {
-    managedPolicyPrompt: {
-      alwaysOn: "append-system-prompt"
-    },
-    taskHydration: {
-      channel: "append-system-prompt"
-    }
-  },
-  catalog: {
-    defaultModel: "sonnet-5",
-    models: [
-      { alias: "fable-5", label: "Fable 5", providerModel: "claude-fable-5", efforts: CLAUDE_LOW_TO_XHIGH_MAX, defaultEffort: "medium", unavailable: "suspended by export-control directive, 2026-06-12", ...codeModel({ contextWindowTokens: CONTEXT_1M }) },
-      { alias: "opus-4.8", label: "Opus 4.8", providerModel: "claude-opus-4-8", efforts: CLAUDE_LOW_TO_XHIGH_MAX, defaultEffort: "medium", ...codeModel({ contextWindowTokens: CONTEXT_200K }) },
-      { alias: "opus-4.8[1m]", label: "Opus 4.8 1M", providerModel: "claude-opus-4-8[1m]", efforts: CLAUDE_LOW_TO_XHIGH_MAX, defaultEffort: "medium", ...codeModel({ contextWindowTokens: CONTEXT_1M }) },
-      { alias: "opus-4.7", label: "Opus 4.7", providerModel: "claude-opus-4-7", efforts: CLAUDE_LOW_TO_XHIGH_MAX, defaultEffort: "medium", ...codeModel({ contextWindowTokens: CONTEXT_200K }) },
-      { alias: "opus-4.7[1m]", label: "Opus 4.7 1M", providerModel: "claude-opus-4-7[1m]", efforts: CLAUDE_LOW_TO_XHIGH_MAX, defaultEffort: "medium", ...codeModel({ contextWindowTokens: CONTEXT_1M }) },
-      { alias: "opus-4.6", label: "Opus 4.6", providerModel: "claude-opus-4-6", efforts: CLAUDE_LOW_TO_MAX, defaultEffort: "medium", ...codeModel({ contextWindowTokens: CONTEXT_200K }) },
-      { alias: "opus-4.6[1m]", label: "Opus 4.6 1M", providerModel: "claude-opus-4-6[1m]", efforts: CLAUDE_LOW_TO_MAX, defaultEffort: "medium", ...codeModel({ contextWindowTokens: CONTEXT_1M }) },
-      { alias: "sonnet-5", label: "Sonnet 5", providerModel: "claude-sonnet-5", efforts: CLAUDE_LOW_TO_XHIGH_MAX, defaultEffort: "medium", ...codeModel({ contextWindowTokens: CONTEXT_200K }) },
-      { alias: "sonnet-5[1m]", label: "Sonnet 5 1M", providerModel: "claude-sonnet-5[1m]", efforts: CLAUDE_LOW_TO_XHIGH_MAX, defaultEffort: "medium", ...codeModel({ contextWindowTokens: CONTEXT_1M }) },
-      { alias: "haiku", label: "Haiku", providerModel: "haiku", efforts: [], ...codeModel() }
-    ]
-  },
-  quotaWindows: [...quotaWindows],
-  capabilityDefaults: {
-    lifecycle: {
-      managed: true,
-      shutdownHard: { when: "headless", value: true, otherwise: false },
-      restartHard: { when: "headless", value: true, otherwise: false },
-      semanticStatus: true,
-      reconnect: true
-    },
-    session: {
-      fileRead: true,
-      fileWrite: { when: "approval:not-read-only", value: true, otherwise: false },
-      shell: true,
-      shellMode: { open: "unrestricted", guarded: "guarded", readOnly: "read-only-guarded" }
-    },
-    context: {
-      managed: "headless",
-      compact: { when: "headless", value: true, otherwise: false },
-      clear: { when: "headless", value: true, otherwise: false },
-      inject: true,
-      resumePreference: ["native", "clear-inject", "none"]
-    },
-    quota: {
-      supported: true,
-      source: "probe",
-      unit: "%",
-      windows: [...quotaWindows]
-    },
-    terminal: {
-      mode: "live",
-      condition: "headless",
-      live: { read: true, write: true }
-    },
-    liveSession: {
-      capture: true,
-      inject: true,
-      interrupt: true,
-      promptEcho: true,
-      reasoning: true,
-      slashCommands: true
-    }
-  },
-  slashCommands: ["/clear", "/compact", "/model", "/help"],
-  resume: { supported: true, idFormat: "uuid-v4", idPattern: "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}" },
-  home: { configDir: ".claude", envPrefix: "CLAUDE", configDirEnvVar: "CLAUDE_CONFIG_DIR", quotaCredentialFile: ".credentials.json", authItems: [".credentials.json", "statsig"], globalInstructionFiles: ["CLAUDE.md"] },
-  provisioning: {
-    pluginManifestPath: ".claude-plugin/plugin.json",
-    bundledPlugin: {
-      ref: "agent-relay-claude-plugin",
-      dir: "runner/plugins/claude",
-      title: "Agent Relay Claude plugin",
-      description: "Bundled Agent Relay Claude plugin, materialized whole through the provisioning registry.",
-      omitFiles: ["monitors/relay-monitor.provisioned.mjs"],
-      fileOverrides: [{ path: "monitors/relay-monitor.ts", sourcePath: "monitors/relay-monitor.provisioned.mjs" }]
-    }
-  },
-  upgrade: {
-    packages: ["agent-relay-runner", "agent-relay-plugin"],
-    detectPackages: ["agent-relay-runner"],
-    detectCommands: ["claude"]
-  },
-  probe: {
-    command: "claude",
-    args: ["--version"],
-    healthCheck: "claude --version",
-    featureChecks: [{ name: "rig", command: "claude-rig", homeDir: ".claude-rig" }]
-  },
-  quotaPoll: { strategy: "none" },
-  shim: { kind: "claude-relay" }
-};
-registerProvider(claudeProviderManifest);
-
-// providers/codex.ts
-var CODEX_REASONING = ["low", "medium", "high", "xhigh"];
-var CONTEXT_200K2 = { value: 200000, source: "catalog", confidence: "declared" };
-var CODE_MODEL_CAPABILITIES2 = {
-  modalities: {
-    input: { text: true, image: true },
-    output: { text: true }
-  },
-  tools: {
-    code: true,
-    review: true,
-    debug: true,
-    refactor: true
-  },
-  source: "catalog",
-  confidence: "declared"
-};
-var quotaWindows2 = [
-  { name: "primary", unit: "%", reset: true },
-  { name: "secondary", unit: "%", reset: true }
-];
-function codeModel2(limits) {
-  return {
-    ...limits ? { limits } : {},
-    capabilities: CODE_MODEL_CAPABILITIES2
-  };
-}
-var codexProviderManifest = {
-  id: "codex",
-  label: "Codex",
-  icon: "\u2328\uFE0F",
-  launch: {
-    managedPolicyPrompt: {
-      alwaysOn: "prompt"
-    },
-    taskHydration: {
-      channel: "prompt"
-    }
-  },
-  catalog: {
-    defaultModel: "gpt-5.5",
-    models: [
-      { alias: "gpt-5.5", label: "GPT-5.5", providerModel: "gpt-5.5", efforts: CODEX_REASONING, defaultEffort: "medium", ...codeModel2({ contextWindowTokens: CONTEXT_200K2 }) },
-      { alias: "gpt-5.4", label: "GPT-5.4", providerModel: "gpt-5.4", efforts: CODEX_REASONING, defaultEffort: "medium", ...codeModel2({ contextWindowTokens: CONTEXT_200K2 }) },
-      { alias: "gpt-5.4-mini", label: "GPT-5.4 Mini", providerModel: "gpt-5.4-mini", efforts: CODEX_REASONING, defaultEffort: "medium", ...codeModel2({ contextWindowTokens: CONTEXT_200K2 }) },
-      { alias: "gpt-5.3-codex", label: "GPT-5.3 Codex", providerModel: "gpt-5.3-codex", efforts: CODEX_REASONING, defaultEffort: "medium", ...codeModel2({ contextWindowTokens: CONTEXT_200K2 }) },
-      { alias: "gpt-5.3-codex-spark", label: "GPT-5.3 Codex Spark", providerModel: "gpt-5.3-codex-spark", efforts: CODEX_REASONING, defaultEffort: "high", ...codeModel2({ contextWindowTokens: CONTEXT_200K2 }) },
-      { alias: "gpt-5.2", label: "GPT-5.2", providerModel: "gpt-5.2", efforts: CODEX_REASONING, defaultEffort: "medium", ...codeModel2({ contextWindowTokens: CONTEXT_200K2 }) }
-    ]
-  },
-  quotaWindows: [...quotaWindows2],
-  capabilityDefaults: {
-    lifecycle: {
-      managed: true,
-      shutdownHard: true,
-      restartHard: true,
-      semanticStatus: true,
-      reconnect: true
-    },
-    session: {
-      fileRead: true,
-      fileWrite: { when: "approval:not-read-only", value: true, otherwise: false },
-      shell: { when: "approval:not-read-only", value: true, otherwise: false },
-      shellMode: { open: "unrestricted", guarded: "guarded", readOnly: "none" }
-    },
-    context: {
-      managed: "always",
-      compact: true,
-      clear: true,
-      inject: true,
-      resumePreference: ["native", "clear-inject", "none"]
-    },
-    quota: {
-      supported: true,
-      source: "probe",
-      unit: "%",
-      windows: [...quotaWindows2]
-    },
-    terminal: {
-      mode: "attach",
-      attach: {
-        create: true,
-        read: true,
-        write: true,
-        detach: true
-      }
-    },
-    liveSession: {
-      capture: true,
-      inject: true,
-      interrupt: true,
-      promptEcho: true,
-      reasoning: true,
-      slashCommands: true
-    }
-  },
-  slashCommands: ["/compact", "/new"],
-  resume: { supported: true, idFormat: "codex-thread-id", idPattern: "[\\w-]+" },
-  home: { configDir: ".codex", envPrefix: "CODEX", configDirEnvVar: "CODEX_HOME", quotaCredentialFile: "auth.json", authItems: ["auth.json", "installation_id"], globalInstructionFiles: ["AGENTS.md"] },
-  provisioning: {
-    pluginManifestPath: ".codex-plugin/plugin.json",
-    bundledSkills: {
-      refPrefix: "agent-relay-codex-",
-      dir: "runner/plugins/codex/skills",
-      titlePrefix: "Agent Relay Codex skill: ",
-      description: "Bundled Agent Relay Codex skill, materialized through the provisioning registry.",
-      entryFile: "SKILL.md"
-    }
-  },
-  upgrade: {
-    packages: ["agent-relay-runner", "agent-relay-codex"],
-    detectPackages: ["agent-relay-runner", "agent-relay-codex"],
-    detectCommands: ["codex-relay", "agent-relay-runner"]
-  },
-  probe: {
-    command: "codex",
-    args: ["--version"],
-    healthCheck: "codex --version"
-  },
-  quotaPoll: { strategy: "codex-app-server" },
-  shim: { kind: "codex-relay", extraBinPaths: ["codex/bin/codex"], cleanLegacyHooks: true }
-};
-registerProvider(codexProviderManifest);
-// sdk/src/types/agents.ts
-var SPAWN_PROVIDERS = getAllManifests().map((manifest) => manifest.id);
-// sdk/src/provider-catalog.ts
-function manifestToCatalogEntry(manifest) {
-  return {
-    provider: manifest.id,
-    label: manifest.label,
-    defaultModel: manifest.catalog.defaultModel,
-    models: manifest.catalog.models
-  };
-}
-var PROVIDER_CATALOG = Object.fromEntries(getAllManifests().map((manifest) => [manifest.id, manifestToCatalogEntry(manifest)]));
-// sdk/src/reconnect.ts
-import { setTimeout as delay } from "timers/promises";
-var DEFAULTS = {
-  initialMs: 1000,
-  maxMs: 30000,
-  jitterMs: 500
-};
-
-class ReconnectionManager {
-  attempts = 0;
-  abort;
-  options;
-  constructor(options = {}) {
-    this.options = {
-      initialMs: options.initialMs ?? DEFAULTS.initialMs,
-      maxMs: options.maxMs ?? DEFAULTS.maxMs,
-      jitterMs: options.jitterMs ?? DEFAULTS.jitterMs
-    };
-  }
-  get attempt() {
-    return this.attempts;
-  }
-  nextDelay() {
-    const base = Math.min(this.options.maxMs, this.options.initialMs * 2 ** this.attempts);
-    this.attempts += 1;
-    const jitter = this.options.jitterMs > 0 ? Math.floor(Math.random() * (this.options.jitterMs + 1)) : 0;
-    return Math.min(this.options.maxMs, base + jitter);
-  }
-  reset() {
-    this.attempts = 0;
-    this.cancel();
-  }
-  async schedule() {
-    this.cancel();
-    this.abort = new AbortController;
-    const ms = this.nextDelay();
-    await delay(ms, undefined, { signal: this.abort.signal }).catch((error) => {
-      if (error.name !== "AbortError")
-        throw error;
-    });
-  }
-  cancel() {
-    this.abort?.abort();
-    this.abort = undefined;
-  }
-}
-// sdk/src/config.ts
-function relayTokenFromEnv() {
-  return process.env.AGENT_RELAY_TOKEN;
-}
-// sdk/src/bus-client.ts
-import { EventEmitter } from "events";
-function unrefTimer(timer) {
-  timer?.unref?.();
-}
-
-class MemoryCursorStore {
-  value = null;
-  async load() {
-    return this.value;
-  }
-  async save(cursor) {
-    this.value = cursor;
-  }
-}
-
-class RelayBusClient extends EventEmitter {
-  options;
-  ws = null;
-  registeredEpoch = 0;
-  lastCursor = 0;
-  serverCursor = 0;
-  closed = false;
-  connecting = null;
-  heartbeat;
-  heartbeatWatchdog;
-  pendingHeartbeatId;
-  pendingHeartbeatSentAt;
-  lastServerFrameAt = 0;
-  lastHeartbeatAckAt = 0;
-  heartbeatAckSupported = false;
-  semanticStatus;
-  transport = { connected: false, reconnecting: false };
-  reconnect;
-  cursorStore;
-  subscriptions = new Set(["message.*", "agent.status", "task.*"]);
-  pending = new Map;
-  constructor(options) {
-    super();
-    this.options = options;
-    this.reconnect = new ReconnectionManager({
-      initialMs: options.reconnect?.initialMs,
-      maxMs: options.reconnect?.maxMs,
-      jitterMs: options.reconnect?.jitterMs
-    });
-    this.cursorStore = options.cursorStore ?? new MemoryCursorStore;
-    this.semanticStatus = options.initialStatus ?? "idle";
-  }
-  get connected() {
-    return this.ws?.readyState === WebSocket.OPEN && this.registeredEpoch > 0;
-  }
-  get epoch() {
-    return this.registeredEpoch;
-  }
-  get cursor() {
-    return this.lastCursor;
-  }
-  get transportState() {
-    return { ...this.transport };
-  }
-  async connect() {
-    if (this.connecting)
-      return this.connecting;
-    this.closed = false;
-    this.connecting = this.connectLoop().finally(() => {
-      this.connecting = null;
-    });
-    return this.connecting;
-  }
-  async close() {
-    this.closed = true;
-    this.stopHeartbeat();
-    this.stopHeartbeatWatchdog();
-    this.reconnect.cancel();
-    for (const pending of this.pending.values())
-      pending.reject(new Error("bus client closed"));
-    this.pending.clear();
-    if (this.ws && this.ws.readyState <= WebSocket.OPEN)
-      this.ws.close();
-    this.ws = null;
-  }
-  setToken(token) {
-    this.options.token = token;
-  }
-  reconnectTransport(reason = "client requested reconnect") {
-    this.forceReconnect(reason, { emitError: false, code: 4001 });
-  }
-  status(update) {
-    if (update.agentStatus === "idle" || update.agentStatus === "busy")
-      this.semanticStatus = update.agentStatus;
-    this.send({
-      type: "status",
-      payload: {
-        agentStatus: update.agentStatus,
-        ready: update.ready,
-        meta: update.meta
-      }
-    });
-  }
-  async statusAsync(update) {
-    this.status(update);
-    await Promise.resolve();
-  }
-  setSemanticStatus(status) {
-    this.semanticStatus = status;
-  }
-  updateCommand(commandId, params) {
-    return this.command("command.update", commandId, params);
-  }
-  command(type, target, params) {
-    const id = crypto.randomUUID();
-    this.send({ type: "command", id, payload: { commandType: type, target, params } });
-    return new Promise((resolve, reject) => {
-      this.pending.set(id, { resolve, reject });
-    });
-  }
-  async subscribe(events, scopes) {
-    for (const event of events)
-      this.subscriptions.add(event);
-    const id = crypto.randomUUID();
-    this.send({ type: "subscribe", id, payload: { events, scopes } });
-    await Promise.resolve();
-  }
-  on(event, listener) {
-    return super.on(event, listener);
-  }
-  off(event, listener) {
-    return super.off(event, listener);
-  }
-  once(event, listener) {
-    return super.once(event, listener);
-  }
-  async connectLoop() {
-    while (!this.closed) {
-      try {
-        await this.openOnce();
-        this.reconnect.reset();
-        return;
-      } catch (error) {
-        if (this.closed)
-          throw error;
-        const delayMs = this.reconnect.nextDelay();
-        this.transport = { ...this.transport, connected: false, reconnecting: true };
-        this.emit("reconnecting", this.reconnect.attempt, delayMs);
-        await new Promise((resolve) => setTimeout(resolve, delayMs));
-      }
-    }
-  }
-  async openOnce() {
-    const cursor = await this.cursorStore.load();
-    if (cursor !== null)
-      this.lastCursor = cursor;
-    await new Promise((resolve, reject) => {
-      const ws = new WebSocket(this.wsUrl());
-      this.ws = ws;
-      let resolved = false;
-      ws.onopen = () => {
-        if (this.ws !== ws)
-          return;
-        const now = Date.now();
-        this.lastServerFrameAt = now;
-        this.transport = { ...this.transport, connected: true, reconnecting: false, lastConnectedAt: now, lastServerFrameAt: now, reconnectReason: undefined };
-        this.emit("connected");
-        this.sendRegister();
-      };
-      ws.onmessage = (message) => {
-        if (this.ws !== ws)
-          return;
-        this.handleMessage(message.data, () => {
-          if (!resolved) {
-            resolved = true;
-            resolve();
-          }
-        });
-      };
-      ws.onerror = () => {
-        if (this.ws !== ws)
-          return;
-        if (!resolved)
-          reject(new Error("bus connection failed"));
-      };
-      ws.onclose = (event) => {
-        if (this.ws !== ws)
-          return;
-        this.stopHeartbeat();
-        this.stopHeartbeatWatchdog();
-        this.registeredEpoch = 0;
-        this.heartbeatAckSupported = false;
-        this.transport = { ...this.transport, connected: false, reconnecting: !this.closed, lastDisconnectedAt: Date.now() };
-        const reason = event.reason || `closed:${event.code}`;
-        this.emit("disconnected", reason);
-        if (!resolved) {
-          resolved = true;
-          reject(new Error(reason));
-          return;
-        }
-        if (!this.closed)
-          this.connect();
-      };
-    });
-  }
-  sendRegister() {
-    this.send({
-      type: "register",
-      id: crypto.randomUUID(),
-      payload: {
-        role: this.options.role,
-        componentId: this.options.componentId,
-        agentId: this.options.agentId,
-        instanceId: this.options.instanceId,
-        capabilities: this.options.capabilities ?? [],
-        tags: this.options.tags ?? [],
-        machine: this.options.machine ?? "unknown",
-        meta: this.registrationMeta()
-      }
-    });
-  }
-  async handleMessage(data, onRegistered) {
-    this.recordServerFrame();
-    let frame;
-    try {
-      frame = JSON.parse(typeof data === "string" ? data : String(data));
-    } catch {
-      this.emit("error", "INVALID_JSON", "server sent invalid JSON");
-      return;
-    }
-    if (frame.type === "registered") {
-      const payload = frame.payload;
-      const resumeFrom = this.lastCursor;
-      this.registeredEpoch = payload.epoch;
-      this.serverCursor = payload.cursor;
-      this.heartbeatAckSupported = payload.features?.heartbeatAck === true;
-      this.emit("registered", payload.epoch, payload.cursor);
-      this.send({ type: "subscribe", id: crypto.randomUUID(), payload: { events: [...this.subscriptions] } });
-      if (resumeFrom > 0 && resumeFrom < payload.cursor) {
-        this.send({ type: "resume", id: crypto.randomUUID(), payload: { since: resumeFrom } });
-      } else {
-        this.lastCursor = payload.cursor;
-        await this.cursorStore.save(this.lastCursor);
-      }
-      this.startHeartbeat();
-      if (this.heartbeatAckSupported)
-        this.startHeartbeatWatchdog();
-      else
-        this.stopHeartbeatWatchdog();
-      onRegistered();
-      return;
-    }
-    if (frame.type === "ack") {
-      if (frame.payload.frameId === this.pendingHeartbeatId) {
-        this.lastHeartbeatAckAt = Date.now();
-        this.pendingHeartbeatId = undefined;
-        this.pendingHeartbeatSentAt = undefined;
-        this.transport = { ...this.transport, lastHeartbeatAckAt: this.lastHeartbeatAckAt };
-      }
-      return;
-    }
-    if (frame.type === "event") {
-      await this.handleEvent(frame.payload);
-      return;
-    }
-    if (frame.type === "resumed") {
-      for (const event of frame.payload.events)
-        await this.handleEvent(event);
-      if (frame.payload.truncated) {
-        const nextSince = typeof frame.payload.nextSince === "number" ? frame.payload.nextSince : frame.payload.toSeq;
-        this.send({ type: "resume", id: crypto.randomUUID(), payload: { since: nextSince } });
-      }
-      return;
-    }
-    if (frame.type === "command.result") {
-      const pending = this.pending.get(frame.payload.commandId);
-      if (!pending)
-        return;
-      this.pending.delete(frame.payload.commandId);
-      if (frame.payload.status === "succeeded")
-        pending.resolve(frame.payload.result ?? null);
-      else
-        pending.reject(new Error(frame.payload.error || frame.payload.status));
-      return;
-    }
-    if (frame.type === "error") {
-      const error = frame;
-      if (error.payload.code === "REPLAY_GAP") {
-        await this.options.reconcile?.();
-        this.lastCursor = this.serverCursor;
-        await this.cursorStore.save(this.lastCursor);
-      }
-      this.emit("error", error.payload.code, error.payload.message);
-      if (error.payload.frameId) {
-        const pending = this.pending.get(error.payload.frameId);
-        if (pending) {
-          this.pending.delete(error.payload.frameId);
-          pending.reject(new Error(error.payload.message));
-        }
-      }
-    }
-  }
-  async handleEvent(event) {
-    this.lastCursor = Math.max(this.lastCursor, event.seq);
-    await this.cursorStore.save(this.lastCursor);
-    this.emit("event", event.eventType, event.data, event.seq);
-    if (event.eventType === "command.requested") {
-      const command = isRecord(event.data.command) ? event.data.command : undefined;
-      if (command) {
-        const commandType = typeof command.type === "string" ? command.type : "";
-        const commandId = typeof command.id === "string" ? command.id : "";
-        const params = isRecord(command.params) ? command.params : {};
-        this.emit("command", commandType, params, commandId, command);
-      }
-    }
-    this.emit(event.eventType, event.data);
-    if (event.eventType.startsWith("task."))
-      this.emit("task.changed", event.data);
-  }
-  startHeartbeat() {
-    this.stopHeartbeat();
-    this.sendHeartbeat();
-    this.heartbeat = setInterval(() => {
-      this.sendHeartbeat();
-    }, this.options.heartbeatIntervalMs ?? 30000);
-    unrefTimer(this.heartbeat);
-  }
-  stopHeartbeat() {
-    if (this.heartbeat)
-      clearInterval(this.heartbeat);
-    this.heartbeat = undefined;
-    this.pendingHeartbeatId = undefined;
-    this.pendingHeartbeatSentAt = undefined;
-  }
-  startHeartbeatWatchdog() {
-    this.stopHeartbeatWatchdog();
-    const intervalMs = Math.max(100, Math.min(5000, this.heartbeatIntervalMs()));
-    this.heartbeatWatchdog = setInterval(() => this.checkHeartbeatAck(), intervalMs);
-    unrefTimer(this.heartbeatWatchdog);
-  }
-  stopHeartbeatWatchdog() {
-    if (this.heartbeatWatchdog)
-      clearInterval(this.heartbeatWatchdog);
-    this.heartbeatWatchdog = undefined;
-  }
-  sendHeartbeat() {
-    if (!this.ws || this.ws.readyState !== WebSocket.OPEN || !this.registeredEpoch)
-      return;
-    const now = Date.now();
-    const expectAck = this.heartbeatAckSupported;
-    if (expectAck && this.pendingHeartbeatId && this.pendingHeartbeatSentAt && now - this.pendingHeartbeatSentAt < this.heartbeatIntervalMs())
-      return;
-    const id = expectAck ? crypto.randomUUID() : undefined;
-    const meta = this.heartbeatMeta();
-    if (expectAck && id) {
-      this.pendingHeartbeatId = id;
-      if (!this.pendingHeartbeatSentAt)
-        this.pendingHeartbeatSentAt = now;
-    }
-    this.send({ type: "heartbeat", ...id ? { id } : {}, payload: { status: this.semanticStatus, ...meta ? { meta } : {} } });
-  }
-  checkHeartbeatAck() {
-    if (!this.pendingHeartbeatSentAt || !this.ws || this.ws.readyState !== WebSocket.OPEN)
-      return;
-    const ageMs = Date.now() - this.pendingHeartbeatSentAt;
-    if (ageMs <= this.heartbeatAckTimeoutMs())
-      return;
-    this.forceReconnect(`heartbeat ack timeout after ${ageMs}ms`, { emitError: true, code: 4000 });
-  }
-  forceReconnect(reason, opts) {
-    if (this.closed)
-      return;
-    this.transport = { ...this.transport, connected: false, reconnecting: true, lastDisconnectedAt: Date.now(), reconnectReason: reason };
-    if (opts.emitError)
-      this.emit("error", "HEARTBEAT_TIMEOUT", reason);
-    this.stopHeartbeat();
-    this.stopHeartbeatWatchdog();
-    const ws = this.ws;
-    this.ws = null;
-    this.registeredEpoch = 0;
-    this.heartbeatAckSupported = false;
-    if (ws && ws.readyState <= WebSocket.OPEN)
-      ws.close(opts.code, reason.slice(0, 120));
-    this.connect();
-  }
-  heartbeatIntervalMs() {
-    return this.options.heartbeatIntervalMs ?? 30000;
-  }
-  heartbeatAckTimeoutMs() {
-    return this.options.heartbeatAckTimeoutMs ?? Math.max(1e4, Math.ceil(this.heartbeatIntervalMs() * 1.5));
-  }
-  recordServerFrame() {
-    this.lastServerFrameAt = Date.now();
-    this.transport = { ...this.transport, lastServerFrameAt: this.lastServerFrameAt };
-  }
-  send(frame) {
-    if (!this.ws || this.ws.readyState !== WebSocket.OPEN)
-      return;
-    this.ws.send(JSON.stringify(frame));
-  }
-  wsUrl() {
-    const url = new URL(this.options.url);
-    const token = this.options.token ?? relayTokenFromEnv();
-    if (token && !url.searchParams.has("token"))
-      url.searchParams.set("token", token);
-    return url.toString();
-  }
-  registrationMeta() {
-    return {
-      ...this.options.meta ?? {},
-      ...this.options.providerCapabilities ? { providerCapabilities: this.options.providerCapabilities } : {},
-      ...this.options.context ? { context: this.options.context } : {}
-    };
-  }
-  heartbeatMeta() {
-    const dynamic = this.options.heartbeatMeta?.();
-    const meta = {
-      ...dynamic ?? {},
-      ...this.options.providerCapabilities ? { providerCapabilities: this.options.providerCapabilities } : {},
-      ...this.options.context ? { context: this.options.context } : {}
-    };
-    return Object.keys(meta).length ? meta : undefined;
-  }
-}
-// sdk/src/provider-base.ts
-function unrefTimer2(timer) {
-  timer?.unref?.();
-}
 
-class ProviderBase {
-  options;
-  client;
-  running = false;
-  pending = new Map;
-  drain;
-  constructor(options) {
-    this.options = options;
-    this.client = new RelayBusClient({
-      url: options.relayUrl,
-      role: "provider",
-      componentId: `${options.adapter.providerName}:${options.agentId}`,
-      agentId: options.agentId,
-      instanceId: options.instanceId,
-      token: options.token,
-      capabilities: options.adapter.capabilities,
-      tags: options.tags ?? [options.adapter.providerName],
-      machine: options.machine,
-      meta: { provider: options.adapter.providerName, ...options.meta ?? {} }
-    });
-  }
-  async run() {
-    if (this.running)
-      return;
-    this.running = true;
-    this.client.on("message.new", (message) => this.queueMessage(message));
-    await this.client.connect();
-    this.startStatusLoop();
-  }
-  async stop() {
-    this.running = false;
-    if (this.drain)
-      clearInterval(this.drain);
-    this.drain = undefined;
-    await this.client.close();
-  }
-  queueMessage(message) {
-    if (message.to !== this.options.agentId && message.to !== "broadcast" && !message.to.startsWith("tag:") && !message.to.startsWith("cap:") && !message.to.startsWith("label:") && !message.to.startsWith("team:")) {
-      return;
-    }
-    this.pending.set(message.id, message);
-    this.drainMessages();
-  }
-  async drainMessages() {
-    if (!this.running || this.pending.size === 0)
-      return;
-    const messages2 = [...this.pending.values()].sort((a, b) => a.id - b.id);
-    this.pending.clear();
-    await this.options.adapter.deliverMessage(this.options.agentId, messages2);
-  }
-  startStatusLoop() {
-    this.drain = setInterval(async () => {
-      if (!this.running)
-        return;
-      try {
-        const status = await this.options.adapter.getAgentStatus(this.options.agentId);
-        this.client.status({ agentStatus: status, ready: true });
-      } catch {
-        this.client.status({ agentStatus: "online", ready: false });
-      }
-    }, 30000);
-    unrefTimer2(this.drain);
-  }
-}
-// sdk/src/claim-tracker.ts
-class WorkClaimTracker {
-  providerActive = false;
-  claims = new Map;
-  setProviderActive(active) {
-    this.providerActive = active;
-  }
-  start(kind, id, expiresAt) {
-    this.claims.set(`${kind}:${id}`, { kind, id, startedAt: Date.now(), expiresAt });
-  }
-  finish(kind, id) {
-    this.claims.delete(`${kind}:${id}`);
-  }
-  expire(now = Date.now()) {
-    for (const [key, claim] of this.claims) {
-      if (claim.expiresAt !== undefined && claim.expiresAt <= now)
-        this.claims.delete(key);
-    }
-  }
-  status() {
-    return this.providerActive || this.claims.size > 0 ? "busy" : "idle";
-  }
-  active() {
-    return [...this.claims.values()];
-  }
-}
-// sdk/src/process-utils.ts
-import { execFile } from "child_process";
-import { promisify } from "util";
-var execFileAsync = promisify(execFile);
-// sdk/src/teams-config.ts
-var TEAM_IDLE_THRESHOLD_MINUTES_MAX = 24 * 60;
-// sdk/src/admission/semaphore.ts
-class Semaphore {
-  #limit;
-  #inFlight = 0;
-  #waiters = [];
-  constructor(limit) {
-    if (!Number.isInteger(limit) || limit < 1) {
-      throw new RangeError(`Semaphore limit must be an integer >= 1, got ${limit}`);
-    }
-    this.#limit = limit;
-  }
-  get limit() {
-    return this.#limit;
-  }
-  get inFlight() {
-    return this.#inFlight;
-  }
-  get waiting() {
-    return this.#waiters.length;
-  }
-  get available() {
-    return this.#limit - this.#inFlight;
-  }
-  tryAcquire() {
-    if (this.#inFlight < this.#limit) {
-      this.#inFlight++;
-      return true;
-    }
-    return false;
-  }
-  acquire() {
-    if (this.tryAcquire())
-      return Promise.resolve();
-    return new Promise((resolve) => {
-      this.#waiters.push(resolve);
-    });
-  }
-  release() {
-    const next = this.#waiters.shift();
-    if (next) {
-      next();
-      return;
-    }
-    if (this.#inFlight > 0)
-      this.#inFlight--;
-  }
-  async run(fn) {
-    await this.acquire();
-    try {
-      return await fn();
-    } finally {
-      this.release();
-    }
-  }
-}
-// runner/src/config.ts
+// runner/src/message-body-config.ts
 function messageBodyMaxCharsFromEnv() {
   return process.env.AGENT_RELAY_MESSAGE_BODY_MAX_CHARS;
 }
@@ -1085,6 +171,38 @@ function providerMessageBodyMaxChars() {
   }
   return DEFAULT_PROVIDER_MESSAGE_BODY_MAX_CHARS;
 }
+function previewDeliveredBody(rawBody, messageId, maxChars = providerMessageBodyMaxChars()) {
+  if (rawBody.length <= maxChars)
+    return { body: rawBody, truncated: false, guidance: [] };
+  const fetchLines = [
+    `Read full: agent-relay get-message ${messageId}`,
+    `Body only: agent-relay get-message ${messageId} --body`
+  ];
+  const marker = (elided2) => `[\u2026 ${elided2} chars elided from the middle \u2014 full report: relay_get_message #${messageId} \u2026]`;
+  const budget = maxChars - marker(rawBody.length).length - 4;
+  if (budget < 200) {
+    const tail2 = rawBody.slice(rawBody.length - maxChars).replace(/^\S*\s+/, "").trimStart();
+    return {
+      body: tail2,
+      truncated: true,
+      guidance: [`[truncated: showing last ${tail2.length} of ${rawBody.length} chars \u2014 head trimmed, tail/verdict preserved]`, ...fetchLines]
+    };
+  }
+  const headChars = Math.floor(budget * 0.35);
+  const tailChars = budget - headChars;
+  const head = rawBody.slice(0, headChars).replace(/\s+\S*$/, "").trimEnd();
+  const tail = rawBody.slice(rawBody.length - tailChars).replace(/^\S*\s+/, "").trimStart();
+  const elided = rawBody.length - head.length - tail.length;
+  return {
+    body: `${head}
+
+${marker(elided)}
+
+${tail}`,
+    truncated: true,
+    guidance: [`[truncated: showing first ${head.length} + last ${tail.length} of ${rawBody.length} chars \u2014 tail/verdict preserved]`, ...fetchLines]
+  };
+}
 function attachmentRefs(message) {
   const payloadRefs = message.payload?.attachments;
   const topLevelRefs = message.attachments;
@@ -1111,9 +229,9 @@ var NOTIFICATION_NUDGE = "\u21AA Notification \u2014 no reply needed.";
 function isNotificationMessage(message) {
   return isPersistedRelayMessage(message) && message.replyExpected === false;
 }
-function dedupePersistedMessages(messages2) {
+function dedupePersistedMessages(messages) {
   const seen = new Set;
-  return messages2.filter((message) => {
+  return messages.filter((message) => {
     if (!isPersistedRelayMessage(message))
       return true;
     if (seen.has(message.id))
@@ -1199,8 +317,8 @@ function providerSenderLabel(message) {
 function shouldShowReplyReminder(deliveryCount) {
   return deliveryCount <= 1 || deliveryCount % REMINDER_EVERY_DELIVERIES === 0;
 }
-function latestReplyableMessage(messages2) {
-  return messages2.filter((message) => isPersistedRelayMessage2(message) && !isMemoryInjection(message) && !isReactionNotification(message) && !isSpawnObligationMessage(message) && message.replyExpected !== false).at(-1);
+function latestReplyableMessage(messages) {
+  return messages.filter((message) => isPersistedRelayMessage2(message) && !isMemoryInjection(message) && !isReactionNotification(message) && !isSpawnObligationMessage(message) && message.replyExpected !== false).at(-1);
 }
 function formatMessage(message, relaySurface) {
   const subject = message.subject ? `Subject: ${message.subject}
@@ -1208,20 +326,8 @@ function formatMessage(message, relaySurface) {
   const isMemoryContext = isMemoryInjection(message);
   const canFetchMessage = isPersistedRelayMessage2(message);
   const rawBody = relaySurface ? message.body : stripRelayScaffolding(message.body);
-  const maxChars = providerMessageBodyMaxChars();
-  const shouldPreview = canFetchMessage && rawBody.length > maxChars;
-  const preview = shouldPreview ? {
-    body: rawBody.slice(0, maxChars),
-    truncated: true
-  } : {
-    body: rawBody,
-    truncated: false
-  };
-  const truncationGuidance = preview.truncated ? [
-    `[truncated: showing first ${maxChars} of ${rawBody.length} chars]`,
-    `Read full: agent-relay get-message ${message.id}`,
-    `Body only: agent-relay get-message ${message.id} --body`
-  ].join(`
+  const preview = canFetchMessage ? previewDeliveredBody(rawBody, message.id, providerMessageBodyMaxChars()) : { body: rawBody, truncated: false, guidance: [] };
+  const truncationGuidance = preview.truncated ? preview.guidance.join(`
 `) : undefined;
   if (isMemoryContext) {
     return [
@@ -1250,9 +356,9 @@ function replyReminder(message, readOnly) {
   ].join(`
 `);
 }
-function claudeProviderMessageText(messages2, options) {
+function claudeProviderMessageText(messages, options) {
   const relaySurface = options.relaySurface !== false;
-  const uniqueMessages = dedupePersistedMessages(messages2);
+  const uniqueMessages = dedupePersistedMessages(messages);
   const sections = uniqueMessages.map((message) => formatMessage(message, relaySurface));
   const replyable = latestReplyableMessage(uniqueMessages);
   if (relaySurface && replyable && shouldShowReplyReminder(options.deliveryCount)) {
@@ -1276,7 +382,7 @@ ws.onmessage = (event) => {
   const payload = parsePayload(String(event.data));
   if (!payload || payload.type !== "message.deliver" || !Array.isArray(payload.messages))
     return;
-  const messages2 = payload.messages;
+  const messages = payload.messages;
   deliveryCount += 1;
   if (firstDelivery) {
     console.log(process.env.AGENT_RELAY_APPROVAL === "read-only" ? claudeReadOnlyRelayContext() : claudeRelayContext());
@@ -1288,14 +394,14 @@ ws.onmessage = (event) => {
     console.log("");
     firstDelivery = false;
   }
-  console.log(claudeProviderMessageText(messages2, {
+  console.log(claudeProviderMessageText(messages, {
     deliveryCount,
     readOnly: process.env.AGENT_RELAY_APPROVAL === "read-only"
   }));
   ws.send(JSON.stringify({
     type: "message.delivered",
     deliveryId: typeof payload.deliveryId === "string" ? payload.deliveryId : "",
-    messageIds: messages2.map((message) => message.id)
+    messageIds: messages.map((message) => message.id)
   }));
 };
 ws.onerror = () => process.exit(1);