@humwick/server 0.0.0-stage → 0.130.0

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

@@ -0,0 +1,786 @@
+// @bun
+// sdk/src/env.ts
+function legacyEnvName(name) {
+  return name.startsWith("HUMWICK_") ? "AGENT_RELAY_" + name.slice(8) : name;
+}
+function canonicalEnvName(name) {
+  return name.startsWith("AGENT_RELAY_") ? "HUMWICK_" + name.slice(12) : name;
+}
+function relayEnv(env, name) {
+  const legacy = legacyEnvName(name);
+  const canonical = canonicalEnvName(legacy);
+  const value = env?.[canonical];
+  const fallback = canonical === legacy ? value : env?.[legacy];
+  if (value !== undefined && fallback !== undefined && value !== fallback) {
+    console.warn(`Conflicting environment keys ${canonical} and ${legacy}; using ${canonical}`);
+  }
+  return value !== undefined ? value : fallback;
+}
+
+// sdk/src/types/users.ts
+var USER_NAMESPACE_PREFIX = "user:";
+var LEGACY_HUMAN_AGENT_ID = "user";
+function userSinkId(userId) {
+  return `${USER_NAMESPACE_PREFIX}${userId}`;
+}
+var CLAUDE_APP_ID = userSinkId("claude-app");
+function isHumanAgentId(id) {
+  return id === LEGACY_HUMAN_AGENT_ID || typeof id === "string" && id.startsWith(USER_NAMESPACE_PREFIX);
+}
+
+// runner/src/response-routing.ts
+function receivesTurnResponseAutomatically(recipient) {
+  return isHumanAgentId(recipient);
+}
+
+// sdk/src/held-for.ts
+var HELD_FOR_PAYLOAD_KEY = "heldFor";
+function heldForSender(message) {
+  if (message.from !== message.to)
+    return;
+  const heldFor = message.payload?.[HELD_FOR_PAYLOAD_KEY];
+  return typeof heldFor === "string" && heldFor ? heldFor : undefined;
+}
+
+// sdk/src/types/guards.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// runner/src/message-body-config/config.ts
+function monitorDeliveryMaxCharsFromEnv() {
+  return relayEnv(process.env, "AGENT_RELAY_MONITOR_DELIVERY_MAX_CHARS");
+}
+function monitorDeliveryLineMaxCharsFromEnv() {
+  return relayEnv(process.env, "AGENT_RELAY_MONITOR_DELIVERY_LINE_MAX_CHARS");
+}
+// runner/src/relay-instructions.ts
+import { existsSync } from "fs";
+// sdk/src/shared-mcp-names.ts
+var SHARED_MCP_SERVER_NAME = "callmux";
+
+// sdk/src/web-tools.ts
+var WEB_TOOLS = {
+  brave: { label: "Web search (Tavily first)", tools: ["web_search"], replaces: "WebSearch", keyRequired: false },
+  jina: { label: "Page reader (local first, keyless Jina fallback)", tools: ["read_url"], replaces: "WebFetch", keyRequired: false }
+};
+function sharedWebToolNames(name) {
+  if (name === "brave")
+    return ["web_search"];
+  const tools = WEB_TOOLS[name].tools.map((tool) => `${name}__${tool}`);
+  return name === "jina" ? ["fetch__fetch", ...tools] : tools;
+}
+function webToolSteerRefs(name, claude, fallback = false) {
+  const tools = sharedWebToolNames(name).filter((tool) => name !== "jina" || (fallback ? tool.startsWith("jina__") : tool.startsWith("fetch__")));
+  const refs = tools.map((tool) => `\`${claude ? `mcp__${SHARED_MCP_SERVER_NAME}__` : ""}${tool}\``).join(" or ");
+  return claude ? `${refs} (load with ToolSearch)` : `${refs} on the \`${SHARED_MCP_SERVER_NAME}\` MCP server`;
+}
+
+// sdk/src/prompt-template-defaults.ts
+function lines(...parts) {
+  return parts.join(`
+`);
+}
+var RELAY_RUN_STANDING_INSTRUCTIONS = lines("## Long-running commands", "Run commands that may print secrets (ssh to hosts, reading env/config files, secret tooling) through `relay_run`, never raw Bash/shell tools. Relay masks stdout/stderr before storing logs or returning output, even on a nonzero exit; masker failures withhold output. Inspect exitCode, signal and timedOut. Reference secret files or variables; never paste secret literals into the command.", "Run long commands, gates, builds and tests through `relay_run` with `waitMs: 0`, then END YOUR TURN and wait for Relay's completion wake (finish, failure or timeout). If it returns queued or still-running, end your turn too.", "Waiting for a condition (epoch closes, deploy finishes, land merges, service healthy, file appears) is also a long command: start ONE detached `relay_run` whose command is a poll loop with a deadline (e.g. `timeout 30m bash -c 'until <check>; do sleep 20; done'`), then END YOUR TURN with no text. Never check once per turn, sleep in the foreground, or keep the turn alive with Monitor/until loops: every turn end is forwarded to your parent as a message.", "A detached wait is exempt from periodic progress-update instructions, including updates every 60 seconds. Never poll with `relay_run{runId}`, `write_stdin`, sleep, ps or tail. Resume on the completion notification and check the reported exit status; missing output or exit status is not a pass.", "This rule overrides older profile, working-state, compaction or recovery guidance that recommends raw exec sessions or polling for long commands. Do not edit the worktree while validation is running.");
+var RELAY_REPLY_INSTRUCTIONS = 'Reply to an agent\'s Relay message with `relay_reply` (messageId, body). CLI fallback: `agent-relay /reply <messageId> "<your reply>"`. Your turn response reaches the human user automatically: never send the user a Relay message to answer them. Send one reply per batch to the latest relevant message. Send no status-only confirmations.';
+var REPOSITORY_SEARCH_FALLBACK = "Use available tools for repository search. If MCP search tools are missing or fail, use shell search (rg, grep, or find) and continue; never stall on a missing tool.";
+var AGENT_CORE_TEMPLATE_SLUG = "relay.agent-core";
+var TEMP_DIR_TEMPLATE_SLUG = "relay.temp-dir";
+var TEMP_DIR_RULE = "Temporary files: use `$TMPDIR`. It is your own directory, removed when you exit. Never write to a literal `/tmp/...` path: other agents on the host share it.";
+var RUNNER_PROMPT_TEMPLATE_DEFAULTS = [
+  {
+    slug: TEMP_DIR_TEMPLATE_SLUG,
+    category: "runner",
+    title: "Private Temp Dir",
+    description: "Shown to every session with Relay context: the agent's TMPDIR is private and reaped (#3084).",
+    template: TEMP_DIR_RULE,
+    defaultTemplate: TEMP_DIR_RULE,
+    variables: []
+  },
+  {
+    slug: "relay.search.fff",
+    category: "runner",
+    title: "Provisioned fff Search",
+    description: "Shown only when this session has a provisioned fff executable or remote server.",
+    template: "Prefer the provisioned fff MCP tools for repository search: find_files, grep, and multi_grep. If they are missing or fail, use shell search (rg, grep, or find) and continue; never stall on a missing tool.",
+    defaultTemplate: "Prefer the provisioned fff MCP tools for repository search: find_files, grep, and multi_grep. If they are missing or fail, use shell search (rg, grep, or find) and continue; never stall on a missing tool.",
+    variables: []
+  },
+  {
+    slug: "relay.web.brave",
+    category: "runner",
+    title: "Web Search Steer (Relay)",
+    description: "Shown when this session has Relay web search; {{tools}} names the exact tool.",
+    template: "Web search: use Relay {{tools}}. Relay tries Tavily first, then budget-capped Brave. If it fails, report the error; never retry in a loop.",
+    defaultTemplate: "Web search: use Relay {{tools}}. Relay tries Tavily first, then budget-capped Brave. If it fails, report the error; never retry in a loop.",
+    variables: ["tools"]
+  },
+  {
+    slug: "relay.web.fetch",
+    category: "runner",
+    title: "URL Reader Steer (local first)",
+    description: "The page-reader capability: {{tools}} is local; {{fallback}} is keyless Jina. Replaces the old Jina-first steer (#3242).",
+    template: "Read a known URL: use the self-hosted page reader {{tools}} first. Use max_length (default 5000 characters) and start_index to read large pages in chunks; respect robots.txt refusals. Only if it fails or returns unusable JS-heavy content, use keyless Jina {{fallback}} with url only (no question or API key). Jina shares a low per-IP limit across the fleet; if it also fails, use the built-in fetch once. Never retry in a loop or use readers to search.",
+    defaultTemplate: "Read a known URL: use the self-hosted page reader {{tools}} first. Use max_length (default 5000 characters) and start_index to read large pages in chunks; respect robots.txt refusals. Only if it fails or returns unusable JS-heavy content, use keyless Jina {{fallback}} with url only (no question or API key). Jina shares a low per-IP limit across the fleet; if it also fails, use the built-in fetch once. Never retry in a loop or use readers to search.",
+    variables: ["tools", "fallback"]
+  },
+  {
+    slug: AGENT_CORE_TEMPLATE_SLUG,
+    category: "runner",
+    title: "Agent Core",
+    description: "The one Relay-injected agent core block every relay.context profile gets exactly once. Edit here to change it fleet-wide.",
+    template: RELAY_RUN_STANDING_INSTRUCTIONS + `
+
+` + REPOSITORY_SEARCH_FALLBACK + `
+
+` + RELAY_REPLY_INSTRUCTIONS,
+    defaultTemplate: RELAY_RUN_STANDING_INSTRUCTIONS + `
+
+` + REPOSITORY_SEARCH_FALLBACK + `
+
+` + RELAY_REPLY_INSTRUCTIONS,
+    variables: []
+  },
+  {
+    slug: "relay.manual.claude",
+    category: "runner",
+    title: "Claude Relay Manual",
+    description: "Bundled CLAUDE.md relay manual written into provisioned Claude homes.",
+    template: lines("# Agent Relay", "", "- Relay messages can come from people, channels, or agents. Read the body and do the work.", "- For a truncated delivery stub, fetch its body with `relay_get_message` (messageId) or `agent-relay get-message <messageId>`.", "- Do not reply to pure info, passive acknowledgements, or reactions without an action request. Never reply or react to a notification-class message; act on it if relevant.", "- If a provider permission prompt holds your current tool call and Relay tools still work, tell your coordinator which tool is held. Do not depend on this report for rescue: a prompt on the Relay call itself can block reporting.", "- Use `agent-relay /react <messageId> <emoji>` for lightweight acknowledgement, approval, thanks, praise, a completed handoff, or an FYI\u2014not questions, tasks, bugs, or textual results. \uD83D\uDC4D to your question approves proceeding; \uD83D\uDC4D to completed status means no further action.", "- Use `agent-relay /status --json` for identity and `agent-relay /guide` for command details."),
+    defaultTemplate: lines("# Agent Relay", "", "- Relay messages can come from people, channels, or agents. Read the body and do the work.", "- For a truncated delivery stub, fetch its body with `relay_get_message` (messageId) or `agent-relay get-message <messageId>`.", "- Do not reply to pure info, passive acknowledgements, or reactions without an action request. Never reply or react to a notification-class message; act on it if relevant.", "- If a provider permission prompt holds your current tool call and Relay tools still work, tell your coordinator which tool is held. Do not depend on this report for rescue: a prompt on the Relay call itself can block reporting.", "- Use `agent-relay /react <messageId> <emoji>` for lightweight acknowledgement, approval, thanks, praise, a completed handoff, or an FYI\u2014not questions, tasks, bugs, or textual results. \uD83D\uDC4D to your question approves proceeding; \uD83D\uDC4D to completed status means no further action.", "- Use `agent-relay /status --json` for identity and `agent-relay /guide` for command details."),
+    variables: []
+  },
+  {
+    slug: "relay.context.claude",
+    category: "runner",
+    title: "Claude Relay Context",
+    description: "One-line relay context note for Claude sessions.",
+    template: "[agent-relay] Relay is available. Follow the Agent Relay rules in CLAUDE.md when present, or run agent-relay /guide.",
+    defaultTemplate: "[agent-relay] Relay is available. Follow the Agent Relay rules in CLAUDE.md when present, or run agent-relay /guide.",
+    variables: []
+  },
+  {
+    slug: "relay.context.claude.readonly",
+    category: "runner",
+    title: "Claude Relay Context (Read Only)",
+    description: "Read-only relay context note for Claude sessions.",
+    template: lines("[agent-relay] Relay is available. Follow the Agent Relay rules in CLAUDE.md when present, or run agent-relay /guide.", "", "This Claude session is running with restricted read-only Relay permissions. Do not invoke Agent Relay skills. Use the CLI for Relay actions."),
+    defaultTemplate: lines("[agent-relay] Relay is available. Follow the Agent Relay rules in CLAUDE.md when present, or run agent-relay /guide.", "", "This Claude session is running with restricted read-only Relay permissions. Do not invoke Agent Relay skills. Use the CLI for Relay actions."),
+    variables: []
+  },
+  {
+    slug: "relay.context.codex",
+    category: "runner",
+    title: "Codex Relay Context",
+    description: "Relay context note injected into Codex sessions.",
+    template: "[agent-relay] Relay is available. Identity and capabilities are in `## Agent Relay Identity`; tool access follows those capabilities. Details: `agent-relay /guide`.",
+    defaultTemplate: "[agent-relay] Relay is available. Identity and capabilities are in `## Agent Relay Identity`; tool access follows those capabilities. Details: `agent-relay /guide`.",
+    variables: []
+  },
+  {
+    slug: "relay.context.opencode",
+    category: "runner",
+    title: "OpenCode Relay Context",
+    description: "Relay context note injected into OpenCode sessions.",
+    template: "[agent-relay] Relay messages can come from people, channels, or agents: read each message and do its work. Fetch a truncated delivery with `agent-relay get-message <messageId>`. Use `agent-relay /react <messageId> <emoji>` only for lightweight acknowledgement. Run `agent-relay /status --json` for identity and `agent-relay /guide` for command details.",
+    defaultTemplate: "[agent-relay] Relay messages can come from people, channels, or agents: read each message and do its work. Fetch a truncated delivery with `agent-relay get-message <messageId>`. Use `agent-relay /react <messageId> <emoji>` only for lightweight acknowledgement. Run `agent-relay /status --json` for identity and `agent-relay /guide` for command details.",
+    variables: []
+  },
+  {
+    slug: "workspace.lifecycle",
+    category: "runner",
+    title: "Runner Workspace Lifecycle Note",
+    description: "Lifecycle note injected by the runner for isolated workspaces.",
+    template: lines("[agent-relay] You are in worktree branch {{branch}}, based on {{baseRef}}, not main. Other agents land to {{baseRef}}; it moving is normal.", "While iterating, run only affected tests via the project command when available; the full gate runs automatically at land/merge.", "Commit here; pushing your own branch and rebasing before delivery are allowed. Never push to main or {{baseRef}}; never rebase or rewrite history after a `complete` delivery has armed a land. Do not merge, resolve conflicts, or enter the main checkout. Relay/steward own those and may rebase in background. When done, self-report the configured validation result through `relay_task_deliver` with `complete`, summary, commits, and passing `typecheck` + `test` gates when the diff touches code/test/config paths. It skips code gates for empty/docs-only diffs, rebases onto {{baseRef}}, lands, and pushes.", "Accepted delivery means status becomes `ready`: NORMAL, healthy handoff, not a stall. Stop your turn; do not poll. Clean rebases auto-merge about every two minutes; a steward appears only when deterministic landing fails. Relay wakes `landed-success` or `landed-failure`; on success it keeps this worktree on its current post-land branch, and the next delivery rebases it against the latest base. `agent-relay workspace status` shows the next step."),
+    defaultTemplate: lines("[agent-relay] You are in worktree branch {{branch}}, based on {{baseRef}}, not main. Other agents land to {{baseRef}}; it moving is normal.", "While iterating, run only affected tests via the project command when available; the full gate runs automatically at land/merge.", "Commit here; pushing your own branch and rebasing before delivery are allowed. Never push to main or {{baseRef}}; never rebase or rewrite history after a `complete` delivery has armed a land. Do not merge, resolve conflicts, or enter the main checkout. Relay/steward own those and may rebase in background. When done, self-report the configured validation result through `relay_task_deliver` with `complete`, summary, commits, and passing `typecheck` + `test` gates when the diff touches code/test/config paths. It skips code gates for empty/docs-only diffs, rebases onto {{baseRef}}, lands, and pushes.", "Accepted delivery means status becomes `ready`: NORMAL, healthy handoff, not a stall. Stop your turn; do not poll. Clean rebases auto-merge about every two minutes; a steward appears only when deterministic landing fails. Relay wakes `landed-success` or `landed-failure`; on success it keeps this worktree on its current post-land branch, and the next delivery rebases it against the latest base. `agent-relay workspace status` shows the next step."),
+    variables: ["branch", "baseRef"]
+  },
+  {
+    slug: "workspace.deps.symlink",
+    category: "runner",
+    title: "Runner Workspace Deps Symlink Note",
+    description: "Symlinked node_modules caveat injected by the runner.",
+    template: "[agent-relay] Isolated workspace: this is a git worktree, and its node_modules are SYMLINKED from the main checkout \u2014 dependencies are already installed and ready to use. Do NOT run a clean dependency install (`bun install` / `npm install` / `pnpm install`): it writes through the symlink and mutates the main checkout's shared node_modules. Build caches written under node_modules are shared too. If typecheck/build fails on a missing module (a dependency added to the base AFTER this worktree was created), run `agent-relay workspace deps` \u2014 it re-provisions only the stale dirs with a real isolated install, safely, without touching the shared node_modules. If you genuinely need to change dependencies in isolation, ask the host to spawn with AGENT_RELAY_WORKSPACE_DEPS=install.",
+    defaultTemplate: "[agent-relay] Isolated workspace: this is a git worktree, and its node_modules are SYMLINKED from the main checkout \u2014 dependencies are already installed and ready to use. Do NOT run a clean dependency install (`bun install` / `npm install` / `pnpm install`): it writes through the symlink and mutates the main checkout's shared node_modules. Build caches written under node_modules are shared too. If typecheck/build fails on a missing module (a dependency added to the base AFTER this worktree was created), run `agent-relay workspace deps` \u2014 it re-provisions only the stale dirs with a real isolated install, safely, without touching the shared node_modules. If you genuinely need to change dependencies in isolation, ask the host to spawn with AGENT_RELAY_WORKSPACE_DEPS=install.",
+    variables: []
+  },
+  {
+    slug: "workspace.deps.command",
+    category: "runner",
+    title: "Runner Workspace Deps Command Note",
+    description: "Repository-command dependency provisioning note injected by the runner.",
+    template: "[agent-relay] Isolated workspace: dependencies were provisioned by the repository command `{{installCommand}}`; node_modules is real, not shared with the main checkout. If dependencies drift, run `{{installCommand}}` yourself from the worktree root (or `agent-relay workspace deps` to ask Relay to rerun it).",
+    defaultTemplate: "[agent-relay] Isolated workspace: dependencies were provisioned by the repository command `{{installCommand}}`; node_modules is real, not shared with the main checkout. If dependencies drift, run `{{installCommand}}` yourself from the worktree root (or `agent-relay workspace deps` to ask Relay to rerun it).",
+    variables: ["installCommand"]
+  },
+  {
+    slug: "workspace.deps.none",
+    category: "runner",
+    title: "Runner Workspace Deps None Note",
+    description: "Missing dependency provisioning caveat injected by the runner.",
+    template: "[agent-relay] Isolated workspace: dependencies were not provisioned (AGENT_RELAY_WORKSPACE_DEPS=none). You may need to install node_modules before typecheck/test/build work.",
+    defaultTemplate: "[agent-relay] Isolated workspace: dependencies were not provisioned (AGENT_RELAY_WORKSPACE_DEPS=none). You may need to install node_modules before typecheck/test/build work.",
+    variables: []
+  },
+  {
+    slug: "workspace.symlinks",
+    category: "runner",
+    title: "Runner Workspace Symlink Note",
+    description: "Write-through symlink caveat injected by the runner.",
+    template: "[agent-relay] Isolated workspace: these untracked paths are SYMLINKED from the main checkout: {{linked}}. They resolve to the real files in main, so editing or deleting them writes THROUGH to main \u2014 treat them as read-only unless you intend to change main.",
+    defaultTemplate: "[agent-relay] Isolated workspace: these untracked paths are SYMLINKED from the main checkout: {{linked}}. They resolve to the real files in main, so editing or deleting them writes THROUGH to main \u2014 treat them as read-only unless you intend to change main.",
+    variables: []
+  }
+];
+
+// runner/src/template-resolver.ts
+var RUNNER_DEFAULTS = new Map(RUNNER_PROMPT_TEMPLATE_DEFAULTS.map((template) => [template.slug, template.defaultTemplate]));
+var templateCache = new Map;
+function renderValue(value) {
+  return value ?? "";
+}
+function applyVariables(template, vars) {
+  return template.replace(/\{\{(\w+)\}\}/g, (_, key) => renderValue(vars[key]));
+}
+function renderRunnerTemplate(slug, vars = {}) {
+  const template = templateCache.get(slug) ?? RUNNER_DEFAULTS.get(slug);
+  if (template === undefined)
+    throw new Error(`unknown runner prompt template slug: ${slug}`);
+  return applyVariables(template, vars);
+}
+
+// runner/src/relay-instructions.ts
+function profileAllowsRelayFeature(config, feature) {
+  return config.agentProfile?.relay?.[feature] !== false;
+}
+function resolveRelayContext(input) {
+  if (input.config && !profileAllowsRelayFeature(input.config, "context")) {
+    return { available: false, text: "" };
+  }
+  const fff = input.mcpServers?.fff;
+  const search = fff && (fff.url || fff.command && existsSync(fff.command)) ? renderRunnerTemplate("relay.search.fff") : "";
+  const web = input.webTools ? webToolsSteer(input.webTools.names, input.webTools.claude) : "";
+  const text = [renderRunnerTemplate(input.slug).trim(), search, web, renderRunnerTemplate(TEMP_DIR_TEMPLATE_SLUG)].filter(Boolean).join(`
+
+`);
+  return { available: text.length > 0, text };
+}
+function webToolsSteer(names, claude) {
+  return names.map((name) => name === "brave" ? `Web search: use ${claude ? "web_search on the agent-relay MCP server (load with ToolSearch)" : "web_search on the agent-relay MCP server"}. Relay tries Tavily, then budget-capped Brave. If the monthly cap is reached, report it; do not retry in a loop.` : renderRunnerTemplate("relay.web.fetch", {
+    tools: webToolSteerRefs(name, claude),
+    fallback: webToolSteerRefs(name, claude, true)
+  })).join(`
+`);
+}
+function claudeRelayContext() {
+  return resolveRelayContext({ slug: "relay.context.claude" }).text;
+}
+function claudeReadOnlyRelayContext() {
+  return resolveRelayContext({ slug: "relay.context.claude.readonly" }).text;
+}
+function workspaceDepsNote(input) {
+  if (input.mode !== "isolated")
+    return "";
+  switch (input.depsMode) {
+    case "symlink":
+      return renderRunnerTemplate("workspace.deps.symlink");
+    case "command":
+      return renderRunnerTemplate("workspace.deps.command", { installCommand: input.installCommand ?? "the repository install command" });
+    case "none":
+      return renderRunnerTemplate("workspace.deps.none");
+    default:
+      return "";
+  }
+}
+function workspaceLifecycleNote(input) {
+  if (input.mode !== "isolated")
+    return "";
+  const branch = input.branch ? `\`${input.branch}\`` : "an isolated agent branch";
+  const base = input.baseRef ? `\`${input.baseRef}\`` : "the base branch";
+  return renderRunnerTemplate("workspace.lifecycle", { branch, baseRef: base });
+}
+function workspaceSymlinksNote(linked) {
+  if (!linked.length)
+    return "";
+  return renderRunnerTemplate("workspace.symlinks", { linked: linked.join(", ") });
+}
+function workspaceDepsNoteFromEnv(env = process.env) {
+  const json = relayEnv(env, "AGENT_RELAY_WORKSPACE_JSON");
+  if (!json)
+    return "";
+  try {
+    const parsed = JSON.parse(json);
+    return [
+      workspaceLifecycleNote({ mode: parsed.mode ?? null, branch: parsed.branch ?? null, baseRef: parsed.baseRef ?? null }),
+      workspaceDepsNote({ mode: parsed.mode ?? null, depsMode: parsed.deps?.mode ?? null, installCommand: parsed.deps?.command ?? null }),
+      parsed.mode === "isolated" ? workspaceSymlinksNote(parsed.symlinks?.linked ?? []) : ""
+    ].filter(Boolean).join(`
+
+`);
+  } catch {
+    return "";
+  }
+}
+// runner/src/adapter.ts
+var DEFAULT_MONITOR_DELIVERY_MAX_CHARS = 2800;
+var DEFAULT_MONITOR_DELIVERY_LINE_MAX_CHARS = 480;
+function resolvePositiveIntEnv(raw, fallback) {
+  if (raw !== undefined) {
+    const parsed = Number.parseInt(raw.trim(), 10);
+    if (Number.isFinite(parsed) && parsed > 0)
+      return parsed;
+  }
+  return fallback;
+}
+function monitorDeliveryMaxChars() {
+  return resolvePositiveIntEnv(monitorDeliveryMaxCharsFromEnv(), DEFAULT_MONITOR_DELIVERY_MAX_CHARS);
+}
+function monitorDeliveryLineMaxChars() {
+  return resolvePositiveIntEnv(monitorDeliveryLineMaxCharsFromEnv(), DEFAULT_MONITOR_DELIVERY_LINE_MAX_CHARS);
+}
+function fitsMonitorDelivery(text, options = {}) {
+  const maxChars = options.maxChars ?? monitorDeliveryMaxChars();
+  const lineMaxChars = options.lineMaxChars ?? monitorDeliveryLineMaxChars();
+  if (text.length + (options.reserved ?? 0) > maxChars)
+    return false;
+  for (const line of text.split(`
+`)) {
+    if (line.length > lineMaxChars)
+      return false;
+  }
+  return true;
+}
+function attachmentRefs(message) {
+  const payloadRefs = message.payload?.attachments;
+  const topLevelRefs = message.attachments;
+  const refs = Array.isArray(payloadRefs) ? payloadRefs : Array.isArray(topLevelRefs) ? topLevelRefs : [];
+  return refs.filter(isRecord);
+}
+function attachmentLabel(ref) {
+  const parts = [
+    typeof ref.kind === "string" ? ref.kind : undefined,
+    typeof ref.role === "string" ? ref.role : undefined,
+    typeof ref.title === "string" ? `"${ref.title}"` : undefined
+  ].filter(Boolean);
+  return parts.length ? ` (${parts.join(", ")})` : "";
+}
+function attachmentCacheMetadata(ref) {
+  const metadata = isRecord(ref.metadata) ? ref.metadata : undefined;
+  const agentRelay = metadata && isRecord(metadata.agentRelay) ? metadata.agentRelay : undefined;
+  return agentRelay;
+}
+function isMemoryInjection(message) {
+  return isRecord(message.payload) && message.payload.memoryInjection === true;
+}
+function isSelfResumeInjection(message) {
+  return isRecord(message.payload) && message.payload.resumeInjection === true;
+}
+function isReactionNotification(message) {
+  const event = isRecord(message.payload?.event) ? message.payload.event : undefined;
+  return message.payload?.reactionNotification === true || event?.type === "message.reaction";
+}
+function isPersistedRelayMessage(message) {
+  return Number.isSafeInteger(message.id) && message.id > 0;
+}
+var NOTIFICATION_NUDGE = "\u21AA Notification \u2014 no reply needed.";
+function isNotificationMessage(message) {
+  return isPersistedRelayMessage(message) && message.replyExpected === false;
+}
+function dedupePersistedMessages(messages) {
+  const seen = new Set;
+  return messages.filter((message) => {
+    if (!isPersistedRelayMessage(message))
+      return true;
+    if (seen.has(message.id))
+      return false;
+    seen.add(message.id);
+    return true;
+  });
+}
+function providerSenderLabel(message) {
+  const heldFor = heldForSender(message);
+  if (heldFor)
+    return isHumanAgentId(heldFor) ? "human user" : heldFor;
+  if (isHumanAgentId(message.from))
+    return "human user";
+  const source = isRecord(message.payload?.source) ? message.payload.source : undefined;
+  const isHumanChannel = Boolean(source && (isRecord(source.telegram) || isRecord(source.slack) || isRecord(source.discord)));
+  return isHumanChannel ? `human user via ${message.from}` : message.from;
+}
+function providerAttachmentText(message) {
+  const refs = attachmentRefs(message);
+  if (!refs.length)
+    return;
+  const refLines = refs.flatMap((ref) => {
+    const artifactId = typeof ref.artifactId === "string" ? ref.artifactId : "unknown-artifact";
+    const source = isRecord(ref.ref) ? [
+      typeof ref.ref.provider === "string" ? ref.ref.provider : undefined,
+      typeof ref.ref.id === "string" ? ref.ref.id : undefined
+    ].filter(Boolean).join(":") : "";
+    const cache = attachmentCacheMetadata(ref);
+    const localPath = typeof cache?.localPath === "string" ? cache.localPath : undefined;
+    const cacheError = typeof cache?.cacheError === "string" ? cache.cacheError : undefined;
+    return [
+      `- ${artifactId}${attachmentLabel(ref)}${source ? ` source=${source}` : ""}`,
+      ...localPath ? [`  local: ${localPath}`] : [],
+      ...cacheError ? [`  cache error: ${cacheError}`] : []
+    ];
+  });
+  const hasLocalPaths = refs.some((ref) => typeof attachmentCacheMetadata(ref)?.localPath === "string");
+  const canFetchMessage = isPersistedRelayMessage(message);
+  const guidance = !canFetchMessage ? [] : hasLocalPaths ? [
+    "Use the local path above when inspecting the attachment.",
+    `Read attachment details: agent-relay get-message ${message.id} --json`
+  ] : [
+    `Read attachment details: agent-relay get-message ${message.id} --json`,
+    `Fetch content: curl -fsS -H "X-Agent-Relay-Token: $AGENT_RELAY_TOKEN" "$AGENT_RELAY_URL/api/artifacts/<artifactId>/content" -o <filename>`
+  ];
+  return [
+    "Attachments:",
+    ...refLines,
+    ...guidance
+  ].join(`
+`);
+}
+
+// runner/src/adapters/claude-monitor-delivery-plan.ts
+import { chmodSync, mkdirSync, writeFileSync } from "fs";
+import { join as joinPath } from "path";
+var join = (items) => items.join(`
+
+`);
+var idsOf = (items) => items.flatMap((item) => item.id === undefined ? [] : [item.id]);
+var DISPOSABLE_TRUNCATION_NOTICE = `
+[\u2026truncated]`;
+function truncateToCaps(text, budget, lineMaxChars) {
+  let charCount = 0;
+  let lineCount = 0;
+  let cut = 0;
+  while (cut < text.length) {
+    const ch = text[cut];
+    const nextCharCount = charCount + 1;
+    const nextLineCount = ch === `
+` ? 0 : lineCount + 1;
+    if (nextCharCount > budget || nextLineCount > lineMaxChars)
+      break;
+    charCount = nextCharCount;
+    lineCount = nextLineCount;
+    cut++;
+  }
+  if (cut > 0 && cut < text.length) {
+    const before = text.charCodeAt(cut - 1);
+    const after = text.charCodeAt(cut);
+    if (before >= 55296 && before <= 56319 && after >= 56320 && after <= 57343)
+      cut--;
+  }
+  return text.slice(0, cut);
+}
+function selfTruncateDisposableSection(section, reserved) {
+  const maxChars = monitorDeliveryMaxChars();
+  const lineMaxChars = monitorDeliveryLineMaxChars();
+  const budget = Math.max(1, maxChars - reserved - DISPOSABLE_TRUNCATION_NOTICE.length);
+  const body = truncateToCaps(section.text, budget, lineMaxChars);
+  return body.length < section.text.length ? `${body}${DISPOSABLE_TRUNCATION_NOTICE}` : body;
+}
+var MAX_FILENAME_LABEL_CHARS = 20;
+var MAX_DISPLAY_LABEL_CHARS = 40;
+function boundLabel(label, maxChars) {
+  const trimmed = (label ?? "").trim();
+  if (!trimmed)
+    return "content";
+  return trimmed.length > maxChars ? `${trimmed.slice(0, Math.max(1, maxChars - 1))}\u2026` : trimmed;
+}
+function sanitizeForFilename(label) {
+  const cleaned = label.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "content";
+  if (cleaned.length <= MAX_FILENAME_LABEL_CHARS)
+    return cleaned;
+  return cleaned.slice(0, MAX_FILENAME_LABEL_CHARS).replace(/-+$/g, "") || "content";
+}
+function writeSpillFileTight(dir, filePath, content) {
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  try {
+    chmodSync(dir, 448);
+  } catch {}
+  writeFileSync(filePath, content, { encoding: "utf8", mode: 384 });
+  try {
+    chmodSync(filePath, 384);
+  } catch {}
+}
+function mustKeepUndeliverableNotice(section, reserved, reason) {
+  const label = boundLabel(section.label ?? "content", MAX_DISPLAY_LABEL_CHARS);
+  const candidates = [
+    `[${label}: ${section.full.length} chars could NOT be delivered in full \u2014 ${reason}]`,
+    `[${label}: could NOT be delivered in full \u2014 ${reason}]`,
+    `[could NOT be delivered in full \u2014 ${reason}]`,
+    `[content lost \u2014 ${reason}]`,
+    `[content lost this delivery]`
+  ];
+  for (const candidate of candidates) {
+    if (fitsMonitorDelivery(candidate, { reserved }))
+      return candidate;
+  }
+  const maxChars = monitorDeliveryMaxChars();
+  const lineMaxChars = monitorDeliveryLineMaxChars();
+  return truncateToCaps(candidates[candidates.length - 1], Math.max(1, maxChars - reserved), lineMaxChars);
+}
+function spillMustKeepSection(section, spillDir, reserved) {
+  const label = section.label ?? "content";
+  if (!spillDir)
+    return { text: mustKeepUndeliverableNotice(section, reserved, "scratch dir unavailable"), spilled: false };
+  let filePath;
+  let fileName;
+  try {
+    fileName = `monitor-injection-${sanitizeForFilename(label)}-${crypto.randomUUID()}.md`;
+    filePath = joinPath(spillDir, fileName);
+    writeSpillFileTight(spillDir, filePath, section.full);
+  } catch {
+    return { text: mustKeepUndeliverableNotice(section, reserved, "scratch dir write failed"), spilled: false };
+  }
+  const bracket = `[${boundLabel(label, MAX_DISPLAY_LABEL_CHARS)} \u2014 spilled to disk, read it now]`;
+  const references = [
+    `Full content (byte-exact): ${filePath}`,
+    `File: ${fileName} \u2014 in your session scratch tmp dir ($AGENT_RELAY_SCRATCH_DIR)`,
+    `File: ${fileName} (scratch dir)`,
+    `File: ${fileName}`
+  ];
+  for (const reference of references) {
+    const withBracket = `${bracket}
+${reference}`;
+    if (fitsMonitorDelivery(withBracket, { reserved }))
+      return { text: withBracket, spilled: true };
+    if (fitsMonitorDelivery(reference, { reserved }))
+      return { text: reference, spilled: true };
+  }
+  return {
+    text: mustKeepUndeliverableNotice(section, reserved, "spilled successfully but no reference fits this delivery's caps"),
+    spilled: false
+  };
+}
+function packWithDeferredNotice(items, reserved) {
+  let kept = [];
+  const DEFERRED_NOTICE_BUDGET = 100;
+  for (const item of items) {
+    const candidate = [...kept, item];
+    if (fitsMonitorDelivery(join(candidate.map((entry) => entry.text)), { reserved: reserved + DEFERRED_NOTICE_BUDGET }))
+      kept = candidate;
+  }
+  const deferred = items.filter((item) => !kept.includes(item));
+  if (deferred.length > 0) {
+    const deferredSpilled = deferred.filter((item) => item.spilled).length;
+    const deferredFailed = deferred.length - deferredSpilled;
+    const parts = [];
+    if (deferredSpilled > 0)
+      parts.push(`${deferredSpilled} more spilled injection${deferredSpilled === 1 ? "" : "s"} \u2014 see session scratch dir`);
+    if (deferredFailed > 0)
+      parts.push(`${deferredFailed} injection${deferredFailed === 1 ? "" : "s"} could NOT be delivered \u2014 content lost`);
+    const notice = `[${parts.join("; ")}]`;
+    kept = [...kept, { full: notice, text: notice, spilled: false }];
+  }
+  return kept;
+}
+function planClaudeMonitorDelivery(sections, options = {}) {
+  const reserved = options.reservedChars ?? 0;
+  const full = join(sections.map((section) => section.full));
+  if (fitsMonitorDelivery(full, { reserved })) {
+    return { events: [{ text: full, messageIds: idsOf(sections) }] };
+  }
+  const rendered = sections.map((section) => ({ ...section, text: section.stub ?? section.full }));
+  const allStubbed = join(rendered.map((section) => section.text));
+  if (fitsMonitorDelivery(allStubbed, { reserved })) {
+    return { events: [{ text: allStubbed, messageIds: idsOf(rendered) }] };
+  }
+  const mustKeep = rendered.filter((section) => !section.stub && section.kind !== "disposable");
+  const optional = rendered.filter((section) => section.stub || section.kind === "disposable");
+  let guaranteed = mustKeep;
+  if (mustKeep.length > 0 && !fitsMonitorDelivery(join(mustKeep.map((item) => item.text)), { reserved })) {
+    const spilled = mustKeep.map((section) => {
+      const result = spillMustKeepSection(section, options.spillDir, reserved);
+      return { ...section, text: result.text, spilled: result.spilled };
+    });
+    if (fitsMonitorDelivery(join(spilled.map((item) => item.text)), { reserved })) {
+      guaranteed = spilled;
+    } else {
+      guaranteed = packWithDeferredNotice(spilled, reserved);
+    }
+  }
+  let chunk = guaranteed;
+  for (const section of optional) {
+    const candidate = [...chunk, section];
+    if (fitsMonitorDelivery(join(candidate.map((item) => item.text)), { reserved })) {
+      chunk = candidate;
+      continue;
+    }
+    if (section.stub) {
+      continue;
+    }
+    const substitute = { ...section, text: selfTruncateDisposableSection(section, reserved) };
+    const withSubstitute = [...chunk, substitute];
+    if (fitsMonitorDelivery(join(withSubstitute.map((item) => item.text)), { reserved })) {
+      chunk = withSubstitute;
+    }
+  }
+  return { events: chunk.length ? [{ text: join(chunk.map((item) => item.text)), messageIds: idsOf(chunk) }] : [] };
+}
+
+// runner/src/adapters/claude-delivery.ts
+var TASK_CLAIM_INSTRUCTION = "Claim this task before working it, then update task status when finished.";
+function stripRelayScaffolding(body) {
+  const bodyLines = body.split(`
+`);
+  const popTrailingBlanks = () => {
+    while (bodyLines.length && (bodyLines.at(-1) ?? "").trim() === "")
+      bodyLines.pop();
+  };
+  popTrailingBlanks();
+  if (bodyLines.at(-1) === TASK_CLAIM_INSTRUCTION) {
+    bodyLines.pop();
+    popTrailingBlanks();
+  }
+  return bodyLines.join(`
+`);
+}
+function formatMessage(message, relaySurface) {
+  const subject = message.subject ? `Subject: ${message.subject}
+` : "";
+  const isMemoryContext = isMemoryInjection(message);
+  const rawBody = relaySurface ? message.body : stripRelayScaffolding(message.body);
+  if (isMemoryContext) {
+    return [
+      `[agent-relay ${isSelfResumeInjection(message) ? "self-resume continuation" : "context"} from ${message.from}]`,
+      providerAttachmentText(message),
+      `${subject}${rawBody}`
+    ].filter(Boolean).join(`
+`);
+  }
+  return [
+    receivesTurnResponseAutomatically(message.from) ? undefined : `[relay message #${message.id} from ${providerSenderLabel(message)}]`,
+    providerAttachmentText(message),
+    `${subject}${rawBody}`
+  ].filter(Boolean).join(`
+`);
+}
+var STUB_GIST_MAX_CHARS = 200;
+function clampToLine(text, max = STUB_GIST_MAX_CHARS) {
+  const collapsed = text.replace(/\s+/g, " ").trim();
+  return collapsed.length > max ? `${collapsed.slice(0, max - 1).trimEnd()}\u2026` : collapsed;
+}
+function firstSentence(body) {
+  const trimmed = body.trim();
+  if (!trimmed)
+    return "";
+  const match = trimmed.match(/^[\s\S]*?[.!?](?=\s|$)/);
+  return clampToLine(match ? match[0] : trimmed);
+}
+function isStubbable(message) {
+  return isPersistedRelayMessage(message) && !isMemoryInjection(message);
+}
+function nonStubbableSectionKind(message) {
+  return isReactionNotification(message) ? "disposable" : "must-keep";
+}
+function nonStubbableSectionLabel(message) {
+  if (isSelfResumeInjection(message))
+    return "self-resume continuation";
+  if (isMemoryInjection(message))
+    return "memory injection";
+  if (isReactionNotification(message))
+    return "reaction notification";
+  return "content";
+}
+function taskDeliverableSummary(message) {
+  const payload = message.payload ?? {};
+  if (payload.kind !== "task.deliverable")
+    return;
+  const lines = [];
+  const taskId = typeof payload.taskId === "number" ? payload.taskId : undefined;
+  const disposition = typeof payload.disposition === "string" && payload.disposition ? payload.disposition : undefined;
+  if (taskId !== undefined || disposition) {
+    lines.push(clampToLine(`Task${taskId !== undefined ? ` T${taskId}` : ""}${disposition ? ` \xB7 ${disposition}` : ""}`));
+  }
+  const headSha = typeof payload.headSha === "string" && payload.headSha ? payload.headSha : undefined;
+  const blockerCount = typeof payload.blockerCount === "number" ? payload.blockerCount : undefined;
+  if (headSha || blockerCount !== undefined) {
+    lines.push(clampToLine(`Head: ${headSha ?? "?"} \xB7 Blockers: ${blockerCount ?? "?"}`));
+  }
+  const nextAction = typeof payload.nextAction === "string" && payload.nextAction ? payload.nextAction : undefined;
+  if (nextAction)
+    lines.push(clampToLine(`Next: ${nextAction}`));
+  return lines.length > 0 ? lines : undefined;
+}
+function stubMessage(message) {
+  const gist = message.subject ? `Subject: ${clampToLine(message.subject)}` : firstSentence(message.body);
+  const summary = taskDeliverableSummary(message);
+  const fetchTarget = message.messageType === "final-turn" && message.sourceMessageId ? message.sourceMessageId : message.id;
+  const finalTurn = message.messageType === "final-turn" ? " | final turn" : "";
+  return [
+    receivesTurnResponseAutomatically(message.from) ? undefined : `[relay message #${message.id} from ${providerSenderLabel(message)}${finalTurn}]`,
+    gist || undefined,
+    ...summary ?? [],
+    message.threadId !== undefined ? `Thread: #${message.threadId}` : undefined,
+    `Over monitor size limit \u2014 full ${message.messageType === "final-turn" ? "turn" : "message"}: relay_get_message #${fetchTarget} (CLI: agent-relay get-message ${fetchTarget})`
+  ].filter(Boolean).join(`
+`);
+}
+function claudeMonitorDeliveryPlan(messages, options = {}) {
+  const relaySurface = options.relaySurface !== false;
+  const uniqueMessages = dedupePersistedMessages(messages);
+  const sections = uniqueMessages.map((message) => ({
+    id: isPersistedRelayMessage(message) ? message.id : undefined,
+    full: formatMessage(message, relaySurface),
+    ...isStubbable(message) ? { stub: stubMessage(message) } : { kind: nonStubbableSectionKind(message), label: nonStubbableSectionLabel(message) }
+  }));
+  if (relaySurface && uniqueMessages.length > 0 && uniqueMessages.every((message) => isNotificationMessage(message) && !receivesTurnResponseAutomatically(message.from))) {
+    sections.push({ id: undefined, full: NOTIFICATION_NUDGE, kind: "disposable", label: "notification" });
+  }
+  if (!options.monitorLimited) {
+    return { events: [{ text: sections.map((section) => section.full).join(`
+
+`), messageIds: sections.flatMap((section) => section.id === undefined ? [] : [section.id]) }] };
+  }
+  return planClaudeMonitorDelivery(sections, { reservedChars: options.reservedChars, spillDir: options.spillDir });
+}
+
+// runner/plugins/claude/monitors/relay-monitor.ts
+var port = relayEnv(process.env, "AGENT_RELAY_RUNNER_PORT");
+if (!port)
+  process.exit(0);
+var firstDelivery = true;
+var ws = new WebSocket(`ws://127.0.0.1:${port}/monitor`);
+ws.onmessage = (event) => {
+  const payload = parsePayload(String(event.data));
+  if (!payload || payload.type !== "message.deliver" || !Array.isArray(payload.messages))
+    return;
+  const messages = payload.messages;
+  let reservedChars = 0;
+  if (firstDelivery) {
+    const contextBlock = relayEnv(process.env, "AGENT_RELAY_APPROVAL") === "read-only" ? claudeReadOnlyRelayContext() : claudeRelayContext();
+    const wsNote = workspaceDepsNoteFromEnv();
+    const prefix = [contextBlock, wsNote].filter(Boolean).join(`
+
+`);
+    console.log(prefix);
+    console.log("");
+    reservedChars = prefix.length + 2;
+    firstDelivery = false;
+  }
+  const plan = claudeMonitorDeliveryPlan(messages, {
+    reservedChars,
+    monitorLimited: true,
+    spillDir: relayEnv(process.env, "AGENT_RELAY_SCRATCH_DIR")
+  });
+  if (plan.events[0])
+    console.log(plan.events[0].text);
+  ws.send(JSON.stringify({
+    type: "message.delivered",
+    deliveryId: typeof payload.deliveryId === "string" ? payload.deliveryId : "",
+    messageIds: plan.events[0]?.messageIds ?? []
+  }));
+};
+ws.onerror = () => process.exit(1);
+function parsePayload(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}