@warble/codex-local 0.4.0

package/dist/cli.js

@@ -0,0 +1,4113 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { readFileSync, writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve3 } from "path";
+import { parseArgs } from "util";
+
+// src/ask_prepare.ts
+import { isAbsolute } from "path";
+
+// src/error.ts
+var CodexDispatchError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CodexDispatchError";
+  }
+};
+
+// src/dispatch_registry.ts
+function assertDispatchableComponentIdentity(node) {
+  if (node.realization_kind !== "skill") {
+    throw new CodexDispatchError(
+      `component '${node.id}' is host-executed and cannot be dispatched by codex:local: realization_kind '${node.realization_kind}' is not 'skill'`
+    );
+  }
+}
+
+// src/ir.ts
+var TARGET = "codex:local";
+var SUPPORTED_IR_VERSION = "0.6";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringArray(value, field) {
+  if (!Array.isArray(value) || !value.every((entry) => typeof entry === "string")) {
+    throw new CodexDispatchError(`${field} must be an array of strings`);
+  }
+  return value;
+}
+function parseCall(value, componentId) {
+  if (!isRecord(value)) {
+    throw new CodexDispatchError(`component '${componentId}' has a malformed llm_call`);
+  }
+  const { name, tier, prompt } = value;
+  if (typeof name !== "string" || typeof tier !== "string" || typeof prompt !== "string" || typeof value["conditional"] !== "boolean" || value["produces"] !== null && typeof value["produces"] !== "string") {
+    throw new CodexDispatchError(
+      `component '${componentId}' llm_call has malformed name/tier/prompt/conditional/produces`
+    );
+  }
+  return {
+    name,
+    tier,
+    prompt,
+    consumes: stringArray(value["consumes"] ?? [], `${componentId}.${name}.consumes`),
+    produces: value["produces"],
+    conditional: value["conditional"],
+    when: value["when"] ?? null
+  };
+}
+function parseGuardrail(value, componentId) {
+  if (!isRecord(value) || typeof value["name"] !== "string" || typeof value["locked"] !== "boolean") {
+    throw new CodexDispatchError(`component '${componentId}' has a malformed guardrail`);
+  }
+  return {
+    name: value["name"],
+    locked: value["locked"],
+    ...typeof value["scope"] === "string" ? { scope: value["scope"] } : {},
+    ...typeof value["threshold"] === "number" ? { threshold: value["threshold"] } : {}
+  };
+}
+function parseComponent(value) {
+  if (!isRecord(value) || typeof value["id"] !== "string") {
+    throw new CodexDispatchError("IR component must be an object with a string id");
+  }
+  const id = value["id"];
+  const trigger = value["trigger"];
+  const effect = value["effect"];
+  const outcome = isRecord(effect) ? effect["outcome"] : null;
+  const context = value["context_binding"];
+  if (typeof value["verb"] !== "string" || typeof value["type"] !== "string" || typeof value["realization_kind"] !== "string" || !Array.isArray(value["llm_calls"]) || !Array.isArray(value["guardrails"]) || !isRecord(trigger) || typeof trigger["kind"] !== "string" || !isRecord(effect) || !isRecord(outcome) || typeof outcome["kind"] !== "string" || !Array.isArray(effect["render_blocks"]) || !isRecord(context) || typeof context["binding_mode"] !== "string" || typeof context["project"] !== "string") {
+    throw new CodexDispatchError(`component '${id}' is missing required IR fields`);
+  }
+  return {
+    id,
+    verb: value["verb"],
+    type: value["type"],
+    realization_kind: value["realization_kind"],
+    llm_calls: value["llm_calls"].map((call) => parseCall(call, id)),
+    required_capabilities: stringArray(
+      value["required_capabilities"] ?? [],
+      `${id}.required_capabilities`
+    ),
+    guardrails: value["guardrails"].map((guard) => parseGuardrail(guard, id)),
+    trigger: { kind: trigger["kind"] },
+    effect: {
+      outcome: { kind: outcome["kind"] },
+      render_blocks: effect["render_blocks"]
+    },
+    context_binding: {
+      binding_mode: context["binding_mode"],
+      project: context["project"]
+    }
+  };
+}
+function parseIr(raw) {
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch (error) {
+    throw new CodexDispatchError(`invalid IR JSON: ${String(error)}`);
+  }
+  if (!isRecord(value) || typeof value["warble_ir_version"] !== "string" || typeof value["profile"] !== "string" || !Array.isArray(value["components"])) {
+    throw new CodexDispatchError("IR requires warble_ir_version, profile, and components");
+  }
+  if (value["warble_ir_version"] !== SUPPORTED_IR_VERSION) {
+    throw new CodexDispatchError(
+      `unsupported warble_ir_version '${value["warble_ir_version"]}' (supported: ${SUPPORTED_IR_VERSION})`
+    );
+  }
+  return {
+    warble_ir_version: value["warble_ir_version"],
+    profile: value["profile"],
+    components: value["components"].map(parseComponent)
+  };
+}
+
+// src/render_contract.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseDashboardRenderBlockContracts(renderBlocks) {
+  const contracts = /* @__PURE__ */ new Map();
+  for (const entry of renderBlocks) {
+    if (!isRecord2(entry) || typeof entry["type"] !== "string" || !isRecord2(entry["fields"])) {
+      throw new CodexDispatchError("dashboard IR contains a malformed render block contract");
+    }
+    const fields = entry["fields"];
+    if (!Object.values(fields).every((field) => typeof field === "string")) {
+      throw new CodexDispatchError("dashboard IR contains a malformed render field contract");
+    }
+    contracts.set(entry["type"], fields);
+  }
+  return contracts;
+}
+function validatePrimitive(value, type, context) {
+  if (type.endsWith("?")) {
+    if (value === void 0 || value === null) return;
+    validatePrimitive(value, type.slice(0, -1), context);
+    return;
+  }
+  if (type.endsWith("[]")) {
+    if (!Array.isArray(value)) throw new CodexDispatchError(`${context} must be an array`);
+    const itemType2 = type.slice(0, -2);
+    for (const [index, item] of value.entries()) {
+      validatePrimitive(item, itemType2, `${context}[${index}]`);
+    }
+    return;
+  }
+  if (type.includes("|")) {
+    const alternatives = type.split("|");
+    if (alternatives.includes("string") && typeof value === "string") return;
+    if (alternatives.includes("number") && typeof value === "number" && Number.isFinite(value)) return;
+    if (typeof value === "string" && alternatives.includes(value)) return;
+    throw new CodexDispatchError(`${context} does not match '${type}'`);
+  }
+  if (type === "string" && typeof value === "string") return;
+  if (type === "number" && typeof value === "number" && Number.isFinite(value)) return;
+  if (type === "boolean" && typeof value === "boolean") return;
+  if (type === "row" && isRecord2(value)) return;
+  throw new CodexDispatchError(`${context} does not match '${type}'`);
+}
+function validateDashboardRenderEnvelope(value, node) {
+  if (!isRecord2(value)) throw new CodexDispatchError("dashboard output must be a JSON object");
+  const keys = Object.keys(value);
+  if (keys.some((key) => !(/* @__PURE__ */ new Set(["blocks", "summary", "verified"])).has(key)) || !Array.isArray(value["blocks"]) || value["blocks"].length === 0 || typeof value["verified"] !== "boolean" || value["summary"] !== void 0 && typeof value["summary"] !== "string") {
+    throw new CodexDispatchError(
+      "dashboard output requires only non-empty blocks, optional summary, and boolean verified"
+    );
+  }
+  const contracts = parseDashboardRenderBlockContracts(node.effect.render_blocks);
+  const blocks = value["blocks"].map((entry, index) => {
+    if (!isRecord2(entry) || typeof entry["type"] !== "string") {
+      throw new CodexDispatchError(`dashboard block[${index}] requires a string type`);
+    }
+    const fields = contracts.get(entry["type"]);
+    if (!fields) {
+      throw new CodexDispatchError(`dashboard block[${index}] uses undeclared type '${entry["type"]}'`);
+    }
+    const allowed = /* @__PURE__ */ new Set(["type", ...Object.keys(fields)]);
+    if (Object.keys(entry).some((key) => !allowed.has(key))) {
+      throw new CodexDispatchError(`dashboard block[${index}] contains undeclared fields`);
+    }
+    const normalized = { ...entry };
+    for (const [field, type] of Object.entries(fields)) {
+      validatePrimitive(normalized[field], type, `dashboard block[${index}].${field}`);
+      if (type.endsWith("?") && normalized[field] === null) delete normalized[field];
+    }
+    return normalized;
+  });
+  return {
+    blocks,
+    ...typeof value["summary"] === "string" ? { summary: value["summary"] } : {},
+    verified: value["verified"]
+  };
+}
+
+// src/request_transport.ts
+var REQUEST_TRANSPORT_SERVER = "warble_request_transport";
+var REQUEST_TRANSPORT_TOOL = "get_original_request";
+var STEP_TRANSPORT_TOOL = "get_step_request";
+
+// src/target_profile.ts
+var mcpVia = (mcpName) => `mcp:${mcpName}`;
+var CAPABILITY_REALIZATION = {
+  "llm:strong": { outcome: "native", via: null },
+  "llm:cheap": { outcome: "native", via: null },
+  "llm:per_step_tier": { outcome: "native", via: null },
+  source_connect: { outcome: "realize-via", via: mcpVia },
+  context_build: { outcome: "realize-via", via: mcpVia },
+  semantic_introspection: { outcome: "realize-via", via: mcpVia },
+  raw_material_read: { outcome: "realize-via", via: mcpVia },
+  "sql_execution:read_only": { outcome: "realize-via", via: mcpVia },
+  genbi_build: { outcome: "native", via: "validated-render-envelope" },
+  render_contract: { outcome: "native", via: "validated-render-envelope" },
+  artifact_write: { outcome: "realize-via", via: "consumer-persisted-render-envelope" }
+};
+function resolveCapabilities(requiredCapabilities, mcpName) {
+  return requiredCapabilities.map((capability) => {
+    const entry = CAPABILITY_REALIZATION[capability];
+    if (!entry) {
+      throw new CodexDispatchError(`capability '${capability}' has no realization on codex:local`);
+    }
+    return {
+      capability,
+      outcome: entry.outcome,
+      via: typeof entry.via === "function" ? entry.via(mcpName) : entry.via
+    };
+  });
+}
+function hasExactCapabilities(requiredCapabilities, expected) {
+  return requiredCapabilities.length === expected.size && requiredCapabilities.every((capability) => expected.has(capability));
+}
+var SETUP_DOMAIN_CAPABILITIES = ["source_connect", "context_build"];
+var SETUP_DOMAIN_CAPABILITY_SET = new Set(SETUP_DOMAIN_CAPABILITIES);
+function isSetupDomainCapability(value) {
+  return SETUP_DOMAIN_CAPABILITY_SET.has(value);
+}
+var ASK_ANSWER_CAPABILITIES = /* @__PURE__ */ new Set([
+  "sql_execution:read_only",
+  "llm:per_step_tier",
+  "llm:strong",
+  "llm:cheap"
+]);
+var ASK_DASHBOARD_CAPABILITIES = /* @__PURE__ */ new Set([
+  "sql_execution:read_only",
+  "genbi_build",
+  "render_contract",
+  "artifact_write",
+  "llm:per_step_tier",
+  "llm:strong",
+  "llm:cheap"
+]);
+var ENRICH_DOMAIN_CAPABILITIES = ["semantic_introspection", "raw_material_read"];
+var ENRICH_DOMAIN_CAPABILITY_SET = new Set(ENRICH_DOMAIN_CAPABILITIES);
+function isEnrichDomainCapability(value) {
+  return ENRICH_DOMAIN_CAPABILITY_SET.has(value);
+}
+var ENRICH_ALLOWED_CAPABILITIES = /* @__PURE__ */ new Set([
+  ...ENRICH_DOMAIN_CAPABILITIES,
+  "llm:cheap",
+  "llm:strong"
+]);
+var GUARDRAIL_ENFORCEMENT = {
+  setup_execution: { locked: true, scope: "." },
+  read_only_execution: { locked: true },
+  deterministic_gate: { locked: true },
+  row_limit: { locked: false, threshold: 1e3 },
+  statement_timeout: { locked: false, threshold: 30 },
+  artifact_write: { locked: true, scope: "." }
+};
+function guardrailMatches(guard, name, options) {
+  const requirement = GUARDRAIL_ENFORCEMENT[name];
+  if (!requirement || !guard || guard.name !== name || guard.locked !== requirement.locked) {
+    return false;
+  }
+  if (requirement.scope !== void 0 && guard.scope !== requirement.scope) {
+    return false;
+  }
+  if (requirement.threshold !== void 0 && guard.threshold !== requirement.threshold) {
+    return false;
+  }
+  if (options?.requireScopeAbsent && guard.scope !== void 0) {
+    return false;
+  }
+  return true;
+}
+
+// src/ask_prepare.ts
+function unique(values) {
+  return [...new Set(values)];
+}
+var TOOLS_BY_EXECUTION_KIND = {
+  answer_query: [["get_context"], ["run_sql"], ["run_sql"]],
+  generate_dashboard: [["get_context"], ["run_sql"]]
+};
+function requireNonEmpty(value, field) {
+  if (value.trim().length === 0) throw new CodexDispatchError(`${field} must not be empty`);
+}
+function parseWhen(step) {
+  if (!step.conditional) {
+    if (step.when !== null) {
+      throw new CodexDispatchError(`step '${step.name}' is unconditional but has a when guard`);
+    }
+    return null;
+  }
+  if (typeof step.when !== "object" || step.when === null || Array.isArray(step.when) || step.when["guard"] !== "on_failure" || typeof step.when["target"] !== "string") {
+    throw new CodexDispatchError(
+      `step '${step.name}' wall-hit: Ask repair requires on_failure(target)`
+    );
+  }
+  return {
+    guard: "on_failure",
+    target: step.when["target"]
+  };
+}
+function validateCommonAnalyticalShape(node) {
+  if (node.type !== "analytical" || node.realization_kind !== "skill" || node.trigger.kind !== "one_shot" || node.effect.outcome.kind !== "none") {
+    throw new CodexDispatchError(
+      `component '${node.id}' wall-hit: Codex analytical execution requires analytical/skill/one_shot/none`
+    );
+  }
+  if (node.context_binding.binding_mode !== "runtime_selected") {
+    throw new CodexDispatchError(
+      `component '${node.id}' wall-hit: Codex analytical execution requires runtime_selected context binding`
+    );
+  }
+}
+function validateStepChain(node) {
+  const calls = node.llm_calls;
+  if (calls.length === 0) {
+    throw new CodexDispatchError(`component '${node.id}' wall-hit: Ask requires at least one llm_call`);
+  }
+  let sawConditional = false;
+  calls.forEach((call, index) => {
+    if (call.tier !== "cheap" && call.tier !== "strong") {
+      throw new CodexDispatchError(
+        `component '${node.id}' wall-hit: step '${call.name}' has unsupported tier '${call.tier}'`
+      );
+    }
+    if (call.produces === null) {
+      throw new CodexDispatchError(
+        `component '${node.id}' wall-hit: step '${call.name}' must produce a named output`
+      );
+    }
+    const when = parseWhen(call);
+    if (index === 0) {
+      if (call.conditional || call.consumes.length !== 0) {
+        throw new CodexDispatchError(
+          `component '${node.id}' wall-hit: first Ask step must be unconditional with no consumes and one output`
+        );
+      }
+      return;
+    }
+    const previous = calls[index - 1];
+    if (call.conditional) {
+      if (when?.target !== previous.name || call.consumes.length !== 1 || call.consumes[0] !== previous.produces) {
+        throw new CodexDispatchError(
+          `component '${node.id}' wall-hit: step '${call.name}' must be an on_failure repair of the immediately preceding step '${previous.name}'`
+        );
+      }
+      sawConditional = true;
+      return;
+    }
+    if (sawConditional) {
+      throw new CodexDispatchError(
+        `component '${node.id}' wall-hit: an unconditional step cannot follow a repair step`
+      );
+    }
+    if (call.consumes.length !== 1 || call.consumes[0] !== previous.produces) {
+      throw new CodexDispatchError(
+        `component '${node.id}' wall-hit: step '${call.name}' must consume exactly the preceding step's output`
+      );
+    }
+  });
+}
+function validateAnswerShape(node) {
+  validateCommonAnalyticalShape(node);
+  validateStepChain(node);
+  if (!hasExactCapabilities(node.required_capabilities, ASK_ANSWER_CAPABILITIES)) {
+    throw new CodexDispatchError(
+      `component '${node.id}' wall-hit: Ask capability set must be read-only SQL plus cheap/strong per-step tiering`
+    );
+  }
+  const guards = new Map(node.guardrails.map((guard) => [guard.name, guard]));
+  if (guards.size !== 4 || !guardrailMatches(guards.get("read_only_execution"), "read_only_execution") || !guardrailMatches(guards.get("deterministic_gate"), "deterministic_gate") || !guardrailMatches(guards.get("row_limit"), "row_limit") || !guardrailMatches(guards.get("statement_timeout"), "statement_timeout")) {
+    throw new CodexDispatchError(
+      `component '${node.id}' wall-hit: Ask guardrails must match the locked read-only/deterministic and bounded row/timeout contract`
+    );
+  }
+}
+function validateDashboardShape(node) {
+  validateCommonAnalyticalShape(node);
+  validateStepChain(node);
+  if (!hasExactCapabilities(node.required_capabilities, ASK_DASHBOARD_CAPABILITIES)) {
+    throw new CodexDispatchError(
+      `component '${node.id}' wall-hit: dashboard capability set must match read-only SQL, build, render, artifact, and cheap/strong per-step tiering`
+    );
+  }
+  const guards = new Map(node.guardrails.map((guard) => [guard.name, guard]));
+  if (guards.size !== 2 || !guardrailMatches(guards.get("read_only_execution"), "read_only_execution") || !guardrailMatches(guards.get("artifact_write"), "artifact_write")) {
+    throw new CodexDispatchError(
+      `component '${node.id}' wall-hit: dashboard guardrails must be locked read-only execution plus scoped artifact_write`
+    );
+  }
+  if (node.effect.render_blocks.length === 0) {
+    throw new CodexDispatchError(
+      `component '${node.id}' wall-hit: dashboard render contract must declare at least one render block type`
+    );
+  }
+  parseDashboardRenderBlockContracts(node.effect.render_blocks);
+}
+function executionKind(node) {
+  const capabilities = new Set(node.required_capabilities);
+  if (capabilities.has("render_contract") || capabilities.has("artifact_write")) {
+    validateDashboardShape(node);
+    return "generate_dashboard";
+  }
+  validateAnswerShape(node);
+  return "answer_query";
+}
+function matchesAskContractShape(node) {
+  try {
+    executionKind(node);
+    return true;
+  } catch (error) {
+    if (error instanceof CodexDispatchError) return false;
+    throw error;
+  }
+}
+function askContractMismatchReason(node) {
+  try {
+    executionKind(node);
+    return null;
+  } catch (error) {
+    if (error instanceof CodexDispatchError) return error.message;
+    throw error;
+  }
+}
+function roleName(stepName) {
+  const value = `warble_${stepName}`.replace(/[^A-Za-z0-9_-]/g, "_");
+  if (!/^[A-Za-z][A-Za-z0-9_-]*$/.test(value)) {
+    throw new CodexDispatchError(`step '${stepName}' cannot be mapped to a Codex agent role`);
+  }
+  return value;
+}
+function prepareAsk(input) {
+  const ir = typeof input.ir === "string" ? parseIr(input.ir) : input.ir;
+  if (ir.warble_ir_version !== SUPPORTED_IR_VERSION) {
+    throw new CodexDispatchError(
+      `unsupported warble_ir_version '${ir.warble_ir_version}' (supported: ${SUPPORTED_IR_VERSION})`
+    );
+  }
+  const node = ir.components.find((candidate) => candidate.id === input.component);
+  if (!node) {
+    throw new CodexDispatchError(
+      `component '${input.component}' was not found in profile '${ir.profile}'`
+    );
+  }
+  assertDispatchableComponentIdentity(node);
+  const kind = executionKind(node);
+  if (!/^[A-Za-z0-9_-]+$/.test(input.mcp.name)) {
+    throw new CodexDispatchError(
+      `MCP server name '${input.mcp.name}' must contain only letters, digits, '_' or '-'`
+    );
+  }
+  if (input.mcp.name === REQUEST_TRANSPORT_SERVER) {
+    throw new CodexDispatchError(`MCP server name '${input.mcp.name}' is reserved by the Ask request transport`);
+  }
+  if (!isAbsolute(input.mcp.command)) {
+    throw new CodexDispatchError("Ask MCP server command must be absolute");
+  }
+  requireNonEmpty(input.models.orchestrator, "orchestrator model binding");
+  requireNonEmpty(input.models.cheap, "cheap-tier model binding");
+  requireNonEmpty(input.models.strong, "strong-tier model binding");
+  const steps = node.llm_calls.map((step, index) => {
+    const tier = step.tier;
+    if (tier !== "cheap" && tier !== "strong") {
+      throw new CodexDispatchError(`step '${step.name}' has unsupported tier '${tier}'`);
+    }
+    const enabledTools = unique(input.mcp.toolsByStep[step.name] ?? []);
+    const expectedTools = TOOLS_BY_EXECUTION_KIND[kind][index];
+    if (expectedTools === void 0) {
+      throw new CodexDispatchError(
+        `step '${step.name}' has no declared MCP tool allowlist for target index ${index}`
+      );
+    }
+    if (enabledTools.length !== expectedTools.length || enabledTools.some((tool, toolIndex) => tool !== expectedTools[toolIndex])) {
+      throw new CodexDispatchError(
+        `step '${step.name}' requires exact MCP tools: ${expectedTools.join(", ")}`
+      );
+    }
+    if (step.produces === null) {
+      throw new CodexDispatchError(`step '${step.name}' must produce a named slot`);
+    }
+    return {
+      name: step.name,
+      role: roleName(step.name),
+      tier,
+      model: input.models[tier],
+      prompt: step.prompt,
+      consumes: [...step.consumes],
+      produces: step.produces,
+      conditional: step.conditional,
+      when: parseWhen(step),
+      enabledTools,
+      requireSuccessfulTool: kind === "generate_dashboard" || index > 0
+    };
+  });
+  return {
+    target: TARGET,
+    profile: ir.profile,
+    node,
+    componentId: node.id,
+    steps,
+    capabilities: resolveCapabilities(node.required_capabilities, input.mcp.name),
+    mcp: input.mcp,
+    models: input.models,
+    executionKind: kind,
+    maxRepairAttempts: steps.filter((step) => step.conditional).length
+  };
+}
+
+// src/app_server_transport.ts
+import { spawn } from "child_process";
+import { existsSync, realpathSync } from "fs";
+import { homedir } from "os";
+import { isAbsolute as isAbsolute2, join, relative, resolve } from "path";
+import { createInterface } from "readline";
+
+// src/config.ts
+var API_BILLING_ENV_KEYS = /* @__PURE__ */ new Set([
+  "OPENAI_API_KEY",
+  "CODEX_API_KEY",
+  "AZURE_OPENAI_API_KEY",
+  "OPENAI_ORGANIZATION",
+  "OPENAI_ORG_ID",
+  "OPENAI_PROJECT",
+  "OPENAI_PROJECT_ID"
+]);
+var DISABLED_FEATURES = [
+  "shell_tool",
+  "unified_exec",
+  "shell_zsh_fork",
+  "unified_exec_zsh_fork",
+  "standalone_web_search",
+  "apps",
+  "plugins",
+  "in_app_browser",
+  "browser_use",
+  "computer_use",
+  "image_generation",
+  "skill_search",
+  "multi_agent"
+];
+function tomlString(value) {
+  return JSON.stringify(value);
+}
+function tomlStringArray(values) {
+  return `[${values.map(tomlString).join(",")}]`;
+}
+function sanitizeCodexToolName(value) {
+  return value.replace(/[^A-Za-z0-9_]/g, "_");
+}
+function codexMcpCallableNamespace(server) {
+  return `mcp__${sanitizeCodexToolName(server)}`;
+}
+function codexMcpCallableName(server, tool) {
+  return `${codexMcpCallableNamespace(server)}__${sanitizeCodexToolName(tool)}`;
+}
+function sanitizeCodexEnvironment(source = process.env) {
+  const clean = {};
+  for (const [key, value] of Object.entries(source)) {
+    if (!API_BILLING_ENV_KEYS.has(key.toUpperCase()) && value !== void 0) clean[key] = value;
+  }
+  return clean;
+}
+function buildIsolationArgs(prepared) {
+  const serverKey = `mcp_servers.${prepared.mcp.name}`;
+  const args = [
+    "-c",
+    "shell_environment_policy.inherit=none",
+    "-c",
+    "project_doc_max_bytes=0",
+    "-c",
+    "project_root_markers=[]",
+    "-c",
+    `web_search=${tomlString("disabled")}`,
+    "-c",
+    "features.code_mode.enabled=false",
+    "-c",
+    `features.code_mode.direct_only_tool_namespaces=${tomlStringArray([codexMcpCallableNamespace(prepared.mcp.name)])}`,
+    "-c",
+    `${serverKey}.command=${tomlString(prepared.mcp.command)}`,
+    "-c",
+    `${serverKey}.args=${tomlStringArray(prepared.mcp.args ?? [])}`,
+    "-c",
+    `${serverKey}.enabled_tools=${tomlStringArray(prepared.enabledTools)}`,
+    "-c",
+    `${serverKey}.default_tools_approval_mode=${tomlString("approve")}`,
+    "-c",
+    `${serverKey}.required=true`
+  ];
+  for (const feature of DISABLED_FEATURES) args.push("--disable", feature);
+  return args;
+}
+function buildIsolationConfig(prepared) {
+  const serverKey = `mcp_servers.${prepared.mcp.name}`;
+  return {
+    "shell_environment_policy.inherit": "none",
+    project_doc_max_bytes: 0,
+    project_root_markers: [],
+    web_search: "disabled",
+    "features.code_mode.enabled": false,
+    "features.code_mode.direct_only_tool_namespaces": [
+      codexMcpCallableNamespace(prepared.mcp.name)
+    ],
+    [`${serverKey}.command`]: prepared.mcp.command,
+    [`${serverKey}.args`]: prepared.mcp.args ?? [],
+    [`${serverKey}.enabled_tools`]: prepared.enabledTools,
+    [`${serverKey}.default_tools_approval_mode`]: "approve",
+    [`${serverKey}.required`]: true,
+    ...Object.fromEntries(DISABLED_FEATURES.map((feature) => [`features.${feature}`, false]))
+  };
+}
+function buildCodexArgs(prepared, step, options) {
+  const args = [
+    ...options.codexArgsPrefix ?? [],
+    "--ask-for-approval",
+    "never",
+    "exec",
+    "--json",
+    "--ephemeral",
+    "--ignore-user-config",
+    "--ignore-rules",
+    "--strict-config",
+    "--skip-git-repo-check",
+    "--sandbox",
+    "read-only",
+    "--cd",
+    options.cwd,
+    "--model",
+    step.model,
+    ...buildIsolationArgs(prepared)
+  ];
+  args.push("-");
+  return args;
+}
+function buildPrompt(prepared, step, request, inputs = {}, options = {}) {
+  const tools = prepared.enabledTools.map(
+    (tool) => `${prepared.mcp.name}.${tool} -> ${codexMcpCallableName(prepared.mcp.name, tool)}`
+  ).join(", ");
+  const terminalContract = [
+    `The final answer must be one JSON object with exactly the produced field '${step.produces}'.`,
+    ...options.producedValue === "string" ? [`The value of '${step.produces}' must be a JSON string, not an object, array, number, boolean, or null.`] : [],
+    "Do not wrap the JSON in Markdown or include prose."
+  ];
+  const inputSection = step.consumes.length === 0 ? [] : [
+    "",
+    "Inputs from earlier steps (JSON):",
+    JSON.stringify(Object.fromEntries(step.consumes.map((name) => [name, inputs[name]])))
+  ];
+  return [
+    `You are executing Warble target ${prepared.target}.`,
+    `Run exactly one profile step: ${prepared.componentId}.${step.name}.`,
+    `Only use the allowlisted MCP tools (raw identity -> Codex callable name): ${tools}.`,
+    "The raw and qualified names identify the same MCP tool; call the qualified Codex name, not a fallback.",
+    "Do not use shell, file mutation, web, browser, apps, plugins, skills, or delegation.",
+    "If the required MCP tool is unavailable or fails, fail loudly; do not substitute another mechanism.",
+    ...terminalContract,
+    ...inputSection,
+    "",
+    "Step contract:",
+    step.prompt,
+    "",
+    "User request:",
+    request
+  ].join("\n");
+}
+
+// src/app_server_transport.ts
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isWithin(parent, candidate) {
+  const path = relative(parent, candidate);
+  return path === "" || !path.startsWith("..") && !isAbsolute2(path);
+}
+function validateSessionIsolation(options) {
+  if (options.externalAuthentication !== "provisioned") {
+    throw new CodexDispatchError(
+      "persistent session authentication must be provisioned externally"
+    );
+  }
+  if (!isAbsolute2(options.codexHome) || !isAbsolute2(options.cwd)) {
+    throw new CodexDispatchError("session codexHome and cwd must be absolute");
+  }
+  if (!existsSync(options.codexHome)) {
+    throw new CodexDispatchError("dedicated session codexHome must be provisioned before start");
+  }
+  if (existsSync(join(options.codexHome, "config.toml"))) {
+    throw new CodexDispatchError("dedicated session codexHome must not contain config.toml");
+  }
+  const codexHome = realpathSync(options.codexHome);
+  const cwd = realpathSync(options.cwd);
+  const inheritedCodexHome = options.env === void 0 ? process.env["CODEX_HOME"] : options.env["CODEX_HOME"];
+  const defaultHome = resolve(inheritedCodexHome ?? join(homedir(), ".codex"));
+  const comparableDefault = existsSync(defaultHome) ? realpathSync(defaultHome) : defaultHome;
+  if (codexHome === comparableDefault) {
+    throw new CodexDispatchError("persistent sessions require a dedicated non-default codexHome");
+  }
+  if (isWithin(cwd, codexHome) || isWithin(codexHome, cwd)) {
+    throw new CodexDispatchError(
+      "dedicated session codexHome and project cwd must not overlap"
+    );
+  }
+  return { codexHome, cwd };
+}
+function buildAppServerArgs(prepared, options) {
+  return [
+    ...options.codexArgsPrefix ?? [],
+    "app-server",
+    "--stdio",
+    "--strict-config",
+    ...buildIsolationArgs(prepared)
+  ];
+}
+function validateCatalogTransport(options) {
+  if (!isAbsolute2(options.cwd) || !existsSync(options.cwd)) {
+    throw new CodexDispatchError("model catalog cwd must be an existing absolute path");
+  }
+  if (options.codexHome !== void 0 && (!isAbsolute2(options.codexHome) || !existsSync(options.codexHome))) {
+    throw new CodexDispatchError("model catalog codexHome must be an existing absolute path");
+  }
+  return {
+    cwd: realpathSync(options.cwd),
+    codexHome: options.codexHome === void 0 ? void 0 : realpathSync(options.codexHome)
+  };
+}
+var CodexAppServerTransport = class _CodexAppServerTransport {
+  constructor(child, timeoutMs, terminationGraceMs, onNotification, onDisconnect) {
+    this.timeoutMs = timeoutMs;
+    this.terminationGraceMs = terminationGraceMs;
+    this.onNotification = onNotification;
+    this.onDisconnect = onDisconnect;
+    this.child = child;
+    if (child.stdout === null || child.stdin === null || child.stderr === null) {
+      throw new CodexDispatchError("app-server requires piped stdio");
+    }
+    child.stderr.resume();
+    this.lines = createInterface({ input: child.stdout });
+    this.lines.on("line", (line) => this.onLine(line));
+    this.closePromise = new Promise((resolveClose) => {
+      child.once("close", (code, signal) => {
+        this.closed = true;
+        this.lines.close();
+        const detail = signal !== null ? `signal ${signal}` : `exit ${code ?? "unknown"}`;
+        this.rejectPending(`app-server transport disconnected (${detail})`);
+        if (!this.closing) this.onDisconnect();
+        resolveClose();
+      });
+      child.once("error", () => {
+        this.rejectPending("failed to start app-server");
+      });
+    });
+  }
+  timeoutMs;
+  terminationGraceMs;
+  onNotification;
+  onDisconnect;
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  lines;
+  child;
+  closing = false;
+  closed = false;
+  killTimer;
+  closePromise;
+  static async start(prepared, options, onNotification, onDisconnect) {
+    return _CodexAppServerTransport.startWithArgs(
+      buildAppServerArgs(prepared, options),
+      options,
+      onNotification,
+      onDisconnect
+    );
+  }
+  static async startWithArgs(args, options, onNotification, onDisconnect) {
+    const isolated = validateSessionIsolation(options);
+    const child = spawn(options.codexBin ?? "codex", args, {
+      cwd: isolated.cwd,
+      env: {
+        ...sanitizeCodexEnvironment(options.env),
+        CODEX_HOME: isolated.codexHome
+      },
+      stdio: ["pipe", "pipe", "pipe"],
+      detached: process.platform !== "win32"
+    });
+    const transport = new _CodexAppServerTransport(
+      child,
+      options.timeoutMs ?? 1e4,
+      options.terminationGraceMs ?? 1e3,
+      onNotification,
+      onDisconnect
+    );
+    try {
+      const initialized = await transport.request("initialize", {
+        clientInfo: { name: "warble_codex_local", title: "Warble Codex Local", version: "0.1.0" },
+        capabilities: { experimentalApi: true, requestAttestation: false }
+      });
+      if (!isRecord3(initialized) || resolve(String(initialized["codexHome"] ?? "")) !== isolated.codexHome) {
+        throw new CodexDispatchError("app-server initialize returned an unexpected codexHome");
+      }
+      transport.notify("initialized");
+      return transport;
+    } catch (error) {
+      await transport.close();
+      throw error;
+    }
+  }
+  /**
+   * Start a narrowly read-only app-server transport for `model/list`. Unlike persistent sessions,
+   * catalog discovery may use the caller's normal logged-in Codex identity, but it never starts a
+   * thread or applies the session's MCP/tool isolation configuration.
+   */
+  static async startCatalog(options) {
+    const catalog = validateCatalogTransport(options);
+    const child = spawn(options.codexBin ?? "codex", [
+      ...options.codexArgsPrefix ?? [],
+      "app-server",
+      "--stdio"
+    ], {
+      cwd: catalog.cwd,
+      env: {
+        ...sanitizeCodexEnvironment(options.env),
+        ...catalog.codexHome === void 0 ? {} : { CODEX_HOME: catalog.codexHome }
+      },
+      stdio: ["pipe", "pipe", "pipe"],
+      detached: process.platform !== "win32"
+    });
+    const transport = new _CodexAppServerTransport(
+      child,
+      options.timeoutMs ?? 1e4,
+      options.terminationGraceMs ?? 1e3,
+      () => void 0,
+      () => void 0
+    );
+    try {
+      const initialized = await transport.request("initialize", {
+        clientInfo: { name: "warble_codex_local_catalog", title: "Warble Codex Model Catalog", version: "0.1.0" },
+        capabilities: { experimentalApi: true, requestAttestation: false }
+      });
+      const returnedCodexHome = isRecord3(initialized) ? initialized["codexHome"] : void 0;
+      if (typeof returnedCodexHome !== "string" || !isAbsolute2(returnedCodexHome) || catalog.codexHome !== void 0 && resolve(returnedCodexHome) !== catalog.codexHome) {
+        throw new CodexDispatchError("app-server initialize returned an invalid catalog response");
+      }
+      transport.notify("initialized");
+      return transport;
+    } catch (error) {
+      await transport.close();
+      throw error;
+    }
+  }
+  request(method, params = {}) {
+    if (this.closed || this.closing || this.child.stdin === null) {
+      return Promise.reject(new CodexDispatchError("app-server transport is not available"));
+    }
+    const id = this.nextId++;
+    return new Promise((resolveRequest, rejectRequest) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        rejectRequest(new CodexDispatchError(`app-server request '${method}' timed out`));
+        void this.close();
+      }, this.timeoutMs);
+      this.pending.set(id, { method, resolve: resolveRequest, reject: rejectRequest, timer });
+      this.write({ jsonrpc: "2.0", id, method, params });
+    });
+  }
+  notify(method, params) {
+    this.write({ jsonrpc: "2.0", method, ...params === void 0 ? {} : { params } });
+  }
+  async close() {
+    if (this.closing || this.closed) return this.closePromise;
+    this.closing = true;
+    this.signalTree("SIGTERM");
+    this.killTimer = setTimeout(() => {
+      if (!this.closed) this.signalTree("SIGKILL");
+    }, this.terminationGraceMs);
+    await this.closePromise;
+    if (this.killTimer !== void 0) clearTimeout(this.killTimer);
+  }
+  write(message) {
+    if (this.child.stdin === null || this.child.stdin.destroyed) {
+      throw new CodexDispatchError("app-server stdin is closed");
+    }
+    this.child.stdin.write(`${JSON.stringify(message)}
+`);
+  }
+  onLine(line) {
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      this.protocolFailure("app-server emitted non-JSON output");
+      return;
+    }
+    if (!isRecord3(message)) {
+      this.protocolFailure("app-server emitted a non-object message");
+      return;
+    }
+    if (typeof message["id"] === "number" && ("result" in message || "error" in message)) {
+      const pending = this.pending.get(message["id"]);
+      if (!pending) {
+        this.protocolFailure("app-server emitted a response for an unknown request");
+        return;
+      }
+      this.pending.delete(message["id"]);
+      clearTimeout(pending.timer);
+      if (message["error"] !== void 0) {
+        if (pending.method === "model/list" && isRecord3(message["error"]) && typeof message["error"]["message"] === "string" && /not authenticated|unauthenticated|authentication|login required|sign in/i.test(message["error"]["message"])) {
+          pending.reject(new CodexDispatchError("app-server model catalog is not authenticated"));
+        } else {
+          pending.reject(new CodexDispatchError(`app-server request '${pending.method}' failed`));
+        }
+      } else {
+        pending.resolve(message["result"]);
+      }
+      return;
+    }
+    if (typeof message["method"] === "string" && message["id"] === void 0) {
+      try {
+        this.onNotification(message["method"], message["params"]);
+      } catch {
+        this.protocolFailure("app-server notification violated the session contract");
+      }
+      return;
+    }
+    if (typeof message["method"] === "string" && message["id"] !== void 0) {
+      this.write({
+        jsonrpc: "2.0",
+        id: message["id"],
+        error: { code: -32601, message: "client request not supported" }
+      });
+      return;
+    }
+    this.protocolFailure("app-server emitted an invalid JSON-RPC message");
+  }
+  protocolFailure(message) {
+    this.rejectPending(message);
+    this.onDisconnect(new CodexDispatchError(message));
+    void this.close();
+  }
+  rejectPending(message) {
+    for (const pending of this.pending.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(new CodexDispatchError(message));
+    }
+    this.pending.clear();
+  }
+  signalTree(signal) {
+    if (this.closed || this.child.pid === void 0) return;
+    if (process.platform !== "win32") {
+      try {
+        process.kill(-this.child.pid, signal);
+        return;
+      } catch (error) {
+        if (error.code === "ESRCH") return;
+      }
+    }
+    this.child.kill(signal);
+  }
+};
+
+// src/ask_config.ts
+import { existsSync as existsSync2, mkdtempSync, rmSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join as join2 } from "path";
+import { fileURLToPath } from "url";
+var ASK_DISABLED_FEATURES = DISABLED_FEATURES.filter(
+  (feature) => feature !== "multi_agent"
+);
+function renderConfigValue(value) {
+  if (typeof value === "string") return tomlString(value);
+  if (typeof value === "boolean" || typeof value === "number") return String(value);
+  if (Array.isArray(value) && value.every((entry) => typeof entry === "string")) {
+    return tomlStringArray(value);
+  }
+  throw new Error("Ask app-server config contains an unsupported value");
+}
+function buildAskAppServerArgs(bundle) {
+  const args = ["app-server", "--stdio", "--strict-config"];
+  for (const [key, value] of Object.entries(bundle.parentConfig)) {
+    args.push("-c", `${key}=${renderConfigValue(value)}`);
+  }
+  return args;
+}
+function childInstructions(prepared, step) {
+  const toolNames = step.enabledTools.map(
+    (tool) => `${prepared.mcp.name}.${tool} -> ${codexMcpCallableName(prepared.mcp.name, tool)}`
+  ).join(", ");
+  const requestTransportCallable = codexMcpCallableName(
+    REQUEST_TRANSPORT_SERVER,
+    REQUEST_TRANSPORT_TOOL
+  );
+  const stepTransportCallable = codexMcpCallableName(
+    REQUEST_TRANSPORT_SERVER,
+    STEP_TRANSPORT_TOOL
+  );
+  const dashboardContract = prepared.executionKind === "generate_dashboard" ? [
+    `The exact allowed dashboard block contract is ${JSON.stringify(prepared.node.effect.render_blocks)}.`,
+    "Each contract entry's fields object is schema metadata, not an output wrapper: emit each declared field directly beside type at the block top level and never emit a fields key.",
+    "A field whose type ends in ? is optional: omit it when unavailable and never emit null for it.",
+    "Use every required field declared for a chosen block type, use no undeclared fields, and represent each row as a JSON object keyed by its column names."
+  ] : [];
+  const dashboardOutput = prepared.executionKind === "generate_dashboard" && step.name === prepared.steps.at(-1)?.name ? [
+    "The value in the successful step envelope must be the dashboard render artifact: a JSON object with non-empty blocks, optional summary, and boolean verified.",
+    "Blocks may use only the block types and fields declared in the exact allowed dashboard block contract above; include at least one data panel and one definition block.",
+    "Set verified=true only when the required MCP queries completed successfully and the returned values were validated."
+  ] : [];
+  const requiredTool = step.requireSuccessfulTool ? [
+    "This step requires at least one successful call to an enabled MCP tool. The configured tool is available: attempt the call before reporting any tool availability failure."
+  ] : [];
+  const wrenToolArguments = step.enabledTools.includes("get_context") ? [
+    "For wren.get_context, pass exactly one argument named question whose value is the authoritative original request text returned by the request transport call."
+  ] : [];
+  const queryCardinality = step.enabledTools.includes("run_sql") ? [
+    "Before claiming verified=true, check join cardinality and fanout. Never compute independent table counts over a raw CROSS JOIN; use scalar subqueries or independently aggregated CTEs. For joined facts, use declared semantic relationships and distinct entity keys where needed so row multiplication cannot inflate aggregates."
+  ] : [];
+  return [
+    `You are the named Warble step agent '${step.role}'.`,
+    `Execute only IR step '${step.name}' and produce slot '${step.produces}'.`,
+    `Before any reasoning or business MCP call, call ${REQUEST_TRANSPORT_SERVER}.${REQUEST_TRANSPORT_TOOL} through its exact qualified Codex callable ${requestTransportCallable} exactly once. Its returned text is the authoritative original user request for this turn.`,
+    `Then call ${REQUEST_TRANSPORT_SERVER}.${STEP_TRANSPORT_TOOL} through its exact qualified Codex callable ${stepTransportCallable} exactly once. Its returned WARBLE_STEP_REQUEST envelope is the authoritative step and input slots; ignore any task-message copy of those inputs.`,
+    `When MCP tools are exposed through code-mode exec, invoke exactly await tools.${requestTransportCallable}({}); do not guess, shorten, or rename the callable.`,
+    "Never ask the parent to copy, summarize, or reconstruct the original request, and never continue if the request transport call fails.",
+    `Use only these MCP tools when needed (raw identity -> exact qualified Codex callable): ${toolNames}.`,
+    "Under code-mode exec, invoke the qualified callable shown above through tools; do not guess an alias or use exec for any non-MCP operation.",
+    "Do not use shell, file mutation, web, browser, apps, plugins, skills, or child agents.",
+    "Return exactly one JSON object with keys warble_step, produces, ok, value, and error.",
+    `warble_step must equal '${step.name}' and produces must equal '${step.produces}'.`,
+    "On success set ok=true, put the produced slot value in value, and set error=null exactly; never use an empty error string.",
+    "On failure set ok=false, keep the produced slot value with any diagnostics needed by a declared repair step, and use a non-empty stable non-secret error string.",
+    "Do not wrap the JSON in markdown and do not add prose.",
+    ...requiredTool,
+    ...wrenToolArguments,
+    ...queryCardinality,
+    ...dashboardContract,
+    ...dashboardOutput,
+    "",
+    "Step contract:",
+    step.prompt
+  ].join("\n");
+}
+function renderAskAgentToml(prepared, step, requestFile, stepRequestFile) {
+  const serverKey = `mcp_servers.${prepared.mcp.name}`;
+  const requestServerKey = `mcp_servers.${REQUEST_TRANSPORT_SERVER}`;
+  const builtRequestMcp = fileURLToPath(new URL("./request_mcp.js", import.meta.url));
+  const sourceRequestMcp = fileURLToPath(new URL("./request_mcp.ts", import.meta.url));
+  const sourceTsx = fileURLToPath(new URL("../node_modules/.bin/tsx", import.meta.url));
+  const requestMcp = existsSync2(builtRequestMcp) ? builtRequestMcp : sourceRequestMcp;
+  const requestMcpCommand = existsSync2(builtRequestMcp) ? process.execPath : sourceTsx;
+  if (!existsSync2(requestMcp) || !existsSync2(requestMcpCommand)) {
+    throw new Error("Ask request transport executable is unavailable");
+  }
+  const lines = [
+    `name = ${tomlString(step.role)}`,
+    `description = ${tomlString(`Executes Warble IR step ${step.name}`)}`,
+    `developer_instructions = ${tomlString(childInstructions(prepared, step))}`,
+    `model = ${tomlString(step.model)}`,
+    `approval_policy = ${tomlString("never")}`,
+    `sandbox_mode = ${tomlString("read-only")}`,
+    "",
+    "[agents]",
+    "enabled = false",
+    "",
+    `[${serverKey}]`,
+    `command = ${tomlString(prepared.mcp.command)}`,
+    `args = ${tomlStringArray(prepared.mcp.args ?? [])}`,
+    `enabled_tools = ${tomlStringArray(step.enabledTools)}`,
+    `default_tools_approval_mode = ${tomlString("approve")}`,
+    "required = true",
+    "",
+    `[${requestServerKey}]`,
+    `command = ${tomlString(requestMcpCommand)}`,
+    `args = ${tomlStringArray([requestMcp, "--request-file", requestFile, "--step-file", stepRequestFile])}`,
+    `enabled_tools = ${tomlStringArray([REQUEST_TRANSPORT_TOOL, STEP_TRANSPORT_TOOL])}`,
+    `default_tools_approval_mode = ${tomlString("approve")}`,
+    "required = true",
+    ""
+  ];
+  return lines.join("\n");
+}
+function createAskAgentConfigBundle(prepared) {
+  const directory = mkdtempSync(join2(tmpdir(), "warble-codex-agents-"));
+  try {
+    const requestFile = join2(directory, "original-request.txt");
+    const stepRequestFile = join2(directory, "step-request.txt");
+    writeFileSync(requestFile, "", { encoding: "utf8", mode: 384 });
+    writeFileSync(stepRequestFile, "", { encoding: "utf8", mode: 384 });
+    const agents = prepared.steps.map((step) => {
+      const path = join2(directory, `${step.role}.toml`);
+      writeFileSync(path, renderAskAgentToml(prepared, step, requestFile, stepRequestFile), { encoding: "utf8", mode: 384 });
+      return { role: step.role, path, model: step.model, tools: [...step.enabledTools] };
+    });
+    const parentConfig = {
+      "shell_environment_policy.inherit": "none",
+      project_doc_max_bytes: 0,
+      project_root_markers: [],
+      web_search: "disabled",
+      // Current Codex collaboration tools are invoked through code-mode exec.
+      // The parent has no business MCP servers and every non-collaboration
+      // surface remains disabled below, so this only exposes the IR driver.
+      "features.code_mode.enabled": true,
+      "features.multi_agent": true,
+      "agents.enabled": true,
+      // Codex applies this as the total spawned-thread capacity for the session.
+      // Warble enforces sequential spawn -> wait ordering in the event validator.
+      "agents.max_concurrent_threads_per_session": prepared.steps.length,
+      ...Object.fromEntries(
+        ASK_DISABLED_FEATURES.map((feature) => [`features.${feature}`, false])
+      )
+    };
+    for (const agent of agents) {
+      parentConfig[`agents.${agent.role}.description`] = `Execute only the Warble step mapped to ${agent.role}`;
+      parentConfig[`agents.${agent.role}.config_file`] = agent.path;
+    }
+    return {
+      directory,
+      requestFile,
+      stepRequestFile,
+      agents,
+      parentConfig,
+      bindRequest: (request) => writeFileSync(requestFile, request, { encoding: "utf8", mode: 384 }),
+      bindStepRequest: (request) => writeFileSync(stepRequestFile, request, { encoding: "utf8", mode: 384 }),
+      cleanup: () => rmSync(directory, { recursive: true, force: true })
+    };
+  } catch (error) {
+    rmSync(directory, { recursive: true, force: true });
+    throw error;
+  }
+}
+
+// src/session_types.ts
+var SESSION_REFERENCE_VERSION = "0.1";
+
+// src/ask_runtime.ts
+var PASSIVE_PARENT_ITEMS = /* @__PURE__ */ new Set([
+  "userMessage",
+  "agentMessage",
+  "reasoning",
+  "plan",
+  "subAgentActivity",
+  "contextCompaction"
+]);
+var IGNORED_NOTIFICATIONS = /* @__PURE__ */ new Set([
+  "thread/started",
+  "thread/status/changed",
+  "thread/tokenUsage/updated",
+  "turn/plan/updated",
+  "item/agentMessage/delta",
+  "item/plan/delta",
+  "item/reasoning/summaryTextDelta",
+  "item/reasoning/summaryPartAdded",
+  "item/reasoning/textDelta",
+  "skills/changed",
+  "mcpServer/startupStatus/updated",
+  "account/updated",
+  "account/rateLimits/updated",
+  "remoteControl/status/changed",
+  "model/rerouted",
+  "configWarning",
+  "warning"
+]);
+var CHILD_THREAD_NOTIFICATIONS = /* @__PURE__ */ new Set([
+  "turn/started",
+  "item/started",
+  "item/completed",
+  "turn/completed"
+]);
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function record(value, context) {
+  if (!isRecord4(value)) throw new CodexDispatchError(`${context} requires an object`);
+  return value;
+}
+function string(recordValue, key, context) {
+  const value = recordValue[key];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new CodexDispatchError(`${context} requires string ${key}`);
+  }
+  return value;
+}
+function sessionReference(thread) {
+  return {
+    version: SESSION_REFERENCE_VERSION,
+    target: "codex:local",
+    threadId: string(thread, "id", "thread"),
+    forkedFromThreadId: typeof thread["forkedFromId"] === "string" ? thread["forkedFromId"] : null
+  };
+}
+function turnStatus(value) {
+  switch (value) {
+    case "inProgress":
+      return "in_progress";
+    case "completed":
+    case "interrupted":
+    case "failed":
+      return value;
+    default:
+      throw new CodexDispatchError("turn requires a recognized status");
+  }
+}
+function turnReference(threadId, value) {
+  const turn = record(value, "turn");
+  return { threadId, turnId: string(turn, "id", "turn"), status: turnStatus(turn["status"]) };
+}
+function validateReference(reference) {
+  if (reference.version !== SESSION_REFERENCE_VERSION || reference.target !== "codex:local" || reference.threadId.length === 0) {
+    throw new CodexDispatchError("invalid codex session reference");
+  }
+}
+function canonical(value) {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  if (isRecord4(value)) {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function parseEnvelope(text2, step) {
+  let value;
+  try {
+    value = JSON.parse(text2);
+  } catch {
+    throw new CodexDispatchError(`agent '${step.role}' returned a non-JSON step envelope`);
+  }
+  const envelope = record(value, `agent '${step.role}' envelope`);
+  const keys = Object.keys(envelope).sort();
+  const expectedKeys = ["error", "ok", "produces", "value", "warble_step"];
+  if (canonical(keys) !== canonical(expectedKeys)) {
+    throw new CodexDispatchError(`agent '${step.role}' returned an unexpected envelope shape`);
+  }
+  if (envelope["warble_step"] !== step.name || envelope["produces"] !== step.produces || typeof envelope["ok"] !== "boolean" || envelope["error"] !== null && typeof envelope["error"] !== "string") {
+    throw new CodexDispatchError(`agent '${step.role}' returned a mismatched step envelope`);
+  }
+  if (envelope["ok"] === true && envelope["error"] !== null) {
+    throw new CodexDispatchError(`agent '${step.role}' marked success with an error`);
+  }
+  if (envelope["ok"] === false && (typeof envelope["error"] !== "string" || envelope["error"].trim().length === 0)) {
+    throw new CodexDispatchError(`agent '${step.role}' marked failure without an error`);
+  }
+  return envelope;
+}
+function validateAnswerQueryValue(value) {
+  const answer = record(value, "answer_query final value");
+  if (canonical(Object.keys(answer).sort()) !== canonical(["columns", "definition", "rows", "summary", "verified"])) {
+    throw new CodexDispatchError("answer_query success requires the canonical rich result shape");
+  }
+  const definition = record(answer["definition"], "answer_query definition");
+  if (canonical(Object.keys(definition).sort()) !== canonical(["filters", "source_tables", "sql"])) {
+    throw new CodexDispatchError("answer_query success requires complete run provenance");
+  }
+  if (!Array.isArray(answer["columns"]) || !answer["columns"].every((column) => typeof column === "string" && column.length > 0) || !Array.isArray(answer["rows"]) || typeof answer["summary"] !== "string" || answer["summary"].trim().length === 0 || answer["verified"] !== true || typeof definition["sql"] !== "string" || definition["sql"].trim().length === 0 || !Array.isArray(definition["source_tables"]) || !definition["source_tables"].every(
+    (table) => typeof table === "string" && table.length > 0
+  ) || !Array.isArray(definition["filters"])) {
+    throw new CodexDispatchError(
+      "answer_query success requires a grounded summary, verification, and complete run provenance"
+    );
+  }
+  return answer;
+}
+function parseStepRequest(text2, step) {
+  const prefix = "WARBLE_STEP_REQUEST\n";
+  if (!text2.startsWith(prefix)) {
+    throw new CodexDispatchError(`agent '${step.role}' input lacks the Warble step envelope`);
+  }
+  let value;
+  try {
+    value = JSON.parse(text2.slice(prefix.length));
+  } catch {
+    throw new CodexDispatchError(`agent '${step.role}' input has malformed JSON`);
+  }
+  const request = record(value, `agent '${step.role}' input`);
+  const keys = Object.keys(request).sort();
+  if (canonical(keys) !== canonical(["inputs", "step"]) || request["step"] !== step.name || !isRecord4(request["inputs"])) {
+    throw new CodexDispatchError(`agent '${step.role}' input does not match its IR step`);
+  }
+  return request;
+}
+function buildStepRequest(step, slots) {
+  return `WARBLE_STEP_REQUEST
+${JSON.stringify({
+    step: step.name,
+    inputs: Object.fromEntries(step.consumes.map((slot) => [slot, slots[slot]]))
+  })}`;
+}
+function stepCountBounds(steps) {
+  return {
+    minimumSteps: steps.filter((step) => !step.conditional).length,
+    maximumSteps: steps.length
+  };
+}
+function repairersByTarget(steps) {
+  const map = /* @__PURE__ */ new Map();
+  for (let index = 1; index < steps.length; index += 1) {
+    const step = steps[index];
+    const previous = steps[index - 1];
+    if (step.conditional && step.when?.target === previous.name) {
+      map.set(previous.name, step);
+    }
+  }
+  return map;
+}
+function buildAskDriverPrompt(prepared) {
+  const steps = prepared.steps.map((step, index) => {
+    const inputDescription = step.consumes.length === 0 ? "an empty inputs object" : `inputs containing only ${step.consumes.join(", ")} copied exactly from the prior agent value`;
+    return `${index + 1}. Spawn agent_type=${step.role} for step=${step.name} with ${inputDescription}. Wait for it before any later spawn.`;
+  });
+  const repairers = repairersByTarget(prepared.steps);
+  const repairRules = prepared.steps.flatMap((step) => {
+    const repairer = repairers.get(step.name);
+    if (repairer === void 0) return [];
+    return [
+      `If '${step.name}' returns ok=true, do not spawn '${repairer.role}'.`,
+      `If it returns ok=false, spawn '${repairer.role}' exactly once; if repair fails, fail loudly.`
+    ];
+  });
+  const producesRenderEnvelope = prepared.executionKind === "generate_dashboard";
+  const executionRules = producesRenderEnvelope ? [
+    "Every declared step is required. If any child returns ok=false, fail loudly and stop.",
+    "Do not write files in the parent or children; the final validated render envelope is the consumer-persistable artifact output.",
+    ...repairRules
+  ] : repairRules;
+  return [
+    `Execute Warble component '${prepared.componentId}' by named child-agent delegation only.`,
+    "Do not perform any IR step in the parent and do not use business MCP tools in the parent.",
+    "Use Codex's direct collaboration tools for every spawn and wait. Call spawn_agent and wait_agent as tool calls; do not invoke collaboration through exec or code mode.",
+    "Select the exact custom agent type named for each step and send the exact child message below. Give the spawn a short unique task name when the current tool schema requires one.",
+    "Do not override the child model or reasoning effort, and do not fork the parent conversation into the child. After each spawn, wait for that child to complete before any later spawn.",
+    `The dispatcher supplies the authoritative original request directly to each child through ${REQUEST_TRANSPORT_SERVER}.${REQUEST_TRANSPORT_TOOL}; never copy, summarize, or include the request in a child message.`,
+    "For every child, send exactly this message:",
+    "WARBLE_STEP_REQUEST",
+    '{"step":"<step>","inputs":{"<slot>":<prior value>}}',
+    "The JSON object must contain only step and inputs. Never add the original request, a request summary, or any extra field.",
+    "Each child returns a JSON envelope. Copy its value exactly into the next declared input slot.",
+    "Spawn without an explicit model override: the named custom-agent config owns the model.",
+    "",
+    ...steps,
+    "",
+    ...executionRules,
+    "Do not copy the final child value into the parent response; large structured values must remain authoritative in the child thread.",
+    'Your final message must be exactly {"warble_final_step":"<actual final successful step name>","ok":true} with no prose.'
+  ].join("\n");
+}
+var CodexAskRuntime = class _CodexAskRuntime {
+  constructor(prepared, options) {
+    this.prepared = prepared;
+    this.options = options;
+  }
+  prepared;
+  options;
+  transport;
+  bundle;
+  session = null;
+  active = null;
+  startingTurn = false;
+  pendingTurnNotifications = [];
+  disconnected = false;
+  static async connect(prepared, options) {
+    const runtime = new _CodexAskRuntime(prepared, options);
+    runtime.bundle = createAskAgentConfigBundle(prepared);
+    try {
+      runtime.transport = await CodexAppServerTransport.startWithArgs(
+        [...options.codexArgsPrefix ?? [], ...buildAskAppServerArgs(runtime.bundle)],
+        options,
+        (method, params) => runtime.onNotification(method, params),
+        (error) => runtime.onDisconnect(error)
+      );
+      return runtime;
+    } catch (error) {
+      runtime.bundle.cleanup();
+      throw error;
+    }
+  }
+  async start() {
+    this.ensureConnected();
+    if (this.session !== null) throw new CodexDispatchError("an Ask session is already loaded");
+    const result = record(
+      await this.transport.request("thread/start", {
+        model: this.prepared.models.orchestrator,
+        cwd: this.options.cwd,
+        approvalPolicy: "never",
+        sandbox: "read-only",
+        config: this.bundle.parentConfig,
+        ephemeral: false,
+        historyMode: "legacy",
+        environments: [],
+        runtimeWorkspaceRoots: [],
+        selectedCapabilityRoots: [],
+        dynamicTools: [],
+        experimentalRawEvents: false
+      }),
+      "thread/start response"
+    );
+    this.session = sessionReference(record(result["thread"], "thread/start thread"));
+    this.emit({ t: "session_started", session: this.session });
+    return this.session;
+  }
+  async resume(reference) {
+    validateReference(reference);
+    this.ensureConnected();
+    if (this.active !== null) throw new CodexDispatchError("cannot resume while an Ask turn is active");
+    const result = record(
+      await this.transport.request("thread/resume", {
+        threadId: reference.threadId,
+        model: this.prepared.models.orchestrator,
+        cwd: this.options.cwd,
+        approvalPolicy: "never",
+        sandbox: "read-only",
+        config: this.bundle.parentConfig,
+        runtimeWorkspaceRoots: []
+      }),
+      "thread/resume response"
+    );
+    const resumed = sessionReference(record(result["thread"], "thread/resume thread"));
+    if (resumed.threadId !== reference.threadId) {
+      throw new CodexDispatchError("thread/resume returned a different thread id");
+    }
+    this.session = resumed;
+    this.emit({ t: "session_resumed", session: resumed });
+    return resumed;
+  }
+  async run(reference, request, signal) {
+    validateReference(reference);
+    this.ensureConnected();
+    if (this.session?.threadId !== reference.threadId) {
+      throw new CodexDispatchError("Ask session reference is not loaded; resume it first");
+    }
+    if (this.active !== null) throw new CodexDispatchError("an Ask turn is already active");
+    if (request.trim().length === 0) throw new CodexDispatchError("Ask request must not be empty");
+    if (signal?.aborted) throw new CodexDispatchError("Ask turn was cancelled before start");
+    let resolveRun;
+    let rejectRun;
+    const completion = new Promise((resolve4, reject) => {
+      resolveRun = resolve4;
+      rejectRun = reject;
+    });
+    let turn;
+    this.startingTurn = true;
+    this.pendingTurnNotifications = [];
+    try {
+      this.bundle.bindRequest(request);
+      const initialStepRequest = buildStepRequest(this.prepared.steps[0], {});
+      this.bundle.bindStepRequest(initialStepRequest);
+      const result = record(
+        await this.transport.request("turn/start", {
+          threadId: reference.threadId,
+          input: [{ type: "text", text: buildAskDriverPrompt(this.prepared), text_elements: [] }],
+          approvalPolicy: "never",
+          environments: [],
+          runtimeWorkspaceRoots: []
+        }),
+        "turn/start response"
+      );
+      turn = turnReference(reference.threadId, result["turn"]);
+      if (turn.status !== "in_progress") {
+        throw new CodexDispatchError("turn/start did not return an in-progress turn");
+      }
+      this.active = {
+        threadId: reference.threadId,
+        turnId: turn.turnId,
+        started: false,
+        completed: false,
+        status: "in_progress",
+        spawns: [],
+        pendingItems: /* @__PURE__ */ new Map(),
+        pendingChildThreadIds: /* @__PURE__ */ new Set(),
+        pendingChildCompletedIds: /* @__PURE__ */ new Set(),
+        deferredWaitItems: [],
+        stepRequests: [initialStepRequest],
+        slots: {},
+        childAnswers: /* @__PURE__ */ new Map(),
+        finalText: null,
+        deferredTurnCompletion: null,
+        stopReason: null,
+        stopCompleted: null,
+        resolve: resolveRun,
+        reject: rejectRun
+      };
+    } catch (error) {
+      this.startingTurn = false;
+      this.pendingTurnNotifications = [];
+      throw error;
+    }
+    this.startingTurn = false;
+    const pendingNotifications = this.pendingTurnNotifications;
+    this.pendingTurnNotifications = [];
+    for (const [method, params] of pendingNotifications) {
+      this.onNotification(method, params);
+    }
+    const timeoutMs = this.options.turnTimeoutMs ?? 12e4;
+    const timer = setTimeout(() => {
+      void this.stopTurn(turn, "turn_timeout");
+    }, timeoutMs);
+    const cancel = () => {
+      void this.stopTurn(turn, "turn_cancelled");
+    };
+    signal?.addEventListener("abort", cancel, { once: true });
+    if (signal?.aborted) cancel();
+    try {
+      await completion;
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", cancel);
+      const active = this.active;
+      if (active === null || active.turnId !== turn.turnId) {
+        throw new CodexDispatchError("Ask turn state was displaced");
+      }
+      const steps = await this.validateChildren(active);
+      const finalStep = steps.at(-1);
+      if (!finalStep?.ok) throw new CodexDispatchError("Ask run has no successful final step");
+      if (!isRecord4(finalStep.value)) {
+        throw new CodexDispatchError("Ask final value must be a JSON object");
+      }
+      let parentFinal;
+      try {
+        parentFinal = JSON.parse(active.finalText ?? "");
+      } catch {
+        throw new CodexDispatchError("Ask parent final message is not JSON");
+      }
+      const expectedReceipt = { warble_final_step: finalStep.step, ok: true };
+      if (canonical(parentFinal) !== canonical(expectedReceipt)) {
+        throw new CodexDispatchError("Ask parent final message does not match the final child receipt");
+      }
+      let artifact = null;
+      let renderDegraded = false;
+      let finalValue = finalStep.value;
+      if (this.prepared.executionKind === "answer_query") {
+        finalValue = validateAnswerQueryValue(finalStep.value);
+        finalStep.value = finalValue;
+      } else {
+        try {
+          const envelope = validateDashboardRenderEnvelope(finalStep.value, this.prepared.node);
+          finalValue = envelope;
+          finalStep.value = envelope;
+          artifact = {
+            version: SESSION_REFERENCE_VERSION,
+            kind: "render_envelope",
+            parentThreadId: active.threadId,
+            parentTurnId: active.turnId,
+            agentThreadId: finalStep.agentThreadId,
+            step: finalStep.step,
+            agentRole: finalStep.agentRole,
+            verified: envelope.verified,
+            blockTypes: envelope.blocks.map((block) => String(block["type"]))
+          };
+          this.emit({ t: "render_artifact", reference: artifact });
+        } catch (error) {
+          if (!(error instanceof CodexDispatchError)) throw error;
+          renderDegraded = true;
+          this.emit({
+            t: "render_degraded",
+            parentThreadId: active.threadId,
+            parentTurnId: active.turnId,
+            reason: "invalid_render_envelope"
+          });
+        }
+      }
+      const completed = {
+        threadId: active.threadId,
+        turnId: active.turnId,
+        status: active.status
+      };
+      this.emit({ t: "turn_completed", turn: completed });
+      return {
+        target: "codex:local",
+        component: this.prepared.componentId,
+        session: reference,
+        turn: completed,
+        finalText: JSON.stringify(finalValue),
+        value: finalValue,
+        steps,
+        artifact,
+        renderDegraded
+      };
+    } finally {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", cancel);
+      this.startingTurn = false;
+      this.pendingTurnNotifications = [];
+      this.active = null;
+    }
+  }
+  async restartAndResume(reference) {
+    if (this.active !== null) throw new CodexDispatchError("cannot restart while an Ask turn is active");
+    await this.transport.close();
+    this.transport = await CodexAppServerTransport.startWithArgs(
+      [...this.options.codexArgsPrefix ?? [], ...buildAskAppServerArgs(this.bundle)],
+      this.options,
+      (method, params) => this.onNotification(method, params),
+      (error) => this.onDisconnect(error)
+    );
+    this.disconnected = false;
+    try {
+      return await this.resume(reference);
+    } catch (error) {
+      this.disconnected = true;
+      await this.transport.close();
+      throw error;
+    }
+  }
+  async close() {
+    this.disconnected = true;
+    this.active?.reject(new CodexDispatchError("Ask runtime closed during an active turn"));
+    this.active = null;
+    await this.transport.close();
+    this.bundle.cleanup();
+  }
+  onNotification(method, paramsValue) {
+    try {
+      if (IGNORED_NOTIFICATIONS.has(method)) return;
+      const params = record(paramsValue, `${method} notification`);
+      if (this.active === null && this.startingTurn) {
+        this.pendingTurnNotifications.push([method, paramsValue]);
+        return;
+      }
+      if (method === "error") {
+        if (params["willRetry"] === true) return;
+        throw new CodexDispatchError("app-server reported a terminal Ask error");
+      }
+      const active = this.active;
+      if (active === null) throw new CodexDispatchError(`unexpected '${method}' without an active Ask turn`);
+      const notificationThreadId = params["threadId"];
+      if (typeof notificationThreadId === "string" && notificationThreadId !== active.threadId) {
+        const knownChild = active.spawns.some(
+          (spawn3) => spawn3.agentThreadId === notificationThreadId
+        );
+        if (knownChild && CHILD_THREAD_NOTIFICATIONS.has(method)) {
+          this.observeChildNotification(method, params, active, notificationThreadId);
+          return;
+        }
+        if (CHILD_THREAD_NOTIFICATIONS.has(method) && active.spawns.length < this.prepared.steps.length) {
+          active.pendingChildThreadIds.add(notificationThreadId);
+          this.observeChildNotification(method, params, active, notificationThreadId);
+          if (method === "turn/completed") {
+            active.pendingChildCompletedIds.add(notificationThreadId);
+          }
+          if (active.pendingChildThreadIds.size > this.prepared.steps.length - active.spawns.length) {
+            throw new CodexDispatchError("Ask received too many unattributed child threads");
+          }
+          return;
+        }
+        throw new CodexDispatchError("Ask notification belongs to an unknown thread");
+      }
+      if (method === "turn/started") {
+        const turn = turnReference(string(params, "threadId", method), params["turn"]);
+        if (turn.threadId !== active.threadId || turn.turnId !== active.turnId || active.started) {
+          throw new CodexDispatchError("Ask turn start notification does not match active state");
+        }
+        active.started = true;
+        this.emit({ t: "turn_started", turn });
+        return;
+      }
+      if (method === "item/started" || method === "item/completed") {
+        this.onItem(method, params, active);
+        this.tryFinalizeTurn(active);
+        return;
+      }
+      if (method === "turn/completed") {
+        const turn = turnReference(string(params, "threadId", method), params["turn"]);
+        if (!active.started || turn.threadId !== active.threadId || turn.turnId !== active.turnId) {
+          throw new CodexDispatchError("Ask turn completion does not match active state");
+        }
+        if (active.stopReason !== null && turn.status === "interrupted") {
+          active.completed = true;
+          active.status = turn.status;
+          active.stopCompleted?.();
+          return;
+        }
+        if (turn.status !== "completed" || active.finalText === null) {
+          throw new CodexDispatchError("Ask parent turn did not complete with a final answer");
+        }
+        this.synthesizeDirectCollaboration(active);
+        active.deferredTurnCompletion = turn;
+        this.tryFinalizeTurn(active);
+        return;
+      }
+      throw new CodexDispatchError(`unsupported app-server notification '${method}'`);
+    } catch (error) {
+      const failure = error instanceof Error ? error : new Error(String(error));
+      this.active?.reject(failure);
+      this.onDisconnect(
+        failure instanceof CodexDispatchError ? failure : new CodexDispatchError(failure.message)
+      );
+      void this.transport.close();
+    }
+  }
+  onItem(method, params, active) {
+    if (string(params, "threadId", method) !== active.threadId || string(params, "turnId", method) !== active.turnId) {
+      throw new CodexDispatchError("Ask item belongs to a different parent turn");
+    }
+    const item = record(params["item"], `${method} item`);
+    const type = string(item, "type", `${method} item`);
+    if (type === "collabAgentToolCall") {
+      this.onCollabItem(method, item, active);
+      return;
+    }
+    if (!PASSIVE_PARENT_ITEMS.has(type)) {
+      throw new CodexDispatchError(`isolation violation: Ask parent emitted forbidden '${type}'`);
+    }
+    if (method === "item/completed" && type === "agentMessage") {
+      active.finalText = string(item, "text", type);
+    }
+  }
+  observeChildNotification(method, params, active, childThreadId) {
+    if (method !== "item/completed") return;
+    const item = record(params["item"], "child item/completed item");
+    if (item["type"] !== "agentMessage") return;
+    if (active.childAnswers.has(childThreadId)) {
+      throw new CodexDispatchError("Ask child emitted more than one final answer");
+    }
+    const answer = string(item, "text", "child agentMessage");
+    active.childAnswers.set(childThreadId, answer);
+    const knownIndex = active.spawns.findIndex((spawn3) => spawn3.agentThreadId === childThreadId);
+    const pendingIndex = [...active.pendingChildThreadIds].indexOf(childThreadId);
+    const stepIndex = knownIndex >= 0 ? knownIndex : active.spawns.length + pendingIndex;
+    const step = this.prepared.steps[stepIndex];
+    if (!step) throw new CodexDispatchError("Ask child answer has no IR step attribution");
+    const envelope = parseEnvelope(answer, step);
+    active.slots[step.produces] = envelope.value;
+    const next = this.prepared.steps[stepIndex + 1];
+    const repairers = repairersByTarget(this.prepared.steps);
+    const isRecoverable = repairers.has(step.name);
+    const shouldPrepareNext = next !== void 0 && (isRecoverable ? !envelope.ok : envelope.ok);
+    if (!shouldPrepareNext || next === void 0) return;
+    const request = buildStepRequest(next, active.slots);
+    active.stepRequests[stepIndex + 1] = request;
+    this.bundle.bindStepRequest(request);
+  }
+  onCollabItem(method, item, active) {
+    const id = string(item, "id", "collaboration item");
+    const tool = string(item, "tool", "collaboration item");
+    if (tool !== "spawnAgent" && tool !== "wait") {
+      throw new CodexDispatchError(`Ask parent used unsupported collaboration tool '${tool}'`);
+    }
+    if (method === "item/started") {
+      if (item["status"] !== "inProgress" || active.pendingItems.has(id)) {
+        throw new CodexDispatchError("collaboration item has an invalid start state");
+      }
+      active.pendingItems.set(id, tool);
+      return;
+    }
+    if (active.pendingItems.get(id) !== tool) {
+      throw new CodexDispatchError("collaboration item completed without a matching start");
+    }
+    active.pendingItems.delete(id);
+    if (item["status"] !== "completed") {
+      throw new CodexDispatchError(`collaboration '${tool}' failed`);
+    }
+    if (tool === "spawnAgent") {
+      const previous = active.spawns.at(-1);
+      if (previous && !previous.waited) {
+        throw new CodexDispatchError("Ask parent spawned the next agent before waiting for the prior one");
+      }
+      const expected = this.prepared.steps[active.spawns.length];
+      if (!expected) throw new CodexDispatchError("Ask parent spawned too many agents");
+      const receiverIds = item["receiverThreadIds"];
+      if (!Array.isArray(receiverIds) || receiverIds.length !== 1 || typeof receiverIds[0] !== "string") {
+        throw new CodexDispatchError("spawnAgent must return exactly one child thread");
+      }
+      const firstPendingChild = active.pendingChildThreadIds.values().next().value;
+      if (firstPendingChild !== void 0 && firstPendingChild !== receiverIds[0]) {
+        throw new CodexDispatchError("spawnAgent attributed a different child thread than its notifications");
+      }
+      if (firstPendingChild !== void 0) active.pendingChildThreadIds.delete(firstPendingChild);
+      active.pendingChildCompletedIds.delete(receiverIds[0]);
+      const requestedModel = item["model"];
+      if (requestedModel !== null && requestedModel !== expected.model) {
+        throw new CodexDispatchError(`agent '${expected.role}' ran on the wrong model`);
+      }
+      const stepRequest = active.stepRequests[active.spawns.length];
+      if (stepRequest === void 0) {
+        throw new CodexDispatchError(`agent '${expected.role}' spawned before its host input was ready`);
+      }
+      const spawn3 = {
+        callId: id,
+        expected,
+        agentThreadId: receiverIds[0],
+        model: expected.model,
+        prompt: item["prompt"] === null ? null : string(item, "prompt", "spawnAgent"),
+        stepRequest,
+        waited: false
+      };
+      active.spawns.push(spawn3);
+      const deferred = active.deferredWaitItems.shift();
+      if (deferred !== void 0) this.completeWait(deferred, active);
+      return;
+    }
+    const current = active.spawns.at(-1);
+    if (!current?.agentThreadId) {
+      if (active.deferredWaitItems.length >= this.prepared.steps.length - active.spawns.length) {
+        throw new CodexDispatchError("too many waits completed before child attribution");
+      }
+      active.deferredWaitItems.push(item);
+      return;
+    }
+    this.completeWait(item, active);
+  }
+  completeWait(item, active) {
+    const current = active.spawns.at(-1);
+    if (!current?.agentThreadId || current.waited) {
+      throw new CodexDispatchError("wait did not follow exactly one active child spawn");
+    }
+    const receiverIds = item["receiverThreadIds"];
+    if (!Array.isArray(receiverIds) || receiverIds.length !== 1 || receiverIds[0] !== current.agentThreadId) {
+      throw new CodexDispatchError("wait targeted a different child thread");
+    }
+    const states = record(item["agentsStates"], "wait agentsStates");
+    const childState = record(states[current.agentThreadId], "wait child state");
+    if (childState["status"] !== "completed") {
+      throw new CodexDispatchError("wait completed before the child agent succeeded");
+    }
+    current.waited = true;
+  }
+  tryFinalizeTurn(active) {
+    const turn = active.deferredTurnCompletion;
+    if (turn === null || active.pendingItems.size > 0 || active.pendingChildThreadIds.size > 0 || active.deferredWaitItems.length > 0) {
+      return;
+    }
+    active.deferredTurnCompletion = null;
+    active.completed = true;
+    active.status = turn.status;
+    active.resolve();
+  }
+  synthesizeDirectCollaboration(active) {
+    if (active.spawns.length > 0 || active.pendingChildThreadIds.size === 0) return;
+    const childIds = [...active.pendingChildThreadIds];
+    const { minimumSteps, maximumSteps } = stepCountBounds(this.prepared.steps);
+    if (childIds.length < minimumSteps || childIds.length > maximumSteps || childIds.some((id) => !active.pendingChildCompletedIds.has(id))) {
+      throw new CodexDispatchError("direct collaboration children did not complete in the required sequence");
+    }
+    if (active.deferredWaitItems.length !== childIds.length) {
+      throw new CodexDispatchError("direct collaboration did not wait once for every child");
+    }
+    active.spawns = childIds.map((agentThreadId, index) => {
+      const stepRequest = active.stepRequests[index];
+      if (stepRequest === void 0) {
+        throw new CodexDispatchError("direct collaboration child spawned before its host input was ready");
+      }
+      return {
+        callId: `direct-${agentThreadId}`,
+        expected: this.prepared.steps[index],
+        agentThreadId,
+        model: this.prepared.steps[index].model,
+        prompt: null,
+        stepRequest,
+        waited: true
+      };
+    });
+    active.pendingChildThreadIds.clear();
+    active.pendingChildCompletedIds.clear();
+    active.deferredWaitItems = [];
+  }
+  async validateChildren(active) {
+    const { minimumSteps, maximumSteps } = stepCountBounds(this.prepared.steps);
+    if (active.spawns.length < minimumSteps || active.spawns.length > maximumSteps || active.spawns.some((spawn3) => !spawn3.waited)) {
+      throw new CodexDispatchError("Ask parent did not complete the required named-agent sequence");
+    }
+    const results = [];
+    const slots = {};
+    const repairers = repairersByTarget(this.prepared.steps);
+    for (const [index, spawn3] of active.spawns.entries()) {
+      const step = this.prepared.steps[index];
+      if (spawn3.expected !== step || spawn3.agentThreadId === null || spawn3.model !== step.model) {
+        throw new CodexDispatchError("Ask child sequence does not match the IR");
+      }
+      const child = record(
+        await this.transport.request("thread/read", {
+          threadId: spawn3.agentThreadId,
+          includeTurns: true
+        }),
+        "child thread/read response"
+      );
+      const thread = record(child["thread"], "child thread/read thread");
+      if (thread["id"] !== spawn3.agentThreadId || thread["parentThreadId"] !== active.threadId || thread["agentRole"] !== step.role) {
+        throw new CodexDispatchError(`child thread attribution failed for agent '${step.role}'`);
+      }
+      this.emit({
+        t: "agent_started",
+        parentThreadId: active.threadId,
+        parentTurnId: active.turnId,
+        step: step.name,
+        agentRole: step.role,
+        agentThreadId: spawn3.agentThreadId,
+        model: step.model
+      });
+      const turns = thread["turns"];
+      if (!Array.isArray(turns) || turns.length !== 1) {
+        throw new CodexDispatchError(`agent '${step.role}' must have exactly one turn`);
+      }
+      const turn = record(turns[0], `agent '${step.role}' turn`);
+      if (turn["status"] !== "completed" || !Array.isArray(turn["items"])) {
+        throw new CodexDispatchError(`agent '${step.role}' turn did not complete`);
+      }
+      let inputText = null;
+      let answerText = null;
+      const artifacts = [];
+      let originalRequestCalls = 0;
+      let stepRequestCalls = 0;
+      let businessToolSeen = false;
+      for (const itemValue of turn["items"]) {
+        const item = record(itemValue, `agent '${step.role}' item`);
+        const type = string(item, "type", `agent '${step.role}' item`);
+        if (type === "userMessage") {
+          const content = item["content"];
+          if (!Array.isArray(content) || !isRecord4(content[0]) || typeof content[0]["text"] !== "string") {
+            throw new CodexDispatchError(`agent '${step.role}' user input is malformed`);
+          }
+          inputText = content[0]["text"];
+        } else if (type === "agentMessage") {
+          answerText = string(item, "text", `agent '${step.role}' answer`);
+        } else if (type === "mcpToolCall") {
+          const server = string(item, "server", "child MCP item");
+          const tool = string(item, "tool", "child MCP item");
+          const status = string(item, "status", "child MCP item");
+          if (status !== "completed" && status !== "failed") {
+            throw new CodexDispatchError(`agent '${step.role}' has an unfinished MCP tool`);
+          }
+          if (server === REQUEST_TRANSPORT_SERVER) {
+            const successful = !businessToolSeen && status === "completed" && (item["error"] === null || item["error"] === void 0);
+            if (tool === REQUEST_TRANSPORT_TOOL) {
+              if (!successful || originalRequestCalls !== 0 || stepRequestCalls !== 0) {
+                throw new CodexDispatchError(`agent '${step.role}' violated the original request transport contract`);
+              }
+              originalRequestCalls += 1;
+            } else if (tool === STEP_TRANSPORT_TOOL) {
+              if (!successful || originalRequestCalls !== 1 || stepRequestCalls !== 0) {
+                throw new CodexDispatchError(`agent '${step.role}' violated the step request transport contract`);
+              }
+              stepRequestCalls += 1;
+            } else {
+              throw new CodexDispatchError(`agent '${step.role}' used an unknown request transport tool`);
+            }
+            continue;
+          }
+          if (server !== this.prepared.mcp.name || !step.enabledTools.includes(tool)) {
+            throw new CodexDispatchError(`agent '${step.role}' used a non-allowlisted MCP tool`);
+          }
+          businessToolSeen = true;
+          const reference = {
+            version: SESSION_REFERENCE_VERSION,
+            kind: "mcp_tool_result",
+            parentThreadId: active.threadId,
+            parentTurnId: active.turnId,
+            agentThreadId: spawn3.agentThreadId,
+            step: step.name,
+            agentRole: step.role,
+            itemId: string(item, "id", "child MCP item"),
+            server,
+            tool,
+            ok: status === "completed" && (item["error"] === null || item["error"] === void 0)
+          };
+          artifacts.push(reference);
+          this.emit({ t: "artifact", reference });
+        } else if (!(/* @__PURE__ */ new Set(["reasoning", "plan"])).has(type)) {
+          throw new CodexDispatchError(`agent '${step.role}' emitted forbidden '${type}'`);
+        }
+      }
+      if (answerText === null) {
+        throw new CodexDispatchError(`agent '${step.role}' lacks a final answer`);
+      }
+      if (originalRequestCalls !== 1) {
+        throw new CodexDispatchError(`agent '${step.role}' did not load the authoritative original request`);
+      }
+      if (stepRequestCalls !== 1) {
+        throw new CodexDispatchError(`agent '${step.role}' did not load the authoritative step request`);
+      }
+      const requestTexts = [spawn3.stepRequest, inputText, spawn3.prompt].filter(
+        (value) => value !== null
+      );
+      const requests = requestTexts.map((text2) => parseStepRequest(text2, step));
+      if (requests.some((request2) => canonical(request2) !== canonical(requests[0]))) {
+        throw new CodexDispatchError(`agent '${step.role}' has conflicting step inputs`);
+      }
+      const request = requests[0];
+      const inputs = request["inputs"];
+      if (Object.keys(inputs).sort().join(",") !== [...step.consumes].sort().join(",")) {
+        throw new CodexDispatchError(`agent '${step.role}' received the wrong input slots`);
+      }
+      for (const consumed of step.consumes) {
+        if (canonical(inputs[consumed]) !== canonical(slots[consumed])) {
+          throw new CodexDispatchError(`agent '${step.role}' input '${consumed}' was not marshalled exactly`);
+        }
+      }
+      const envelope = parseEnvelope(answerText, step);
+      const repairer = repairers.get(step.name);
+      if (repairer === void 0) {
+        if (!envelope.ok) {
+          throw new CodexDispatchError(
+            step.conditional ? "bounded repair attempt did not recover generation" : `required step '${step.name}' failed`
+          );
+        }
+      } else {
+        const repairerSpawned = active.spawns.length > index + 1;
+        if (!envelope.ok && !repairerSpawned) {
+          throw new CodexDispatchError(
+            `step '${step.name}' failure did not trigger repair step '${repairer.name}'`
+          );
+        }
+        if (envelope.ok && repairerSpawned) {
+          throw new CodexDispatchError(
+            `repair step '${repairer.name}' ran even though '${step.name}' succeeded`
+          );
+        }
+      }
+      if (step.requireSuccessfulTool && artifacts.length === 0) {
+        throw new CodexDispatchError(`agent '${step.role}' completed without its required MCP tool attempt`);
+      }
+      if (envelope.ok && step.requireSuccessfulTool && !artifacts.some((artifact) => artifact.ok)) {
+        throw new CodexDispatchError(`agent '${step.role}' claimed success without a successful MCP tool`);
+      }
+      slots[step.produces] = envelope.value;
+      const result = {
+        step: step.name,
+        agentRole: step.role,
+        agentThreadId: spawn3.agentThreadId,
+        model: step.model,
+        produced: step.produces,
+        ok: envelope.ok,
+        value: envelope.value,
+        artifacts
+      };
+      results.push(result);
+      this.emit({
+        t: "step_finished",
+        parentThreadId: active.threadId,
+        parentTurnId: active.turnId,
+        step: step.name,
+        agentRole: step.role,
+        agentThreadId: spawn3.agentThreadId,
+        ok: envelope.ok
+      });
+    }
+    return results;
+  }
+  async stopTurn(turn, reason) {
+    if (this.active?.turnId !== turn.turnId || this.active.stopReason !== null) return;
+    this.active.stopReason = reason;
+    const transport = this.transport;
+    let resolveStopped;
+    const stopped = new Promise((resolve4) => {
+      resolveStopped = resolve4;
+    });
+    this.active.stopCompleted = resolveStopped;
+    try {
+      await transport.request("turn/interrupt", {
+        threadId: turn.threadId,
+        turnId: turn.turnId
+      });
+    } catch {
+    }
+    let graceTimer;
+    await Promise.race([
+      stopped,
+      new Promise((resolve4) => {
+        graceTimer = setTimeout(resolve4, this.options.terminationGraceMs ?? 1e3);
+      })
+    ]);
+    if (graceTimer !== void 0) clearTimeout(graceTimer);
+    await transport.close();
+    if (this.active?.turnId !== turn.turnId) return;
+    const error = new CodexDispatchError(
+      reason === "turn_timeout" ? `Ask turn '${turn.turnId}' timed out` : `Ask turn '${turn.turnId}' was cancelled`
+    );
+    this.active.reject(error);
+    this.onDisconnect(void 0, reason);
+  }
+  onDisconnect(protocolError, reasonOverride) {
+    if (this.disconnected) return;
+    this.disconnected = true;
+    if (protocolError) {
+      this.emit({ t: "session_failed", threadId: this.session?.threadId ?? null, reason: "protocol_violation" });
+      this.active?.reject(protocolError);
+    } else {
+      this.emit({
+        t: "session_recoverable",
+        threadId: this.session?.threadId ?? null,
+        reason: reasonOverride ?? (this.active ? "app_server_crash" : "transport_disconnect")
+      });
+      this.active?.reject(new CodexDispatchError("app-server disconnected during an Ask turn"));
+    }
+  }
+  ensureConnected() {
+    if (this.disconnected) throw new CodexDispatchError("app-server transport disconnected; resume required");
+  }
+  emit(event) {
+    this.options.onAskEvent?.(event);
+  }
+};
+
+// src/enrich_prepare.ts
+import { isAbsolute as isAbsolute3 } from "path";
+
+// src/step_engine.ts
+function parseStepWhen(step) {
+  if (!step.conditional) {
+    if (step.when !== null) {
+      throw new CodexDispatchError(`step '${step.name}' is unconditional but has a when guard`);
+    }
+    return null;
+  }
+  if (typeof step.when !== "object" || step.when === null || Array.isArray(step.when) || step.when["guard"] !== "on_failure" || typeof step.when["target"] !== "string") {
+    throw new CodexDispatchError(`step '${step.name}' wall-hit: repair requires on_failure(target)`);
+  }
+  return {
+    guard: "on_failure",
+    target: step.when["target"]
+  };
+}
+function validateStepTopology(node) {
+  const names = /* @__PURE__ */ new Set();
+  for (const step of node.llm_calls) {
+    if (names.has(step.name)) {
+      throw new CodexDispatchError(
+        `component '${node.id}' wall-hit: step name '${step.name}' is declared more than once`
+      );
+    }
+    names.add(step.name);
+  }
+  const topology = [];
+  const produced = /* @__PURE__ */ new Set();
+  for (let index = 0; index < node.llm_calls.length; index += 1) {
+    const step = node.llm_calls[index];
+    for (const consumed of step.consumes) {
+      if (!produced.has(consumed)) {
+        throw new CodexDispatchError(
+          `component '${node.id}' wall-hit: step '${step.name}' consumes '${consumed}' but no earlier step produces it`
+        );
+      }
+    }
+    if (step.produces === null) {
+      throw new CodexDispatchError(
+        `component '${node.id}' wall-hit: this transport requires a produced slot; step '${step.name}' produces none`
+      );
+    }
+    produced.add(step.produces);
+    const when = parseStepWhen(step);
+    if (when !== null) {
+      if (index !== node.llm_calls.length - 1) {
+        throw new CodexDispatchError(
+          `component '${node.id}' wall-hit: conditional step '${step.name}' must be the last step; a step nothing downstream can safely consume from must not have output others rely on`
+        );
+      }
+      if (!names.has(when.target) || !node.llm_calls.slice(0, index).some((earlier) => earlier.name === when.target)) {
+        throw new CodexDispatchError(
+          `component '${node.id}' wall-hit: step '${step.name}' on_failure target '${when.target}' is not an earlier step`
+        );
+      }
+    }
+    topology.push({ when });
+  }
+  return topology;
+}
+function parseStepTerminal(text2, produces) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text2);
+  } catch {
+    throw new CodexDispatchError("step terminal is not JSON");
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new CodexDispatchError("step terminal must be a JSON object");
+  }
+  const record2 = parsed;
+  const keys = Object.keys(record2);
+  if (keys.length !== 1 || keys[0] !== produces || record2[produces] === null) {
+    throw new CodexDispatchError(`step terminal requires exactly the produced field '${produces}'`);
+  }
+  return record2;
+}
+function shouldRunStep(when, outcomes) {
+  if (when === null) return true;
+  const target = outcomes.get(when.target);
+  return target !== void 0 && target.ran && !target.ok;
+}
+function resolveStepModel(model, tier, componentId) {
+  const resolved = typeof model === "string" ? model : model[tier];
+  if (resolved === void 0 || resolved.trim().length === 0) {
+    throw new CodexDispatchError(
+      `component '${componentId}' wall-hit: no model binding for tier '${tier}'`
+    );
+  }
+  return resolved;
+}
+
+// src/enrich_prepare.ts
+function unique2(values) {
+  return [...new Set(values)];
+}
+function validateEnrichShape(node) {
+  assertDispatchableComponentIdentity(node);
+  for (const capability of node.required_capabilities) {
+    if (!ENRICH_ALLOWED_CAPABILITIES.has(capability)) {
+      throw new CodexDispatchError(
+        `component '${node.id}' cannot be dispatched by codex:local: required capability '${capability}' has no honest realization on this target`
+      );
+    }
+  }
+  if (node.type !== "analytical" || node.realization_kind !== "skill" || node.trigger.kind !== "one_shot" || node.effect.outcome.kind !== "none") {
+    throw new CodexDispatchError(
+      `component '${node.id}' wall-hit: requires analytical/skill/one_shot/none`
+    );
+  }
+  if (node.context_binding.binding_mode !== "pinned") {
+    throw new CodexDispatchError(
+      `component '${node.id}' wall-hit: requires a pinned context binding`
+    );
+  }
+  if (node.llm_calls.length === 0) {
+    throw new CodexDispatchError(`component '${node.id}' wall-hit: at least one llm_call is required`);
+  }
+  validateStepTopology(node);
+  if (node.guardrails.length !== 1 || !guardrailMatches(node.guardrails[0], "read_only_execution", { requireScopeAbsent: true })) {
+    throw new CodexDispatchError(
+      `component '${node.id}' wall-hit: exactly one locked read_only_execution guardrail with no scope is required`
+    );
+  }
+  const domainCapabilities = node.required_capabilities.filter(isEnrichDomainCapability);
+  if (domainCapabilities.length === 0) {
+    throw new CodexDispatchError(
+      `component '${node.id}' wall-hit: at least one of semantic_introspection/raw_material_read is required`
+    );
+  }
+  const tiers = unique2(node.llm_calls.map((step) => step.tier));
+  if (tiers.length !== 1) {
+    throw new CodexDispatchError(
+      `component '${node.id}' wall-hit: this transport's persistent session supports exactly one tier per component; found '${tiers.join("', '")}'`
+    );
+  }
+  const expectedLlm = `llm:${tiers[0]}`;
+  if (!node.required_capabilities.includes(expectedLlm)) {
+    throw new CodexDispatchError(
+      `component '${node.id}' wall-hit: required capability '${expectedLlm}' is missing`
+    );
+  }
+  const expectedCapabilities = /* @__PURE__ */ new Set([...domainCapabilities, expectedLlm]);
+  if (!hasExactCapabilities(node.required_capabilities, expectedCapabilities)) {
+    throw new CodexDispatchError(
+      `component '${node.id}' wall-hit: supports exactly '${domainCapabilities.join("', '")}' and '${expectedLlm}' capabilities`
+    );
+  }
+  return domainCapabilities;
+}
+function matchesEnrichContractShape(node) {
+  try {
+    validateEnrichShape(node);
+    return true;
+  } catch (error) {
+    if (error instanceof CodexDispatchError) return false;
+    throw error;
+  }
+}
+function enrichContractMismatchReason(node) {
+  try {
+    validateEnrichShape(node);
+    return null;
+  } catch (error) {
+    if (error instanceof CodexDispatchError) return error.message;
+    throw error;
+  }
+}
+function prepareEnrich(input) {
+  const ir = typeof input.ir === "string" ? parseIr(input.ir) : input.ir;
+  if (ir.warble_ir_version !== SUPPORTED_IR_VERSION) {
+    throw new CodexDispatchError(
+      `unsupported warble_ir_version '${ir.warble_ir_version}' (supported: ${SUPPORTED_IR_VERSION})`
+    );
+  }
+  const node = ir.components.find((candidate) => candidate.id === input.component);
+  if (!node) {
+    throw new CodexDispatchError(
+      `component '${input.component}' was not found in profile '${ir.profile}'`
+    );
+  }
+  const domainCapabilities = validateEnrichShape(node);
+  const componentId = node.id;
+  if (!/^[A-Za-z0-9_-]+$/.test(input.mcp.name)) {
+    throw new CodexDispatchError(
+      `MCP server name '${input.mcp.name}' must contain only letters, digits, '_' or '-'`
+    );
+  }
+  if (!isAbsolute3(input.mcp.command)) {
+    throw new CodexDispatchError(
+      `MCP server command must be absolute when shell_environment_policy.inherit=none`
+    );
+  }
+  const enabledTools = unique2(
+    domainCapabilities.flatMap((capability) => input.mcp.toolsByCapability[capability] ?? [])
+  );
+  if (enabledTools.length === 0) {
+    throw new CodexDispatchError(
+      `component '${componentId}' has no allowlisted MCP tools for '${domainCapabilities.join("', '")}'`
+    );
+  }
+  const topology = validateStepTopology(node);
+  const steps = node.llm_calls.map((call, index) => ({
+    name: call.name,
+    tier: call.tier,
+    model: resolveStepModel(input.model, call.tier, componentId),
+    prompt: call.prompt,
+    consumes: call.consumes,
+    produces: call.produces,
+    when: topology[index].when
+  }));
+  return {
+    target: TARGET,
+    profile: ir.profile,
+    node,
+    componentId,
+    domainCapabilities,
+    steps,
+    capabilities: resolveCapabilities(node.required_capabilities, input.mcp.name),
+    enabledTools,
+    mcp: input.mcp
+  };
+}
+
+// src/prepare.ts
+import { isAbsolute as isAbsolute4 } from "path";
+function unique3(values) {
+  return [...new Set(values)];
+}
+function validateSetupShape(node) {
+  if (node.type !== "analytical" || node.realization_kind !== "skill" || node.trigger.kind !== "one_shot" || node.effect.outcome.kind !== "none" || node.effect.render_blocks.length !== 0) {
+    throw new CodexDispatchError(
+      `component '${node.id}' wall-hit: requires analytical/skill/one_shot/none with no render blocks`
+    );
+  }
+  if (node.llm_calls.length === 0) {
+    throw new CodexDispatchError(`component '${node.id}' wall-hit: at least one llm_call is required`);
+  }
+  validateStepTopology(node);
+  if (node.guardrails.length !== 1 || !guardrailMatches(node.guardrails[0], "setup_execution")) {
+    throw new CodexDispatchError(
+      `component '${node.id}' wall-hit: exactly one locked setup_execution guardrail with scope '.' is required`
+    );
+  }
+  const domainCapabilities = node.required_capabilities.filter(isSetupDomainCapability);
+  if (domainCapabilities.length !== 1) {
+    throw new CodexDispatchError(
+      `component '${node.id}' wall-hit: exactly one of source_connect/context_build is required`
+    );
+  }
+  const tiers = unique3(node.llm_calls.map((step) => step.tier));
+  const expectedLlm = tiers.length === 1 ? `llm:${tiers[0]}` : "llm:per_step_tier";
+  if (!node.required_capabilities.includes(expectedLlm)) {
+    throw new CodexDispatchError(
+      `component '${node.id}' wall-hit: required capability '${expectedLlm}' is missing`
+    );
+  }
+  const expectedCapabilities = /* @__PURE__ */ new Set([domainCapabilities[0], expectedLlm]);
+  if (!hasExactCapabilities(node.required_capabilities, expectedCapabilities)) {
+    throw new CodexDispatchError(
+      `component '${node.id}' wall-hit: supports exactly '${domainCapabilities[0]}' and '${expectedLlm}' capabilities`
+    );
+  }
+  return domainCapabilities[0];
+}
+function matchesSetupContractShape(node) {
+  try {
+    validateSetupShape(node);
+    return true;
+  } catch (error) {
+    if (error instanceof CodexDispatchError) return false;
+    throw error;
+  }
+}
+function setupContractMismatchReason(node) {
+  try {
+    validateSetupShape(node);
+    return null;
+  } catch (error) {
+    if (error instanceof CodexDispatchError) return error.message;
+    throw error;
+  }
+}
+function prepareSetup(input) {
+  const ir = typeof input.ir === "string" ? parseIr(input.ir) : input.ir;
+  if (ir.warble_ir_version !== SUPPORTED_IR_VERSION) {
+    throw new CodexDispatchError(
+      `unsupported warble_ir_version '${ir.warble_ir_version}' (supported: ${SUPPORTED_IR_VERSION})`
+    );
+  }
+  const node = ir.components.find((candidate) => candidate.id === input.component);
+  if (!node) {
+    throw new CodexDispatchError(`component '${input.component}' was not found in profile '${ir.profile}'`);
+  }
+  assertDispatchableComponentIdentity(node);
+  const domainCapability = validateSetupShape(node);
+  const componentId = node.id;
+  if (!/^[A-Za-z0-9_-]+$/.test(input.mcp.name)) {
+    throw new CodexDispatchError(
+      `MCP server name '${input.mcp.name}' must contain only letters, digits, '_' or '-'`
+    );
+  }
+  if (!isAbsolute4(input.mcp.command)) {
+    throw new CodexDispatchError(
+      `MCP server command must be absolute when shell_environment_policy.inherit=none`
+    );
+  }
+  const enabledTools = unique3(input.mcp.toolsByCapability[domainCapability]);
+  if (enabledTools.length === 0) {
+    throw new CodexDispatchError(
+      `component '${componentId}' has no allowlisted MCP tools for '${domainCapability}'`
+    );
+  }
+  const topology = validateStepTopology(node);
+  const steps = node.llm_calls.map((call, index) => ({
+    name: call.name,
+    tier: call.tier,
+    model: resolveStepModel(input.model, call.tier, componentId),
+    prompt: call.prompt,
+    consumes: call.consumes,
+    produces: call.produces,
+    when: topology[index].when
+  }));
+  return {
+    target: TARGET,
+    profile: ir.profile,
+    node,
+    componentId,
+    domainCapability,
+    steps,
+    capabilities: resolveCapabilities(node.required_capabilities, input.mcp.name),
+    enabledTools,
+    mcp: input.mcp
+  };
+}
+function prepareAllSetup(raw, config) {
+  const ir = parseIr(raw);
+  for (const node of ir.components) assertDispatchableComponentIdentity(node);
+  return ir.components.map(
+    (node) => prepareSetup({ ...config, ir, component: node.id })
+  );
+}
+
+// src/dispatch_contract.ts
+function selectedComponent(ir, component) {
+  const node = ir.components.find((candidate) => candidate.id === component);
+  if (!node) {
+    throw new CodexDispatchError(`component '${component}' was not found in profile '${ir.profile}'`);
+  }
+  return node;
+}
+function classifyDispatchContract(ir, component) {
+  const node = selectedComponent(ir, component);
+  assertDispatchableComponentIdentity(node);
+  const matches = [
+    ...matchesSetupContractShape(node) ? ["setup"] : [],
+    ...matchesAskContractShape(node) ? ["ask"] : [],
+    ...matchesEnrichContractShape(node) ? ["enrich"] : []
+  ];
+  if (matches.length === 1) return matches[0];
+  if (matches.length === 0) {
+    const reasons = [
+      setupContractMismatchReason(node),
+      askContractMismatchReason(node),
+      enrichContractMismatchReason(node)
+    ].filter((reason) => reason !== null);
+    throw new CodexDispatchError(
+      `component '${node.id}' wall-hit: no supported codex:local execution contract matches its complete IR shape` + (reasons.length > 0 ? ` (${reasons.join(" | ")})` : "")
+    );
+  }
+  throw new CodexDispatchError(
+    `component '${node.id}' wall-hit: ambiguous codex:local execution contracts (${matches.join(", ")})`
+  );
+}
+function supportsSetupAggregate(ir) {
+  for (const node of ir.components) assertDispatchableComponentIdentity(node);
+  return ir.components.length > 0 && ir.components.every(matchesSetupContractShape);
+}
+
+// src/manifest.ts
+var SESSION_LIFECYCLE_OPERATIONS = [
+  "start",
+  "resume",
+  "read",
+  "turn",
+  "steer",
+  "interrupt",
+  "fork"
+];
+function buildAskAgentManifest(prepared) {
+  const toolAgents = /* @__PURE__ */ new Map();
+  for (const step of prepared.steps) {
+    for (const tool of step.enabledTools) {
+      const agents = toolAgents.get(tool) ?? [];
+      if (!agents.includes(step.role)) agents.push(step.role);
+      toolAgents.set(tool, agents);
+    }
+  }
+  const dashboard = prepared.executionKind === "generate_dashboard";
+  return {
+    id: prepared.node.id,
+    verb: prepared.node.verb,
+    component_type: prepared.node.type,
+    realization_kind: prepared.node.realization_kind,
+    trigger: prepared.node.trigger.kind,
+    outcome: prepared.node.effect.outcome.kind,
+    steps: prepared.steps.map((step) => ({
+      name: step.name,
+      tier: step.tier,
+      model: step.model,
+      consumes: [...step.consumes],
+      produces: step.produces,
+      agent_role: step.role,
+      conditional: step.conditional,
+      when: step.when,
+      tools: [...step.enabledTools]
+    })),
+    capabilities: prepared.capabilities,
+    tools: [...toolAgents].map(([name, agents]) => ({
+      name,
+      source: `mcp:${prepared.mcp.name}`,
+      agents
+    })),
+    guardrails: {
+      read_only_execution: { enforcement: "per_agent_mcp_only_read_only_sandbox", locked: true },
+      ...dashboard ? {
+        artifact_write: {
+          enforcement: "consumer_persisted_render_envelope",
+          locked: true,
+          scope: "."
+        },
+        render_contract: {
+          enforcement: "validated_ir_declared_render_envelope",
+          on_failure: "degrade"
+        }
+      } : {
+        deterministic_gate: {
+          enforcement: "child_result_envelope_and_event_attribution",
+          locked: true
+        },
+        row_limit: { threshold: 1e3 },
+        statement_timeout: { threshold: 30 }
+      },
+      ordered_delegation: {
+        enforcement: "named_child_threads_in_ir_order",
+        flattening: "forbidden"
+      },
+      ...dashboard ? {} : {
+        conditional_repair: {
+          guard: prepared.steps[2].when,
+          max_attempts: prepared.maxRepairAttempts,
+          exhaustion: "loud_fail"
+        }
+      },
+      isolated_codex_config: {
+        parent_tools: "multi_agent_only",
+        child_tools: "per_step_exact_mcp_allowlist",
+        approval_policy: "never",
+        sandbox: "read-only",
+        api_key_environment: "removed"
+      }
+    },
+    ...dashboard ? {
+      artifact_output: {
+        kind: "render_envelope",
+        persistence: "consumer",
+        block_types: prepared.node.effect.render_blocks.map(
+          (block) => typeof block === "object" && block !== null && "type" in block ? String(block.type) : "unknown"
+        )
+      }
+    } : {}
+  };
+}
+function buildAskManifest(prepared) {
+  return {
+    manifest_version: "0.1",
+    compat: {
+      min_ir_version: SUPPORTED_IR_VERSION,
+      max_ir_version: SUPPORTED_IR_VERSION
+    },
+    profile: prepared.profile,
+    target: TARGET,
+    session: {
+      persistence: "codex_thread_history",
+      lifecycle_operations: [...SESSION_LIFECYCLE_OPERATIONS],
+      artifact_reference: prepared.executionKind === "generate_dashboard" ? "allowlisted_mcp_tool_result_or_render_envelope" : "allowlisted_mcp_tool_result",
+      isolation: "dedicated_persistent_codex_home",
+      authentication: "externally_provisioned"
+    },
+    agents: [buildAskAgentManifest(prepared)]
+  };
+}
+function describeAskTarget(prepared) {
+  return {
+    target: TARGET,
+    phase: prepared.executionKind === "generate_dashboard" ? "setup-ask-and-dashboard-parity" : "setup-and-ask-parity",
+    execution_modes: ["persistent_session"],
+    session_persistence: "codex_thread_history",
+    lifecycle_operations: [...SESSION_LIFECYCLE_OPERATIONS],
+    supported_components: [prepared.componentId],
+    tiers: [...new Set(prepared.steps.map((step) => step.tier))],
+    capabilities: prepared.capabilities.map((entry) => entry.capability),
+    tools: [...new Set(prepared.steps.flatMap((step) => step.enabledTools))],
+    guardrails: prepared.executionKind === "generate_dashboard" ? [
+      "read_only_execution",
+      "artifact_write",
+      "render_contract",
+      "ordered_delegation",
+      "isolated_codex_config"
+    ] : [
+      "read_only_execution",
+      "deterministic_gate",
+      "row_limit",
+      "statement_timeout",
+      "ordered_delegation",
+      "conditional_repair",
+      "isolated_codex_config"
+    ]
+  };
+}
+function buildAgentManifest(prepared) {
+  return {
+    id: prepared.node.id,
+    verb: prepared.node.verb,
+    component_type: prepared.node.type,
+    realization_kind: prepared.node.realization_kind,
+    trigger: prepared.node.trigger.kind,
+    outcome: prepared.node.effect.outcome.kind,
+    steps: prepared.steps.map((step) => ({
+      name: step.name,
+      tier: step.tier,
+      model: step.model,
+      consumes: step.consumes,
+      produces: step.produces
+    })),
+    capabilities: prepared.capabilities,
+    tools: prepared.enabledTools.map((name) => ({
+      name,
+      source: `mcp:${prepared.mcp.name}`
+    })),
+    guardrails: {
+      setup_execution: {
+        enforcement: "mcp_only_read_only_sandbox",
+        locked: true,
+        scope: "."
+      },
+      isolated_codex_config: {
+        ignore_user_config: true,
+        ephemeral: true,
+        approval_policy: "never",
+        sandbox: "read-only",
+        api_key_environment: "removed"
+      }
+    }
+  };
+}
+function buildManifest(prepared) {
+  const first = prepared[0];
+  if (!first) {
+    throw new Error("cannot build a manifest without prepared components");
+  }
+  return {
+    manifest_version: "0.1",
+    compat: {
+      min_ir_version: SUPPORTED_IR_VERSION,
+      max_ir_version: SUPPORTED_IR_VERSION
+    },
+    profile: first.profile,
+    target: TARGET,
+    session: {
+      persistence: "codex_thread_history",
+      lifecycle_operations: [...SESSION_LIFECYCLE_OPERATIONS],
+      artifact_reference: "allowlisted_mcp_tool_result",
+      isolation: "dedicated_persistent_codex_home",
+      authentication: "externally_provisioned"
+    },
+    agents: prepared.map(buildAgentManifest)
+  };
+}
+function describeTarget(prepared) {
+  return {
+    target: TARGET,
+    phase: "setup-only",
+    execution_modes: ["one_shot", "persistent_session"],
+    session_persistence: "codex_thread_history",
+    lifecycle_operations: [...SESSION_LIFECYCLE_OPERATIONS],
+    supported_components: prepared.map((component) => component.componentId),
+    tiers: [...new Set(prepared.flatMap((component) => component.steps.map((step) => step.tier)))],
+    capabilities: [
+      ...new Set(prepared.flatMap((component) => component.capabilities.map((entry) => entry.capability)))
+    ],
+    tools: [...new Set(prepared.flatMap((component) => component.enabledTools))],
+    guardrails: ["setup_execution", "isolated_codex_config"]
+  };
+}
+function buildEnrichAgentManifest(prepared) {
+  return {
+    id: prepared.node.id,
+    verb: prepared.node.verb,
+    component_type: prepared.node.type,
+    realization_kind: prepared.node.realization_kind,
+    trigger: prepared.node.trigger.kind,
+    outcome: prepared.node.effect.outcome.kind,
+    steps: prepared.steps.map((step) => ({
+      name: step.name,
+      tier: step.tier,
+      model: step.model,
+      consumes: step.consumes,
+      produces: step.produces
+    })),
+    capabilities: prepared.capabilities,
+    tools: prepared.enabledTools.map((name) => ({
+      name,
+      source: `mcp:${prepared.mcp.name}`
+    })),
+    guardrails: {
+      read_only_execution: {
+        enforcement: "mcp_only_read_only_sandbox",
+        locked: true
+      },
+      isolated_codex_config: {
+        ignore_user_config: true,
+        ephemeral: true,
+        approval_policy: "never",
+        sandbox: "read-only",
+        api_key_environment: "removed"
+      }
+    }
+  };
+}
+function buildEnrichManifest(prepared) {
+  return {
+    manifest_version: "0.1",
+    compat: {
+      min_ir_version: SUPPORTED_IR_VERSION,
+      max_ir_version: SUPPORTED_IR_VERSION
+    },
+    profile: prepared.profile,
+    target: TARGET,
+    session: {
+      persistence: "codex_thread_history",
+      lifecycle_operations: [...SESSION_LIFECYCLE_OPERATIONS],
+      artifact_reference: "allowlisted_mcp_tool_result",
+      isolation: "dedicated_persistent_codex_home",
+      authentication: "externally_provisioned"
+    },
+    agents: [buildEnrichAgentManifest(prepared)]
+  };
+}
+function describeEnrichTarget(prepared) {
+  return {
+    target: TARGET,
+    phase: "enrich-parity",
+    execution_modes: ["one_shot", "persistent_session"],
+    session_persistence: "codex_thread_history",
+    lifecycle_operations: [...SESSION_LIFECYCLE_OPERATIONS],
+    supported_components: [prepared.componentId],
+    tiers: [...new Set(prepared.steps.map((step) => step.tier))],
+    capabilities: prepared.capabilities.map((entry) => entry.capability),
+    tools: [...prepared.enabledTools],
+    guardrails: ["read_only_execution", "isolated_codex_config"]
+  };
+}
+
+// src/model_catalog.ts
+import { resolve as resolve2 } from "path";
+var MODEL_CATALOG_VERSION = 1;
+var PAGE_LIMIT = 100;
+var MAX_PAGES = 100;
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function unavailable(code, retryable) {
+  return { version: MODEL_CATALOG_VERSION, status: "unavailable", provider: "codex", code, retryable };
+}
+function classify(error) {
+  const message = error instanceof Error ? error.message.toLowerCase() : "";
+  if (message.includes("timed out")) return unavailable("timeout", true);
+  if (/(not authenticated|unauthenticated|authentication|login required|sign in)/.test(message)) {
+    return unavailable("not_authenticated", false);
+  }
+  if (/(enoent|failed to start|not found|transport is not available|disconnected)/.test(message)) {
+    return unavailable("runtime_unavailable", true);
+  }
+  return unavailable("protocol_error", false);
+}
+function text(record2, field, required = false) {
+  const value = record2[field];
+  if (value === void 0 && !required) return void 0;
+  if (typeof value !== "string") throw new Error("malformed model catalog response");
+  return value;
+}
+function mapModel(raw) {
+  if (!isRecord5(raw)) throw new Error("malformed model catalog response");
+  if (raw["hidden"] === true) return null;
+  const model = text(raw, "model", true);
+  const displayName = text(raw, "displayName", true);
+  const description = text(raw, "description");
+  const isDefault = raw["isDefault"];
+  if (isDefault !== void 0 && typeof isDefault !== "boolean") {
+    throw new Error("malformed model catalog response");
+  }
+  const effortsRaw = raw["supportedReasoningEfforts"];
+  let reasoningEfforts;
+  if (effortsRaw !== void 0) {
+    if (!Array.isArray(effortsRaw)) throw new Error("malformed model catalog response");
+    reasoningEfforts = effortsRaw.map((effort) => {
+      if (!isRecord5(effort)) throw new Error("malformed model catalog response");
+      const value = text(effort, "reasoningEffort", true);
+      const effortDescription = text(effort, "description");
+      return {
+        value,
+        // The app-server protocol exposes an effort value, not a separate label.
+        displayName: value,
+        ...effortDescription === void 0 ? {} : { description: effortDescription }
+      };
+    });
+  }
+  return {
+    model,
+    displayName,
+    ...description === void 0 ? {} : { description },
+    ...isDefault === void 0 ? {} : { isDefault },
+    ...reasoningEfforts === void 0 ? {} : { reasoningEfforts }
+  };
+}
+function pageResponse(value) {
+  if (!isRecord5(value) || !Array.isArray(value["data"])) {
+    throw new Error("malformed model catalog response");
+  }
+  const nextCursor = value["nextCursor"];
+  if (nextCursor !== null && nextCursor !== void 0 && typeof nextCursor !== "string") {
+    throw new Error("malformed model catalog response");
+  }
+  return { data: value["data"], nextCursor: nextCursor ?? null };
+}
+async function discoverCodexModels(options = {}) {
+  const timeoutMs = options.timeoutMs ?? 1e4;
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) return unavailable("protocol_error", false);
+  let transport;
+  let timeout;
+  try {
+    const transportOptions = {
+      cwd: resolve2(options.cwd ?? process.cwd()),
+      timeoutMs,
+      ...options.codexHome ? { codexHome: resolve2(options.codexHome) } : {},
+      ...options.codexBin ? { codexBin: resolve2(options.codexBin) } : {},
+      ...options.env ? { env: options.env } : {}
+    };
+    const deadline = new Promise((_, reject) => {
+      timeout = setTimeout(() => {
+        void transport?.close();
+        reject(new Error("model catalog timed out"));
+      }, timeoutMs);
+    });
+    const list = (async () => {
+      transport = await CodexAppServerTransport.startCatalog(transportOptions);
+      const models = [];
+      let cursor = null;
+      for (let page = 0; page < MAX_PAGES; page += 1) {
+        const response = pageResponse(await transport.request("model/list", {
+          cursor,
+          limit: PAGE_LIMIT,
+          includeHidden: false
+        }));
+        for (const raw of response.data) {
+          const model = mapModel(raw);
+          if (model !== null) models.push(model);
+        }
+        if (response.nextCursor === null) {
+          return { version: MODEL_CATALOG_VERSION, status: "ready", provider: "codex", models };
+        }
+        cursor = response.nextCursor;
+      }
+      throw new Error("model catalog pagination limit exceeded");
+    })();
+    return await Promise.race([list, deadline]);
+  } catch (error) {
+    return classify(error);
+  } finally {
+    if (timeout !== void 0) clearTimeout(timeout);
+    await transport?.close();
+  }
+}
+
+// src/session.ts
+var FORBIDDEN_ITEM_TYPES = /* @__PURE__ */ new Set([
+  "commandExecution",
+  "fileChange",
+  "webSearch",
+  "imageGeneration",
+  "collabAgentToolCall",
+  "subAgentActivity",
+  "dynamicToolCall",
+  "imageView",
+  "sleep",
+  "enteredReviewMode",
+  "exitedReviewMode"
+]);
+var PASSIVE_ITEM_TYPES = /* @__PURE__ */ new Set([
+  "userMessage",
+  "agentMessage",
+  "reasoning",
+  "plan",
+  "compacted",
+  "contextCompaction"
+]);
+var IGNORED_NOTIFICATIONS2 = /* @__PURE__ */ new Set([
+  "skills/changed",
+  "thread/name/updated",
+  "thread/goal/updated",
+  "thread/goal/cleared",
+  "thread/settings/updated",
+  "thread/status/changed",
+  "thread/tokenUsage/updated",
+  "thread/compacted",
+  "turn/diff/updated",
+  "turn/plan/updated",
+  "item/agentMessage/delta",
+  "item/plan/delta",
+  "item/mcpToolCall/progress",
+  "item/reasoning/summaryTextDelta",
+  "item/reasoning/summaryPartAdded",
+  "item/reasoning/textDelta",
+  "mcpServer/startupStatus/updated",
+  "account/updated",
+  "account/rateLimits/updated",
+  "app/list/updated",
+  "remoteControl/status/changed",
+  "fs/changed",
+  "model/rerouted",
+  "model/verification",
+  "model/safetyBuffering/updated",
+  "turn/moderationMetadata",
+  "warning",
+  "guardianWarning",
+  "deprecationNotice"
+]);
+function isRecord6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requiredRecord(value, context) {
+  if (!isRecord6(value)) throw new CodexDispatchError(`${context} requires an object`);
+  return value;
+}
+function requiredString(record2, key, context) {
+  const value = record2[key];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new CodexDispatchError(`${context} requires string ${key}`);
+  }
+  return value;
+}
+function sessionReference2(thread) {
+  return {
+    version: SESSION_REFERENCE_VERSION,
+    target: "codex:local",
+    threadId: requiredString(thread, "id", "thread"),
+    forkedFromThreadId: typeof thread["forkedFromId"] === "string" ? thread["forkedFromId"] : null
+  };
+}
+function turnStatus2(value) {
+  switch (value) {
+    case "inProgress":
+      return "in_progress";
+    case "completed":
+    case "interrupted":
+    case "failed":
+      return value;
+    default:
+      throw new CodexDispatchError("turn requires a recognized status");
+  }
+}
+function turnReference2(threadId, turn) {
+  return {
+    threadId,
+    turnId: requiredString(turn, "id", "turn"),
+    status: turnStatus2(turn["status"])
+  };
+}
+function validateReference2(reference) {
+  if (reference.version !== SESSION_REFERENCE_VERSION || reference.target !== "codex:local" || reference.threadId.length === 0) {
+    throw new CodexDispatchError("invalid codex session reference");
+  }
+}
+var CodexSessionRuntime = class _CodexSessionRuntime {
+  constructor(prepared, options) {
+    this.prepared = prepared;
+    this.options = options;
+  }
+  prepared;
+  options;
+  transport;
+  session = null;
+  activeTurns = /* @__PURE__ */ new Map();
+  waiters = /* @__PURE__ */ new Map();
+  stepNameByTurn = /* @__PURE__ */ new Map();
+  disconnected = false;
+  /**
+   * The model bound to this persistent thread for its whole lifetime. `thread/start` takes a
+   * single `model` with no per-turn override, so unlike Setup's one-shot-process-per-step
+   * transport, every step dispatched through one session must resolve to the same model — see
+   * `enrich_prepare.ts`'s single-tier-per-component requirement, which is what makes this true by
+   * construction rather than by convention.
+   */
+  get model() {
+    return this.prepared.steps[0].model;
+  }
+  static async connect(prepared, options) {
+    if (prepared.steps.length === 0) {
+      throw new CodexDispatchError("cannot connect a session runtime without at least one prepared step");
+    }
+    const sessionModel = prepared.steps[0].model;
+    for (const step of prepared.steps) {
+      if (step.model !== sessionModel) {
+        throw new CodexDispatchError(
+          `this transport's persistent session is bound to one model per thread; step '${step.name}' requires a different model than the session's first step`
+        );
+      }
+    }
+    const runtime = new _CodexSessionRuntime(prepared, options);
+    runtime.transport = await CodexAppServerTransport.start(
+      prepared,
+      options,
+      (method, params) => runtime.onNotification(method, params),
+      (error) => runtime.onDisconnect(error)
+    );
+    return runtime;
+  }
+  async start() {
+    this.ensureConnected();
+    if (this.session !== null) {
+      throw new CodexDispatchError("a session is already loaded; use a new runtime to start another");
+    }
+    const result = requiredRecord(
+      await this.transport.request("thread/start", {
+        model: this.model,
+        cwd: this.options.cwd,
+        approvalPolicy: "never",
+        sandbox: "read-only",
+        config: buildIsolationConfig(this.prepared),
+        ephemeral: false,
+        historyMode: "legacy",
+        environments: [],
+        runtimeWorkspaceRoots: [],
+        selectedCapabilityRoots: [],
+        dynamicTools: [],
+        experimentalRawEvents: false
+      }),
+      "thread/start response"
+    );
+    const reference = sessionReference2(requiredRecord(result["thread"], "thread/start thread"));
+    this.session = reference;
+    this.emit({ t: "session_started", session: reference });
+    return reference;
+  }
+  async resume(reference) {
+    validateReference2(reference);
+    this.ensureConnected();
+    this.requireNoActiveTurns("resume");
+    if (this.session !== null && this.session.threadId !== reference.threadId) {
+      throw new CodexDispatchError(
+        "a different session is already loaded; use a new runtime to resume another"
+      );
+    }
+    const result = requiredRecord(
+      await this.transport.request("thread/resume", {
+        threadId: reference.threadId,
+        model: this.model,
+        cwd: this.options.cwd,
+        approvalPolicy: "never",
+        sandbox: "read-only",
+        config: buildIsolationConfig(this.prepared),
+        runtimeWorkspaceRoots: []
+      }),
+      "thread/resume response"
+    );
+    const resumed = sessionReference2(requiredRecord(result["thread"], "thread/resume thread"));
+    if (resumed.threadId !== reference.threadId) {
+      throw new CodexDispatchError("thread/resume returned a different thread id");
+    }
+    this.session = resumed;
+    this.emit({ t: "session_resumed", session: resumed });
+    return resumed;
+  }
+  async read(reference) {
+    validateReference2(reference);
+    this.ensureConnected();
+    const result = requiredRecord(
+      await this.transport.request("thread/read", { threadId: reference.threadId, includeTurns: true }),
+      "thread/read response"
+    );
+    const thread = requiredRecord(result["thread"], "thread/read thread");
+    const readReference = sessionReference2(thread);
+    if (readReference.threadId !== reference.threadId) {
+      throw new CodexDispatchError("thread/read returned a different thread id");
+    }
+    const turns = Array.isArray(thread["turns"]) ? thread["turns"].map((turn) => this.projectHistoryTurn(reference.threadId, turn)) : [];
+    return { session: readReference, turns };
+  }
+  /**
+   * `step`/`inputs` default to this component's first (and, for every existing single-step
+   * fixture, only) step with no marshalled inputs — so every pre-existing caller that never named
+   * a step keeps building the exact same prompt as before. A multi-step caller (the n-step Enrich
+   * executor) passes the step actually being dispatched this turn, plus that step's marshalled
+   * `consumes` values, and this records which step owns the resulting turn id so the
+   * `step_start`/`step_finish` events this turn emits are attributed correctly rather than always
+   * naming the component's first step.
+   */
+  async turn(reference, input, step = this.prepared.steps[0], inputs = {}) {
+    this.requireCurrent(reference);
+    if (input.length === 0) throw new CodexDispatchError("turn input must not be empty");
+    const result = requiredRecord(
+      await this.transport.request("turn/start", {
+        threadId: reference.threadId,
+        input: [
+          { type: "text", text: buildPrompt(this.prepared, step, input, inputs), text_elements: [] }
+        ],
+        approvalPolicy: "never",
+        environments: [],
+        runtimeWorkspaceRoots: []
+      }),
+      "turn/start response"
+    );
+    const turn = turnReference2(reference.threadId, requiredRecord(result["turn"], "turn/start turn"));
+    if (turn.status !== "in_progress") {
+      throw new CodexDispatchError("turn/start did not return an in-progress turn");
+    }
+    this.ensureActiveTurn(turn.turnId);
+    this.stepNameByTurn.set(turn.turnId, step.name);
+    return turn;
+  }
+  async steer(reference, turnId, input) {
+    this.requireCurrent(reference);
+    const result = requiredRecord(
+      await this.transport.request("turn/steer", {
+        threadId: reference.threadId,
+        expectedTurnId: turnId,
+        input: [{ type: "text", text: input, text_elements: [] }]
+      }),
+      "turn/steer response"
+    );
+    if (requiredString(result, "turnId", "turn/steer response") !== turnId) {
+      throw new CodexDispatchError("turn/steer returned a different turn id");
+    }
+    return { threadId: reference.threadId, turnId, status: "in_progress" };
+  }
+  async interrupt(reference, turnId) {
+    this.requireCurrent(reference);
+    await this.transport.request("turn/interrupt", { threadId: reference.threadId, turnId });
+  }
+  async fork(reference, lastTurnId) {
+    validateReference2(reference);
+    this.ensureConnected();
+    this.requireNoActiveTurns("fork");
+    const result = requiredRecord(
+      await this.transport.request("thread/fork", {
+        threadId: reference.threadId,
+        ...lastTurnId === void 0 ? {} : { lastTurnId },
+        model: this.model,
+        cwd: this.options.cwd,
+        approvalPolicy: "never",
+        sandbox: "read-only",
+        config: buildIsolationConfig(this.prepared),
+        ephemeral: false,
+        runtimeWorkspaceRoots: []
+      }),
+      "thread/fork response"
+    );
+    const forked = sessionReference2(requiredRecord(result["thread"], "thread/fork thread"));
+    if (forked.threadId === reference.threadId || forked.forkedFromThreadId !== reference.threadId) {
+      throw new CodexDispatchError("thread/fork returned an invalid lineage");
+    }
+    this.emit({ t: "session_forked", session: forked });
+    return forked;
+  }
+  waitForTurn(turn, timeoutMs = this.options.timeoutMs ?? 12e4) {
+    if (turn.status !== "in_progress") return Promise.resolve(turn);
+    if (this.disconnected || !this.activeTurns.has(turn.turnId)) {
+      return Promise.reject(new CodexDispatchError("turn is no longer active; resume required"));
+    }
+    return new Promise((resolveWaiter, rejectWaiter) => {
+      const timer = setTimeout(() => {
+        this.removeWaiter(turn.turnId, waiter);
+        const error = new CodexDispatchError(`turn '${turn.turnId}' timed out`);
+        void (async () => {
+          try {
+            await this.interrupt(
+              { version: SESSION_REFERENCE_VERSION, target: "codex:local", threadId: turn.threadId, forkedFromThreadId: null },
+              turn.turnId
+            );
+          } catch {
+          }
+          this.onDisconnect(error, "turn_timeout");
+          await this.transport.close();
+          rejectWaiter(error);
+        })();
+      }, timeoutMs);
+      const waiter = { resolve: resolveWaiter, reject: rejectWaiter, timer };
+      const list = this.waiters.get(turn.turnId) ?? [];
+      list.push(waiter);
+      this.waiters.set(turn.turnId, list);
+    });
+  }
+  async restartAndResume(reference) {
+    if (!this.disconnected && this.activeTurns.size > 0) {
+      throw new CodexDispatchError("cannot restart while a turn is active; interrupt it first");
+    }
+    await this.transport.close();
+    const transport = await CodexAppServerTransport.start(
+      this.prepared,
+      this.options,
+      (method, params) => this.onNotification(method, params),
+      (error) => this.onDisconnect(error)
+    );
+    this.transport = transport;
+    this.disconnected = false;
+    try {
+      return await this.resume(reference);
+    } catch (error) {
+      this.disconnected = true;
+      await this.transport.close();
+      throw error;
+    }
+  }
+  async close() {
+    this.disconnected = true;
+    const error = new CodexDispatchError("session runtime closed during an active turn");
+    for (const [turnId] of this.activeTurns) {
+      this.settleWaiters(
+        { threadId: this.session?.threadId ?? "unknown", turnId, status: "failed" },
+        error
+      );
+    }
+    this.activeTurns.clear();
+    this.stepNameByTurn.clear();
+    await this.transport.close();
+  }
+  onNotification(method, paramsValue) {
+    const params = requiredRecord(paramsValue, `${method} notification`);
+    if (method === "thread/started" || IGNORED_NOTIFICATIONS2.has(method)) return;
+    if (method === "error") {
+      const threadId = requiredString(params, "threadId", method);
+      this.requireNotificationThread(threadId);
+      const turnId = requiredString(params, "turnId", method);
+      requiredRecord(params["error"], "error notification error");
+      const active = this.activeTurns.get(turnId);
+      if (!active?.started) {
+        throw new CodexDispatchError("app-server error notification has no active turn");
+      }
+      if (params["willRetry"] === true) return;
+      if (params["willRetry"] !== false) {
+        throw new CodexDispatchError("app-server error notification requires willRetry");
+      }
+      throw new CodexDispatchError("app-server reported a terminal turn error");
+    }
+    if (method === "turn/started") {
+      const threadId = requiredString(params, "threadId", method);
+      this.requireNotificationThread(threadId);
+      const turn = turnReference2(threadId, requiredRecord(params["turn"], `${method} turn`));
+      const active = this.ensureActiveTurn(turn.turnId);
+      if (active.started) throw new CodexDispatchError("duplicate turn start notification");
+      active.started = true;
+      this.emit({ t: "turn_started", turn });
+      const stepName = this.stepNameByTurn.get(turn.turnId) ?? this.prepared.steps[0].name;
+      this.emit({ threadId, turnId: turn.turnId, t: "step_start", id: stepName, name: stepName });
+      return;
+    }
+    if (method === "item/started" || method === "item/completed") {
+      this.onItem(method, params);
+      return;
+    }
+    if (method === "turn/completed") {
+      this.onTurnCompleted(params);
+      return;
+    }
+    throw new CodexDispatchError(`unsupported app-server notification '${method}'`);
+  }
+  onItem(method, params) {
+    const threadId = requiredString(params, "threadId", method);
+    this.requireNotificationThread(threadId);
+    const turnId = requiredString(params, "turnId", method);
+    const item = requiredRecord(params["item"], `${method} item`);
+    const type = requiredString(item, "type", `${method} item`);
+    if (FORBIDDEN_ITEM_TYPES.has(type)) {
+      throw new CodexDispatchError(`isolation violation: app-server emitted forbidden '${type}'`);
+    }
+    const active = this.ensureActiveTurn(turnId);
+    if (!active.started) throw new CodexDispatchError("item emitted before turn started");
+    if (type === "mcpToolCall") {
+      const itemId = requiredString(item, "id", type);
+      const server = requiredString(item, "server", type);
+      const tool = requiredString(item, "tool", type);
+      if (server !== this.prepared.mcp.name || !this.prepared.enabledTools.includes(tool)) {
+        throw new CodexDispatchError(`isolation violation: non-allowlisted MCP tool '${server}.${tool}'`);
+      }
+      if (method === "item/started") {
+        if (item["status"] !== "inProgress") {
+          throw new CodexDispatchError("MCP item start requires in-progress status");
+        }
+        if (active.pendingTools.has(itemId)) throw new CodexDispatchError("duplicate MCP item start");
+        active.pendingTools.add(itemId);
+        this.emit({ threadId, turnId, t: "tool_call", id: itemId, name: `${server}.${tool}` });
+        return;
+      }
+      if (!active.pendingTools.delete(itemId)) throw new CodexDispatchError("MCP item completed without start");
+      const status = requiredString(item, "status", type);
+      if (status !== "completed" && status !== "failed") {
+        throw new CodexDispatchError("MCP item completed with an invalid status");
+      }
+      const ok = status === "completed" && (item["error"] === null || item["error"] === void 0);
+      if (ok) active.successfulTools += 1;
+      const reference = {
+        version: SESSION_REFERENCE_VERSION,
+        kind: "mcp_tool_result",
+        threadId,
+        turnId,
+        itemId,
+        server,
+        tool,
+        ok
+      };
+      this.emit({ t: "artifact", reference });
+      this.emit({ threadId, turnId, t: "tool_result", id: itemId, ok, ...ok ? {} : { error: "allowlisted MCP tool failed" } });
+      return;
+    }
+    if (!PASSIVE_ITEM_TYPES.has(type)) {
+      throw new CodexDispatchError(`unsupported app-server item type '${type}'`);
+    }
+    if (method === "item/completed" && type === "agentMessage") {
+      const text2 = requiredString(item, "text", type);
+      active.hasAnswer = true;
+      this.emit({ threadId, turnId, t: "answer", text: text2 });
+    }
+  }
+  onTurnCompleted(params) {
+    const threadId = requiredString(params, "threadId", "turn/completed");
+    this.requireNotificationThread(threadId);
+    const turn = turnReference2(threadId, requiredRecord(params["turn"], "turn/completed turn"));
+    const active = this.activeTurns.get(turn.turnId);
+    if (!active) throw new CodexDispatchError("turn completed without starting");
+    if (!active.started) throw new CodexDispatchError("turn completed before start notification");
+    if (active.pendingTools.size > 0) throw new CodexDispatchError("turn completed with pending MCP tools");
+    if (turn.status === "completed" && (active.successfulTools === 0 || !active.hasAnswer)) {
+      throw new CodexDispatchError("completed turn lacks a successful allowlisted tool or answer");
+    }
+    this.activeTurns.delete(turn.turnId);
+    const ok = turn.status === "completed";
+    const stepName = this.stepNameByTurn.get(turn.turnId) ?? this.prepared.steps[0].name;
+    this.stepNameByTurn.delete(turn.turnId);
+    this.emit({ threadId, turnId: turn.turnId, t: "step_finish", id: stepName, ok });
+    this.emit({ t: "turn_completed", turn });
+    const error = turn.status === "failed" ? new CodexDispatchError(`turn '${turn.turnId}' failed`) : null;
+    this.settleWaiters(turn, error);
+  }
+  projectHistoryTurn(threadId, value) {
+    const turn = requiredRecord(value, "history turn");
+    const reference = turnReference2(threadId, turn);
+    const items = [];
+    if (Array.isArray(turn["items"])) {
+      for (const itemValue of turn["items"]) {
+        const item = requiredRecord(itemValue, "history item");
+        const type = requiredString(item, "type", "history item");
+        if (type === "agentMessage") {
+          items.push({ type: "assistant", itemId: requiredString(item, "id", type) });
+        } else if (type === "userMessage") {
+          items.push({ type: "user", itemId: requiredString(item, "id", type) });
+        } else if (type === "mcpToolCall") {
+          const server = requiredString(item, "server", type);
+          const tool = requiredString(item, "tool", type);
+          if (server !== this.prepared.mcp.name || !this.prepared.enabledTools.includes(tool)) {
+            throw new CodexDispatchError("history contains a non-allowlisted MCP tool");
+          }
+          const status = requiredString(item, "status", type);
+          if (status !== "completed" && status !== "failed") {
+            throw new CodexDispatchError("history MCP item has an invalid status");
+          }
+          items.push({
+            type: "artifact",
+            reference: {
+              version: SESSION_REFERENCE_VERSION,
+              kind: "mcp_tool_result",
+              threadId,
+              turnId: reference.turnId,
+              itemId: requiredString(item, "id", type),
+              server,
+              tool,
+              ok: status === "completed" && (item["error"] === null || item["error"] === void 0)
+            }
+          });
+        } else if (FORBIDDEN_ITEM_TYPES.has(type)) {
+          throw new CodexDispatchError(`history contains forbidden '${type}' item`);
+        } else if (!PASSIVE_ITEM_TYPES.has(type)) {
+          throw new CodexDispatchError(`history contains unsupported '${type}' item`);
+        }
+      }
+    }
+    return { id: reference.turnId, status: reference.status, items };
+  }
+  ensureActiveTurn(turnId) {
+    let active = this.activeTurns.get(turnId);
+    if (!active) {
+      active = { started: false, pendingTools: /* @__PURE__ */ new Set(), successfulTools: 0, hasAnswer: false };
+      this.activeTurns.set(turnId, active);
+    }
+    return active;
+  }
+  requireCurrent(reference) {
+    validateReference2(reference);
+    this.ensureConnected();
+    if (this.session?.threadId !== reference.threadId) {
+      throw new CodexDispatchError("session reference is not loaded; resume it first");
+    }
+  }
+  requireNotificationThread(threadId) {
+    if (this.session?.threadId !== threadId) {
+      throw new CodexDispatchError("app-server notification belongs to a different thread");
+    }
+  }
+  requireNoActiveTurns(operation) {
+    if (this.activeTurns.size > 0) {
+      throw new CodexDispatchError(
+        `cannot ${operation} while a turn is active; interrupt it first`
+      );
+    }
+  }
+  ensureConnected() {
+    if (this.disconnected) throw new CodexDispatchError("app-server transport disconnected; resume required");
+  }
+  onDisconnect(protocolError, reasonOverride) {
+    if (this.disconnected) return;
+    this.disconnected = true;
+    if (protocolError && reasonOverride === void 0) {
+      this.emit({
+        t: "session_failed",
+        threadId: this.session?.threadId ?? null,
+        reason: "protocol_violation"
+      });
+    } else {
+      const reason = reasonOverride ?? (this.activeTurns.size > 0 ? "app_server_crash" : "transport_disconnect");
+      this.emit({ t: "session_recoverable", threadId: this.session?.threadId ?? null, reason });
+    }
+    for (const [turnId] of this.activeTurns) {
+      this.settleWaiters(
+        { threadId: this.session?.threadId ?? "unknown", turnId, status: "failed" },
+        protocolError ?? new CodexDispatchError("app-server disconnected during an active turn")
+      );
+    }
+    this.activeTurns.clear();
+    this.stepNameByTurn.clear();
+  }
+  settleWaiters(turn, error) {
+    const waiters = this.waiters.get(turn.turnId) ?? [];
+    this.waiters.delete(turn.turnId);
+    for (const waiter of waiters) {
+      clearTimeout(waiter.timer);
+      if (error) waiter.reject(error);
+      else waiter.resolve(turn);
+    }
+  }
+  removeWaiter(turnId, waiter) {
+    const remaining = (this.waiters.get(turnId) ?? []).filter((candidate) => candidate !== waiter);
+    if (remaining.length === 0) this.waiters.delete(turnId);
+    else this.waiters.set(turnId, remaining);
+  }
+  emit(event) {
+    this.options.onEvent?.(event);
+  }
+};
+
+// src/enrich_run.ts
+async function runEnrich(prepared, request, options) {
+  if (request.trim().length === 0) throw new CodexDispatchError("enrichment request must not be empty");
+  const events = [];
+  let currentAnswer = null;
+  const onEvent = (event) => {
+    events.push(event);
+    if (event.t === "answer") currentAnswer = event.text;
+    options.onEvent?.(event);
+  };
+  const runtime = await CodexSessionRuntime.connect(prepared, { ...options, onEvent });
+  try {
+    const session = await runtime.start();
+    const slots = {};
+    const outcomes = /* @__PURE__ */ new Map();
+    const steps = [];
+    let lastFinalText = null;
+    let lastValue;
+    for (const step of prepared.steps) {
+      if (!shouldRunStep(step.when, outcomes)) {
+        outcomes.set(step.name, { ran: false });
+        steps.push({ name: step.name, ran: false, ok: false });
+        continue;
+      }
+      const inputs = Object.fromEntries(step.consumes.map((name) => [name, slots[name]]));
+      currentAnswer = null;
+      const turn = await runtime.turn(session, request, step, inputs);
+      const completed = await runtime.waitForTurn(turn, options.timeoutMs ?? 12e4);
+      if (completed.status !== "completed" || currentAnswer === null) {
+        throw new CodexDispatchError(`enrichment step '${step.name}' did not complete with a terminal answer`);
+      }
+      const finalText = currentAnswer;
+      const hasGuardedConsumer = prepared.steps.some((candidate) => candidate.when?.target === step.name);
+      let record2;
+      try {
+        record2 = parseStepTerminal(finalText, step.produces);
+      } catch (error) {
+        if (hasGuardedConsumer && error instanceof CodexDispatchError) {
+          outcomes.set(step.name, { ran: true, ok: false });
+          steps.push({ name: step.name, ran: true, ok: false });
+          lastFinalText = finalText;
+          continue;
+        }
+        throw error;
+      }
+      const value = record2[step.produces];
+      slots[step.produces] = value;
+      outcomes.set(step.name, { ran: true, ok: true, value });
+      steps.push({ name: step.name, ran: true, ok: true, value });
+      lastFinalText = finalText;
+      lastValue = record2;
+    }
+    if (lastFinalText === null) {
+      throw new CodexDispatchError("enrichment dispatch completed without running any step");
+    }
+    return {
+      target: prepared.target,
+      component: prepared.componentId,
+      finalText: lastFinalText,
+      value: lastValue,
+      events,
+      steps
+    };
+  } finally {
+    await runtime.close();
+  }
+}
+
+// src/run.ts
+import { spawn as spawn2 } from "child_process";
+import { createInterface as createInterface2 } from "readline";
+
+// src/events.ts
+function isRecord7(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function itemOf(event) {
+  return isRecord7(event["item"]) ? event["item"] : null;
+}
+function itemType(item) {
+  return typeof item["type"] === "string" ? item["type"] : "";
+}
+function toolIdentity(item) {
+  const server = typeof item["server"] === "string" ? item["server"] : "";
+  const tool = typeof item["tool"] === "string" ? item["tool"] : "";
+  if (server.length === 0 || tool.length === 0) {
+    throw new CodexDispatchError("mcp_tool_call requires string server and tool fields");
+  }
+  return { server, tool, name: `${server}.${tool}` };
+}
+var FORBIDDEN_ITEM_TYPES2 = /* @__PURE__ */ new Set([
+  "command_execution",
+  "file_change",
+  "web_search",
+  "image_generation",
+  "collab_agent_tool_call"
+]);
+var CodexJsonlMapper = class {
+  constructor(stepId, expectedMcpServer, enabledTools) {
+    this.stepId = stepId;
+    this.expectedMcpServer = expectedMcpServer;
+    this.enabledTools = new Set(enabledTools);
+  }
+  stepId;
+  expectedMcpServer;
+  started = false;
+  finished = false;
+  threadStarted = false;
+  finalText = null;
+  failureDetail = null;
+  toolFailureDetail = null;
+  pendingTools = /* @__PURE__ */ new Map();
+  successfulToolCount = 0;
+  enabledTools;
+  nextLine(line) {
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch (error) {
+      throw new CodexDispatchError(`codex stdout contained non-JSONL data: ${String(error)}`);
+    }
+    if (!isRecord7(parsed) || typeof parsed["type"] !== "string") {
+      throw new CodexDispatchError("codex JSONL event requires a string type");
+    }
+    const type = parsed["type"];
+    if (this.finished) {
+      throw new CodexDispatchError(`codex emitted '${type}' after the terminal turn event`);
+    }
+    if (type === "thread.started") {
+      if (this.threadStarted || this.started) {
+        throw new CodexDispatchError("codex emitted duplicate or out-of-order thread.started");
+      }
+      this.threadStarted = true;
+      return [];
+    }
+    if (type === "turn.started") {
+      if (!this.threadStarted) {
+        throw new CodexDispatchError("codex emitted turn.started before thread.started");
+      }
+      if (this.started) throw new CodexDispatchError("codex emitted duplicate turn.started");
+      this.started = true;
+      return [{ t: "step_start", id: this.stepId, name: this.stepId }];
+    }
+    if (type === "item.started" || type === "item.completed") {
+      if (!this.started) {
+        throw new CodexDispatchError(`codex emitted ${type} before turn.started`);
+      }
+      return this.onItem(type, parsed);
+    }
+    if (type === "turn.failed" || type === "error") {
+      return this.finish(false, type === "turn.failed" ? "codex turn failed" : "codex runtime error");
+    }
+    if (type === "turn.completed") {
+      return this.finish(true);
+    }
+    return [];
+  }
+  result() {
+    if (!this.threadStarted) throw new CodexDispatchError("codex JSONL ended without thread.started");
+    if (!this.finished) throw new CodexDispatchError("codex JSONL ended without turn.completed");
+    if (this.failureDetail !== null) {
+      throw new CodexDispatchError(`codex turn failed: ${this.failureDetail}`);
+    }
+    if (this.successfulToolCount === 0) {
+      if (this.toolFailureDetail !== null) {
+        throw new CodexDispatchError(`required MCP tool failed: ${this.toolFailureDetail}`);
+      }
+      throw new CodexDispatchError("codex turn completed without a successful allowlisted MCP tool call");
+    }
+    if (this.finalText === null) throw new CodexDispatchError("codex JSONL ended without an agent message");
+    return {
+      finalText: this.finalText,
+      threadStarted: this.threadStarted,
+      turnCompleted: this.finished
+    };
+  }
+  onItem(eventType, event) {
+    const item = itemOf(event);
+    if (!item) throw new CodexDispatchError(`${eventType} requires an item object`);
+    const type = itemType(item);
+    if (FORBIDDEN_ITEM_TYPES2.has(type)) {
+      throw new CodexDispatchError(
+        `isolation violation: codex emitted forbidden '${type}' item`
+      );
+    }
+    if (type === "mcp_tool_call") {
+      const id = typeof item["id"] === "string" ? item["id"] : "";
+      if (id.length === 0) throw new CodexDispatchError("mcp_tool_call requires an id");
+      const identity = toolIdentity(item);
+      if (identity.server !== this.expectedMcpServer || !this.enabledTools.has(identity.tool)) {
+        throw new CodexDispatchError(
+          `isolation violation: codex emitted non-allowlisted MCP tool '${identity.name}'`
+        );
+      }
+      if (eventType === "item.started") {
+        if (this.pendingTools.has(id)) {
+          throw new CodexDispatchError(`mcp_tool_call '${id}' started more than once`);
+        }
+        this.pendingTools.set(id, identity.name);
+        return [
+          {
+            t: "tool_call",
+            id,
+            name: identity.name
+          }
+        ];
+      }
+      const name = this.pendingTools.get(id);
+      if (name === void 0) {
+        throw new CodexDispatchError(`mcp_tool_call '${id}' completed without starting`);
+      }
+      if (name !== identity.name) {
+        throw new CodexDispatchError(
+          `mcp_tool_call '${id}' completed as '${identity.name}' after starting as '${name}'`
+        );
+      }
+      this.pendingTools.delete(id);
+      const status = item["status"];
+      if (status !== "completed" && status !== "failed") {
+        throw new CodexDispatchError(
+          `completed mcp_tool_call '${id}' requires completed or failed status`
+        );
+      }
+      const failed = status === "failed" || item["error"] !== void 0 && item["error"] !== null;
+      if (failed) this.toolFailureDetail = name;
+      else this.successfulToolCount += 1;
+      return [
+        {
+          t: "tool_result",
+          id,
+          ok: !failed,
+          ...failed ? { error: "allowlisted MCP tool failed" } : {}
+        }
+      ];
+    }
+    if (eventType === "item.completed" && type === "agent_message") {
+      const text2 = item["text"];
+      if (typeof text2 !== "string") {
+        throw new CodexDispatchError("completed agent_message requires text");
+      }
+      this.finalText = text2;
+      return [{ t: "answer", text: text2 }];
+    }
+    return [];
+  }
+  finish(ok, detail) {
+    if (!this.started) {
+      throw new CodexDispatchError("codex turn finished before turn.started");
+    }
+    if (this.finished) throw new CodexDispatchError("codex emitted duplicate terminal turn event");
+    if (this.pendingTools.size > 0) {
+      throw new CodexDispatchError(
+        `codex turn finished with pending MCP tool calls: ${[...this.pendingTools.keys()].join(", ")}`
+      );
+    }
+    if (ok && this.successfulToolCount === 0) {
+      if (this.toolFailureDetail !== null) {
+        throw new CodexDispatchError(`required MCP tool failed: ${this.toolFailureDetail}`);
+      }
+      throw new CodexDispatchError("codex turn completed without a successful allowlisted MCP tool call");
+    }
+    if (ok && this.finalText === null) {
+      throw new CodexDispatchError("codex JSONL ended without an agent message");
+    }
+    this.finished = true;
+    if (!ok) this.failureDetail = detail ?? "unknown failure";
+    return [
+      {
+        t: "step_finish",
+        id: this.stepId,
+        ok,
+        ...detail !== void 0 ? { detail } : {}
+      }
+    ];
+  }
+};
+
+// src/run.ts
+async function runOneStep(prepared, step, inputs, options, events) {
+  const mapper = new CodexJsonlMapper(step.name, prepared.mcp.name, prepared.enabledTools);
+  const args = buildCodexArgs(prepared, step, {
+    cwd: options.cwd,
+    ...options.codexArgsPrefix ? { codexArgsPrefix: options.codexArgsPrefix } : {}
+  });
+  let child;
+  try {
+    child = spawn2(options.codexBin ?? "codex", args, {
+      cwd: options.cwd,
+      env: sanitizeCodexEnvironment(options.env),
+      stdio: ["pipe", "pipe", "pipe"],
+      detached: process.platform !== "win32"
+    });
+  } catch (error) {
+    throw new CodexDispatchError(`failed to start codex: ${String(error)}`);
+  }
+  if (child.stdin === null || child.stdout === null || child.stderr === null) {
+    child.kill("SIGTERM");
+    throw new CodexDispatchError("failed to start codex with piped stdio");
+  }
+  const childStdin = child.stdin;
+  const childStdout = child.stdout;
+  const childStderr = child.stderr;
+  const exitPromise = new Promise(
+    (resolve4, reject) => {
+      child.once(
+        "error",
+        (error) => reject(new CodexDispatchError(`failed to start codex: ${error.message}`))
+      );
+      child.once("close", (code, signal) => resolve4({ code, signal }));
+    }
+  );
+  childStderr.resume();
+  let terminalError = null;
+  let terminationRequested = false;
+  let killTimer;
+  const terminationGraceMs = options.terminationGraceMs ?? 1e3;
+  const signalProcessTree = (signal) => {
+    if (child.pid === void 0) return;
+    if (process.platform !== "win32") {
+      try {
+        process.kill(-child.pid, signal);
+        return;
+      } catch (error) {
+        if (error.code === "ESRCH") return;
+      }
+    }
+    child.kill(signal);
+  };
+  const terminateProcessTree = () => {
+    if (terminationRequested) return;
+    terminationRequested = true;
+    signalProcessTree("SIGTERM");
+    killTimer = setTimeout(() => signalProcessTree("SIGKILL"), terminationGraceMs);
+  };
+  const lines = createInterface2({ input: childStdout });
+  lines.on("line", (line) => {
+    if (line.trim().length === 0 || terminalError) return;
+    try {
+      for (const event of mapper.nextLine(line)) {
+        events.push(event);
+        options.onEvent?.(event);
+      }
+    } catch (error) {
+      terminalError = error instanceof Error ? error : new Error(String(error));
+      terminateProcessTree();
+    }
+  });
+  const prompt = buildPrompt(prepared, step, options.request, inputs, { producedValue: "string" });
+  childStdin.end(prompt);
+  let aborted = false;
+  const abort = () => {
+    aborted = true;
+    terminateProcessTree();
+  };
+  options.signal?.addEventListener("abort", abort, { once: true });
+  const timeoutMs = options.timeoutMs ?? 12e4;
+  const timer = setTimeout(abort, timeoutMs);
+  const exit = await exitPromise.finally(() => {
+    clearTimeout(timer);
+    options.signal?.removeEventListener("abort", abort);
+    lines.close();
+    if (terminationRequested) signalProcessTree("SIGKILL");
+    if (killTimer !== void 0) clearTimeout(killTimer);
+  });
+  if (terminalError) throw terminalError;
+  if (aborted) {
+    const reason = options.signal?.aborted ? "cancelled" : `timed out after ${timeoutMs}ms`;
+    throw new CodexDispatchError(`codex dispatch ${reason}`);
+  }
+  if (exit.code !== 0) {
+    throw new CodexDispatchError(
+      `codex exited with ${exit.code ?? exit.signal ?? "unknown"}`
+    );
+  }
+  return mapper.result().finalText;
+}
+async function runSetup(prepared, options) {
+  if (options.signal?.aborted) {
+    throw new CodexDispatchError("codex dispatch cancelled before start");
+  }
+  const events = [];
+  const slots = {};
+  const outcomes = /* @__PURE__ */ new Map();
+  const steps = [];
+  let lastFinalText = null;
+  for (const step of prepared.steps) {
+    if (!shouldRunStep(step.when, outcomes)) {
+      outcomes.set(step.name, { ran: false });
+      steps.push({ name: step.name, ran: false, ok: false });
+      continue;
+    }
+    const inputs = Object.fromEntries(step.consumes.map((name) => [name, slots[name]]));
+    const finalText = await runOneStep(prepared, step, inputs, options, events);
+    const hasGuardedConsumer = prepared.steps.some((candidate) => candidate.when?.target === step.name);
+    let record2;
+    try {
+      record2 = parseStepTerminal(finalText, step.produces);
+    } catch (error) {
+      if (hasGuardedConsumer && error instanceof CodexDispatchError) {
+        outcomes.set(step.name, { ran: true, ok: false });
+        steps.push({ name: step.name, ran: true, ok: false });
+        lastFinalText = finalText;
+        continue;
+      }
+      throw error;
+    }
+    const value = record2[step.produces];
+    slots[step.produces] = value;
+    outcomes.set(step.name, { ran: true, ok: true, value });
+    steps.push({ name: step.name, ran: true, ok: true, value });
+    lastFinalText = finalText;
+  }
+  if (lastFinalText === null) {
+    throw new CodexDispatchError("codex dispatch completed without running any step");
+  }
+  return {
+    target: prepared.target,
+    component: prepared.componentId,
+    finalText: lastFinalText,
+    events,
+    steps
+  };
+}
+
+// src/cli.ts
+var USAGE = "usage: warble-codex-local <dispatch|manifest|describe> <ir.json> [request] --component <id> --server-command <absolute-path> [options]\n       warble-codex-local list-models [--project <dir>] [--codex-home <dir>] [--codex-bin <path>] [--timeout <ms>]";
+function fail(message) {
+  process.stderr.write(`error: ${message}
+`);
+  process.exit(1);
+}
+function valuesList(value) {
+  if (value === void 0) return [];
+  return Array.isArray(value) ? value : [value];
+}
+async function main() {
+  const { values, positionals } = parseArgs({
+    allowPositionals: true,
+    options: {
+      component: { type: "string" },
+      model: { type: "string" },
+      project: { type: "string" },
+      out: { type: "string" },
+      timeout: { type: "string" },
+      "codex-bin": { type: "string" },
+      server: { type: "string" },
+      "server-command": { type: "string" },
+      "server-arg": { type: "string", multiple: true },
+      "source-tool": { type: "string", multiple: true },
+      "context-tool": { type: "string", multiple: true },
+      "inspect-tool": { type: "string", multiple: true },
+      "query-tool": { type: "string", multiple: true },
+      "semantic-tool": { type: "string", multiple: true },
+      "raw-material-tool": { type: "string", multiple: true },
+      "orchestrator-model": { type: "string" },
+      "cheap-model": { type: "string" },
+      "strong-model": { type: "string" },
+      "codex-home": { type: "string" },
+      "stream-json": { type: "boolean" }
+    }
+  });
+  const [subcommand, irPathArg, request] = positionals;
+  if (subcommand === "list-models") {
+    if (irPathArg !== void 0 || request !== void 0) fail("list-models does not take an <ir.json> or request");
+    const timeout = values.timeout === void 0 ? void 0 : Number(values.timeout);
+    if (timeout !== void 0 && (!Number.isFinite(timeout) || timeout <= 0)) fail("--timeout must be a positive number");
+    const catalog = await discoverCodexModels({
+      ...values.project ? { cwd: values.project } : {},
+      ...values["codex-home"] ? { codexHome: values["codex-home"] } : {},
+      ...values["codex-bin"] ? { codexBin: values["codex-bin"] } : {},
+      ...timeout !== void 0 ? { timeoutMs: timeout } : {}
+    });
+    process.stdout.write(`${JSON.stringify(catalog)}
+`);
+    return;
+  }
+  if (!["dispatch", "manifest", "describe"].includes(subcommand ?? "")) fail(USAGE);
+  if (!irPathArg) fail("missing <ir.json>");
+  if (!values["server-command"]) fail("missing --server-command");
+  const raw = readFileSync(resolve3(irPathArg), "utf8");
+  const ir = parseIr(raw);
+  const model = values.model ?? "gpt-5.4";
+  if (!values.component && subcommand !== "dispatch" && supportsSetupAggregate(ir)) {
+    const mcp2 = {
+      name: values.server ?? "setup",
+      command: resolve3(values["server-command"]),
+      args: valuesList(values["server-arg"]),
+      toolsByCapability: {
+        source_connect: valuesList(values["source-tool"]),
+        context_build: valuesList(values["context-tool"])
+      }
+    };
+    const prepared2 = prepareAllSetup(raw, { model, mcp: mcp2 });
+    const output = subcommand === "manifest" ? buildManifest(prepared2) : describeTarget(prepared2);
+    const text2 = `${JSON.stringify(output, null, 2)}
+`;
+    if (values.out) writeFileSync2(resolve3(values.out), text2);
+    else process.stdout.write(text2);
+    return;
+  }
+  const component = values.component;
+  if (!component) fail(`${subcommand} requires --component for the selected component execution contract`);
+  const contract = classifyDispatchContract(ir, component);
+  if (contract === "enrich") {
+    const enrichMcp = {
+      name: values.server ?? "enrich",
+      command: resolve3(values["server-command"]),
+      args: valuesList(values["server-arg"]),
+      toolsByCapability: {
+        semantic_introspection: valuesList(values["semantic-tool"]),
+        raw_material_read: valuesList(values["raw-material-tool"])
+      }
+    };
+    const preparedEnrich = prepareEnrich({ ir: raw, component, model, mcp: enrichMcp });
+    if (subcommand === "manifest" || subcommand === "describe") {
+      const output = subcommand === "manifest" ? buildEnrichManifest(preparedEnrich) : describeEnrichTarget(preparedEnrich);
+      const text2 = `${JSON.stringify(output, null, 2)}
+`;
+      if (values.out) writeFileSync2(resolve3(values.out), text2);
+      else process.stdout.write(text2);
+      return;
+    }
+    if (!request) fail("dispatch requires a request");
+    if (!values["codex-home"]) fail("selected component requires --codex-home");
+    const result2 = await runEnrich(preparedEnrich, request, {
+      codexHome: resolve3(values["codex-home"]),
+      cwd: resolve3(values.project ?? "."),
+      externalAuthentication: "provisioned",
+      ...values["codex-bin"] ? { codexBin: resolve3(values["codex-bin"]) } : {},
+      ...values.timeout ? { timeoutMs: Number(values.timeout) } : {},
+      ...values["stream-json"] ? { onEvent: (event) => process.stdout.write(`${JSON.stringify(event)}
+`) } : {}
+    });
+    if (!values["stream-json"]) process.stdout.write(`${result2.finalText}
+`);
+    return;
+  }
+  if (contract === "ask") {
+    for (const option of ["orchestrator-model", "cheap-model", "strong-model"]) {
+      if (!values[option]) fail(`selected component requires --${option}`);
+    }
+    const askMcp = {
+      name: values.server ?? "wren",
+      command: resolve3(values["server-command"]),
+      args: valuesList(values["server-arg"]),
+      toolsByStep: {
+        resolve_intent: valuesList(values["inspect-tool"]),
+        generate_sql: valuesList(values["query-tool"]),
+        repair_sql: valuesList(values["query-tool"]),
+        plan_dashboard: valuesList(values["inspect-tool"]),
+        compose_layout: valuesList(values["query-tool"])
+      }
+    };
+    const preparedAsk = prepareAsk({
+      ir: raw,
+      component,
+      models: {
+        orchestrator: values["orchestrator-model"],
+        cheap: values["cheap-model"],
+        strong: values["strong-model"]
+      },
+      mcp: askMcp
+    });
+    if (subcommand === "manifest" || subcommand === "describe") {
+      const output = subcommand === "manifest" ? buildAskManifest(preparedAsk) : describeAskTarget(preparedAsk);
+      const text2 = `${JSON.stringify(output, null, 2)}
+`;
+      if (values.out) writeFileSync2(resolve3(values.out), text2);
+      else process.stdout.write(text2);
+      return;
+    }
+    if (!request) fail("dispatch requires a request");
+    if (!values["codex-home"]) fail("selected component requires --codex-home");
+    const runtime = await CodexAskRuntime.connect(preparedAsk, {
+      codexHome: resolve3(values["codex-home"]),
+      cwd: resolve3(values.project ?? "."),
+      externalAuthentication: "provisioned",
+      ...values["codex-bin"] ? { codexBin: resolve3(values["codex-bin"]) } : {},
+      ...values.timeout ? { turnTimeoutMs: Number(values.timeout) } : {},
+      ...values["stream-json"] ? { onAskEvent: (event) => process.stdout.write(`${JSON.stringify(event)}
+`) } : {}
+    });
+    try {
+      const session = await runtime.start();
+      const result2 = await runtime.run(session, request);
+      if (values["stream-json"]) {
+        process.stdout.write(`${JSON.stringify({ t: "answer", text: result2.finalText })}
+`);
+      } else {
+        process.stdout.write(`${result2.finalText}
+`);
+      }
+    } finally {
+      await runtime.close();
+    }
+    return;
+  }
+  const mcp = {
+    name: values.server ?? "setup",
+    command: resolve3(values["server-command"]),
+    args: valuesList(values["server-arg"]),
+    toolsByCapability: {
+      source_connect: valuesList(values["source-tool"]),
+      context_build: valuesList(values["context-tool"])
+    }
+  };
+  const prepared = prepareSetup({ ir: raw, component, model, mcp });
+  if (subcommand === "manifest" || subcommand === "describe") {
+    const output = subcommand === "manifest" ? buildManifest([prepared]) : describeTarget([prepared]);
+    const text2 = `${JSON.stringify(output, null, 2)}
+`;
+    if (values.out) writeFileSync2(resolve3(values.out), text2);
+    else process.stdout.write(text2);
+    return;
+  }
+  if (!request) fail("dispatch requires a request");
+  const result = await runSetup(prepared, {
+    cwd: resolve3(values.project ?? "."),
+    request,
+    ...values["codex-bin"] ? { codexBin: resolve3(values["codex-bin"]) } : {},
+    ...values.timeout ? { timeoutMs: Number(values.timeout) } : {},
+    ...values["stream-json"] ? {
+      onEvent: (event) => process.stdout.write(`${JSON.stringify(event)}
+`)
+    } : {}
+  });
+  if (!values["stream-json"]) process.stdout.write(`${result.finalText}
+`);
+}
+main().catch((error) => {
+  if (error instanceof CodexDispatchError) fail(error.message);
+  fail(error instanceof Error ? error.stack ?? error.message : String(error));
+});
+//# sourceMappingURL=cli.js.map