{"version":3,"sources":["../src/schema.ts","../src/protocol/acp-client.ts","../src/mcp-servers.ts","../src/protocol/print-arm.ts","../src/protocol/proprietary.ts","../src/manifest/compose.ts","../src/define-agent-cli.ts"],"names":["join","writeFileSync","spawn"],"mappings":"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","file":"chunk-XTZNZ7MA.mjs","sourcesContent":["/**\n * AIP-45 AGENT-CLI.md frontmatter zod schema.\n *\n * Mirrors `resources/aip-45/draft/AGENT-CLI.schema.json`. AIP-45 is a\n * sibling of AIP-29 (CLI.md, tool CLIs) covering interactive\n * agent-as-process binaries. The `protocol` discriminator (acp / mcp\n * / proprietary) selects the wire arm; cross-field rules ensure the\n * matching arm-specific block is present.\n *\n * Both authoring paths (`define-agent-cli.ts` and\n * `manifest/index.ts`) validate against this schema, so every\n * field-level constraint runs in both paths from a single source of\n * truth.\n */\n\nimport { z } from \"zod\"\n\nconst ID_PATTERN = /^[a-z0-9][a-z0-9-]{1,63}$/\nconst SEMVER_PATTERN = /^\\d+\\.\\d+\\.\\d+(?:[-+][\\w.-]+)?$/\nconst TAG_PATTERN = /^[a-z0-9][a-z0-9-]{0,63}$/\nconst SEMVER_RANGE_PATTERN = /^[><=^~ \\d.\\-+\\w*xX|, ]+$/\nconst ADAPTER_PATTERN = /^@?[a-z0-9][a-z0-9-./]*$/\nconst BIN_PATTERN = /^[A-Za-z0-9._\\-/]+$/\nconst MODE_ID_PATTERN = /^[a-z0-9][a-z0-9-]{0,63}$/\nconst OPTION_ID_PATTERN = /^[a-z0-9][a-z0-9_]{0,63}$/\n\nconst CONTINUATION_STRATEGY_IDS = [\n  \"none\",\n  \"pinned-session\",\n  \"transcript\",\n  \"native-resume\",\n] as const\n\nconst CONTINUATION_KEY_SCOPES = [\n  \"conversation\",\n  \"operator\",\n  \"user\",\n  \"guild\",\n  \"workspace\",\n] as const\n\n// AIP-29 install methods, mirrored locally to avoid a runtime cross-package import.\n// Schema-level $ref to AIP-29 is preserved on the JSON Schema side\n// (resources/aip-45/draft/AGENT-CLI.schema.json); this zod copy is the\n// TS-side mirror used by `defineAgentCli`. When AIP-29 grows new\n// install methods, both sides update together via scaffold-aip.\n\nconst installMethodSchema = z.discriminatedUnion(\"method\", [\n  z.object({ method: z.literal(\"brew\"), package: z.string(), experimental: z.boolean().optional() }).strict(),\n  z.object({ method: z.literal(\"apt\"), package: z.string(), experimental: z.boolean().optional() }).strict(),\n  z.object({ method: z.literal(\"dnf\"), package: z.string(), experimental: z.boolean().optional() }).strict(),\n  z.object({ method: z.literal(\"pacman\"), package: z.string(), experimental: z.boolean().optional() }).strict(),\n  z.object({ method: z.literal(\"choco\"), package: z.string(), experimental: z.boolean().optional() }).strict(),\n  z.object({ method: z.literal(\"scoop\"), package: z.string(), experimental: z.boolean().optional() }).strict(),\n  z.object({ method: z.literal(\"npm\"), package: z.string(), global: z.boolean().optional(), experimental: z.boolean().optional() }).strict(),\n  z.object({ method: z.literal(\"pip\"), package: z.string(), user: z.boolean().optional(), experimental: z.boolean().optional() }).strict(),\n  z.object({ method: z.literal(\"cargo\"), package: z.string(), experimental: z.boolean().optional() }).strict(),\n  z.object({ method: z.literal(\"go\"), package: z.string(), experimental: z.boolean().optional() }).strict(),\n  z.object({\n    method: z.literal(\"curl\"),\n    url: z.string().url(),\n    verify_sha256: z.string().regex(/^[a-f0-9]{64}$/).optional(),\n    experimental: z.boolean().optional(),\n  }).strict(),\n  z.object({\n    method: z.literal(\"download\"),\n    url: z.string().url(),\n    extract_bin: z.string(),\n    verify_sha256: z.string().regex(/^[a-f0-9]{64}$/).optional(),\n    experimental: z.boolean().optional(),\n  }).strict(),\n  z.object({ method: z.literal(\"vendored\"), path: z.string(), experimental: z.boolean().optional() }).strict(),\n])\n\nconst versionCheckSchema = z.object({\n  cmd: z.string(),\n  parse: z.string().describe(\"ECMAScript regex with at least one capture group.\"),\n  range: z.string().regex(SEMVER_RANGE_PATTERN).describe(\"npm-style semver range.\"),\n  timeout_ms: z.number().int().min(100).default(5000),\n}).strict()\n\nconst SETUP_STEP_ID_PATTERN = /^[a-z0-9][a-z0-9-]{0,63}$/\nconst SECRET_SLUG_PATTERN = /^([a-z][a-z0-9-]*[a-z0-9]\\/)?[a-z][a-z0-9-]*[a-z0-9]$/\n\n// `skip_if`: re-runnable health check that, when matching, skips the\n// enclosing setup step. Lets `agentproto setup <slug>` re-runs be\n// idempotent without external completion-ledger state.\nconst skipIfSchema = z\n  .object({\n    cmd: z.string(),\n    exit_code: z.number().int().default(0),\n    timeout_ms: z.number().int().min(100).default(5_000),\n  })\n  .strict()\n\n// `persist`: where the captured value lands so the runner can reuse\n// it on every spawn. Exactly one of env / secret_slug / cmd, enforced\n// via discriminated union.\nconst persistEnvSchema = z\n  .object({ env: z.string().regex(/^[A-Z][A-Z0-9_]*$/) })\n  .strict()\nconst persistSecretSchema = z\n  .object({ secret_slug: z.string().regex(SECRET_SLUG_PATTERN).min(2).max(80) })\n  .strict()\nconst persistCmdSchema = z.object({ cmd: z.string() }).strict()\nconst setupPersistSchema = z.union([\n  persistEnvSchema,\n  persistSecretSchema,\n  persistCmdSchema,\n])\n\n// AIP-29 § Setup. Mirrors `resources/aip-29/draft/CLI.schema.json#/$defs/setupStep`.\n// The runner runs steps in declared order, persists completion per\n// (bundle.id, workspace.id, user.id), and surfaces `setup_required`\n// to headless callers when steps remain pending.\nconst setupStepSchema = z.discriminatedUnion(\"kind\", [\n  z\n    .object({\n      id: z.string().regex(SETUP_STEP_ID_PATTERN),\n      kind: z.literal(\"cmd\"),\n      cmd: z.string(),\n      description: z.string().max(2000).optional(),\n      skip_if: skipIfSchema.optional(),\n      timeout_ms: z.number().int().min(100).default(60_000),\n      interactive: z.boolean().default(false),\n      persist: setupPersistSchema.optional(),\n    })\n    .strict(),\n  z\n    .object({\n      id: z.string().regex(SETUP_STEP_ID_PATTERN),\n      kind: z.literal(\"prompt\"),\n      prompt: z.string().min(1),\n      description: z.string().max(2000).optional(),\n      type: z.enum([\"text\", \"select\", \"boolean\", \"secret\"]).default(\"text\"),\n      default: z.string().optional(),\n      options: z\n        .union([\n          z.array(z.string().min(1)).min(1),\n          z\n            .object({\n              cmd: z.string(),\n              timeout_ms: z.number().int().min(100).default(30_000),\n            })\n            .strict(),\n        ])\n        .optional(),\n      skip_if: skipIfSchema.optional(),\n      persist: setupPersistSchema.optional(),\n    })\n    .strict(),\n  z\n    .object({\n      id: z.string().regex(SETUP_STEP_ID_PATTERN),\n      kind: z.literal(\"oauth\"),\n      secret_slug: z.string().regex(SECRET_SLUG_PATTERN).min(2).max(80),\n      description: z.string().max(2000).optional(),\n      skip_if: skipIfSchema.optional(),\n    })\n    .strict(),\n  z\n    .object({\n      id: z.string().regex(SETUP_STEP_ID_PATTERN),\n      kind: z.literal(\"external\"),\n      url: z.string().url(),\n      description: z.string().max(2000).optional(),\n      callback: z\n        .object({\n          param: z.string().min(1).optional(),\n          timeout_ms: z.number().int().min(1_000).default(600_000),\n        })\n        .strict()\n        .optional(),\n      skip_if: skipIfSchema.optional(),\n      persist: setupPersistSchema.optional(),\n    })\n    .strict(),\n])\n\nconst authSchema = z.object({\n  ref: z.string().optional(),\n  state: z.object({\n    paths: z.array(z.string()).optional(),\n    env: z.array(z.string()).optional(),\n  }).strict().optional(),\n  login: z.object({\n    cmd: z.string(),\n    interactive: z.boolean().optional(),\n    requires_callback_url: z.boolean().optional(),\n  }).strict().optional(),\n  refresh: z.object({\n    cmd: z.string(),\n    interval_s: z.number().int().positive().optional(),\n  }).strict().optional(),\n  expiry: z.object({\n    parse: z.string().optional(),\n    grace_s: z.number().int().nonnegative().optional(),\n  }).strict().optional(),\n}).strict()\n\n// Subscription (OAuth/bearer) billing declaration — see\n// AgentCliAuthSubscription. Only the Claude adapters declare it; presence =\n// \"supports subscription mode\". `setEnv` is the var SET; `conflictEnv` are\n// sibling credential vars scrubbed in every mode (except when set);\n// `unsetEnvAdd` is native-mode-only gateway hygiene.\nconst authSubscriptionSchema = z.object({\n  setEnv: z.string().min(1),\n  conflictEnv: z.array(z.string()).optional(),\n  unsetEnvAdd: z.array(z.string()).optional(),\n}).strict()\n\nconst sessionSchema = z.object({\n  mode: z.enum([\"ephemeral\", \"persistent\", \"resumable\"]).default(\"ephemeral\"),\n  idle_timeout_ms: z.number().int().min(1000).default(600_000),\n  // No default: undefined disables the per-turn watchdog entirely. Only\n  // adapters known to sometimes drop the final `prompt` response (e.g.\n  // hermes) should declare this — applying it broadly would risk\n  // false-positiving on another adapter's legitimately long turns.\n  turn_idle_timeout_ms: z.number().int().min(1000).optional(),\n  max_turns: z.number().int().positive().optional(),\n  context_carryover: z.boolean().default(true),\n}).strict()\n\nconst modelsSchema = z.object({\n  default: z.string().optional(),\n  allowed: z.array(z.string()).optional(),\n  // Model-id patterns the adapter must never route to (case-insensitive,\n  // trailing `*` = prefix match). Enforced at compose time — see\n  // AgentCliModels.deny. Reserves premium providers for dedicated adapters.\n  deny: z.array(z.string()).optional(),\n  env: z.record(z.string(), z.string()).optional(),\n  // How a model is selected at session start: \"config\" (ACP\n  // set_config_option, default) | \"command\" (a `/model <id>` control turn,\n  // for agents like hermes that ignore the ACP session model config).\n  apply: z.enum([\"config\", \"command\"]).optional(),\n}).strict()\n\nconst capabilitiesSchema = z.object({\n  streaming: z.boolean().optional(),\n  tool_calls: z.boolean().optional(),\n  sub_agents: z.boolean().optional(),\n  file_io: z.boolean().optional(),\n  multimodal: z.boolean().optional(),\n  resumable: z.boolean().optional(),\n  bidirectional: z.boolean().optional(),\n  /**\n   * Adapter can ingest a filesystem path that the host UI just placed\n   * on disk (host-side drag-drop into a terminal pastes the path\n   * here). Implies the adapter has a Read-file tool wired so the\n   * dropped path actually does something. Hosts gate drag-drop UI on\n   * this flag — defaults to false (conservative).\n   */\n  file_attach: z.boolean().optional(),\n}).strict()\n\nexport const modeSchema = z.object({\n  id: z.string().regex(MODE_ID_PATTERN),\n  description: z.string().optional(),\n  bin_args_prepend: z.array(z.string()).optional(),\n  bin_args_append: z.array(z.string()).optional(),\n  env: z.record(z.string(), z.string()).optional(),\n  // Env keys to DELETE from the spawn env (auth hygiene for gateway\n  // modes — see AgentCliMode.env_unset). Applied at the runtime merge\n  // point, not as a static set.\n  env_unset: z.array(z.string()).optional(),\n  // Honest support status surfaced to clients. Absent ⇒ \"active\".\n  status: z.enum([\"active\", \"noop\", \"planned\"]).optional(),\n  status_note: z.string().optional(),\n  // How the host activates this mode: \"bin_args\" (default, argv/env\n  // composed at spawn) | \"config\" (no CLI surface — forwarded to the ACP\n  // arm's connect({mode}) and applied via session/set_config_option\n  // configId:\"mode\", e.g. opencode).\n  apply: z.enum([\"bin_args\", \"config\"]).optional(),\n}).strict()\n\nconst optionSchema = z.object({\n  id: z.string().regex(OPTION_ID_PATTERN),\n  type: z.enum([\"boolean\", \"integer\", \"string\", \"enum\"]),\n  description: z.string().optional(),\n  enum: z.array(z.string()).min(1).optional(),\n  default: z.union([z.boolean(), z.number(), z.string()]).optional(),\n  min: z.number().int().optional(),\n  max: z.number().int().optional(),\n  bin_args_prepend: z.array(z.string()).optional(),\n  bin_args_template: z.array(z.string()).optional(),\n  bin_args_append_when_true: z.array(z.string()).optional(),\n  env: z.record(z.string(), z.string()).optional(),\n  // Env keys to DELETE from the spawn env when this option is active\n  // (auth hygiene for value-bearing gateway options — see\n  // AgentCliOption.env_unset). Symmetric with modeSchema.env_unset.\n  env_unset: z.array(z.string()).optional(),\n}).strict().refine(\n  // type === \"enum\" REQUIRES an `enum` array. The JSON Schema enforces\n  // this via `if/then`; the zod side mirrors with a refine so both\n  // validation paths reject the same shapes.\n  o => o.type !== \"enum\" || (Array.isArray(o.enum) && o.enum.length > 0),\n  { message: \"option.type === 'enum' requires a non-empty `enum` array\" }\n)\n\n// AIP-45 gateway-preset declaration (see AgentCliPresetDeclaration). A\n// backend an Anthropic/OpenAI-compatible adapter can front, declared in\n// the manifest so the catalog can surface adapter-contributed presets\n// alongside the built-in registry. `scrubEnv` is optional here — an\n// adapter that scrubs in code may omit it.\nconst presetSchema = z.object({\n  id: z.string().min(1),\n  label: z.string().min(1),\n  description: z.string().optional(),\n  schemaFlavor: z.enum([\"anthropic\", \"openai\"]),\n  baseUrl: z.string().min(1),\n  keyEnv: z.string().min(1),\n  scrubEnv: z.array(z.string()).optional(),\n  defaultModel: z.string().optional(),\n  homepage: z.string().optional(),\n}).strict()\n\n\nconst continuationStrategyIdSchema = z.enum(CONTINUATION_STRATEGY_IDS)\n\nconst continuationSchema = z.object({\n  default: continuationStrategyIdSchema,\n  supported: z.array(continuationStrategyIdSchema).min(1),\n  pinned_session: z.object({\n    idle_timeout_ms: z.number().int().min(1000).default(1_800_000),\n    key_scope: z\n      .array(z.enum(CONTINUATION_KEY_SCOPES))\n      .min(1)\n      .default([\"conversation\", \"operator\"]),\n  }).strict().optional(),\n}).strict().refine(\n  // The chosen `default` must appear in `supported` — otherwise the\n  // host has no valid strategy to fall back to.\n  c => c.supported.includes(c.default),\n  {\n    message: \"continuation.default must be a member of continuation.supported\",\n  }\n)\n\nconst mcpBlockSchema = z.object({\n  command: z.string().optional(),\n  args: z.array(z.string()).optional(),\n  transport: z.enum([\"stdio\", \"http\", \"sse\"]),\n  url: z.string().url().optional(),\n}).strict()\n\nconst printConfigSchema = z.object({\n  prompt_flag: z.string().optional(),\n  output_format: z.array(z.string()).optional(),\n  pre_prompt: z.array(z.string()).optional(),\n  resume: z.object({\n    flag: z.string(),\n    kind: z.enum([\"value\", \"boolean\"]),\n  }).strict().optional(),\n  event_schema: z.enum([\"claude-stream-json\", \"mastra-jsonl\"]).optional(),\n}).strict().optional()\n\nexport const agentCliFrontmatterSchema = z\n  .object({\n    name: z.string().min(1).max(80),\n    id: z.string().regex(ID_PATTERN),\n    description: z.string().min(1).max(2000),\n    version: z.string().regex(SEMVER_PATTERN),\n    bin: z.string().regex(BIN_PATTERN),\n    bin_args: z.array(z.string()).optional(),\n    // Always-on spawn env (merged before mode/option env, which can\n    // override). See AgentCliDefinition.env — used by generic ACP agents.\n    env: z.record(z.string(), z.string()).optional(),\n    install: z.array(installMethodSchema).min(1),\n    version_check: versionCheckSchema,\n    setup: z.array(setupStepSchema).optional(),\n    auth: authSchema.optional(),\n    // Billing-auth resolver inputs (DECISION 3). `provider` is a CatalogProvider\n    // id (validated against the catalog by the runtime resolver, not here, to\n    // keep this generic doctype decoupled from @agentproto/model-catalog).\n    provider: z.string().min(1).optional(),\n    authSubscription: authSubscriptionSchema.optional(),\n    authEnforce: z.enum([\"always\", \"when-configured\"]).optional(),\n    sandbox: z.union([z.string(), z.record(z.string(), z.unknown())]),\n    runner: z.union([z.string(), z.record(z.string(), z.unknown())]).optional(),\n    protocol: z.enum([\"acp\", \"mcp\", \"proprietary\", \"print\"]),\n    acp: z.string().optional(),\n    mcp: mcpBlockSchema.optional(),\n    adapter: z.string().regex(ADAPTER_PATTERN).optional(),\n    print: printConfigSchema,\n    session: sessionSchema.optional(),\n    models: modelsSchema.optional(),\n    capabilities: capabilitiesSchema.optional(),\n    modes: z.array(modeSchema).optional(),\n    options: z.array(optionSchema).optional(),\n    // AIP-45 gateway presets this adapter can drive (merged into the\n    // provider-preset catalog; built-in wins on id collision).\n    presets: z.array(presetSchema).optional(),\n    continuation: continuationSchema.optional(),\n    requires: z.object({\n      os: z.array(z.enum([\"darwin\", \"linux\", \"windows\"])).optional(),\n      arch: z.array(z.enum([\"x64\", \"arm64\", \"x86\", \"arm\"])).optional(),\n      min_disk_mb: z.number().int().nonnegative().optional(),\n      min_memory_mb: z.number().int().nonnegative().optional(),\n    }).strict().optional(),\n    examples: z.array(z.object({\n      goal: z.string(),\n      prompt: z.string(),\n      note: z.string().optional(),\n    }).strict()).optional(),\n    tags: z.array(z.string().regex(TAG_PATTERN)).optional(),\n    metadata: z.record(z.string(), z.unknown()).optional(),\n  })\n  .strict()\n  .superRefine((m, ctx) => {\n    // Unique mode ids — duplicates would silently shadow.\n    if (m.modes) {\n      const seen = new Set<string>()\n      for (const mode of m.modes) {\n        if (seen.has(mode.id)) {\n          ctx.addIssue({\n            code: z.ZodIssueCode.custom,\n            path: [\"modes\"],\n            message: `Duplicate mode id '${mode.id}' — mode ids must be unique within a manifest.`,\n          })\n        }\n        seen.add(mode.id)\n      }\n    }\n    // Unique setup step ids — duplicates would silently shadow each\n    // other in the host's completion ledger, leading to one step\n    // never re-prompting and another always re-prompting.\n    if (m.setup) {\n      const seen = new Set<string>()\n      for (const step of m.setup) {\n        if (seen.has(step.id)) {\n          ctx.addIssue({\n            code: z.ZodIssueCode.custom,\n            path: [\"setup\"],\n            message: `Duplicate setup step id '${step.id}' — step ids must be unique within a manifest.`,\n          })\n        }\n        seen.add(step.id)\n      }\n    }\n    // Unique option ids — same reasoning as modes.\n    if (m.options) {\n      const seen = new Set<string>()\n      for (const opt of m.options) {\n        if (seen.has(opt.id)) {\n          ctx.addIssue({\n            code: z.ZodIssueCode.custom,\n            path: [\"options\"],\n            message: `Duplicate option id '${opt.id}' — option ids must be unique within a manifest.`,\n          })\n        }\n        seen.add(opt.id)\n      }\n    }\n    // continuation.default === \"native-resume\" requires capabilities.resumable: true.\n    // Mirrors the JSON Schema's allOf rule so both validation paths\n    // reject the same shape.\n    if (\n      m.continuation?.default === \"native-resume\" &&\n      !m.capabilities?.resumable\n    ) {\n      ctx.addIssue({\n        code: z.ZodIssueCode.custom,\n        path: [\"continuation\", \"default\"],\n        message:\n          \"continuation.default === 'native-resume' requires capabilities.resumable: true.\",\n      })\n    }\n  })\n  .describe(\n    \"Validates the YAML frontmatter portion of an AIP-45 AGENT-CLI.md manifest.\",\n  )\n\nexport type AgentCliFrontmatter = z.infer<typeof agentCliFrontmatterSchema>\n\n// Re-export the per-call config schema for hosts that want to validate\n// `OPERATOR.runtime.config` against a manifest at load time. Validation\n// against the manifest's modes/options/continuation lives in\n// `manifest/compose.ts` (the spawn-arg composer) — this schema covers\n// only the SHAPE checks (types, enum values).\nexport const runtimeConfigSchema = z.object({\n  mode: z.string().optional(),\n  options: z.record(z.string(), z.union([z.boolean(), z.number(), z.string()]))\n    .optional(),\n  continuation: continuationStrategyIdSchema.optional(),\n}).strict()\n\nexport type RuntimeConfigInput = z.infer<typeof runtimeConfigSchema>\n","/**\n * AIP-45 protocol arm: `protocol: \"acp\"`.\n *\n * Wraps a subprocess's stdio in an `@agentproto/acp` client and\n * exposes the `AgentCliClient` shape the runner consumes. Each\n * `send()` call delegates to a single AcpClientSession.prompt() and\n * forwards the resulting StreamEvent stream.\n */\n\nimport type { ChildProcess } from \"node:child_process\"\nimport { Readable, Writable } from \"node:stream\"\nimport {\n  createAcpClient,\n  type AcpClient,\n  type AcpClientSession,\n  type AcpPermissionResolution,\n} from \"@agentproto/acp/client\"\nimport type {\n  AgentCliClient,\n  AgentCliConnectOptions,\n  StreamEvent,\n} from \"../types.js\"\n\n/**\n * Outcome the host returns to the agent on a permission request.\n *\n * Mirrors the upstream ACP `RequestPermissionResponse` shape EXACTLY —\n * note the doubly-nested `outcome` field: the outer is the response\n * envelope, the inner is the discriminator (string literal, not a\n * `{ type: ... }` object). Get this wrong and the agent silently\n * interprets the response as a refusal (\"User refused permission to\n * run tool\"), so we type it strictly here.\n *\n *   { outcome: { outcome: \"selected\", optionId: \"...\" } }\n *   { outcome: { outcome: \"cancelled\" } }\n */\nexport type AcpPermissionOutcome =\n  | { outcome: { outcome: \"selected\"; optionId: string } }\n  | { outcome: { outcome: \"cancelled\" } }\n\nexport interface AcpPermissionRequestParams {\n  sessionId?: string\n  // `title`/`kind` allow `null` (not just `undefined`) so the upstream ACP\n  // `RequestPermissionRequest` — whose `toolCall` is a `ToolCallUpdate` with\n  // `title: string | null` / `kind: ToolKind | null` — is structurally\n  // assignable to this shape. That lets the arm's handler take the SDK type\n  // directly, with no `as` cast at the `createAcpClient` call site.\n  toolCall?: {\n    toolCallId?: string\n    title?: string | null\n    kind?: string | null\n    rawInput?: unknown\n  }\n  options?: Array<{ optionId: string; name?: string; kind?: string }>\n}\n\nexport type AcpPermissionHandler = (\n  params: AcpPermissionRequestParams\n) => Promise<AcpPermissionOutcome> | AcpPermissionOutcome\n\n/**\n * Default handler: pick the first option whose `kind` starts with\n * `allow_` (Claude Code offers `allow_once` and `allow_always`).\n * Falls back to the first option if none match — keeps the agent\n * unblocked rather than throwing on an unfamiliar option set.\n *\n * Mirrors the trust model of in-process Mastra agents: the user\n * approved the operator binding once; subsequent tool calls don't\n * re-prompt by default. Hosts that want explicit per-call gating\n * pass their own `onPermissionRequest`.\n *\n * NOT safe to use as-is for a `mode: \"plan\"` session — see\n * `planModePermissionHandler` below.\n */\nexport const autoAllowPermissionHandler: AcpPermissionHandler = ({\n  options,\n}) => {\n  if (!options || options.length === 0) {\n    // No options offered — return cancelled so the agent gets a\n    // deterministic answer instead of hanging on a dropped request.\n    return { outcome: { outcome: \"cancelled\" } }\n  }\n  const allow =\n    options.find(o => typeof o.kind === \"string\" && o.kind.startsWith(\"allow_\")) ??\n    options[0]\n  return { outcome: { outcome: \"selected\", optionId: allow!.optionId } }\n}\n\n/**\n * `toolCall.kind` Claude Code's ACP wrapper attaches to the \"ready to\n * code?\" permission request it raises when the agent wants to leave\n * plan mode (its internal `ExitPlanMode` tool, mapped by\n * `@agentclientprotocol/claude-agent-acp`'s `toolInfoFromToolUse`).\n * This is the ONLY reliable discriminator for that request — its\n * `options[].kind` values (`allow_always` / `allow_once` / `reject_once`)\n * are the same vocabulary an ordinary tool-permission request uses, so\n * `option.kind` alone can't tell the two apart.\n */\nconst PLAN_MODE_EXIT_TOOL_CALL_KIND = \"switch_mode\"\n\n/**\n * Permission handler for a session spawned with `mode: \"plan\"`.\n *\n * `autoAllowPermissionHandler` picks the first `allow_*` option, but for\n * the plan-mode-exit request that option is always an escalation away\n * from plan (`auto`, `acceptEdits`, or `bypassPermissions` depending on\n * what the wrapper offers) — auto-approving it silently defeats the\n * mode the caller asked for (see the regression this fixes: a `plan`\n * session that wrote a file when prompted to). Noted as a known gap in\n * a naive auto-allow handler when #143 shipped the `CLAUDE_CONFIG_DIR`\n * override that makes `mode: \"plan\"` take effect in the first place;\n * this closes it.\n *\n * Behaves exactly like `autoAllowPermissionHandler` for every other\n * request. For the plan-mode-exit request specifically, it selects the\n * offered `reject_once` option (\"No, keep planning\") so the wrapper\n * denies the exit with a clean, structured outcome — the tool call\n * fails, the agent stays in plan mode and can keep reasoning or tell\n * the user it's blocked, instead of the turn throwing on a `cancelled`\n * outcome. Falls back to `cancelled` if no `reject_once` option is\n * offered (shouldn't happen with the current wrapper, but a safe\n * default beats guessing an allow).\n *\n * This is a deliberate one-way gate: a plan-mode session driven by this\n * handler can never escalate itself out of plan mode. A caller that\n * wants a human (or a policy engine) to approve that escalation must\n * supply its own `onPermissionRequest` — this handler is only the\n * default for callers that don't.\n */\nexport const planModePermissionHandler: AcpPermissionHandler = params => {\n  const { options, toolCall } = params\n  if (!options || options.length === 0) {\n    return { outcome: { outcome: \"cancelled\" } }\n  }\n  if (toolCall?.kind === PLAN_MODE_EXIT_TOOL_CALL_KIND) {\n    const keepPlanning = options.find(o => o.kind === \"reject_once\")\n    return keepPlanning\n      ? { outcome: { outcome: \"selected\", optionId: keepPlanning.optionId } }\n      : { outcome: { outcome: \"cancelled\" } }\n  }\n  return autoAllowPermissionHandler(params)\n}\n\n/** Picks the safe default permission handler for a requested AIP-45\n *  mode when the caller didn't supply their own `onPermissionRequest`.\n *  Only `\"plan\"` gets special handling today — other modes (accept-edits,\n *  bypass-permissions) are already at-or-above the auto-allow handler's\n *  trust level, so there's no escalation for it to guard against. */\nfunction defaultPermissionHandlerForMode(\n  requestedMode: string | undefined,\n): AcpPermissionHandler {\n  return requestedMode === \"plan\"\n    ? planModePermissionHandler\n    : autoAllowPermissionHandler\n}\n\nexport interface AcpProtocolOptions {\n  child: ChildProcess\n  cwd: string\n  clientInfo?: { name: string; title?: string; version?: string }\n  /** Called when the agent asks for permission to run a tool (Write,\n   *  Bash, ...). Defaults to `autoAllowPermissionHandler`, or\n   *  `planModePermissionHandler` when `requestedMode === \"plan\"`. Pass a\n   *  custom handler to plumb requests through a UI / governance\n   *  policy. Throwing or returning a rejected promise bubbles to the\n   *  agent as an internal error. */\n  onPermissionRequest?: AcpPermissionHandler\n  /**\n   * AIP-45 mode requested at spawn (`opts.config.mode` in\n   * `define-agent-cli.ts`'s `start()`), if any. Used to pick the default\n   * permission handler when `onPermissionRequest` is omitted — see\n   * `defaultPermissionHandlerForMode`.\n   */\n  requestedMode?: string\n  /**\n   * When true, permission requests are surfaced as `agent-prompt` StreamEvents\n   * and HELD in the daemon's permission inbox rather than auto-answered —\n   * forwarded verbatim to `createAcpClient({ permissionHold })`. The\n   * `onPermissionRequest` / `requestedMode` handler is bypassed while this is\n   * set. Default false (unchanged: requests are auto-answered in-arm).\n   */\n  permissionHold?: boolean\n}\n\nexport function createAcpProtocolArm(\n  options: AcpProtocolOptions,\n): AgentCliClient {\n  const { child, cwd } = options\n\n  if (!child.stdin || !child.stdout) {\n    throw new Error(\n      \"AcpProtocolArm: subprocess must be spawned with piped stdin + stdout\",\n    )\n  }\n\n  const output = Writable.toWeb(child.stdin) as WritableStream<Uint8Array>\n  const input = Readable.toWeb(child.stdout) as ReadableStream<Uint8Array>\n\n  let client: AcpClient | null = null\n  let session: AcpClientSession | null = null\n  const pendingByTurn = new Map<string, AsyncIterable<StreamEvent>>()\n\n  return {\n    get sessionId(): string | undefined {\n      return session?.sessionId\n    },\n    async connect(opts: AgentCliConnectOptions) {\n      const permissionHandler =\n        options.onPermissionRequest ??\n        defaultPermissionHandlerForMode(options.requestedMode)\n      client = await createAcpClient({\n        output,\n        input,\n        clientInfo: options.clientInfo,\n        capabilities: {\n          fs: { readTextFile: true, writeTextFile: true },\n        },\n        onActivity: opts.onActivity,\n        turnIdleTimeoutMs: opts.turnIdleTimeoutMs,\n        // Permission-hold mode: surface + park requests for the daemon inbox\n        // instead of auto-answering them in-arm (see AcpProtocolOptions).\n        ...(options.permissionHold ? { permissionHold: true } : {}),\n        // Wire the permission handler so the agent's `session/request_permission`\n        // callbacks get a real answer instead of bubbling up as\n        // \"AcpClient.requestPermission: no handler configured\" → which\n        // surfaces in the chat as an opaque \"Internal error\" when the\n        // agent tries to Write / Bash anything gated.\n        // `params` is contextually typed as the SDK's `RequestPermissionRequest`\n        // (via `AcpClientOptions.handlers`), which is assignable to\n        // `AcpPermissionRequestParams` — so no cast is needed on either side.\n        handlers: {\n          requestPermission: async params => permissionHandler(params),\n        },\n      })\n      // When the host hands us a `resumeSessionId`, reattach to the\n      // agent's existing session via `loadSession` so the conversation\n      // (model context, tool history, working files) carries over a\n      // cold start. We trust the host to only send ids it persisted\n      // from a prior turn; if the agent's `loadSession: true` capability\n      // wasn't advertised the SDK call surfaces the per-protocol error.\n      //\n      // No silent fallback to `newSession` on resume failure — that\n      // would create a new session quietly and lose continuity, which\n      // is the bug we're trying to prevent. Let the error propagate.\n      if (opts.resumeSessionId) {\n        session = await client.loadSession({\n          sessionId: opts.resumeSessionId,\n          cwd,\n          mcpServers: opts.mcpServers,\n        })\n      } else {\n        session = await client.newSession({\n          cwd,\n          mcpServers: opts.mcpServers,\n          ...(opts.model ? { model: opts.model } : {}),\n          ...(opts.effort ? { effort: opts.effort } : {}),\n          ...(opts.mode ? { mode: opts.mode } : {}),\n        })\n      }\n    },\n    async send(turnId, message) {\n      if (!session) throw new Error(\"AcpProtocolArm.send: not connected\")\n      // ACP's `prompt` field is `ContentBlock[]` — multiple blocks\n      // together form the user's turn (text + image + resource_link\n      // + ...). Callers MAY pass either:\n      //   - a single block (`{type:\"text\",text:\"...\"}`) — wrapped\n      //     into a one-element array for the wire\n      //   - an array of blocks — forwarded verbatim, supporting\n      //     multimodal turns without callers re-shaping per-arm\n      const messages = Array.isArray(message) ? message : [message]\n      const stream = session.prompt({ messages })\n      pendingByTurn.set(turnId, stream)\n    },\n    async *events(): AsyncIterable<StreamEvent> {\n      const last = Array.from(pendingByTurn.values()).at(-1)\n      if (!last) return\n      for await (const evt of last) yield evt\n    },\n    async cancel(_turnId) {\n      if (!session) return\n      await session.cancel()\n    },\n    respondPermission(\n      requestId: string,\n      resolution: AcpPermissionResolution,\n    ): boolean {\n      // Resolve a permission request parked by permission-hold mode. Routed\n      // through the client (its pending map is keyed globally by request id).\n      return client?.respondPermission(requestId, resolution) ?? false\n    },\n    async close() {\n      if (session) await session.close()\n      if (client) await client.close()\n    },\n  }\n}\n","/**\n * Shared converter from this repo's generic `AcpMcpServer[]`\n * (`{ name, transport: \"stdio\"|\"http\"|\"sse\", ref? }`) to the\n * `Record<string, McpServerConfig>` shape mastracode expects — both\n * for the in-process SDK config (`MastraCodeConfig.mcpServers`) and\n * for the file-based `.mastracode/mcp.json` the print arm writes.\n *\n * The target type is structurally identical in both contexts:\n *   - stdio → `{ command, args?, env? }`\n *   - http  → `{ url, headers? }`\n *   - sse   → `{ url }` (mastracode's `McpHttpServerConfig` doc says\n *             it handles SSE through the same `url` field, no separate\n *             discriminator)\n *\n * Neither `McpServerConfig`/`McpStdioServerConfig`/`McpHttpServerConfig`\n * is exported from `mastracode`'s public surface (only `.`, `./tui`,\n * `./acp`, `./headless`, `./plugin` subpaths are exported — no `./mcp`),\n * so we define a local, structurally-matching type here. TS structural\n * typing means a plain object literal shaped correctly type-checks fine\n * against `MastraCodeConfig.mcpServers` without a named import.\n *\n * Mirrors EXACTLY the same transport→field semantics the ACP arm uses\n * in `toAcpMcpServer` (`@agentproto/acp/client`), just flattened to\n * mastracode's keyed-record shape instead of the ACP wire array.\n */\n\nimport type { AcpMcpServer } from \"./types.js\"\n\n/**\n * mastracode's per-server config entry (structural — not imported from\n * `mastracode`, which doesn't export these types from its public\n * surface). Detected structurally by mastracode: `command` present →\n * stdio, `url` present → http. Both keys present → entry is skipped\n * (mastracode's own validation).\n */\nexport type MastracodeMcpServerConfig =\n  | { command: string; args?: string[]; env?: Record<string, string> }\n  | { url: string; headers?: Record<string, string> }\n\n/**\n * Convert the repo's compact `AcpMcpServer[]` into mastracode's\n * `Record<string, McpServerConfig>` keyed by server name. Returns\n * `undefined` for an empty/missing input so callers can spread the\n * result conditionally (`...(cond ? { mcpServers } : {})`).\n *\n * On key collision the caller's entry simply overwrites — this matches\n * mastracode's own \"higher precedence overrides lower, by server name\"\n * merge semantics for both the SDK config field and the file-based\n * load-order.\n */\nexport function toFileBasedMcpServers(\n  servers: readonly AcpMcpServer[] | undefined,\n): Record<string, MastracodeMcpServerConfig> | undefined {\n  if (!servers || servers.length === 0) return undefined\n  const out: Record<string, MastracodeMcpServerConfig> = {}\n  for (const s of servers) {\n    out[s.name] =\n      s.transport === \"stdio\"\n        ? { command: s.ref ?? \"\" }\n        : { url: s.ref ?? \"\" }\n  }\n  return out\n}\n","/**\n * AIP-45 protocol arm: `protocol: \"print\"`.\n *\n * Drives a headless CLI as one fresh subprocess per turn — no\n * long-lived ACP connection. Simpler than the ACP arm and immune to\n * the stale-proxy race condition: the session object itself never dies\n * between turns; only the per-turn child does.\n *\n * ## Configuration\n *\n * The adapter's `print` manifest block declares the CLI's one-shot\n * surface (flags, output format, event taxonomy). When the block is\n * absent, Claude Code defaults are applied for backward compatibility.\n *\n * ## Session tracking\n *\n * The `sessionId` property starts empty (or pre-seeded from\n * `resumeSessionId`) and is updated after the first successful turn\n * from the wire event that carries the session / thread identifier\n * (Claude: `result.session_id`; Mastra: `result.threadId`).\n * Subsequent turns pass the appropriate resume flag so the CLI\n * rehydrates the conversation.\n */\n\nimport { spawn } from \"node:child_process\"\nimport { existsSync, mkdirSync, readFileSync, rmdirSync, rmSync, writeFileSync } from \"node:fs\"\nimport { createInterface } from \"node:readline\"\nimport { join } from \"node:path\"\nimport { toFileBasedMcpServers } from \"../mcp-servers.js\"\nimport type {\n  AcpMcpServer,\n  AgentCliPrintConfig,\n  AgentCliRuntimeSession,\n  StreamEvent,\n} from \"../types.js\"\n\nexport interface PrintArmOptions {\n  bin: string\n  /** Base argv passed to the binary BEFORE print flags and prompt.\n   *  Typically permission-mode and model overrides from `composeSpawn`. */\n  baseArgs: string[]\n  cwd: string\n  env: Record<string, string>\n  /** Pre-seed from `resumeSessionId` so the first turn reattaches. */\n  resumeSessionId?: string\n  /** Adapter-declared print surface config. Omit for Claude defaults. */\n  printConfig?: AgentCliPrintConfig\n  /**\n   * MCP servers to mount into the agent's session. For the `mastracode`\n   * print arm (`event_schema: \"mastra-jsonl\"`) these are written to\n   * `<cwd>/.mastracode/mcp.json` before the first turn's spawn (the\n   * mastracode CLI has no CLI flag / env var / config-dir override for\n   * MCP config — this was exhaustively verified against its source) and\n   * restored/removed on `close()`. Ignored for other print schemas\n   * (e.g. Claude Code), which don't load MCP config from this path.\n   */\n  mcpServers?: AcpMcpServer[]\n}\n\n// ── Defaults (Claude Code backward-compatible) ──────────────────────\n\nconst DEFAULT_OUTPUT: string[] = [\"--output-format\", \"stream-json\"]\nconst DEFAULT_PRE_PROMPT: string[] = [\"--no-interactive\"]\nconst DEFAULT_RESUME = { flag: \"--resume\", kind: \"value\" as const }\n\nexport function createPrintSession(\n  opts: PrintArmOptions,\n): AgentCliRuntimeSession {\n  const config = opts.printConfig\n  const outputFormat = config?.output_format ?? DEFAULT_OUTPUT\n  const prePrompt = config?.pre_prompt ?? DEFAULT_PRE_PROMPT\n  const promptFlag = config?.prompt_flag\n  const resumeCfg = config?.resume ?? DEFAULT_RESUME\n  const eventSchema = config?.event_schema ?? \"claude-stream-json\"\n\n  let sessionId = opts.resumeSessionId ?? \"\"\n  let activeChild: ReturnType<typeof spawn> | null = null\n\n  // ── MCP server injection (mastracode print arm only) ─────────────\n  // The mastracode CLI has no CLI flag, env var, or config-dir override\n  // for MCP config (exhaustively verified against its source). The only\n  // way to mount host-chosen MCP servers into a print-arm subprocess is\n  // to write them into `<cwd>/.mastracode/mcp.json`, which mastracode\n  // loads at process startup as its highest-precedence project-scope\n  // config. This is done once here (before the first turn's spawn) and\n  // restored on close(). Only applies when the adapter is mastracode\n  // (`event_schema: \"mastra-jsonl\"`) — other print adapters (Claude\n  // Code) don't read this path.\n  const mcpRestore = setupMcpConfigFile(opts, eventSchema)\n\n  return {\n    get sessionId(): string {\n      return sessionId\n    },\n\n    async *send(message: unknown): AsyncIterable<StreamEvent> {\n      const prompt = extractPromptText(message)\n\n      // Build argv: baseArgs + output_format + pre_prompt +\n      //             resume_flag(+value) + prompt_flag(+text) | positional\n      const args: string[] = [\n        ...opts.baseArgs,\n        ...outputFormat,\n        ...prePrompt,\n      ]\n\n      // Resume flag\n      if (sessionId) {\n        args.push(resumeCfg.flag)\n        if (resumeCfg.kind === \"value\") args.push(sessionId)\n      }\n\n      // Prompt: flag or positional\n      if (promptFlag) {\n        args.push(promptFlag, prompt)\n      } else {\n        args.push(prompt)\n      }\n\n      const child = spawn(opts.bin, args, {\n        cwd: opts.cwd,\n        env: opts.env,\n        stdio: [\"ignore\", \"pipe\", \"pipe\"],\n      })\n      activeChild = child\n\n      const stderrLines: string[] = []\n      const STDERR_KEEP = 80\n      child.stderr?.setEncoding(\"utf8\")\n      child.stderr?.on(\"data\", (chunk: string) => {\n        for (const line of chunk.split(/\\r?\\n/)) {\n          if (!line) continue\n          stderrLines.push(line)\n          if (stderrLines.length > STDERR_KEEP) stderrLines.shift()\n        }\n      })\n\n      try {\n        if (!child.stdout)\n          throw new Error(\"print-arm: child has no stdout pipe\")\n\n        let capturedSessionId = \"\"\n        const mastraState =\n          eventSchema === \"mastra-jsonl\"\n            ? createMastraMapperState()\n            : undefined\n\n        // ── Decouple pipe draining from downstream consumption ────────\n        // A `for await (const line of rl)` loop backpressures onto\n        // `child.stdout`: when the loop suspends at a slow downstream\n        // consumer (e.g. an SSE write to the orchestrator client that has\n        // stopped reading), readline pauses the stream, the child's stdout\n        // OS pipe buffer fills, and the child's next `write()` fails with\n        // `ENOBUFS` and the process dies. High-volume producers (kimi via\n        // mastracode: 900+ tool results / 1200+ lines) hit this reliably.\n        //\n        // Instead, readline's `\"line\"` event (flowing mode) drains the\n        // pipe CONTINUOUSLY — parsing and mapping each line the instant it\n        // arrives — and pushes mapped events into an in-memory queue. The\n        // generator below yields from that queue at whatever pace\n        // downstream consumes. The child therefore never observes\n        // backpressure from a slow client.\n        const rl = createInterface({ input: child.stdout, crlfDelay: Infinity })\n        const queue = new EventQueue()\n\n        rl.on(\"line\", (line: string) => {\n          if (!line.trim()) return\n          let evt: Record<string, unknown>\n          try {\n            evt = JSON.parse(line) as Record<string, unknown>\n          } catch {\n            return\n          }\n\n          // Capture the session/thread id from the wire event\n          const csid = captureSessionId(evt, eventSchema)\n          if (csid) capturedSessionId = csid\n\n          const sid = capturedSessionId || sessionId || \"\"\n          const mapped = mapEvent(evt, sid, stderrLines, eventSchema, mastraState)\n          if (mapped) queue.push(mapped)\n        })\n        rl.once(\"close\", () => queue.end())\n\n        // Yield mapped events as downstream pulls them; the `\"line\"`\n        // handler above keeps draining the pipe regardless of how far\n        // behind this loop is.\n        for await (const mapped of queue) {\n          yield mapped\n        }\n\n        const exitCode = await waitForExit(child)\n        if (capturedSessionId) sessionId = capturedSessionId\n\n        if (exitCode !== 0 && exitCode !== null) {\n          const binLabel =\n            eventSchema === \"mastra-jsonl\" ? \"mastracode\" : \"claude\"\n          const errEvt: StreamEvent = {\n            kind: \"error\",\n            error: {\n              message: `${binLabel} exited with code ${exitCode}`,\n              ...(stderrLines.length\n                ? { data: { stderr: stderrLines.join(\"\\n\") } }\n                : {}),\n            },\n          }\n          yield errEvt\n        }\n      } finally {\n        activeChild = null\n      }\n    },\n\n    async cancel(): Promise<void> {\n      activeChild?.kill(\"SIGTERM\")\n    },\n\n    async close(): Promise<void> {\n      activeChild?.kill(\"SIGTERM\")\n      mcpRestore?.()\n    },\n  }\n}\n\n// ── MCP config file injection (mastracode print arm) ────────────────\n\n/**\n * Before the first turn's spawn, shallow-merges our injected MCP servers\n * into `<cwd>/.mastracode/mcp.json` (the highest-precedence project-scope\n * config mastracode loads). Returns a restore function that reverts the\n * file to its pre-session state on `close()`, or `undefined` if no\n * injection was performed.\n *\n * Only activates when `eventSchema === \"mastra-jsonl\"` (mastracode) AND\n * `opts.mcpServers` is non-empty. Other print adapters (Claude Code)\n * don't read this path and are left untouched.\n *\n * Our injected servers win on key collision — this matches mastracode's\n * own \"higher precedence overrides lower, by server name\" merge\n * semantics, and the SDK's documented \"merged with, and overriding,\n * file-based configs\" behavior for the in-process arm, so both arms\n * behave consistently.\n *\n * KNOWN LIMITATION: two concurrent mastracode print sessions sharing\n * the SAME `cwd` will race on this read-merge-write (last writer wins\n * on the shared file). This is an upstream mastracode CLI limitation —\n * no config-dir isolation exists to route around it. This is a real but\n * narrow edge case (only matters for concurrent orchestrator children\n * spawned into the identical directory); no locking mechanism is built\n * here, by design.\n */\nfunction setupMcpConfigFile(\n  opts: PrintArmOptions,\n  eventSchema: \"claude-stream-json\" | \"mastra-jsonl\",\n): (() => void) | undefined {\n  if (eventSchema !== \"mastra-jsonl\") return undefined\n  if (!opts.mcpServers || opts.mcpServers.length === 0) return undefined\n\n  const dir = join(opts.cwd, \".mastracode\")\n  const file = join(dir, \"mcp.json\")\n  const injected = toFileBasedMcpServers(opts.mcpServers)\n  if (!injected) return undefined\n\n  // Snapshot the pre-session state so close() can restore it.\n  const fileExisted = existsSync(file)\n  let originalContent: string | undefined\n  if (fileExisted) {\n    try {\n      originalContent = readFileSync(file, \"utf8\")\n    } catch {\n      originalContent = undefined\n    }\n  }\n  const dirExisted = existsSync(dir)\n\n  // Ensure `.mastracode/` exists, then read-merge-write.\n  if (!dirExisted) {\n    mkdirSync(dir, { recursive: true })\n  }\n\n  let existingServers: Record<string, unknown> = {}\n  if (originalContent !== undefined) {\n    try {\n      const parsed = JSON.parse(originalContent) as Record<string, unknown>\n      if (parsed && typeof parsed.mcpServers === \"object\" && parsed.mcpServers !== null) {\n        existingServers = parsed.mcpServers as Record<string, unknown>\n      }\n    } catch {\n      // Corrupt or unparseable file — start fresh with just our servers.\n      existingServers = {}\n    }\n  }\n\n  // Shallow-merge: our injected servers override on key collision.\n  const merged: Record<string, unknown> = { ...existingServers, ...injected }\n  const output = JSON.stringify({ mcpServers: merged }, null, 2)\n  writeFileSync(file, output, \"utf8\")\n\n  // Return the restore function.\n  return () => {\n    try {\n      if (!fileExisted) {\n        // We created the file — remove it. Also remove the `.mastracode/`\n        // dir only if we created that too AND it's now empty (don't\n        // rm -rf someone's existing directory).\n        rmSync(file, { force: true })\n        if (!dirExisted) {\n          try {\n            // `rmdirSync` (not `rmSync`) — only removes an EMPTY\n            // directory, throwing ENOTEMPTY otherwise. `rmSync` without\n            // `recursive: true` throws on any directory regardless of\n            // contents, which would always land in the catch below and\n            // silently leave the directory behind even when empty.\n            rmdirSync(dir)\n          } catch {\n            // Directory not empty (other files were added) — leave it.\n          }\n        }\n      } else if (originalContent !== undefined) {\n        // File existed before — restore its original content, but first\n        // remove only our injected keys from the merged object so any\n        // concurrent changes (if the file was modified externally) are\n        // preserved minus our entries. If that produces an empty\n        // mcpServers map, restore the original file verbatim.\n        let current: Record<string, unknown> = {}\n        try {\n          const parsed = JSON.parse(readFileSync(file, \"utf8\")) as Record<string, unknown>\n          if (parsed && typeof parsed.mcpServers === \"object\" && parsed.mcpServers !== null) {\n            current = parsed.mcpServers as Record<string, unknown>\n          }\n        } catch {\n          // Can't read current state — restore original verbatim.\n          writeFileSync(file, originalContent, \"utf8\")\n          return\n        }\n        for (const key of Object.keys(injected)) {\n          delete current[key]\n        }\n        if (Object.keys(current).length === 0) {\n          // All servers were ours — restore original file content.\n          writeFileSync(file, originalContent, \"utf8\")\n        } else {\n          writeFileSync(file, JSON.stringify({ mcpServers: current }, null, 2), \"utf8\")\n        }\n      }\n    } catch {\n      // Best-effort — never throw from close().\n    }\n  }\n}\n\n// ── Prompt extraction ───────────────────────────────────────────────\n\nfunction extractPromptText(message: unknown): string {\n  if (typeof message === \"string\") return message\n  if (message !== null && typeof message === \"object\") {\n    const m = message as Record<string, unknown>\n    if (typeof m.text === \"string\") return m.text\n    if (Array.isArray(message)) {\n      return (message as Array<Record<string, unknown>>)\n        .filter(b => b.type === \"text\" && typeof b.text === \"string\")\n        .map(b => b.text as string)\n        .join(\"\\n\")\n    }\n  }\n  return JSON.stringify(message)\n}\n\n// ── Session id capture per event schema ─────────────────────────────\n\nfunction captureSessionId(\n  evt: Record<string, unknown>,\n  schema: \"claude-stream-json\" | \"mastra-jsonl\",\n): string | null {\n  switch (schema) {\n    case \"claude-stream-json\":\n      if (\n        evt.type === \"result\" &&\n        typeof evt.session_id === \"string\" &&\n        evt.session_id\n      )\n        return evt.session_id\n      return null\n    case \"mastra-jsonl\":\n      // Mastra Code writes exactly one authoritative final line per run\n      // regardless of success/failure path: { type: \"result\", threadId,\n      // text, finishReason, exitCode, ... }. Reading it here (rather than\n      // the incidental om_status event, which only fires when\n      // Observational Memory is enabled) guarantees the thread id is\n      // captured on every turn.\n      if (\n        evt.type === \"result\" &&\n        typeof evt.threadId === \"string\" &&\n        evt.threadId\n      )\n        return evt.threadId\n      return null\n  }\n}\n\n// ── Event mapping ───────────────────────────────────────────────────\n\nfunction mapEvent(\n  evt: Record<string, unknown>,\n  sessionId: string,\n  stderrLines: string[],\n  schema: \"claude-stream-json\" | \"mastra-jsonl\",\n  mastraState?: MastraMapperState,\n): StreamEvent | null {\n  switch (schema) {\n    case \"claude-stream-json\":\n      return mapClaudeEvent(evt, sessionId, stderrLines)\n    case \"mastra-jsonl\": {\n      if (!mastraState) {\n        // Should never happen — mastra-jsonl schema always creates state\n        return mapClaudeEvent(evt, sessionId, stderrLines)\n      }\n      return mapMastraEvent(evt, sessionId, stderrLines, mastraState)\n    }\n    default:\n      return mapClaudeEvent(evt, sessionId, stderrLines)\n  }\n}\n\n// ── Claude Code stream-json mapper ──────────────────────────────────\n\nfunction mapClaudeEvent(\n  evt: Record<string, unknown>,\n  sessionId: string,\n  stderrLines: string[],\n): StreamEvent | null {\n  switch (evt.type) {\n    case \"text\":\n      return typeof evt.text === \"string\"\n        ? { kind: \"text-delta\", sessionId, text: evt.text }\n        : null\n\n    case \"thinking\":\n      return typeof evt.thinking === \"string\"\n        ? { kind: \"thought\", sessionId, text: evt.thinking }\n        : null\n\n    case \"tool_use\":\n      return {\n        kind: \"tool-call\",\n        sessionId,\n        toolCallId: typeof evt.id === \"string\" ? evt.id : \"\",\n        toolName: typeof evt.name === \"string\" ? evt.name : \"?\",\n        arguments: evt.input ?? {},\n      }\n\n    case \"tool_result\":\n      return {\n        kind: \"tool-result\",\n        sessionId,\n        toolCallId:\n          typeof evt.tool_use_id === \"string\" ? evt.tool_use_id : \"\",\n        result: evt.content ?? null,\n        isError: evt.is_error === true,\n      }\n\n    case \"result\":\n      if (\n        evt.subtype === \"error_during_execution\" ||\n        evt.is_error === true\n      ) {\n        return {\n          kind: \"error\",\n          sessionId,\n          error: {\n            message:\n              typeof evt.error === \"string\"\n                ? evt.error\n                : \"Unknown error\",\n            ...(stderrLines.length\n              ? { data: { stderr: stderrLines.join(\"\\n\") } }\n              : {}),\n          },\n        }\n      }\n      if (evt.subtype === \"success\") {\n        return { kind: \"turn-end\", sessionId, reason: \"completed\" }\n      }\n      return null\n\n    case \"system\":\n    case \"assistant\":\n      return null\n\n    default:\n      return null\n  }\n}\n\n// ── Mastra Code JSONL mapper ────────────────────────────────────────\n\n/**\n * Mutable per-stream state for the Mastra Code event mapper.\n * Mastra Code sends the FULL accumulated text on each `message_update`,\n * so we track the previous length to emit only the new portion.\n *\n * Exported so other Mastra Code protocol arms (e.g. the in-process\n * `proprietary` arm in `@agentproto/adapter-mastracode-inprocess`) can\n * reuse the same event mapper instead of reimplementing it — the wire\n * shape here is `AgentControllerEvent` regardless of whether it arrived\n * over a JSONL subprocess pipe or as a live in-process object.\n */\nexport interface MastraMapperState {\n  lastTextLength: number\n}\n\nexport function createMastraMapperState(): MastraMapperState {\n  return { lastTextLength: 0 }\n}\n\n/**\n * Extract text from Mastra Code content blocks.\n * Blocks are `{ type: \"text\", text: \"...\" }` arrays on `message.content`.\n */\nfunction extractTextFromBlocks(\n  content: unknown,\n): string {\n  if (!Array.isArray(content)) return \"\"\n  return (content as Array<Record<string, unknown>>)\n    .filter(c => c.type === \"text\" && typeof c.text === \"string\")\n    .map(c => c.text as string)\n    .join(\"\")\n}\n\n/**\n * Maps a single Mastra Code `AgentControllerEvent` (already a plain\n * object — JSON-parsed from a subprocess line, or handed over directly\n * by an in-process arm) to this repo's {@link StreamEvent} taxonomy.\n * `stderrLines` enriches `error` events for arms that have a real\n * subprocess to report on; pass `[]` when there is none (e.g. the\n * in-process arm).\n */\nexport function mapMastraEvent(\n  evt: Record<string, unknown>,\n  sessionId: string,\n  stderrLines: string[],\n  state: MastraMapperState,\n): StreamEvent | null {\n  switch (evt.type) {\n    // ── Text streaming ──────────────────────────────────────────\n    case \"message_update\": {\n      const content = (evt.message as Record<string, unknown>)?.content\n      const fullText = extractTextFromBlocks(content)\n      if (fullText.length > state.lastTextLength) {\n        const delta = fullText.slice(state.lastTextLength)\n        state.lastTextLength = fullText.length\n        return delta ? { kind: \"text-delta\", sessionId, text: delta } : null\n      }\n      return null\n    }\n\n    case \"message_end\": {\n      const msg = evt.message as Record<string, unknown> | undefined\n      if (msg?.role !== \"assistant\") return null\n      const fullText = extractTextFromBlocks(msg?.content)\n      // Emit any remaining text not covered by message_update deltas\n      if (fullText.length > state.lastTextLength) {\n        const delta = fullText.slice(state.lastTextLength)\n        state.lastTextLength = fullText.length\n        return delta ? { kind: \"text-delta\", sessionId, text: delta } : null\n      }\n      return null\n    }\n\n    // ── Tool calls ──────────────────────────────────────────────\n    case \"tool_start\":\n      return {\n        kind: \"tool-call\",\n        sessionId,\n        toolCallId:\n          typeof evt.toolCallId === \"string\" ? evt.toolCallId : \"\",\n        toolName:\n          typeof evt.toolName === \"string\" ? evt.toolName : \"?\",\n        // Mastra's controller event carries the tool call payload under\n        // `args`, not `input` (that's the Claude Code stream-json field\n        // name used by the sibling mapClaudeEvent tool_use case below).\n        arguments: evt.args ?? {},\n      }\n\n    case \"tool_end\":\n      return {\n        kind: \"tool-result\",\n        sessionId,\n        toolCallId:\n          typeof evt.toolCallId === \"string\" ? evt.toolCallId : \"\",\n        result: evt.result ?? null,\n        isError: evt.isError === true,\n      }\n\n    // ── Turn end ────────────────────────────────────────────────\n    case \"agent_end\": {\n      const rawReason =\n        typeof evt.reason === \"string\"\n          ? evt.reason\n          : \"complete\"\n      const reason = mapMastraFinishReason(rawReason)\n      return { kind: \"turn-end\", sessionId, reason }\n    }\n\n    // ── Final result line ────────────────────────────────────────\n    // Always written last, once, whether or not `agent_end` fired —\n    // pre-flight failures (bad model, unresolvable thread, missing API\n    // key) call straight into this without ever streaming an\n    // `agent_end` or `error` event. `turn-end` already came from\n    // `agent_end` on the success path, so this only needs to surface\n    // an error for the pre-flight-failure path.\n    case \"result\": {\n      const err = evt.error as Record<string, unknown> | undefined\n      if (!err) return null\n      return {\n        kind: \"error\",\n        sessionId,\n        error: {\n          message:\n            typeof err.message === \"string\" ? err.message : \"Unknown error\",\n          ...(stderrLines.length\n            ? { data: { stderr: stderrLines.join(\"\\n\") } }\n            : {}),\n        },\n      }\n    }\n\n    // ── Errors ─────────────────────────────────────────────────\n    case \"error\": {\n      const err = evt.error as Record<string, unknown> | undefined\n      return {\n        kind: \"error\",\n        sessionId,\n        error: {\n          message:\n            typeof err?.message === \"string\"\n              ? err.message\n              : \"Unknown error\",\n          ...(stderrLines.length\n            ? { data: { stderr: stderrLines.join(\"\\n\") } }\n            : {}),\n        },\n      }\n    }\n\n    // ── Token usage ─────────────────────────────────────────────\n    // Mastra Code DOES expose usage: its `AgentController` emits a native\n    // `usage_update` event ({ type: \"usage_update\", usage: TokenUsage })\n    // on every model step-finish — verified against @mastra/core 1.48.0's\n    // AgentControllerEvent union and its emit site\n    // (`this.#session.emit({ type: \"usage_update\", usage: stepUsage })`).\n    // `TokenUsage` carries `{ promptTokens, completionTokens, totalTokens }`.\n    // Map it to this repo's `usage_update` StreamEvent (the SAME shape\n    // claude-code emits over ACP) so mastracode sessions — both the print\n    // arm and the in-process arm, which share this mapper — carry token\n    // telemetry in the transcript. mastracode reports these cumulatively\n    // (its own headless `runMC` result-usage is last-write-wins over these\n    // events), and last-write-wins on the descriptor matches that. It\n    // carries no context-window size/used or per-turn cost here, so those\n    // stay 0 / absent (projectEvent guards on >0, never clobbering a real\n    // size).\n    case \"usage_update\": {\n      const usage = evt.usage as Record<string, unknown> | undefined\n      const promptTokens =\n        typeof usage?.promptTokens === \"number\" ? usage.promptTokens : undefined\n      const completionTokens =\n        typeof usage?.completionTokens === \"number\"\n          ? usage.completionTokens\n          : undefined\n      if (promptTokens === undefined && completionTokens === undefined)\n        return null\n      return {\n        kind: \"usage_update\",\n        sessionId,\n        size: 0,\n        used: 0,\n        ...(promptTokens !== undefined ? { tokensIn: promptTokens } : {}),\n        ...(completionTokens !== undefined\n          ? { tokensOut: completionTokens }\n          : {}),\n      }\n    }\n\n    // ── Shell output (tool-like) ────────────────────────────────\n    case \"shell_output\":\n      return typeof evt.output === \"string\"\n        ? {\n            kind: \"tool-result\",\n            sessionId,\n            toolCallId: \"\",\n            result: evt.output,\n            isError: false,\n          }\n        : null\n\n    // ── Skipped events ─────────────────────────────────────────\n    case \"agent_start\":\n    case \"subagent_start\":\n    case \"subagent_end\":\n    case \"tool_approval_required\":\n    case \"tool_suspended\":\n      return null\n\n    default:\n      return null\n  }\n}\n\n// ── Decoupling queue ────────────────────────────────────────────────\n\n/**\n * High-water mark (in buffered events) at which {@link EventQueue} logs a\n * single warning. This does NOT cap the buffer or drop events: the whole\n * point of this queue is to keep draining `child.stdout` so the subprocess\n * never hits `ENOBUFS`, and dropping mapped events would corrupt the\n * transcript / ring buffer this feeds. The mark exists purely to make a\n * genuinely stuck downstream consumer (one that has stopped pulling for an\n * extended period, letting the buffer grow toward a memory problem)\n * observable to operators instead of failing silently.\n *\n * Sized well above the worst incident seen in the wild (a mastracode run\n * emitting ~1200 lines / ~900 tool results): a transient burst is absorbed\n * without noise, while a persistently slow client trips the warning.\n */\nconst QUEUE_HIGH_WATER_MARK = 10_000\n\n/**\n * A bounded-signal async FIFO that decouples a fast push-side producer\n * (readline draining a subprocess pipe) from a slow pull-side consumer\n * (the daemon's event projector → transcript + ring buffer + SSE stream).\n *\n * `push()` never blocks and never rejects — the producer keeps draining\n * the OS pipe so the child never backpressures into `ENOBUFS`. The\n * consumer drives it as an async iterable; each `next()` resolves as soon\n * as an event is available (or immediately if one is already buffered),\n * and completes once {@link end} is called and the buffer is exhausted.\n *\n * Backpressure is applied to the CONSUMER, not the producer: the iterator\n * only advances when the caller pulls. If the caller stops pulling for a\n * long time the buffer grows; crossing {@link QUEUE_HIGH_WATER_MARK} emits\n * one warning so the condition is never silent (see the constant's doc for\n * why we favour bounded-visibility growth over dropping events).\n */\nclass EventQueue implements AsyncIterable<StreamEvent> {\n  private readonly buffer: StreamEvent[] = []\n  private resolveNext: (() => void) | null = null\n  private ended = false\n  private highWaterWarned = false\n\n  push(evt: StreamEvent): void {\n    this.buffer.push(evt)\n    if (\n      this.buffer.length > QUEUE_HIGH_WATER_MARK &&\n      !this.highWaterWarned\n    ) {\n      this.highWaterWarned = true\n      console.warn(\n        `print-arm: event backlog exceeded ${QUEUE_HIGH_WATER_MARK} ` +\n          `buffered events — downstream consumer is not keeping up. The ` +\n          `child's stdout is still being drained (no ENOBUFS), but memory ` +\n          `will grow until the consumer catches up.`,\n      )\n    }\n    // Wake a consumer parked in next().\n    const resolve = this.resolveNext\n    this.resolveNext = null\n    resolve?.()\n  }\n\n  /** Signal that no further events will be pushed. */\n  end(): void {\n    this.ended = true\n    const resolve = this.resolveNext\n    this.resolveNext = null\n    resolve?.()\n  }\n\n  async *[Symbol.asyncIterator](): AsyncIterator<StreamEvent> {\n    for (;;) {\n      const evt = this.buffer.shift()\n      if (evt !== undefined) {\n        yield evt\n        continue\n      }\n      if (this.ended) return\n      // Nothing buffered and not ended — park until push()/end() wakes us.\n      await new Promise<void>(resolve => {\n        this.resolveNext = resolve\n      })\n    }\n  }\n}\n\n// ── Process helpers ─────────────────────────────────────────────────\n\n/**\n * Normalize Mastra Code `agent_end.finishReason` to StreamEvent turn-end reason.\n * Mastra uses: \"complete\", \"aborted\", \"error\", \"suspended\"\n * StreamEvent expects: \"completed\", \"cancelled\", \"error\", \"max_turns\"\n */\nfunction mapMastraFinishReason(\n  raw: string,\n): \"completed\" | \"cancelled\" | \"max_turns\" | \"error\" {\n  switch (raw) {\n    case \"complete\":\n      return \"completed\"\n    case \"aborted\":\n    case \"suspended\":\n      return \"cancelled\"\n    case \"error\":\n      return \"error\"\n    default:\n      return \"completed\"\n  }\n}\n\nfunction waitForExit(\n  child: ReturnType<typeof spawn>,\n): Promise<number | null> {\n  return new Promise(resolve => {\n    child.once(\"exit\", code => resolve(code))\n    child.once(\"error\", () => resolve(null))\n  })\n}\n","/**\n * AIP-45 protocol arm: `protocol: \"proprietary\"`.\n *\n * Loads an NPM adapter package (named in the manifest's `adapter`\n * field) implementing `AgentCliClient`. The package translates the\n * vendor's REPL/proprietary stream into the canonical StreamEvent\n * taxonomy.\n *\n * Unlike the `acp` / `print` arms (built into this package, driving a\n * spawned subprocess), a proprietary arm may not involve a subprocess\n * at all — e.g. an in-process SDK integration. `createAgentCliRuntime`\n * skips the subprocess spawn entirely for `protocol: \"proprietary\"`\n * (see `define-agent-cli.ts`); this loader has no opinion on whether\n * the loaded package owns a child process, a socket, or nothing.\n *\n * ## Adapter package contract\n *\n * The named package's default export path (its `main`/`exports[\".\"]`)\n * must export a factory:\n *\n *   export function createAgentCliClient(\n *     definition: AgentCliHandle,\n *   ): AgentCliClient | Promise<AgentCliClient>\n *\n * A default export function is accepted as a fallback for adapters\n * that only have one thing to export. The factory receives the full\n * manifest handle so adapter-specific config (models, capabilities,\n * metadata) is available without a second lookup — mirrors the ACP\n * arm receiving `clientInfo` derived from the manifest.\n */\n\nimport type { AgentCliClient, AgentCliHandle } from \"../types.js\"\n\nexport interface ProprietaryProtocolOptions {\n  /** NPM package name to load — from manifest.adapter. */\n  adapter: string\n  /** Full manifest handle, forwarded verbatim to the loaded factory. */\n  definition: AgentCliHandle\n}\n\ntype AgentCliClientFactory = (\n  definition: AgentCliHandle,\n) => AgentCliClient | Promise<AgentCliClient>\n\nexport async function createProprietaryProtocolArm(\n  options: ProprietaryProtocolOptions,\n): Promise<AgentCliClient> {\n  let mod: Record<string, unknown>\n  try {\n    mod = (await import(options.adapter)) as Record<string, unknown>\n  } catch (err) {\n    const cause = err instanceof Error ? err.message : String(err)\n    throw new Error(\n      `createProprietaryProtocolArm: could not load adapter package '${options.adapter}'. ` +\n        `Install it with: npm i ${options.adapter}\\n  cause: ${cause}`,\n    )\n  }\n\n  const candidate =\n    \"createAgentCliClient\" in mod ? mod.createAgentCliClient : mod.default\n  if (typeof candidate !== \"function\") {\n    throw new Error(\n      `createProprietaryProtocolArm: adapter package '${options.adapter}' does not export a ` +\n        `'createAgentCliClient' factory function (or a default export function). A ` +\n        `protocol=\"proprietary\" adapter must export ` +\n        `createAgentCliClient(definition: AgentCliHandle): AgentCliClient | Promise<AgentCliClient>.`,\n    )\n  }\n\n  return await (candidate as AgentCliClientFactory)(options.definition)\n}\n","/**\n * Spawn-argument composer.\n *\n * Pure function: given an `AgentCliHandle` and a per-call\n * `RuntimeConfig`, produces the final `binArgs + env` to pass to the\n * runtime's `start()`. Validates the config against the manifest's\n * declared `modes` / `options` / `continuation.supported`; unknown ids\n * throw `RuntimeConfigError` (the host should NOT spawn — the user\n * configured something the manifest doesn't accept).\n *\n * Composition order (matches AIP-45 spec):\n *   1. Every declared `bin_args_prepend` (mode's, then each present\n *      option's in declaration order) — argv that must precede a\n *      subcommand baked into `bin_args` (e.g. hermes'\n *      `--ignore-user-config` ahead of `acp`).\n *   2. Manifest's default `bin_args` (from `handle.bin_args`).\n *   3. Every declared `bin_args_append` / `bin_args_append_when_true`\n *      / `bin_args_template` (mode's, then each present option's in\n *      declaration order).\n * Final argv is `[...prepend, ...bin_args, ...append]`.\n *\n * Mode is applied before options because modes are coarse profile\n * switches (claude-code's `--permission-mode`) — options refine them.\n * Within options, declaration order is honoured so adapter authors\n * can express \"this flag must come after that one\" without the host\n * needing to know the rule.\n */\n\nimport type {\n  AgentCliHandle,\n  AgentCliOption,\n  RuntimeConfig,\n} from \"../types.js\"\n\n/**\n * Thrown when `RuntimeConfig` references manifest entries that don't\n * exist or violates a declared constraint (type / enum / bounds). The\n * `code` field lets callers map to friendly UI messages without\n * inspecting the message string.\n */\nexport class RuntimeConfigError extends Error {\n  readonly code:\n    | \"unknown_mode\"\n    | \"unknown_option\"\n    | \"option_type_mismatch\"\n    | \"option_enum_violation\"\n    | \"option_bounds_violation\"\n    | \"unsupported_continuation\"\n    | \"model_denied\"\n    | \"missing_auth_credential\"\n  readonly path: string\n  constructor(\n    code: RuntimeConfigError[\"code\"],\n    path: string,\n    message: string\n  ) {\n    super(`[${code} at ${path}] ${message}`)\n    this.code = code\n    this.path = path\n    this.name = \"RuntimeConfigError\"\n  }\n}\n\n/**\n * Resolved spawn args + env. The runtime's `start()` impl merges\n * `env` into the host process env / sandbox env before exec.\n */\nexport interface ComposedSpawn {\n  binArgs: string[]\n  env: Record<string, string>\n  /**\n   * Env keys the active mode AND active options declared for deletion\n   * (AgentCliMode.env_unset / AgentCliOption.env_unset). Surfaced\n   * pure-side so the runtime's `start()` — which owns the process.env\n   * merge — can apply the deletions at the one point where the ambient\n   * env is actually present (compose starts from `{}` and can't delete\n   * what isn't there yet). Empty when nothing declares any.\n   */\n  envUnset: string[]\n}\n\n/**\n * Compose the final spawn args from a manifest + per-call config.\n * Pure — no I/O, no sandbox access, no global state. Safe to call\n * repeatedly with the same input.\n *\n * `config` may be undefined or an empty object — both fall back to\n * the manifest's defaults verbatim (manifest `bin_args`, no mode\n * patch, no option patches). Continuation is not applied here — the\n * `ContinuationStrategy` registry handles that — but we DO validate\n * `config.continuation` against `manifest.continuation.supported` so\n * a misconfigured operator fails fast at compose time, not at the\n * point the strategy tries to acquire a session.\n */\nexport function composeSpawn(\n  handle: AgentCliHandle,\n  config?: RuntimeConfig\n): ComposedSpawn {\n  if (!config)\n    return {\n      binArgs: [...(handle.bin_args ?? [])],\n      env: { ...(handle.env ?? {}) },\n      envUnset: [],\n    }\n\n  const prepend: string[] = []\n  const append: string[] = []\n  // Always-on manifest env goes in first so a selected mode/option can\n  // still override any key it also declares (mode/option intent wins).\n  const env: Record<string, string> = { ...(handle.env ?? {}) }\n  const envUnset: string[] = []\n\n  // ── Mode patch ──────────────────────────────────────────────────\n  if (config.mode !== undefined) {\n    const mode = (handle.modes ?? []).find(m => m.id === config.mode)\n    if (!mode) {\n      const known = (handle.modes ?? []).map(m => m.id).join(\", \") || \"(none)\"\n      throw new RuntimeConfigError(\n        \"unknown_mode\",\n        \"config.mode\",\n        `Mode '${config.mode}' is not declared by manifest '${handle.id}'. Known modes: ${known}`\n      )\n    }\n    // \"config\" modes have no argv/env surface — the CLI doesn't accept a\n    // flag for this mode at all (e.g. opencode's plan/build). The mode id\n    // is instead forwarded to the ACP arm's connect({mode}) by\n    // define-agent-cli.ts and applied via session/set_config_option. Skip\n    // bin_args_prepend/bin_args_append/env here even if an author declared\n    // them alongside apply:\"config\" — config wins, argv is never composed,\n    // so a typo'd flag can't crash the spawn the way this whole bug did.\n    if ((mode.apply ?? \"bin_args\") === \"bin_args\") {\n      if (mode.bin_args_prepend) prepend.push(...mode.bin_args_prepend)\n      if (mode.bin_args_append) append.push(...mode.bin_args_append)\n      if (mode.env) Object.assign(env, mode.env)\n      if (mode.env_unset) envUnset.push(...mode.env_unset)\n    }\n  }\n\n  // ── Option patches (declaration order) ──────────────────────────\n  if (config.options && Object.keys(config.options).length > 0) {\n    const declared = handle.options ?? []\n    const declaredById = new Map(declared.map(o => [o.id, o]))\n    // Reject unknown ids first so the operator sees ALL the typos\n    // (not just the one we hit first when iterating declared).\n    for (const id of Object.keys(config.options)) {\n      if (!declaredById.has(id)) {\n        const known = declared.map(o => o.id).join(\", \") || \"(none)\"\n        throw new RuntimeConfigError(\n          \"unknown_option\",\n          `config.options.${id}`,\n          `Option '${id}' is not declared by manifest '${handle.id}'. Known options: ${known}`\n        )\n      }\n    }\n    // Then apply patches in declaration order so adapter-author intent\n    // wins over operator-config key order.\n    for (const option of declared) {\n      if (!(option.id in config.options)) continue\n      const value = config.options[option.id] as boolean | number | string\n      validateOptionValue(option, value)\n      const patch = renderOptionPatch(option, value)\n      prepend.push(...patch.prepend)\n      append.push(...patch.append)\n      Object.assign(env, patch.env)\n      if (patch.envUnset.length) envUnset.push(...patch.envUnset)\n    }\n  }\n\n  // ── Model deny-list enforcement ─────────────────────────────────\n  // The `model` option is deliberately free-form (any provider id), so\n  // `models.allowed` is only a curated menu — it can't *prevent* a caller\n  // from passing an off-menu id. `models.deny` is the hard guardrail: a\n  // requested model matching any deny pattern is refused here, before we\n  // spawn anything, so a budget adapter can't be steered onto a provider it\n  // must never use (e.g. Anthropic models are reserved for claude-code).\n  const requestedModel = config.options?.model\n  if (typeof requestedModel === \"string\" && handle.models?.deny?.length) {\n    const denyHit = handle.models.deny.find(pattern =>\n      matchesModelPattern(pattern, requestedModel)\n    )\n    if (denyHit) {\n      throw new RuntimeConfigError(\n        \"model_denied\",\n        \"config.options.model\",\n        `Model '${requestedModel}' is denied by manifest '${handle.id}' (matches deny pattern '${denyHit}'). This adapter deliberately does not route to that provider — use a permitted model or a different adapter.`\n      )\n    }\n  }\n\n  // ── Continuation validation (no patch — strategy registry owns) ─\n  if (config.continuation !== undefined && handle.continuation) {\n    if (!handle.continuation.supported.includes(config.continuation)) {\n      throw new RuntimeConfigError(\n        \"unsupported_continuation\",\n        \"config.continuation\",\n        `Continuation strategy '${config.continuation}' is not in manifest '${handle.id}'.continuation.supported (${handle.continuation.supported.join(\", \")}).`\n      )\n    }\n  }\n\n  return {\n    binArgs: [...prepend, ...(handle.bin_args ?? []), ...append],\n    env,\n    envUnset,\n  }\n}\n\n/**\n * Resolve the continuation strategy id to use for this call. Operator\n * config wins; manifest default is the fallback; \"none\" if neither\n * declares anything (preserves pre-AIP-45-extension behaviour).\n */\nexport function resolveContinuationStrategy(\n  handle: AgentCliHandle,\n  config?: RuntimeConfig\n): import(\"../types.js\").ContinuationStrategyId {\n  if (config?.continuation) return config.continuation\n  return handle.continuation?.default ?? \"none\"\n}\n\n/**\n * Case-insensitive match of a model id against a deny/allow pattern.\n * Supports a single trailing `*` wildcard (prefix match); otherwise exact.\n */\nfunction matchesModelPattern(pattern: string, modelId: string): boolean {\n  const p = pattern.toLowerCase()\n  const m = modelId.toLowerCase()\n  return p.endsWith(\"*\") ? m.startsWith(p.slice(0, -1)) : m === p\n}\n\nfunction validateOptionValue(\n  option: AgentCliOption,\n  value: boolean | number | string\n): void {\n  const path = `config.options.${option.id}`\n  switch (option.type) {\n    case \"boolean\":\n      if (typeof value !== \"boolean\") {\n        throw new RuntimeConfigError(\n          \"option_type_mismatch\",\n          path,\n          `Expected boolean, got ${typeof value} (${JSON.stringify(value)}).`\n        )\n      }\n      return\n    case \"integer\":\n      if (typeof value !== \"number\" || !Number.isInteger(value)) {\n        throw new RuntimeConfigError(\n          \"option_type_mismatch\",\n          path,\n          `Expected integer, got ${typeof value === \"number\" ? \"non-integer number\" : typeof value} (${JSON.stringify(value)}).`\n        )\n      }\n      if (option.min !== undefined && value < option.min) {\n        throw new RuntimeConfigError(\n          \"option_bounds_violation\",\n          path,\n          `Value ${value} is below the declared minimum ${option.min}.`\n        )\n      }\n      if (option.max !== undefined && value > option.max) {\n        throw new RuntimeConfigError(\n          \"option_bounds_violation\",\n          path,\n          `Value ${value} is above the declared maximum ${option.max}.`\n        )\n      }\n      return\n    case \"string\":\n      if (typeof value !== \"string\") {\n        throw new RuntimeConfigError(\n          \"option_type_mismatch\",\n          path,\n          `Expected string, got ${typeof value} (${JSON.stringify(value)}).`\n        )\n      }\n      return\n    case \"enum\":\n      if (typeof value !== \"string\") {\n        throw new RuntimeConfigError(\n          \"option_type_mismatch\",\n          path,\n          `Expected string (enum value), got ${typeof value} (${JSON.stringify(value)}).`\n        )\n      }\n      if (!(option.enum ?? []).includes(value)) {\n        throw new RuntimeConfigError(\n          \"option_enum_violation\",\n          path,\n          `Value '${value}' is not in the declared enum (${(option.enum ?? []).join(\", \")}).`\n        )\n      }\n      return\n  }\n}\n\nfunction renderOptionPatch(\n  option: AgentCliOption,\n  value: boolean | number | string\n): { prepend: string[]; append: string[]; env: Record<string, string>; envUnset: string[] } {\n  const stringValue = String(value)\n\n  // boolean type: only emit the bare flag when value === true and the\n  // option declared `bin_args_append_when_true`. Honor `env` too —\n  // adapter authors might want to surface the bool via env. Booleans\n  // have no prepend counterpart — `bin_args_append_when_true` is for\n  // bare flags, which never need to precede a baked-in subcommand.\n  if (option.type === \"boolean\") {\n    if (value !== true) return { prepend: [], append: [], env: {}, envUnset: [] }\n    return {\n      prepend: [],\n      append: option.bin_args_append_when_true\n        ? [...option.bin_args_append_when_true]\n        : [],\n      env: option.env ? interpolateEnv(option.env, stringValue) : {},\n      envUnset: option.env_unset ? [...option.env_unset] : [],\n    }\n  }\n\n  // value-bearing types — apply `bin_args_prepend` / `bin_args_template`\n  // (with `{value}` interpolation) and merge `env`. `env_unset` applies\n  // whenever the option is active with a non-default value (the same\n  // condition under which `env` merges) — so a `base_url` option, e.g.,\n  // scrubs the ambient ANTHROPIC_API_KEY the moment it's set.\n  return {\n    prepend: option.bin_args_prepend\n      ? option.bin_args_prepend.map(token =>\n          token.replace(/\\{value\\}/g, stringValue)\n        )\n      : [],\n    append: option.bin_args_template\n      ? option.bin_args_template.map(token =>\n          token.replace(/\\{value\\}/g, stringValue)\n        )\n      : [],\n    env: option.env ? interpolateEnv(option.env, stringValue) : {},\n    envUnset: option.env_unset ? [...option.env_unset] : [],\n  }\n}\n\nfunction interpolateEnv(\n  env: Record<string, string>,\n  value: string\n): Record<string, string> {\n  const out: Record<string, string> = {}\n  for (const [k, v] of Object.entries(env)) {\n    out[k] = v.replace(/\\{value\\}/g, value)\n  }\n  return out\n}\n","import { spawn, type ChildProcess } from \"node:child_process\"\nimport { randomUUID } from \"node:crypto\"\nimport { mkdtempSync, writeFileSync } from \"node:fs\"\nimport { tmpdir } from \"node:os\"\nimport { join } from \"node:path\"\nimport { createDoctype } from \"@agentproto/define-doctype\"\nimport { agentCliFrontmatterSchema } from \"./schema.js\"\nimport { createAcpProtocolArm } from \"./protocol/acp-client.js\"\nimport { createPrintSession } from \"./protocol/print-arm.js\"\nimport { createProprietaryProtocolArm } from \"./protocol/proprietary.js\"\nimport { composeSpawn, RuntimeConfigError } from \"./manifest/compose.js\"\nimport type {\n  AgentCliClient,\n  AgentCliDefinition,\n  AgentCliHandle,\n  AgentCliRuntime,\n  AgentCliRuntimeSession,\n  AgentCliStartOptions,\n  StreamEvent,\n} from \"./types.js\"\n\nexport const defineAgentCli = createDoctype<AgentCliDefinition, AgentCliHandle>(\n  {\n    aip: 45,\n    name: \"agent-cli\",\n    readIdentity: (def) => def.id,\n    validate(def: AgentCliDefinition) {\n      const result = agentCliFrontmatterSchema.safeParse(def)\n      if (!result.success) {\n        throw new Error(\n          `defineAgentCli (AIP-45): ${result.error.issues\n            .map((i) => `${i.path.join(\".\")}: ${i.message}`)\n            .join(\"; \")}`,\n        )\n      }\n\n      const data = result.data\n\n      if (data.protocol === \"acp\" && !data.acp) {\n        throw new Error(\n          \"defineAgentCli (AIP-45): `acp` ref is required when protocol=acp\",\n        )\n      }\n      if (data.protocol === \"mcp\" && !data.mcp) {\n        throw new Error(\n          \"defineAgentCli (AIP-45): `mcp` block is required when protocol=mcp\",\n        )\n      }\n      if (data.protocol === \"proprietary\" && !data.adapter) {\n        throw new Error(\n          \"defineAgentCli (AIP-45): `adapter` package is required when protocol=proprietary\",\n        )\n      }\n\n      if (\n        data.session?.mode === \"resumable\" &&\n        data.capabilities?.resumable !== true\n      ) {\n        throw new Error(\n          \"defineAgentCli (AIP-45): session.mode=resumable requires capabilities.resumable: true\",\n        )\n      }\n    },\n    build(def: AgentCliDefinition) {\n      return { ...def } as AgentCliHandle\n    },\n  },\n)\n\nexport function createAgentCliRuntime(\n  definition: AgentCliHandle,\n): AgentCliRuntime {\n  return {\n    definition,\n    async start(opts?: AgentCliStartOptions): Promise<AgentCliRuntimeSession> {\n      const cwd = opts?.cwd ?? process.cwd()\n      // Compose final argv + env from the manifest + per-call config.\n      // Mode patches and option patches land BEFORE the host-provided\n      // env so an operator-set option can be observed by the CLI even\n      // when the manifest also touches the same env key (operator\n      // intent wins). Validation runs here too — a misconfigured\n      // operator throws RuntimeConfigError before we exec anything.\n      const composed = composeSpawn(definition, opts?.config)\n      const env: Record<string, string> = {\n        ...filterStringEnv(process.env),\n        ...composed.env,\n      }\n      // Mode-declared env scrub (AgentCliMode.env_unset): delete AFTER the\n      // ambient + mode/option env are merged but BEFORE the host-provided\n      // opts.env. A gateway mode (e.g. claude-code's `moonshot`) declares\n      // keys that must never reach a non-native Anthropic-compatible endpoint\n      // — scrubbing here is the only point where the real key is actually\n      // present (compose starts from `{}` and can't delete what isn't there).\n      // opts.env is applied after so an operator who explicitly forwards a\n      // scrubbed key takes responsibility for it (operator intent wins).\n      for (const k of composed.envUnset) delete env[k]\n\n      // Deterministic billing-auth (AgentCliStartOptions.auth). MECHANICAL:\n      // the runtime resolver already decided the provider, mode, env var to\n      // SET, and vars to SCRUB — this driver imports no catalog/registry and\n      // makes no policy choice, it just applies the resolved spec. EXPLICIT\n      // credential selection, not scrub-by-absence: the credential is SET from\n      // the resolver's named ref, never inferred from what's ambient.\n      //\n      // ENGAGE when the adapter enforces `always` (claude-code — every spawn,\n      // preserving #312 fail-fast) OR the operator explicitly configured auth\n      // (`explicit`). An unconfigured `when-configured` adapter (codex/hermes/\n      // claude-sdk with no auth) does NOT engage → runs ambient, unchanged.\n      const authSpec = opts?.auth\n      // A gateway mode (moonshot/openrouter) or an explicit `auth_token`\n      // option already injected ANTHROPIC_AUTH_TOKEN into composed.env for\n      // Bearer auth against a non-Anthropic endpoint. Billing-auth\n      // engagement must not run in that case: an `always`-enforcing adapter\n      // (claude-code) would otherwise SET CLAUDE_CODE_OAUTH_TOKEN for\n      // subscription mode alongside it — two credentials the claude binary\n      // can't reconcile with a gateway ANTHROPIC_BASE_URL, and the resolved\n      // spec's own conflictEnv scrub can't remove ANTHROPIC_AUTH_TOKEN\n      // either (composed.env's own keys are protected from the blanket\n      // scrub below, by design). The gateway's Bearer token wins outright —\n      // skip engagement rather than let two auth mechanisms collide.\n      const hasGatewayAuthToken = \"ANTHROPIC_AUTH_TOKEN\" in composed.env\n      const engageAuth =\n        !!authSpec &&\n        !hasGatewayAuthToken &&\n        (authSpec.enforce === \"always\" || authSpec.explicit === true)\n      if (authSpec && engageAuth) {\n        // Scrub the conflicting credential(s)/toggles BEFORE setting this\n        // mode's own credential. A key this spawn's own mode/option patch\n        // explicitly SET (e.g. a gateway preset's ANTHROPIC_BASE_URL) wins\n        // over the blanket scrub — composed.env is the record of keys this\n        // spawn's own config explicitly assigned.\n        for (const key of authSpec.unsetEnv) {\n          if (!(key in composed.env)) delete env[key]\n        }\n        // Fail-fast: the credential is resolved by the HOST from a named\n        // config/store ref, never read ambiently — if it didn't resolve,\n        // refuse the spawn rather than silently falling back to another or an\n        // ambient credential. Checked against the RESOLVED credential, not the\n        // merged env, so an unrelated `opts.env` key can't paper over a\n        // genuinely missing one.\n        if (!authSpec.credential) {\n          throw new RuntimeConfigError(\n            \"missing_auth_credential\",\n            \"opts.auth.credential\",\n            `agent-cli '${definition.id}': auth mode \"${authSpec.mode}\" requires ` +\n              `an explicit credential (resolved from a named config/store ref), ` +\n              `but none was provided.` +\n              (authSpec.mode === \"subscription\"\n                ? ` Mint one via \\`claude setup-token\\` (bills the Max/Pro ` +\n                  `subscription, not API credits) and configure it — never ` +\n                  `inherited from the shell.`\n                : ` Configure an API key (\\`agentproto auth provider set …\\` or ` +\n                  `per-spawn) — never inherited from the shell.`),\n          )\n        }\n        env[authSpec.setEnv] = authSpec.credential\n      }\n\n      Object.assign(env, opts?.env ?? {})\n\n      // claude-code's ACP wrapper never reads `--permission-mode` from argv\n      // (the `bin_args_append` above is a no-op against it) — it resolves\n      // `permissions.defaultMode` exclusively via `CLAUDE_CONFIG_DIR`/\n      // `<cwd>/.claude/settings(.local).json`, merged through the SDK's\n      // `resolveSettings`. Point a per-session `CLAUDE_CONFIG_DIR` at a\n      // throwaway temp dir carrying just that one field, so a non-default\n      // requested mode (e.g. \"plan\") actually takes effect without ever\n      // touching the target repo's own `.claude` directory. A repo that\n      // commits its own escalated `permissions.defaultMode` can still\n      // defeat this (see resolveClaudeCodePermissionMode's doc) — that's a\n      // documented limitation, not a bug in this override.\n      const permissionMode = resolveClaudeCodePermissionMode(\n        definition,\n        opts?.config?.mode,\n      )\n      if (permissionMode) {\n        const configDir = mkdtempSync(\n          join(tmpdir(), \"agentproto-claude-config-\"),\n        )\n        writeFileSync(\n          join(configDir, \"settings.json\"),\n          JSON.stringify({ permissions: { defaultMode: permissionMode } }),\n        )\n        env.CLAUDE_CONFIG_DIR = configDir\n      }\n\n      // The print arm spawns a fresh subprocess per turn — no\n      // long-lived child, no AgentCliClient connect/events cycle.\n      // Short-circuit here so buildProtocolArm is never called for it.\n      if (definition.protocol === \"print\") {\n        return createPrintSession({\n          bin: definition.bin,\n          baseArgs: composed.binArgs,\n          cwd,\n          env,\n          ...(opts?.resumeSessionId\n            ? { resumeSessionId: opts.resumeSessionId }\n            : {}),\n          ...(opts?.mcpServers ? { mcpServers: opts.mcpServers } : {}),\n          printConfig: definition.print,\n        })\n      }\n\n      // `proprietary` arms are not guaranteed to own a subprocess at all\n      // (e.g. an in-process SDK integration) — `buildProtocolArm` decides\n      // per-protocol whether `child` is required. Skip the spawn entirely\n      // for `proprietary` so an in-process arm pays no subprocess cost.\n      let child: ChildProcess | undefined\n      const stderrBuf: string[] = []\n      if (definition.protocol !== \"proprietary\") {\n        child = spawn(definition.bin, composed.binArgs, {\n          cwd,\n          env,\n          stdio: [\"pipe\", \"pipe\", \"pipe\"],\n          signal: opts?.signal,\n        })\n\n        // Drain child.stderr — without this the kernel pipe buffer\n        // (~64 KB on macOS / Linux) eventually fills up and blocks the\n        // child mid-write, hanging the entire ACP exchange. Buffer the\n        // last few KB so a downstream error event can attach the tail\n        // for debugging — adapters like claude-agent-acp print useful\n        // context here (\"not authenticated\", \"model gated\") that the\n        // JSON-RPC reply would otherwise reduce to \"Invalid params\".\n        const STDERR_KEEP_LINES = 80\n        child.stderr?.setEncoding(\"utf8\")\n        child.stderr?.on(\"data\", (chunk: string) => {\n          for (const line of chunk.split(/\\r?\\n/)) {\n            if (!line) continue\n            stderrBuf.push(line)\n            if (stderrBuf.length > STDERR_KEEP_LINES) stderrBuf.shift()\n          }\n        })\n      }\n\n      const arm = await buildProtocolArm(\n        definition,\n        child,\n        cwd,\n        opts?.config?.mode,\n        opts?.permissionHold ?? false,\n      )\n      arm._stderrTail = () => stderrBuf.join(\"\\n\")\n\n      const abortController = new AbortController()\n      if (opts?.signal) {\n        opts.signal.addEventListener(\"abort\", () => abortController.abort(), {\n          once: true,\n        })\n      }\n      // Extract model + effort from the config options so the protocol\n      // arm can apply them via ACP session/set_config_option — the ACP\n      // wrapper (claude-agent-acp) does not read its own CLI args and\n      // forward them to claude, so bin_args_template alone is not\n      // sufficient. The compose step still adds them to binArgs as a\n      // best-effort fallback for non-ACP arms.\n      const optModel = opts?.config?.options?.model\n      const optEffort = opts?.config?.options?.effort\n      // Model-selection strategy (AgentCliModels.apply, default \"config\"):\n      //   \"config\"  → apply via ACP session config (set_config_option) at\n      //               connect — works for claude-code.\n      //   \"command\" → the ACP session config is a no-op on this agent\n      //               (e.g. hermes silently keeps its own default), so we\n      //               DON'T pass model to connect; instead we send a\n      //               `/model <id>` control turn after newSession (below).\n      const modelApply = definition.models?.apply ?? \"config\"\n      const configModel =\n        optModel && modelApply === \"config\" ? String(optModel) : undefined\n      // Mode-selection strategy (AgentCliMode.apply, default \"bin_args\"):\n      //   \"bin_args\" → the mode's argv/env patch (already composed above)\n      //               is how the CLI picks the mode — no ACP config to send.\n      //   \"config\"   → the CLI has no argv/env surface for this mode (e.g.\n      //               opencode's plan/build); compose.ts already skipped its\n      //               bin_args/env, so forward the mode id to the ACP arm's\n      //               connect({mode}) instead, applied via\n      //               session/set_config_option(configId:\"mode\").\n      const requestedModeId = opts?.config?.mode\n      const requestedModeDecl = requestedModeId\n        ? (definition.modes ?? []).find(m => m.id === requestedModeId)\n        : undefined\n      const configMode =\n        requestedModeDecl?.apply === \"config\" ? requestedModeId : undefined\n      // Caller-supplied override wins; otherwise fall back to the\n      // manifest's declared default (if any) so an adapter known to drop\n      // responses (e.g. hermes) gets watchdog protection without every\n      // host having to opt in per spawn.\n      const turnIdleTimeoutMs =\n        opts?.turnIdleTimeoutMs ?? definition.session?.turn_idle_timeout_ms\n      await arm.connect({\n        cwd,\n        env,\n        abortSignal: abortController.signal,\n        ...(opts?.resumeSessionId\n          ? { resumeSessionId: opts.resumeSessionId }\n          : {}),\n        ...(opts?.mcpServers ? { mcpServers: opts.mcpServers } : {}),\n        ...(configModel ? { model: configModel } : {}),\n        ...(optEffort ? { effort: String(optEffort) } : {}),\n        ...(configMode ? { mode: configMode } : {}),\n        ...(opts?.onActivity ? { onActivity: opts.onActivity } : {}),\n        ...(turnIdleTimeoutMs !== undefined ? { turnIdleTimeoutMs } : {}),\n        ...(opts?.permissionHold ? { permissionHold: true } : {}),\n      })\n\n      // \"command\" model strategy: switch the model via a drained `/model\n      // <id>` control turn. Best-effort — a failure is warned, never fatal,\n      // so the session still starts (on the agent's default model).\n      if (optModel && modelApply === \"command\") {\n        await applyModelCommand(arm, String(optModel))\n      }\n\n      // Prefer the protocol-layer session id (ACP, etc.) so the host\n      // can persist it for a future native-resume. Fall back to a\n      // random UUID for protocols that don't model sessions — keeps\n      // the field always-populated for downstream loggers.\n      const sessionId = arm.sessionId ?? randomUUID()\n\n      return {\n        sessionId,\n        pid: child?.pid,\n        send(message): AsyncIterable<StreamEvent> {\n          const turnId = randomUUID()\n          return promptTurn(arm, turnId, message)\n        },\n        async cancel() {\n          abortController.abort()\n        },\n        ...(arm.respondPermission\n          ? {\n              respondPermission(requestId, resolution) {\n                return arm.respondPermission!(requestId, resolution)\n              },\n            }\n          : {}),\n        async close() {\n          await arm.close()\n          if (child && !child.killed) child.kill(\"SIGTERM\")\n        },\n      }\n    },\n  }\n}\n\n/**\n * Switch the active model via a `/model <id>` control turn, for adapters\n * whose ACP session config doesn't select the model (`models.apply:\n * \"command\"`, e.g. hermes). The turn is fully drained so the switch\n * completes before the caller's first real turn. Best-effort: a transport\n * failure or a missing acknowledgement is warned, never thrown — the\n * session simply continues on the agent's default model.\n */\nasync function applyModelCommand(\n  arm: AgentCliClient,\n  modelId: string,\n): Promise<void> {\n  const turnId = randomUUID()\n  let acked = false\n  try {\n    for await (const evt of promptTurn(arm, turnId, {\n      type: \"text\",\n      text: `/model ${modelId}`,\n    })) {\n      // Loose check across the serialised event — hermes replies\n      // \"Model switched to: <id> · Provider: …\". We don't couple to a\n      // specific StreamEvent shape; any \"switch\" mention = acknowledged.\n      if (/switch|model\\s+set|now using/i.test(JSON.stringify(evt))) acked = true\n    }\n  } catch (err) {\n    console.warn(\n      `[agent-cli] /model ${modelId} control turn failed (continuing on default):`,\n      err instanceof Error ? err.message : err,\n    )\n    return\n  }\n  if (!acked) {\n    console.warn(\n      `[agent-cli] /model ${modelId}: no switch acknowledgement — agent may be on its default model`,\n    )\n  }\n}\n\nasync function* promptTurn(\n  arm: AgentCliClient,\n  turnId: string,\n  message: unknown,\n): AsyncIterable<StreamEvent> {\n  await arm.send(turnId, message)\n  // Re-attach the recent stderr tail to error events. The ACP layer\n  // surfaces a terse `{message: \"Invalid params\"}`; the child's\n  // stderr almost always has a more useful line (\"npx claude-agent-acp:\n  // not authenticated, run `claude login`\"). Hosts read `error.data`\n  // when present, falling back to `message` for older payloads.\n  const stderrTail = arm._stderrTail\n  for await (const evt of arm.events()) {\n    if (evt.kind === \"error\" && typeof stderrTail === \"function\") {\n      const tail = stderrTail()\n      if (tail) {\n        const existing = (evt.error.data ?? {}) as Record<string, unknown>\n        evt.error.data = { ...existing, stderr: tail }\n      }\n    }\n    yield evt\n  }\n}\n\nasync function buildProtocolArm(\n  def: AgentCliHandle,\n  child: ChildProcess | undefined,\n  cwd: string,\n  requestedMode?: string,\n  permissionHold?: boolean,\n): Promise<AgentCliClient> {\n  switch (def.protocol) {\n    case \"acp\":\n      if (!child) {\n        throw new Error(\"createAgentCliRuntime: acp protocol requires a spawned subprocess\")\n      }\n      return createAcpProtocolArm({\n        child,\n        cwd,\n        clientInfo: { name: def.id, version: def.version },\n        requestedMode,\n        ...(permissionHold ? { permissionHold: true } : {}),\n      })\n    case \"mcp\":\n      throw new Error(\"createAgentCliRuntime: mcp protocol arm not yet implemented\")\n    case \"proprietary\":\n      if (!def.adapter) {\n        // defineAgentCli's validate() already enforces this for manifests\n        // built through it — this guards a hand-built AgentCliHandle that\n        // bypassed that check.\n        throw new Error(\n          \"createAgentCliRuntime: proprietary protocol requires manifest.adapter\",\n        )\n      }\n      return createProprietaryProtocolArm({ adapter: def.adapter, definition: def })\n    case \"print\":\n      // Unreachable: print is handled by the early-return in start() above.\n      throw new Error(\"createAgentCliRuntime: print arm bypasses buildProtocolArm\")\n  }\n}\n\n/**\n * Derives the `permissions.defaultMode` value claude-code's settings.json\n * expects for a requested AIP-45 mode, by reading the same\n * `[\"--permission-mode\", \"<value>\"]` pair already declared in the\n * adapter's `modes[].bin_args_append` (one vocabulary, one source of\n * truth — see `adapters/claude-code/src/index.ts`). Scoped to\n * `definition.id === \"claude-code\"` since this settings-file mechanism\n * is specific to that adapter's ACP wrapper; every other adapter's\n * `bin_args_append` is applied to argv as normal and this returns\n * `undefined` for them. Also `undefined` for an unrequested mode, or a\n * mode (like \"default\") that has no `--permission-mode` patch —\n * callers use that to skip the `CLAUDE_CONFIG_DIR` override entirely.\n */\nfunction resolveClaudeCodePermissionMode(\n  definition: AgentCliHandle,\n  configMode: string | undefined,\n): string | undefined {\n  if (definition.id !== \"claude-code\" || !configMode) return undefined\n  const mode = (definition.modes ?? []).find((m) => m.id === configMode)\n  const args = mode?.bin_args_append ?? []\n  const flagIndex = args.indexOf(\"--permission-mode\")\n  if (flagIndex === -1 || flagIndex + 1 >= args.length) return undefined\n  return args[flagIndex + 1]\n}\n\nfunction filterStringEnv(env: NodeJS.ProcessEnv): Record<string, string> {\n  const out: Record<string, string> = {}\n  for (const [k, v] of Object.entries(env)) {\n    if (typeof v === \"string\") out[k] = v\n  }\n  return out\n}\n"]}