@aexhq/sdk 0.13.6

package/dist/cli.mjs

@@ -0,0 +1,4140 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// dist/cli.js
+import { readFile as readFile2, writeFile, readdir as readdir2, stat as stat2 } from "node:fs/promises";
+import { resolve as resolvePath4 } from "node:path";
+
+// ../contracts/dist/proxy-protocol.js
+var PROXY_PROTOCOL_VERSION = "1";
+var PROXY_PROTOCOL_HEADER = "x-aex-proxy-protocol";
+var PROXY_METHOD_HEADER = "x-aex-method";
+var PROXY_PATH_HEADER = "x-aex-path";
+var PROXY_QUERY_HEADER = "x-aex-query";
+var PROXY_HEADERS_HEADER = "x-aex-headers";
+var PROXY_RESPONSE_MODE_HEADER = "x-aex-response-mode";
+var PROXY_RESPONSE_MODES = ["status_only", "headers_only", "full"];
+var PROXY_ENDPOINT_DEFAULTS = {
+  allowHeaders: [],
+  responseMode: "headers_only",
+  maxRequestBytes: 64 * 1024,
+  maxResponseBytes: 1024 * 1024,
+  timeoutMs: 1e4,
+  perCallBudget: 60,
+  responseByteBudget: 1024 * 1024
+};
+
+// ../contracts/dist/provider-support.js
+var COMMON_DOCS = [
+  { label: "Credentials", href: "credentials.md" },
+  { label: "Events", href: "events.md" }
+];
+var COMMON_EVIDENCE = [
+  { label: "Submission parser and routing parity", href: "../../contracts/test/submission.test.ts" },
+  { label: "Runtime support validator", href: "../../contracts/test/runtime-support.test.ts" },
+  { label: "Generated matrix freshness", href: "../../../scripts/validate/capability-matrix.test.ts" }
+];
+var LIVE_USER_MATRIX_EVIDENCE = [
+  { label: "Installed-SDK live user matrix", href: "../../../apps/user-tests/test/live/live-sdk-comprehensive.test.ts" }
+];
+var MANAGED_PROXY_EVIDENCE = [
+  ...LIVE_USER_MATRIX_EVIDENCE,
+  { label: "Runtime support validator", href: "../../contracts/test/runtime-support.test.ts" }
+];
+var PROVIDER_PUBLIC_SUPPORT = {
+  anthropic: {
+    displayName: "Anthropic",
+    status: "supported",
+    docsAnchor: "anthropic",
+    docs: COMMON_DOCS,
+    evidence: [...COMMON_EVIDENCE, ...MANAGED_PROXY_EVIDENCE],
+    runtimeEvidence: {
+      managed: MANAGED_PROXY_EVIDENCE
+    }
+  },
+  deepseek: {
+    displayName: "DeepSeek",
+    status: "supported",
+    docsAnchor: "deepseek",
+    docs: COMMON_DOCS,
+    evidence: [...COMMON_EVIDENCE, ...MANAGED_PROXY_EVIDENCE],
+    runtimeEvidence: {
+      managed: MANAGED_PROXY_EVIDENCE
+    }
+  },
+  openai: {
+    displayName: "OpenAI",
+    status: "live-unverified",
+    docsAnchor: "openai",
+    docs: COMMON_DOCS,
+    evidence: COMMON_EVIDENCE,
+    runtimeEvidence: {
+      managed: COMMON_EVIDENCE
+    }
+  },
+  gemini: {
+    displayName: "Gemini",
+    status: "live-unverified",
+    docsAnchor: "gemini",
+    docs: COMMON_DOCS,
+    evidence: COMMON_EVIDENCE,
+    runtimeEvidence: {
+      managed: COMMON_EVIDENCE
+    }
+  },
+  mistral: {
+    displayName: "Mistral",
+    status: "live-unverified",
+    docsAnchor: "mistral",
+    docs: COMMON_DOCS,
+    evidence: COMMON_EVIDENCE,
+    runtimeEvidence: {
+      managed: COMMON_EVIDENCE
+    }
+  }
+};
+
+// ../contracts/dist/status.js
+var TERMINAL_RUN_STATUSES = [
+  "succeeded",
+  "failed",
+  "timed_out",
+  "cancelled",
+  "cleanup_failed",
+  "pending_delete",
+  "deleted"
+];
+var terminalRunStatuses = new Set(TERMINAL_RUN_STATUSES);
+
+// ../contracts/dist/run-config.js
+var SKILL_BUNDLE_LIMITS = {
+  /** Compressed (.zip) ceiling. */
+  maxCompressedBytes: 10 * 1024 * 1024,
+  /** Sum of uncompressed file sizes. */
+  maxDecompressedBytes: 50 * 1024 * 1024,
+  /** Number of regular file entries (directories don't count). */
+  maxFiles: 1e3,
+  /** Maximum directory nesting depth — `a/b/c/d` has depth 4. */
+  maxDepth: 16,
+  /** Single-entry path length cap. */
+  maxPathLength: 512,
+  /** Stored file mode for ordinary files. */
+  defaultFileMode: 420,
+  /** Stored directory mode. */
+  defaultDirMode: 493
+};
+var ASSET_ID_PATTERN = /^asset_[A-Za-z0-9_-]{8,128}$/;
+function parseSkillRef(input, path) {
+  if (input === null || typeof input !== "object" || Array.isArray(input)) {
+    throw new Error(`${path} must be a SkillRef object`);
+  }
+  const record = input;
+  const kind = record.kind;
+  if (kind === "provider") {
+    for (const key of Object.keys(record)) {
+      if (key !== "kind" && key !== "vendor" && key !== "skillId" && key !== "version") {
+        throw new Error(`${path} contains unexpected field for provider SkillRef: ${key}`);
+      }
+    }
+    const vendor = record.vendor;
+    if (vendor !== "anthropic" && vendor !== "custom") {
+      throw new Error(`${path}.vendor must be 'anthropic' or 'custom'`);
+    }
+    const skillId = record.skillId;
+    if (typeof skillId !== "string" || skillId.length === 0 || skillId.length > 256) {
+      throw new Error(`${path}.skillId must be a non-empty string (<= 256 chars)`);
+    }
+    const version = record.version;
+    if (version !== void 0 && (typeof version !== "string" || version.length === 0 || version.length > 64)) {
+      throw new Error(`${path}.version, when provided, must be a non-empty string (<= 64 chars)`);
+    }
+    return {
+      kind: "provider",
+      vendor,
+      skillId,
+      ...version !== void 0 ? { version } : {}
+    };
+  }
+  if (kind === "asset") {
+    return parseAssetRefFields(record, path);
+  }
+  throw new Error(`${path}.kind must be 'provider' or 'asset'`);
+}
+function parseAssetRefFields(record, path) {
+  for (const key of Object.keys(record)) {
+    if (key !== "kind" && key !== "assetId" && key !== "name" && key !== "mountPath") {
+      throw new Error(`${path} contains unexpected field for asset ref: ${key}`);
+    }
+  }
+  const assetId = record.assetId;
+  if (typeof assetId !== "string" || !ASSET_ID_PATTERN.test(assetId)) {
+    throw new Error(`${path}.assetId must match ${ASSET_ID_PATTERN.source}`);
+  }
+  const name = record.name;
+  if (typeof name !== "string" || name.length === 0 || name.length > 128) {
+    throw new Error(`${path}.name must be a non-empty string (<= 128 chars)`);
+  }
+  const mountPath = record.mountPath;
+  if (mountPath !== void 0 && (typeof mountPath !== "string" || mountPath.length === 0)) {
+    throw new Error(`${path}.mountPath, when provided, must be a non-empty string`);
+  }
+  return {
+    kind: "asset",
+    assetId,
+    name,
+    ...mountPath !== void 0 ? { mountPath } : {}
+  };
+}
+var SkillBundleValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SkillBundleValidationError";
+  }
+};
+function normaliseSkillBundlePath(input) {
+  if (typeof input !== "string") {
+    throw new SkillBundleValidationError("bundle entry path must be a string");
+  }
+  if (input.length === 0 || input.trim().length === 0) {
+    throw new SkillBundleValidationError("bundle entry path must be non-empty");
+  }
+  if (input.length > SKILL_BUNDLE_LIMITS.maxPathLength) {
+    throw new SkillBundleValidationError(`bundle entry path exceeds maxPathLength (${SKILL_BUNDLE_LIMITS.maxPathLength}): ${input}`);
+  }
+  if (input.includes("\0")) {
+    throw new SkillBundleValidationError(`bundle entry path contains NUL byte: ${JSON.stringify(input)}`);
+  }
+  if (input.includes("\\")) {
+    throw new SkillBundleValidationError(`bundle entry path uses backslash separator: ${input}`);
+  }
+  if (/^[A-Za-z]:[\\/]/.test(input)) {
+    throw new SkillBundleValidationError(`bundle entry path uses a drive letter: ${input}`);
+  }
+  if (input.startsWith("/")) {
+    throw new SkillBundleValidationError(`bundle entry path must be relative: ${input}`);
+  }
+  if (input.endsWith("/")) {
+    throw new SkillBundleValidationError(`bundle entry path must not end with '/': ${input}`);
+  }
+  const segments = input.split("/");
+  for (const segment of segments) {
+    if (segment === "..") {
+      throw new SkillBundleValidationError(`bundle entry path contains '..' segment: ${input}`);
+    }
+    if (segment === "." || segment === "") {
+      throw new SkillBundleValidationError(`bundle entry path contains empty or '.' segment: ${input}`);
+    }
+  }
+  if (segments.length > SKILL_BUNDLE_LIMITS.maxDepth) {
+    throw new SkillBundleValidationError(`bundle entry path exceeds maxDepth (${SKILL_BUNDLE_LIMITS.maxDepth}): ${input}`);
+  }
+  return input;
+}
+function validateSkillBundleEntry(input) {
+  const path = normaliseSkillBundlePath(input.path);
+  if (!Number.isFinite(input.size) || !Number.isInteger(input.size) || input.size < 0) {
+    throw new SkillBundleValidationError(`bundle entry size must be a non-negative integer (${path})`);
+  }
+  if (input.size > SKILL_BUNDLE_LIMITS.maxDecompressedBytes) {
+    throw new SkillBundleValidationError(`bundle entry size exceeds maxDecompressedBytes (${SKILL_BUNDLE_LIMITS.maxDecompressedBytes}): ${path}`);
+  }
+  const mode = (input.mode ?? SKILL_BUNDLE_LIMITS.defaultFileMode) & 511;
+  if (mode !== SKILL_BUNDLE_LIMITS.defaultFileMode && mode !== SKILL_BUNDLE_LIMITS.defaultDirMode) {
+    return { path, size: input.size, mode: SKILL_BUNDLE_LIMITS.defaultFileMode };
+  }
+  return { path, size: input.size, mode };
+}
+var REMOTE_MCP_TRANSPORTS = ["http", "sse"];
+var REMOTE_MCP_STDIO_REJECTED_MESSAGE = "stdio MCP servers are not supported by Aex. Aex supports remote MCP servers over HTTP/SSE only.";
+var STDIO_ONLY_FIELDS = ["command", "args", "env"];
+var MCP_SERVER_NAME_PATTERN = /^[a-z][a-z0-9_-]{0,62}$/;
+function parseMcpServerRef(input, path) {
+  if (input === null || typeof input !== "object" || Array.isArray(input)) {
+    throw new Error(`${path} must be an object`);
+  }
+  const record = input;
+  rejectStdioMcpShape(record);
+  for (const key of Object.keys(record)) {
+    if (key !== "name" && key !== "url" && key !== "transport") {
+      throw new Error(`${path}.${key} is not an allowed field for McpServerRef; permitted: name, url, transport`);
+    }
+  }
+  const name = record.name;
+  if (typeof name !== "string" || !MCP_SERVER_NAME_PATTERN.test(name)) {
+    throw new Error(`${path}.name must match ${MCP_SERVER_NAME_PATTERN.source}`);
+  }
+  const url = record.url;
+  if (typeof url !== "string" || url.length === 0) {
+    throw new Error(`${path}.url must be a non-empty string`);
+  }
+  try {
+    const parsed = new URL(url);
+    if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+      throw new Error(`${path}.url must use http or https (got ${parsed.protocol})`);
+    }
+    if (parsed.username !== "" || parsed.password !== "") {
+      throw new Error(`${path}.url must not contain userinfo (username/password); use secrets.mcpServers[].headers for auth`);
+    }
+    const ssrfDenial = denyReasonForMcpHost(parsed);
+    if (ssrfDenial !== null) {
+      throw new Error(`${path}.url ${ssrfDenial}`);
+    }
+  } catch (cause) {
+    if (cause instanceof Error && cause.message.startsWith(path)) {
+      throw cause;
+    }
+    throw new Error(`${path}.url is not a valid URL: ${url}`);
+  }
+  const transport = parseRemoteMcpTransport(record.transport, `${path}.transport`);
+  return transport ? { name, url, transport } : { name, url };
+}
+function rejectStdioMcpShape(record) {
+  if (record.transport === "stdio") {
+    throw new Error(REMOTE_MCP_STDIO_REJECTED_MESSAGE);
+  }
+  for (const field of STDIO_ONLY_FIELDS) {
+    if (record[field] !== void 0) {
+      throw new Error(REMOTE_MCP_STDIO_REJECTED_MESSAGE);
+    }
+  }
+}
+function denyReasonForMcpHost(parsed) {
+  const host = parsed.hostname.toLowerCase().replace(/^\[|\]$/g, "");
+  if (host === "localhost" || host.endsWith(".localhost")) {
+    return "must not target a loopback hostname";
+  }
+  if (/^127(?:\.[0-9]+){3}$/.test(host)) {
+    return "must not target loopback IPv4 (127.0.0.0/8)";
+  }
+  if (host === "::1" || host === "0:0:0:0:0:0:0:1") {
+    return "must not target loopback IPv6 (::1)";
+  }
+  if (/^fe[89ab][0-9a-f]?:/.test(host)) {
+    return "must not target link-local IPv6 (fe80::/10)";
+  }
+  if (/^169\.254\.[0-9]+\.[0-9]+$/.test(host)) {
+    return "must not target link-local IPv4 (169.254.0.0/16) \u2014 cloud metadata range";
+  }
+  if (/^10\.[0-9]+\.[0-9]+\.[0-9]+$/.test(host)) {
+    return "must not target RFC1918 IPv4 (10.0.0.0/8)";
+  }
+  if (/^172\.(1[6-9]|2[0-9]|3[01])\.[0-9]+\.[0-9]+$/.test(host)) {
+    return "must not target RFC1918 IPv4 (172.16.0.0/12)";
+  }
+  if (/^192\.168\.[0-9]+\.[0-9]+$/.test(host)) {
+    return "must not target RFC1918 IPv4 (192.168.0.0/16)";
+  }
+  if (parsed.protocol === "https:" && parsed.port !== "" && parsed.port !== "443") {
+    return `must use port 443 for https (got ${parsed.port})`;
+  }
+  return null;
+}
+function parseRemoteMcpTransport(input, field) {
+  if (input === void 0) {
+    return void 0;
+  }
+  if (typeof input !== "string" || !REMOTE_MCP_TRANSPORTS.includes(input)) {
+    throw new Error(`${field} must be one of: ${REMOTE_MCP_TRANSPORTS.join(", ")} (got ${JSON.stringify(input)})`);
+  }
+  return input;
+}
+function parseRunConfigMcpServerRef(input, path) {
+  if (input === null || typeof input !== "object" || Array.isArray(input)) {
+    throw new Error(`${path} must be an object`);
+  }
+  const record = input;
+  rejectStdioMcpShape(record);
+  for (const key of Object.keys(record)) {
+    if (key !== "name" && key !== "url" && key !== "headers" && key !== "transport") {
+      throw new Error(`${path}.${key} is not an allowed field for RunConfigMcpServer; permitted: name, url, transport, headers`);
+    }
+  }
+  const stripped = { name: record.name, url: record.url };
+  if (record.transport !== void 0)
+    stripped.transport = record.transport;
+  const ref = parseMcpServerRef(stripped, path);
+  const rawHeaders = record.headers;
+  if (rawHeaders === void 0) {
+    return ref;
+  }
+  if (rawHeaders === null || typeof rawHeaders !== "object" || Array.isArray(rawHeaders)) {
+    throw new Error(`${path}.headers, when provided, must be a string-keyed object`);
+  }
+  const headers = {};
+  for (const [hk, hv] of Object.entries(rawHeaders)) {
+    if (typeof hv !== "string") {
+      throw new Error(`${path}.headers.${hk} must be a string`);
+    }
+    headers[hk] = hv;
+  }
+  return { ...ref, headers };
+}
+function parseRunRequestConfig(input) {
+  if (input === null || typeof input !== "object" || Array.isArray(input)) {
+    throw new Error("run request config must be an object");
+  }
+  const record = input;
+  const allowed = /* @__PURE__ */ new Set([
+    "model",
+    "system",
+    "prompt",
+    "skills",
+    "mcpServers",
+    "environment",
+    "runtimeSize",
+    "timeout",
+    "proxyEndpoints",
+    "metadata"
+  ]);
+  for (const key of Object.keys(record)) {
+    if (!allowed.has(key)) {
+      throw new Error(`run request config contains unexpected field: ${key}`);
+    }
+  }
+  const model = record.model;
+  if (typeof model !== "string" || model.length === 0) {
+    throw new Error("run request config model must be a non-empty string");
+  }
+  const system = record.system;
+  if (system !== void 0 && typeof system !== "string") {
+    throw new Error("run request config system, when provided, must be a string");
+  }
+  const prompt = parseRunRequestConfigPrompt(record.prompt);
+  const skills = parseRunRequestConfigSkills(record.skills);
+  const mcpServers = parseRunRequestConfigMcpServers(record.mcpServers);
+  return {
+    model,
+    ...system !== void 0 ? { system } : {},
+    prompt,
+    ...skills !== void 0 ? { skills } : {},
+    ...mcpServers !== void 0 ? { mcpServers } : {},
+    // environment / proxyEndpoints / metadata: passed through
+    // as-is — the BFF revalidates them via `parseRunSubmissionRequest`,
+    // so duplicating the heavyweight parsers here would mean two sources
+    // of truth. The CLI surfaces structural errors at submission time.
+    ...record.environment !== void 0 ? { environment: record.environment } : {},
+    ...record.runtimeSize !== void 0 ? { runtimeSize: record.runtimeSize } : {},
+    ...record.timeout !== void 0 ? { timeout: record.timeout } : {},
+    ...record.proxyEndpoints !== void 0 ? { proxyEndpoints: record.proxyEndpoints } : {},
+    ...record.metadata !== void 0 ? { metadata: record.metadata } : {}
+  };
+}
+function parseRunRequestConfigPrompt(value) {
+  if (typeof value === "string") {
+    if (value.length === 0) {
+      throw new Error("run request config prompt must be a non-empty string");
+    }
+    return value;
+  }
+  if (Array.isArray(value)) {
+    const arr = [];
+    for (let i = 0; i < value.length; i++) {
+      const item = value[i];
+      if (typeof item !== "string" || item.length === 0) {
+        throw new Error(`run request config prompt[${i}] must be a non-empty string`);
+      }
+      arr.push(item);
+    }
+    if (arr.length === 0) {
+      throw new Error("run request config prompt must be a non-empty string or array of strings");
+    }
+    return arr;
+  }
+  throw new Error("run request config prompt must be a string or array of strings");
+}
+function parseRunRequestConfigSkills(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!Array.isArray(value)) {
+    throw new Error("run request config skills must be an array");
+  }
+  return value.map((item, index) => parseSkillRef(item, `run request config skills[${index}]`));
+}
+function parseRunRequestConfigMcpServers(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!Array.isArray(value)) {
+    throw new Error("run request config mcpServers must be an array");
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return value.map((item, index) => {
+    const entry = parseRunConfigMcpServerRef(item, `run request config mcpServers[${index}]`);
+    if (seen.has(entry.name)) {
+      throw new Error(`run request config mcpServers duplicate name: ${entry.name}`);
+    }
+    seen.add(entry.name);
+    return entry;
+  });
+}
+
+// ../contracts/dist/runtime-sizes.js
+var RUNTIME_SIZE_PRESETS = {
+  "shared-1x-256mb": { cpus: 1, memoryMb: 256 },
+  "shared-1x-512mb": { cpus: 1, memoryMb: 512 },
+  "shared-1x-1gb": { cpus: 1, memoryMb: 1024 },
+  "shared-1x-2gb": { cpus: 1, memoryMb: 2048 },
+  "shared-2x-512mb": { cpus: 2, memoryMb: 512 },
+  "shared-2x-1gb": { cpus: 2, memoryMb: 1024 },
+  "shared-2x-2gb": { cpus: 2, memoryMb: 2048 },
+  "shared-2x-4gb": { cpus: 2, memoryMb: 4096 },
+  "shared-4x-1gb": { cpus: 4, memoryMb: 1024 },
+  "shared-4x-2gb": { cpus: 4, memoryMb: 2048 },
+  "shared-4x-4gb": { cpus: 4, memoryMb: 4096 },
+  "shared-4x-8gb": { cpus: 4, memoryMb: 8192 },
+  "shared-8x-2gb": { cpus: 8, memoryMb: 2048 },
+  "shared-8x-4gb": { cpus: 8, memoryMb: 4096 },
+  "shared-8x-8gb": { cpus: 8, memoryMb: 8192 },
+  "shared-8x-16gb": { cpus: 8, memoryMb: 16384 }
+};
+var RUNTIME_SIZES = Object.keys(RUNTIME_SIZE_PRESETS);
+var DEFAULT_RUN_TIMEOUT_MS = 60 * 60 * 1e3;
+var MAX_RUN_TIMEOUT_MS = 6 * 60 * 60 * 1e3;
+var MIN_RUN_TIMEOUT_MS = 60 * 1e3;
+var RUN_PROCESS_KILL_GRACE_MS = 60 * 1e3;
+var RUN_TERMINAL_GRACE_MS = 90 * 1e3;
+
+// ../contracts/dist/runtime-security-profile.js
+var RUNTIME_SECURITY_PROFILE_CONFIG = Object.freeze({
+  strict: Object.freeze({
+    name: "strict",
+    defaultNetworkingMode: "limited",
+    allowOpenNetworking: false,
+    allowRuntimePackages: false,
+    allowCustomerEnvVars: true,
+    allowProxyEndpoints: true,
+    allowMcpServers: true
+  }),
+  standard: Object.freeze({
+    name: "standard",
+    defaultNetworkingMode: "limited",
+    allowOpenNetworking: true,
+    allowRuntimePackages: true,
+    allowCustomerEnvVars: true,
+    allowProxyEndpoints: true,
+    allowMcpServers: true
+  }),
+  developer: Object.freeze({
+    name: "developer",
+    defaultNetworkingMode: "open",
+    allowOpenNetworking: true,
+    allowRuntimePackages: true,
+    allowCustomerEnvVars: true,
+    allowProxyEndpoints: true,
+    allowMcpServers: true
+  })
+});
+
+// ../contracts/dist/managed-key.js
+var MANAGED_KEY_POLICY_SCHEMA_VERSION = 1;
+var BLOCKED_MANAGED_KEY_FEATURE_POLICY_V1 = Object.freeze({
+  files: "disabled",
+  packages: "disabled",
+  builtins: "disabled",
+  mcpServers: "disabled",
+  proxyEndpoints: "disabled",
+  openNetworking: "disabled"
+});
+var BLOCKED_MANAGED_KEY_POLICY_V1 = Object.freeze({
+  schemaVersion: MANAGED_KEY_POLICY_SCHEMA_VERSION,
+  credentialMode: "managed",
+  launchStage: "blocked",
+  serviceAvailable: false,
+  billingRequired: true,
+  providers: Object.freeze([]),
+  runtimes: Object.freeze([]),
+  features: BLOCKED_MANAGED_KEY_FEATURE_POLICY_V1
+});
+
+// ../contracts/dist/submission.js
+var RUN_PROVIDERS = [
+  "anthropic",
+  "deepseek",
+  "openai",
+  "gemini",
+  "mistral"
+];
+var DEFAULT_RUN_PROVIDER = "anthropic";
+var RUNTIME_KINDS = ["managed"];
+var MIN_REDACTION_TARGET_BYTES = 4;
+var MIN_PROXY_SECRET_BYTES = 8;
+var _MIN_PROXY_SECRET_BYTES_OK = MIN_PROXY_SECRET_BYTES >= MIN_REDACTION_TARGET_BYTES;
+
+// ../contracts/dist/connection-ticket.js
+var encoder = new TextEncoder();
+
+// ../contracts/dist/runtime-manifest.js
+var ANTHROPIC_PATHS = Object.freeze({
+  skillsRoot: "/workspace/skills",
+  filesRoot: "/mnt/session/uploads/aex/files",
+  assetsRoot: "/mnt/session/uploads/aex/assets",
+  aexCli: "/mnt/session/uploads/aex/aex",
+  indexJson: "/mnt/session/uploads/aex/index.json",
+  readme: "/mnt/session/uploads/aex/SKILLS.md",
+  runtimeJson: "/mnt/session/uploads/aex/RUNTIME.json",
+  runtimeEnv: "/mnt/session/uploads/aex/RUNTIME.env"
+});
+
+// ../contracts/dist/run-custody.js
+function scanCustodyPayloadForSensitiveValues(input) {
+  const findings = [];
+  visitCustodyValue(input, "$", findings);
+  return Object.freeze(findings);
+}
+function visitCustodyValue(input, path, findings) {
+  if (typeof input === "string") {
+    scanStringValue(input, path, findings);
+    return;
+  }
+  if (Array.isArray(input)) {
+    input.forEach((value, index) => visitCustodyValue(value, `${path}[${index}]`, findings));
+    return;
+  }
+  if (!input || typeof input !== "object") {
+    return;
+  }
+  for (const [key, value] of Object.entries(input)) {
+    const childPath = `${path}.${key}`;
+    if (isForbiddenCustodyFieldName(key)) {
+      findings.push(Object.freeze({ path: childPath, reason: "forbidden_field_name" }));
+    }
+    visitCustodyValue(value, childPath, findings);
+  }
+}
+function scanStringValue(value, path, findings) {
+  for (const pattern of forbiddenStringPatterns) {
+    if (pattern.regex.test(value)) {
+      findings.push(Object.freeze({
+        path,
+        reason: pattern.reason,
+        valueLength: value.length
+      }));
+    }
+  }
+}
+var forbiddenStringPatterns = Object.freeze([
+  { reason: "bearer_token", regex: /\bBearer\s+[A-Za-z0-9._~+/=-]{8,}/i },
+  {
+    reason: "provider_key",
+    regex: /\b(?:sk-(?:ant|proj|live|test|deepseek|openai)|xox[baprs]-|AIza)[A-Za-z0-9_-]{8,}/i
+  },
+  { reason: "signed_url", regex: /[?&](?:X-Amz-Signature|X-Amz-Credential|X-Amz-Algorithm|AWSAccessKeyId)=/i },
+  { reason: "r2_object_key", regex: /(^|[\s"'`])(?:runs|assets)\/[^?<#\s"'`]+/i },
+  { reason: "vault_id", regex: /\b(?:vault|vlt|secret)[_:-][A-Za-z0-9][A-Za-z0-9_-]{7,}\b/i },
+  {
+    reason: "private_resource_handle",
+    regex: /\b(?:machine|session|agent|file|skill|env|resource|handle|token_hash|bearer_hash)[_:-][A-Za-z0-9][A-Za-z0-9_-]{7,}\b/i
+  },
+  { reason: "high_entropy_token", regex: /\b(?=[A-Za-z0-9_-]{40,}\b)(?=.*[A-Za-z])(?=.*\d)[A-Za-z0-9_-]{40,}\b/ }
+]);
+function isForbiddenCustodyFieldName(key) {
+  return /^(apiKey|secretValue|bearerHash|signedUrl|r2Key|objectKey|vaultId|providerResponseBody|responseBody|privateResourceHandle|resourceHandle|rawBody)$/i.test(key);
+}
+
+// ../contracts/dist/run-record.js
+var RUN_RECORD_SCHEMA_VERSION = "aex.run-record.v1";
+var RUN_RECORD_MANIFEST_SCHEMA_VERSION = "aex.run-record.manifest.v1";
+var RunRecordArchiveRedactionError = class extends Error {
+  code = "run_record_archive_not_public_safe";
+  findings;
+  constructor(findings) {
+    super(`run record archive contains non-public data at ${formatArchiveFindingPaths(findings)}`);
+    this.name = "RunRecordArchiveRedactionError";
+    this.findings = Object.freeze([...findings]);
+  }
+};
+function buildRunRecordDownloadManifestV1(input) {
+  const outputs = input.outputs.map((file2) => normalizeArtifactSummary(file2));
+  const logs = input.logs.map((file2) => normalizeArtifactSummary(file2));
+  const errors = (input.errors ?? []).map((error) => Object.freeze({ ...error }));
+  return Object.freeze({
+    schemaVersion: RUN_RECORD_MANIFEST_SCHEMA_VERSION,
+    runRecordSchemaVersion: RUN_RECORD_SCHEMA_VERSION,
+    runId: input.runId,
+    namespaces: Object.freeze([
+      namespace("metadata", "Run metadata, submission snapshot, custody, and cost files."),
+      namespace("events", "Typed event-channel exports and optional full-stream/log-channel exports."),
+      namespace("outputs", "Captured deliverables produced by the run."),
+      namespace("logs", "Platform diagnostics and runtime log artifacts.")
+    ]),
+    files: Object.freeze([
+      file("metadata", "metadata/run.json", "run_metadata", "present"),
+      file("metadata", "metadata/submission.json", "submission_snapshot", input.submission?.status ?? "unavailable"),
+      file("metadata", "metadata/cost.json", "cost", input.cost?.status ?? "pending"),
+      file("metadata", "metadata/custody.json", "custody", input.custody?.status ?? "pending"),
+      file("events", "events/events.jsonl", "typed_events", "present", {
+        recordCount: input.typedEventCount ?? 0
+      }),
+      file("events", "events/logs.jsonl", "log_events", input.logEvents?.status ?? "unavailable", recordCountExtra(input.logEvents)),
+      file("events", "events/all.jsonl", "all_events", input.allEvents?.status ?? "unavailable", recordCountExtra(input.allEvents)),
+      file("events", "events/manifest.json", "coordinator_events_manifest", input.coordinatorEventsManifest?.status ?? "unavailable"),
+      ...outputs.map((output) => artifactFile("outputs", "output", "outputs/", output)),
+      ...logs.map((log) => artifactFile("logs", "log", "logs/", log))
+    ]),
+    outputs: Object.freeze(outputs),
+    logs: Object.freeze(logs),
+    errors: Object.freeze(errors)
+  });
+}
+function namespace(name, description) {
+  return Object.freeze({
+    name,
+    prefix: `${name}/`,
+    status: "present",
+    description
+  });
+}
+function file(namespaceName, path, role, status, extra) {
+  return Object.freeze({
+    namespace: namespaceName,
+    path,
+    role,
+    status,
+    ...extra?.recordCount !== void 0 ? { recordCount: extra.recordCount } : {}
+  });
+}
+function recordCountExtra(input) {
+  return input?.status === "present" && input.recordCount !== void 0 ? { recordCount: input.recordCount } : void 0;
+}
+function artifactFile(namespaceName, role, prefix, artifact) {
+  return Object.freeze({
+    namespace: namespaceName,
+    path: `${prefix}${artifact.filename ?? artifact.id}`,
+    role,
+    status: "present",
+    id: artifact.id,
+    filename: artifact.filename,
+    ...artifact.sizeBytes !== void 0 ? { sizeBytes: artifact.sizeBytes } : {},
+    ...artifact.contentType !== void 0 ? { contentType: artifact.contentType } : {}
+  });
+}
+function normalizeArtifactSummary(input) {
+  return Object.freeze({
+    id: input.id,
+    filename: input.filename,
+    ...input.sizeBytes !== void 0 ? { sizeBytes: input.sizeBytes } : {},
+    ...input.contentType !== void 0 ? { contentType: input.contentType } : {}
+  });
+}
+function scanRunRecordArchiveEntriesV1(entries) {
+  const findings = [];
+  for (const entry of entries) {
+    if (entry.customerContent || !shouldScanArchiveEntry(entry)) {
+      continue;
+    }
+    for (const finding of scanArchiveEntry(entry)) {
+      findings.push(finding);
+    }
+  }
+  return Object.freeze(findings);
+}
+function assertRunRecordArchivePublicSafeV1(entries) {
+  const findings = scanRunRecordArchiveEntriesV1(entries);
+  if (findings.length > 0) {
+    throw new RunRecordArchiveRedactionError(findings);
+  }
+}
+function shouldScanArchiveEntry(entry) {
+  if (entry.path.startsWith("outputs/")) {
+    return false;
+  }
+  const contentType = entry.contentType?.toLowerCase() ?? "";
+  if (contentType.startsWith("text/") || contentType.includes("json") || contentType.includes("xml") || contentType.includes("yaml")) {
+    return true;
+  }
+  return /\.(?:json|jsonl|ndjson|txt|log|md|csv|tsv|ya?ml)$/i.test(entry.path);
+}
+function scanArchiveEntry(entry) {
+  const text = new TextDecoder().decode(entry.bytes);
+  const parsedValues = parseArchiveTextValues(entry.path, text);
+  const rawFindings = parsedValues.length > 0 ? parsedValues.flatMap((value) => [...scanCustodyPayloadForSensitiveValues(value.value)].map((finding) => ({
+    ...finding,
+    path: `${value.path}${finding.path === "$" ? "" : finding.path.slice(1)}`
+  }))) : scanCustodyPayloadForSensitiveValues(text);
+  return Object.freeze(rawFindings.filter((finding) => !isAllowedArchiveHighEntropyField(entry.path, finding)).map((finding) => Object.freeze({
+    entryPath: entry.path,
+    path: finding.path,
+    reason: finding.reason,
+    ...finding.valueLength !== void 0 ? { valueLength: finding.valueLength } : {}
+  })));
+}
+function isAllowedArchiveHighEntropyField(entryPath, finding) {
+  if (finding.reason !== "high_entropy_token" || !entryPath.endsWith("manifest.json")) {
+    return false;
+  }
+  return /^\$(?:\.files\[\d+\]|\.outputs\[\d+\]|\.logs\[\d+\])\.id$/.test(finding.path);
+}
+function parseArchiveTextValues(path, text) {
+  if (/\.json$/i.test(path)) {
+    const parsed = tryParseJson(text);
+    return parsed.ok ? Object.freeze([{ path: "$", value: parsed.value }]) : Object.freeze([]);
+  }
+  if (/\.(?:jsonl|ndjson)$/i.test(path)) {
+    const values = [];
+    const lines = text.split(/\r?\n/);
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (!line?.trim()) {
+        continue;
+      }
+      const parsed = tryParseJson(line);
+      if (!parsed.ok) {
+        return Object.freeze([]);
+      }
+      values.push({ path: `$[${i}]`, value: parsed.value });
+    }
+    return Object.freeze(values);
+  }
+  return Object.freeze([]);
+}
+function tryParseJson(text) {
+  try {
+    return { ok: true, value: JSON.parse(text) };
+  } catch {
+    return { ok: false };
+  }
+}
+function formatArchiveFindingPaths(findings) {
+  return findings.map((finding) => `${finding.entryPath}${finding.path} (${finding.reason})`).join(", ");
+}
+
+// ../contracts/dist/run-retention.js
+var forbiddenStringPatterns2 = Object.freeze([
+  { reason: "signed_url", regex: /[?&](?:X-Amz-Signature|X-Amz-Credential|X-Amz-Algorithm|AWSAccessKeyId)=/i },
+  { reason: "r2_object_key", regex: /(^|[\s"'`])(?:runs|assets)\/[^?<#\s"'`]+/i },
+  { reason: "vault_id", regex: /\b(?:vault|vlt|secret)[_:-][A-Za-z0-9][A-Za-z0-9_-]{7,}\b/i },
+  {
+    reason: "private_resource_handle",
+    regex: /\b(?:machine|session|resource|handle|provider|asset)[_:-][A-Za-z0-9][A-Za-z0-9_-]{7,}\b/i
+  },
+  { reason: "hash_like_value", regex: /\b(?:sha256|hash)[:_-][A-Fa-f0-9]{16,}\b/ }
+]);
+
+// ../contracts/dist/side-effect-audit.js
+var forbiddenStringPatterns3 = Object.freeze([
+  { reason: "bearer_token", regex: /\bBearer\s+[A-Za-z0-9._~+/=-]{8,}/i },
+  {
+    reason: "provider_key",
+    regex: /\b(?:sk-(?:ant|proj|live|test|deepseek|openai)|xox[baprs]-|AIza)[A-Za-z0-9_-]{8,}/i
+  },
+  { reason: "signed_url", regex: /[?&](?:X-Amz-Signature|X-Amz-Credential|X-Amz-Algorithm|AWSAccessKeyId)=/i },
+  { reason: "r2_object_key", regex: /(^|[\s"'`])(?:runs|assets)\/[^?<#\s"'`]+/i },
+  { reason: "vault_id", regex: /\b(?:vault|vlt|secret)[_:-][A-Za-z0-9][A-Za-z0-9_-]{7,}\b/i },
+  {
+    reason: "private_resource_handle",
+    regex: /\b(?:machine|session|agent|file|skill|env|resource|handle|token_hash|bearer_hash)[_:-][A-Za-z0-9][A-Za-z0-9_-]{7,}\b/i
+  },
+  { reason: "raw_url", regex: /\bhttps?:\/\/\S+/i },
+  { reason: "raw_path", regex: /(^|[\s"'`])\/[A-Za-z0-9._~!$&'()*+,;=:@%-]+(?:[/?#][^\s"'`]*)?/ },
+  { reason: "high_entropy_token", regex: /\b(?=[A-Za-z0-9_-]{40,}\b)(?=.*[A-Za-z])(?=.*\d)[A-Za-z0-9_-]{40,}\b/ }
+]);
+
+// ../contracts/dist/stable.js
+import { createHash } from "node:crypto";
+var AEX_DEFAULT_BASE_URL = "https://api.aex.dev";
+
+// ../contracts/dist/sdk-secrets.js
+import { Transform } from "node:stream";
+var SECRET_PATTERNS = [
+  // postgres / postgresql connection strings — redact the whole URI so the
+  // embedded password can never survive as a substring (the `sed`-mask leak).
+  /\bpostgres(?:ql)?:\/\/[^\s"']+/gi,
+  // Authorization: Bearer <token> — redact the credential, keep the header name
+  // so logs stay legible.
+  /\b(Authorization\s*:\s*Bearer)\s+[A-Za-z0-9._~+/=-]{8,}/gi,
+  // Anthropic + OpenAI-style prefixed keys.
+  /sk-ant-[A-Za-z0-9_-]{16,}/g,
+  /sk-[A-Za-z0-9_-]{20,}/g,
+  // aex workspace / proxy tokens: apt_… / ant_….
+  /\b(?:apt|ant)_[A-Za-z0-9_-]{16,}/g,
+  // Slack tokens.
+  /xox[pbar]-[A-Za-z0-9-]{10,}/g,
+  // AWS access key id + secret access key shapes.
+  /\b(?:AKIA|ASIA)[A-Z0-9]{16}\b/g,
+  /\baws_secret_access_key["'\s:=]+[A-Za-z0-9/+=]{40}/gi,
+  // JWT-shaped: header.payload.signature, each base64url, header starts `eyJ`.
+  /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g,
+  // Keyword-introduced secret assignments (bearer/token/api_key/…).
+  /(?:bearer|token|api[_-]?key|access[_-]?token|refresh[_-]?token|client[_-]?secret)["'\s:=]+[A-Za-z0-9_\-./+=]{12,}/gi
+];
+var REDACTED = "[REDACTED]";
+var HIGH_ENTROPY_CANDIDATE = /[A-Za-z0-9+/=-]{24,}/g;
+var ENTROPY_BITS_PER_CHAR = 3;
+var MIN_CHAR_CLASSES = 2;
+var HIGH_ENTROPY_NO_DIGIT_MIN_LEN = 40;
+function redactSecrets(value) {
+  if (typeof value === "string") {
+    return redactString(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => redactSecrets(item));
+  }
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [key, item] of Object.entries(value)) {
+      if (isSecretKey(key)) {
+        out[key] = REDACTED;
+      } else {
+        out[key] = redactSecrets(item);
+      }
+    }
+    return out;
+  }
+  return value;
+}
+function redactString(input, known = []) {
+  let out = input;
+  for (const value of known) {
+    if (value && value.length >= 4) {
+      out = out.split(value).join(REDACTED);
+    }
+  }
+  out = SECRET_PATTERNS.reduce((current, pattern) => current.replace(pattern, (match, captured) => (
+    // Patterns with a captured prefix (Authorization header) keep the
+    // prefix; the rest replace the whole match.
+    typeof captured === "string" ? `${captured} ${REDACTED}` : REDACTED
+  )), out);
+  return out.replace(HIGH_ENTROPY_CANDIDATE, (match) => looksHighEntropySecret(match) ? REDACTED : match);
+}
+function isSecretKey(key) {
+  return /(?:api[_-]?key|authorization|token|secret|password|credential)/i.test(key);
+}
+function looksHighEntropySecret(value) {
+  if (charClassCount(value) < MIN_CHAR_CLASSES)
+    return false;
+  if (shannonEntropyBits(value) < ENTROPY_BITS_PER_CHAR)
+    return false;
+  return /[0-9]/.test(value) || value.length >= HIGH_ENTROPY_NO_DIGIT_MIN_LEN;
+}
+function charClassCount(value) {
+  let count = 0;
+  if (/[a-z]/.test(value))
+    count++;
+  if (/[A-Z]/.test(value))
+    count++;
+  if (/[0-9]/.test(value))
+    count++;
+  return count;
+}
+function shannonEntropyBits(value) {
+  if (value.length === 0) {
+    return 0;
+  }
+  const counts = /* @__PURE__ */ new Map();
+  for (const char of value) {
+    counts.set(char, (counts.get(char) ?? 0) + 1);
+  }
+  let bits = 0;
+  for (const count of counts.values()) {
+    const p = count / value.length;
+    bits -= p * Math.log2(p);
+  }
+  return bits;
+}
+
+// ../contracts/dist/sdk-errors.js
+var AexError = class extends Error {
+  code;
+  details;
+  constructor(code, message, details) {
+    super(redactSecrets(message));
+    this.name = this.constructor.name;
+    this.code = code;
+    this.details = details === void 0 ? void 0 : redactSecrets(details);
+  }
+};
+var RunStateError = class extends AexError {
+  constructor(message, details) {
+    super("RUN_STATE_ERROR", message, details);
+  }
+};
+var AexApiError = class extends AexError {
+  status;
+  body;
+  constructor(status, message, body) {
+    super("API_ERROR", message, body);
+    this.status = status;
+    this.body = redactSecrets(body);
+  }
+};
+
+// ../contracts/dist/http.js
+var HttpClient = class {
+  #baseUrl;
+  #apiToken;
+  #fetch;
+  #debug;
+  constructor(options) {
+    if (!options.apiToken) {
+      throw new Error("HttpClient: apiToken is required");
+    }
+    const raw = options.baseUrl ?? AEX_DEFAULT_BASE_URL;
+    const normalized = raw.endsWith("/") ? raw : `${raw}/`;
+    this.#baseUrl = new URL(normalized);
+    this.#apiToken = options.apiToken;
+    this.#fetch = options.fetch ?? fetch;
+    this.#debug = options.debug;
+  }
+  /** Emit a redacted round-trip trace (no auth header, body, or query). */
+  #trace(method, url, status, startedMs) {
+    this.#debug?.(`[aex] ${(method ?? "GET").toUpperCase()} ${url.pathname} -> ${status} ${Date.now() - startedMs}ms`);
+  }
+  async request(path, init = {}, query = {}) {
+    const url = new URL(path.replace(/^\//, ""), this.#baseUrl);
+    for (const [key, value] of Object.entries(query)) {
+      url.searchParams.set(key, value);
+    }
+    const headers = {
+      accept: "application/json",
+      authorization: `Bearer ${this.#apiToken}`,
+      ...normalizeHeaders(init.headers)
+    };
+    if (init.body !== void 0 && init.body !== null && !headers["content-type"]) {
+      if (typeof init.body === "string") {
+        headers["content-type"] = "application/json";
+      }
+    }
+    const startedMs = Date.now();
+    const response = await this.#fetch(url, { ...init, headers });
+    this.#trace(init.method, url, response.status, startedMs);
+    const body = await readJson(response);
+    if (!response.ok) {
+      throw new AexApiError(response.status, extractErrorMessage(body), body);
+    }
+    return body;
+  }
+  async download(path, init = {}, query = {}) {
+    const url = new URL(path.replace(/^\//, ""), this.#baseUrl);
+    for (const [key, value] of Object.entries(query)) {
+      url.searchParams.set(key, value);
+    }
+    const headers = {
+      authorization: `Bearer ${this.#apiToken}`,
+      ...normalizeHeaders(init.headers)
+    };
+    const startedMs = Date.now();
+    const response = await this.#fetch(url, { ...init, headers });
+    this.#trace(init.method, url, response.status, startedMs);
+    if (!response.ok) {
+      const body = await readJson(response);
+      throw new AexApiError(response.status, extractErrorMessage(body), body);
+    }
+    return { response };
+  }
+};
+function normalizeHeaders(headers) {
+  if (!headers)
+    return {};
+  if (headers instanceof Headers)
+    return Object.fromEntries(headers.entries());
+  if (Array.isArray(headers))
+    return Object.fromEntries(headers);
+  return headers;
+}
+async function readJson(response) {
+  const text = await response.text();
+  if (text.length === 0)
+    return {};
+  try {
+    return JSON.parse(text);
+  } catch {
+    return { raw: text };
+  }
+}
+function extractErrorMessage(body) {
+  if (body && typeof body === "object") {
+    const obj = body;
+    if (typeof obj.error === "string")
+      return obj.error;
+    if (obj.error && typeof obj.error === "object" && "message" in obj.error) {
+      const message = obj.error.message;
+      if (typeof message === "string")
+        return message;
+    }
+    if (typeof obj.message === "string")
+      return obj.message;
+  }
+  return "aex API request failed";
+}
+
+// ../contracts/dist/run-artifacts.js
+function runArtifactRel(rel) {
+  if (rel.startsWith(".runtime-logs/"))
+    return `runtime/${rel.slice(".runtime-logs/".length)}`;
+  if (rel.startsWith("runtime/"))
+    return rel;
+  if (rel.startsWith(".host-logs/"))
+    return `host/${rel.slice(".host-logs/".length)}`;
+  if (rel.startsWith("host/"))
+    return rel;
+  if (rel.startsWith(".provider-proxy/"))
+    return `provider-proxy/${rel.slice(".provider-proxy/".length)}`;
+  if (rel.startsWith("provider-proxy/"))
+    return rel;
+  if (rel.startsWith(".control-plane/"))
+    return `control-plane/${rel.slice(".control-plane/".length)}`;
+  if (rel.startsWith("control-plane/"))
+    return rel;
+  if (rel.startsWith(".goose-logs/"))
+    return `runtime/${rel.slice(".goose-logs/".length)}`;
+  if (rel.startsWith("goose-logs/"))
+    return `runtime/${rel.slice("goose-logs/".length)}`;
+  if (rel.startsWith(".fly-logs/"))
+    return `host/${rel.slice(".fly-logs/".length)}`;
+  if (rel.startsWith("fly-logs/"))
+    return `host/${rel.slice("fly-logs/".length)}`;
+  if (rel.startsWith(".anthropic-debug/"))
+    return `provider-proxy/${rel.slice(".anthropic-debug/".length)}`;
+  if (rel.startsWith("anthropic-debug/"))
+    return `provider-proxy/${rel.slice("anthropic-debug/".length)}`;
+  return rel;
+}
+
+// ../contracts/dist/operations.js
+var operations_exports = {};
+__export(operations_exports, {
+  cancelRun: () => cancelRun,
+  createAgentsMd: () => createAgentsMd,
+  createFile: () => createFile,
+  createOutputLink: () => createOutputLink,
+  createSkillBundle: () => createSkillBundle,
+  createSkillBundleDirect: () => createSkillBundleDirect,
+  deleteAgentsMd: () => deleteAgentsMd,
+  deleteFile: () => deleteFile,
+  deleteRun: () => deleteRun,
+  deleteSkill: () => deleteSkill,
+  deleteWorkspaceAsset: () => deleteWorkspaceAsset,
+  download: () => download,
+  downloadEvents: () => downloadEvents,
+  downloadLogs: () => downloadLogs,
+  downloadMetadata: () => downloadMetadata,
+  downloadOutput: () => downloadOutput,
+  downloadOutputs: () => downloadOutputs,
+  findSkillByHash: () => findSkillByHash,
+  findSkillByName: () => findSkillByName,
+  getAgentsMd: () => getAgentsMd,
+  getCoordinatorTicket: () => getCoordinatorTicket,
+  getFile: () => getFile,
+  getRun: () => getRun,
+  getRunUnit: () => getRunUnit,
+  getSkill: () => getSkill,
+  listAgentsMd: () => listAgentsMd,
+  listFiles: () => listFiles,
+  listLogs: () => listLogs,
+  listOutputs: () => listOutputs,
+  listRunEvents: () => listRunEvents,
+  listSkills: () => listSkills,
+  resolveOutputFileSelector: () => resolveOutputFileSelector,
+  submitRun: () => submitRun,
+  submitRunMultipart: () => submitRunMultipart,
+  uploadWorkspaceAsset: () => uploadWorkspaceAsset,
+  whoami: () => whoami
+});
+
+// ../../node_modules/.pnpm/fflate@0.8.3/node_modules/fflate/esm/index.mjs
+import { createRequire } from "module";
+var require2 = createRequire("/");
+var _a;
+var Worker;
+var isMarkedAsUntransferable;
+try {
+  _a = require2("worker_threads"), Worker = _a.Worker, isMarkedAsUntransferable = _a.isMarkedAsUntransferable;
+} catch (e) {
+}
+var u8 = Uint8Array;
+var u16 = Uint16Array;
+var i32 = Int32Array;
+var fleb = new u8([
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  1,
+  1,
+  2,
+  2,
+  2,
+  2,
+  3,
+  3,
+  3,
+  3,
+  4,
+  4,
+  4,
+  4,
+  5,
+  5,
+  5,
+  5,
+  0,
+  /* unused */
+  0,
+  0,
+  /* impossible */
+  0
+]);
+var fdeb = new u8([
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  2,
+  2,
+  3,
+  3,
+  4,
+  4,
+  5,
+  5,
+  6,
+  6,
+  7,
+  7,
+  8,
+  8,
+  9,
+  9,
+  10,
+  10,
+  11,
+  11,
+  12,
+  12,
+  13,
+  13,
+  /* unused */
+  0,
+  0
+]);
+var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
+var freb = function(eb, start) {
+  var b = new u16(31);
+  for (var i = 0; i < 31; ++i) {
+    b[i] = start += 1 << eb[i - 1];
+  }
+  var r = new i32(b[30]);
+  for (var i = 1; i < 30; ++i) {
+    for (var j = b[i]; j < b[i + 1]; ++j) {
+      r[j] = j - b[i] << 5 | i;
+    }
+  }
+  return { b, r };
+};
+var _a = freb(fleb, 2);
+var fl = _a.b;
+var revfl = _a.r;
+fl[28] = 258, revfl[258] = 28;
+var _b = freb(fdeb, 0);
+var fd = _b.b;
+var revfd = _b.r;
+var rev = new u16(32768);
+for (i = 0; i < 32768; ++i) {
+  x = (i & 43690) >> 1 | (i & 21845) << 1;
+  x = (x & 52428) >> 2 | (x & 13107) << 2;
+  x = (x & 61680) >> 4 | (x & 3855) << 4;
+  rev[i] = ((x & 65280) >> 8 | (x & 255) << 8) >> 1;
+}
+var x;
+var i;
+var hMap = (function(cd, mb, r) {
+  var s = cd.length;
+  var i = 0;
+  var l = new u16(mb);
+  for (; i < s; ++i) {
+    if (cd[i])
+      ++l[cd[i] - 1];
+  }
+  var le = new u16(mb);
+  for (i = 1; i < mb; ++i) {
+    le[i] = le[i - 1] + l[i - 1] << 1;
+  }
+  var co;
+  if (r) {
+    co = new u16(1 << mb);
+    var rvb = 15 - mb;
+    for (i = 0; i < s; ++i) {
+      if (cd[i]) {
+        var sv = i << 4 | cd[i];
+        var r_1 = mb - cd[i];
+        var v = le[cd[i] - 1]++ << r_1;
+        for (var m = v | (1 << r_1) - 1; v <= m; ++v) {
+          co[rev[v] >> rvb] = sv;
+        }
+      }
+    }
+  } else {
+    co = new u16(s);
+    for (i = 0; i < s; ++i) {
+      if (cd[i]) {
+        co[i] = rev[le[cd[i] - 1]++] >> 15 - cd[i];
+      }
+    }
+  }
+  return co;
+});
+var flt = new u8(288);
+for (i = 0; i < 144; ++i)
+  flt[i] = 8;
+var i;
+for (i = 144; i < 256; ++i)
+  flt[i] = 9;
+var i;
+for (i = 256; i < 280; ++i)
+  flt[i] = 7;
+var i;
+for (i = 280; i < 288; ++i)
+  flt[i] = 8;
+var i;
+var fdt = new u8(32);
+for (i = 0; i < 32; ++i)
+  fdt[i] = 5;
+var i;
+var flm = /* @__PURE__ */ hMap(flt, 9, 0);
+var fdm = /* @__PURE__ */ hMap(fdt, 5, 0);
+var shft = function(p) {
+  return (p + 7) / 8 | 0;
+};
+var slc = function(v, s, e) {
+  if (s == null || s < 0)
+    s = 0;
+  if (e == null || e > v.length)
+    e = v.length;
+  return new u8(v.subarray(s, e));
+};
+var ec = [
+  "unexpected EOF",
+  "invalid block type",
+  "invalid length/literal",
+  "invalid distance",
+  "stream finished",
+  "no stream handler",
+  ,
+  // determined by compression function
+  "no callback",
+  "invalid UTF-8 data",
+  "extra field too long",
+  "date not in range 1980-2099",
+  "filename too long",
+  "stream finishing",
+  "invalid zip data"
+  // determined by unknown compression method
+];
+var err = function(ind, msg, nt) {
+  var e = new Error(msg || ec[ind]);
+  e.code = ind;
+  if (Error.captureStackTrace)
+    Error.captureStackTrace(e, err);
+  if (!nt)
+    throw e;
+  return e;
+};
+var wbits = function(d, p, v) {
+  v <<= p & 7;
+  var o = p / 8 | 0;
+  d[o] |= v;
+  d[o + 1] |= v >> 8;
+};
+var wbits16 = function(d, p, v) {
+  v <<= p & 7;
+  var o = p / 8 | 0;
+  d[o] |= v;
+  d[o + 1] |= v >> 8;
+  d[o + 2] |= v >> 16;
+};
+var hTree = function(d, mb) {
+  var t = [];
+  for (var i = 0; i < d.length; ++i) {
+    if (d[i])
+      t.push({ s: i, f: d[i] });
+  }
+  var s = t.length;
+  var t2 = t.slice();
+  if (!s)
+    return { t: et, l: 0 };
+  if (s == 1) {
+    var v = new u8(t[0].s + 1);
+    v[t[0].s] = 1;
+    return { t: v, l: 1 };
+  }
+  t.sort(function(a, b) {
+    return a.f - b.f;
+  });
+  t.push({ s: -1, f: 25001 });
+  var l = t[0], r = t[1], i0 = 0, i1 = 1, i2 = 2;
+  t[0] = { s: -1, f: l.f + r.f, l, r };
+  while (i1 != s - 1) {
+    l = t[t[i0].f < t[i2].f ? i0++ : i2++];
+    r = t[i0 != i1 && t[i0].f < t[i2].f ? i0++ : i2++];
+    t[i1++] = { s: -1, f: l.f + r.f, l, r };
+  }
+  var maxSym = t2[0].s;
+  for (var i = 1; i < s; ++i) {
+    if (t2[i].s > maxSym)
+      maxSym = t2[i].s;
+  }
+  var tr = new u16(maxSym + 1);
+  var mbt = ln(t[i1 - 1], tr, 0);
+  if (mbt > mb) {
+    var i = 0, dt = 0;
+    var lft = mbt - mb, cst = 1 << lft;
+    t2.sort(function(a, b) {
+      return tr[b.s] - tr[a.s] || a.f - b.f;
+    });
+    for (; i < s; ++i) {
+      var i2_1 = t2[i].s;
+      if (tr[i2_1] > mb) {
+        dt += cst - (1 << mbt - tr[i2_1]);
+        tr[i2_1] = mb;
+      } else
+        break;
+    }
+    dt >>= lft;
+    while (dt > 0) {
+      var i2_2 = t2[i].s;
+      if (tr[i2_2] < mb)
+        dt -= 1 << mb - tr[i2_2]++ - 1;
+      else
+        ++i;
+    }
+    for (; i >= 0 && dt; --i) {
+      var i2_3 = t2[i].s;
+      if (tr[i2_3] == mb) {
+        --tr[i2_3];
+        ++dt;
+      }
+    }
+    mbt = mb;
+  }
+  return { t: new u8(tr), l: mbt };
+};
+var ln = function(n, l, d) {
+  return n.s == -1 ? Math.max(ln(n.l, l, d + 1), ln(n.r, l, d + 1)) : l[n.s] = d;
+};
+var lc = function(c) {
+  var s = c.length;
+  while (s && !c[--s])
+    ;
+  var cl = new u16(++s);
+  var cli = 0, cln = c[0], cls = 1;
+  var w = function(v) {
+    cl[cli++] = v;
+  };
+  for (var i = 1; i <= s; ++i) {
+    if (c[i] == cln && i != s)
+      ++cls;
+    else {
+      if (!cln && cls > 2) {
+        for (; cls > 138; cls -= 138)
+          w(32754);
+        if (cls > 2) {
+          w(cls > 10 ? cls - 11 << 5 | 28690 : cls - 3 << 5 | 12305);
+          cls = 0;
+        }
+      } else if (cls > 3) {
+        w(cln), --cls;
+        for (; cls > 6; cls -= 6)
+          w(8304);
+        if (cls > 2)
+          w(cls - 3 << 5 | 8208), cls = 0;
+      }
+      while (cls--)
+        w(cln);
+      cls = 1;
+      cln = c[i];
+    }
+  }
+  return { c: cl.subarray(0, cli), n: s };
+};
+var clen = function(cf, cl) {
+  var l = 0;
+  for (var i = 0; i < cl.length; ++i)
+    l += cf[i] * cl[i];
+  return l;
+};
+var wfblk = function(out, pos, dat) {
+  var s = dat.length;
+  var o = shft(pos + 2);
+  out[o] = s & 255;
+  out[o + 1] = s >> 8;
+  out[o + 2] = out[o] ^ 255;
+  out[o + 3] = out[o + 1] ^ 255;
+  for (var i = 0; i < s; ++i)
+    out[o + i + 4] = dat[i];
+  return (o + 4 + s) * 8;
+};
+var wblk = function(dat, out, final, syms, lf, df, eb, li, bs, bl, p) {
+  wbits(out, p++, final);
+  ++lf[256];
+  var _a2 = hTree(lf, 15), dlt = _a2.t, mlb = _a2.l;
+  var _b2 = hTree(df, 15), ddt = _b2.t, mdb = _b2.l;
+  var _c = lc(dlt), lclt = _c.c, nlc = _c.n;
+  var _d = lc(ddt), lcdt = _d.c, ndc = _d.n;
+  var lcfreq = new u16(19);
+  for (var i = 0; i < lclt.length; ++i)
+    ++lcfreq[lclt[i] & 31];
+  for (var i = 0; i < lcdt.length; ++i)
+    ++lcfreq[lcdt[i] & 31];
+  var _e = hTree(lcfreq, 7), lct = _e.t, mlcb = _e.l;
+  var nlcc = 19;
+  for (; nlcc > 4 && !lct[clim[nlcc - 1]]; --nlcc)
+    ;
+  var flen = bl + 5 << 3;
+  var ftlen = clen(lf, flt) + clen(df, fdt) + eb;
+  var dtlen = clen(lf, dlt) + clen(df, ddt) + eb + 14 + 3 * nlcc + clen(lcfreq, lct) + 2 * lcfreq[16] + 3 * lcfreq[17] + 7 * lcfreq[18];
+  if (bs >= 0 && flen <= ftlen && flen <= dtlen)
+    return wfblk(out, p, dat.subarray(bs, bs + bl));
+  var lm, ll, dm, dl;
+  wbits(out, p, 1 + (dtlen < ftlen)), p += 2;
+  if (dtlen < ftlen) {
+    lm = hMap(dlt, mlb, 0), ll = dlt, dm = hMap(ddt, mdb, 0), dl = ddt;
+    var llm = hMap(lct, mlcb, 0);
+    wbits(out, p, nlc - 257);
+    wbits(out, p + 5, ndc - 1);
+    wbits(out, p + 10, nlcc - 4);
+    p += 14;
+    for (var i = 0; i < nlcc; ++i)
+      wbits(out, p + 3 * i, lct[clim[i]]);
+    p += 3 * nlcc;
+    var lcts = [lclt, lcdt];
+    for (var it = 0; it < 2; ++it) {
+      var clct = lcts[it];
+      for (var i = 0; i < clct.length; ++i) {
+        var len = clct[i] & 31;
+        wbits(out, p, llm[len]), p += lct[len];
+        if (len > 15)
+          wbits(out, p, clct[i] >> 5 & 127), p += clct[i] >> 12;
+      }
+    }
+  } else {
+    lm = flm, ll = flt, dm = fdm, dl = fdt;
+  }
+  for (var i = 0; i < li; ++i) {
+    var sym = syms[i];
+    if (sym > 255) {
+      var len = sym >> 18 & 31;
+      wbits16(out, p, lm[len + 257]), p += ll[len + 257];
+      if (len > 7)
+        wbits(out, p, sym >> 23 & 31), p += fleb[len];
+      var dst = sym & 31;
+      wbits16(out, p, dm[dst]), p += dl[dst];
+      if (dst > 3)
+        wbits16(out, p, sym >> 5 & 8191), p += fdeb[dst];
+    } else {
+      wbits16(out, p, lm[sym]), p += ll[sym];
+    }
+  }
+  wbits16(out, p, lm[256]);
+  return p + ll[256];
+};
+var deo = /* @__PURE__ */ new i32([65540, 131080, 131088, 131104, 262176, 1048704, 1048832, 2114560, 2117632]);
+var et = /* @__PURE__ */ new u8(0);
+var dflt = function(dat, lvl, plvl, pre, post, st) {
+  var s = st.z || dat.length;
+  var o = new u8(pre + s + 5 * (1 + Math.ceil(s / 7e3)) + post);
+  var w = o.subarray(pre, o.length - post);
+  var lst = st.l;
+  var pos = (st.r || 0) & 7;
+  if (lvl) {
+    if (pos)
+      w[0] = st.r >> 3;
+    var opt = deo[lvl - 1];
+    var n = opt >> 13, c = opt & 8191;
+    var msk_1 = (1 << plvl) - 1;
+    var prev = st.p || new u16(32768), head = st.h || new u16(msk_1 + 1);
+    var bs1_1 = Math.ceil(plvl / 3), bs2_1 = 2 * bs1_1;
+    var hsh = function(i2) {
+      return (dat[i2] ^ dat[i2 + 1] << bs1_1 ^ dat[i2 + 2] << bs2_1) & msk_1;
+    };
+    var syms = new i32(25e3);
+    var lf = new u16(288), df = new u16(32);
+    var lc_1 = 0, eb = 0, i = st.i || 0, li = 0, wi = st.w || 0, bs = 0;
+    for (; i + 2 < s; ++i) {
+      var hv = hsh(i);
+      var imod = i & 32767, pimod = head[hv];
+      prev[imod] = pimod;
+      head[hv] = imod;
+      if (wi <= i) {
+        var rem = s - i;
+        if ((lc_1 > 7e3 || li > 24576) && (rem > 423 || !lst)) {
+          pos = wblk(dat, w, 0, syms, lf, df, eb, li, bs, i - bs, pos);
+          li = lc_1 = eb = 0, bs = i;
+          for (var j = 0; j < 286; ++j)
+            lf[j] = 0;
+          for (var j = 0; j < 30; ++j)
+            df[j] = 0;
+        }
+        var l = 2, d = 0, ch_1 = c, dif = imod - pimod & 32767;
+        if (rem > 2 && hv == hsh(i - dif)) {
+          var maxn = Math.min(n, rem) - 1;
+          var maxd = Math.min(32767, i);
+          var ml = Math.min(258, rem);
+          while (dif <= maxd && --ch_1 && imod != pimod) {
+            if (dat[i + l] == dat[i + l - dif]) {
+              var nl = 0;
+              for (; nl < ml && dat[i + nl] == dat[i + nl - dif]; ++nl)
+                ;
+              if (nl > l) {
+                l = nl, d = dif;
+                if (nl > maxn)
+                  break;
+                var mmd = Math.min(dif, nl - 2);
+                var md = 0;
+                for (var j = 0; j < mmd; ++j) {
+                  var ti = i - dif + j & 32767;
+                  var pti = prev[ti];
+                  var cd = ti - pti & 32767;
+                  if (cd > md)
+                    md = cd, pimod = ti;
+                }
+              }
+            }
+            imod = pimod, pimod = prev[imod];
+            dif += imod - pimod & 32767;
+          }
+        }
+        if (d) {
+          syms[li++] = 268435456 | revfl[l] << 18 | revfd[d];
+          var lin = revfl[l] & 31, din = revfd[d] & 31;
+          eb += fleb[lin] + fdeb[din];
+          ++lf[257 + lin];
+          ++df[din];
+          wi = i + l;
+          ++lc_1;
+        } else {
+          syms[li++] = dat[i];
+          ++lf[dat[i]];
+        }
+      }
+    }
+    for (i = Math.max(i, wi); i < s; ++i) {
+      syms[li++] = dat[i];
+      ++lf[dat[i]];
+    }
+    pos = wblk(dat, w, lst, syms, lf, df, eb, li, bs, i - bs, pos);
+    if (!lst) {
+      st.r = pos & 7 | w[pos / 8 | 0] << 3;
+      pos -= 7;
+      st.h = head, st.p = prev, st.i = i, st.w = wi;
+    }
+  } else {
+    for (var i = st.w || 0; i < s + lst; i += 65535) {
+      var e = i + 65535;
+      if (e >= s) {
+        w[pos / 8 | 0] = lst;
+        e = s;
+      }
+      pos = wfblk(w, pos + 1, dat.subarray(i, e));
+    }
+    st.i = s;
+  }
+  return slc(o, 0, pre + shft(pos) + post);
+};
+var crct = /* @__PURE__ */ (function() {
+  var t = new Int32Array(256);
+  for (var i = 0; i < 256; ++i) {
+    var c = i, k = 9;
+    while (--k)
+      c = (c & 1 && -306674912) ^ c >>> 1;
+    t[i] = c;
+  }
+  return t;
+})();
+var crc = function() {
+  var c = -1;
+  return {
+    p: function(d) {
+      var cr = c;
+      for (var i = 0; i < d.length; ++i)
+        cr = crct[cr & 255 ^ d[i]] ^ cr >>> 8;
+      c = cr;
+    },
+    d: function() {
+      return ~c;
+    }
+  };
+};
+var dopt = function(dat, opt, pre, post, st) {
+  if (!st) {
+    st = { l: 1 };
+    if (opt.dictionary) {
+      var dict = opt.dictionary.subarray(-32768);
+      var newDat = new u8(dict.length + dat.length);
+      newDat.set(dict);
+      newDat.set(dat, dict.length);
+      dat = newDat;
+      st.w = dict.length;
+    }
+  }
+  return dflt(dat, opt.level == null ? 6 : opt.level, opt.mem == null ? st.l ? Math.ceil(Math.max(8, Math.min(13, Math.log(dat.length))) * 1.5) : 20 : 12 + opt.mem, pre, post, st);
+};
+var mrg = function(a, b) {
+  var o = {};
+  for (var k in a)
+    o[k] = a[k];
+  for (var k in b)
+    o[k] = b[k];
+  return o;
+};
+var wbytes = function(d, b, v) {
+  for (; v; ++b)
+    d[b] = v, v >>>= 8;
+};
+function deflateSync(data, opts) {
+  return dopt(data, opts || {}, 0, 0);
+}
+var fltn = function(d, p, t, o) {
+  for (var k in d) {
+    var val = d[k], n = p + k, op = o;
+    if (Array.isArray(val))
+      op = mrg(o, val[1]), val = val[0];
+    if (ArrayBuffer.isView(val))
+      t[n] = [val, op];
+    else {
+      t[n += "/"] = [new u8(0), op];
+      fltn(val, n, t, o);
+    }
+  }
+};
+var te = typeof TextEncoder != "undefined" && /* @__PURE__ */ new TextEncoder();
+var td = typeof TextDecoder != "undefined" && /* @__PURE__ */ new TextDecoder();
+var tds = 0;
+try {
+  td.decode(et, { stream: true });
+  tds = 1;
+} catch (e) {
+}
+function strToU8(str, latin1) {
+  if (latin1) {
+    var ar_1 = new u8(str.length);
+    for (var i = 0; i < str.length; ++i)
+      ar_1[i] = str.charCodeAt(i);
+    return ar_1;
+  }
+  if (te)
+    return te.encode(str);
+  var l = str.length;
+  var ar = new u8(str.length + (str.length >> 1));
+  var ai = 0;
+  var w = function(v) {
+    ar[ai++] = v;
+  };
+  for (var i = 0; i < l; ++i) {
+    if (ai + 5 > ar.length) {
+      var n = new u8(ai + 8 + (l - i << 1));
+      n.set(ar);
+      ar = n;
+    }
+    var c = str.charCodeAt(i);
+    if (c < 128 || latin1)
+      w(c);
+    else if (c < 2048)
+      w(192 | c >> 6), w(128 | c & 63);
+    else if (c > 55295 && c < 57344)
+      c = 65536 + (c & 1023 << 10) | str.charCodeAt(++i) & 1023, w(240 | c >> 18), w(128 | c >> 12 & 63), w(128 | c >> 6 & 63), w(128 | c & 63);
+    else
+      w(224 | c >> 12), w(128 | c >> 6 & 63), w(128 | c & 63);
+  }
+  return slc(ar, 0, ai);
+}
+var exfl = function(ex) {
+  var le = 0;
+  if (ex) {
+    for (var k in ex) {
+      var l = ex[k].length;
+      if (l > 65535)
+        err(9);
+      le += l + 4;
+    }
+  }
+  return le;
+};
+var wzh = function(d, b, f, fn, u, c, ce, co) {
+  var fl2 = fn.length, ex = f.extra, col = co && co.length;
+  var exl = exfl(ex);
+  wbytes(d, b, ce != null ? 33639248 : 67324752), b += 4;
+  if (ce != null)
+    d[b++] = 20, d[b++] = f.os;
+  d[b] = 20, b += 2;
+  d[b++] = f.flag << 1 | (c < 0 && 8), d[b++] = u && 8;
+  d[b++] = f.compression & 255, d[b++] = f.compression >> 8;
+  var dt = new Date(f.mtime == null ? Date.now() : f.mtime), y = dt.getFullYear() - 1980;
+  if (y < 0 || y > 119)
+    err(10);
+  wbytes(d, b, y << 25 | dt.getMonth() + 1 << 21 | dt.getDate() << 16 | dt.getHours() << 11 | dt.getMinutes() << 5 | dt.getSeconds() >> 1), b += 4;
+  if (c != -1) {
+    wbytes(d, b, f.crc);
+    wbytes(d, b + 4, c < 0 ? -c - 2 : c);
+    wbytes(d, b + 8, f.size);
+  }
+  wbytes(d, b + 12, fl2);
+  wbytes(d, b + 14, exl), b += 16;
+  if (ce != null) {
+    wbytes(d, b, col);
+    wbytes(d, b + 6, f.attrs);
+    wbytes(d, b + 10, ce), b += 14;
+  }
+  d.set(fn, b);
+  b += fl2;
+  if (exl) {
+    for (var k in ex) {
+      var exf = ex[k], l = exf.length;
+      wbytes(d, b, +k);
+      wbytes(d, b + 2, l);
+      d.set(exf, b + 4), b += 4 + l;
+    }
+  }
+  if (col)
+    d.set(co, b), b += col;
+  return b;
+};
+var wzf = function(o, b, c, d, e) {
+  wbytes(o, b, 101010256);
+  wbytes(o, b + 8, c);
+  wbytes(o, b + 10, c);
+  wbytes(o, b + 12, d);
+  wbytes(o, b + 16, e);
+};
+function zipSync(data, opts) {
+  if (!opts)
+    opts = {};
+  var r = {};
+  var files = [];
+  fltn(data, "", r, opts);
+  var o = 0;
+  var tot = 0;
+  for (var fn in r) {
+    var _a2 = r[fn], file2 = _a2[0], p = _a2[1];
+    var compression = p.level == 0 ? 0 : 8;
+    var f = strToU8(fn), s = f.length;
+    var com = p.comment, m = com && strToU8(com), ms = m && m.length;
+    var exl = exfl(p.extra);
+    if (s > 65535)
+      err(11);
+    var d = compression ? deflateSync(file2, p) : file2, l = d.length;
+    var c = crc();
+    c.p(file2);
+    files.push(mrg(p, {
+      size: file2.length,
+      crc: c.d(),
+      c: d,
+      f,
+      m,
+      u: s != fn.length || m && com.length != ms,
+      o,
+      compression
+    }));
+    o += 30 + s + exl + l;
+    tot += 76 + 2 * (s + exl) + (ms || 0) + l;
+  }
+  var out = new u8(tot + 22), oe = o, cdl = tot - o;
+  for (var i = 0; i < files.length; ++i) {
+    var f = files[i];
+    wzh(out, f.o, f, f.f, f.u, f.c.length);
+    var badd = 30 + f.f.length + exfl(f.extra);
+    out.set(f.c, f.o + badd);
+    wzh(out, o, f, f.f, f.u, f.c.length, f.o, f.m), o += 16 + badd + (f.m ? f.m.length : 0);
+  }
+  wzf(out, o, files.length, cdl, oe);
+  return out;
+}
+
+// ../contracts/dist/operations.js
+async function getRun(http, runId) {
+  const result = await http.request(`/api/runs/${encodeURIComponent(runId)}`);
+  return hasRun(result) ? result.run : result;
+}
+async function getRunUnit(http, runId) {
+  return http.request(`/api/runs/${encodeURIComponent(runId)}`);
+}
+async function listRunEvents(http, runId, options = {}) {
+  const query = options.channel && options.channel !== "event" ? { channel: options.channel } : {};
+  const result = await http.request(`/api/runs/${encodeURIComponent(runId)}/events`, {}, query);
+  return result.events;
+}
+async function getCoordinatorTicket(http, runId) {
+  return http.request(`/api/runs/${encodeURIComponent(runId)}/events/ticket`, { method: "POST" });
+}
+async function listOutputs(http, runId) {
+  const result = await http.request(`/api/runs/${encodeURIComponent(runId)}/outputs`);
+  return result.outputs;
+}
+async function listLogs(http, runId) {
+  const result = await http.request(`/api/runs/${encodeURIComponent(runId)}/logs`);
+  return result.logs.map((log) => typeof log.filename === "string" ? { ...log, filename: runArtifactRel(log.filename) } : log);
+}
+async function createOutputLink(http, runId, outputId) {
+  return http.request(`/api/runs/${encodeURIComponent(runId)}/outputs/${encodeURIComponent(outputId)}/link`, { method: "POST" });
+}
+function resolveOutputFileSelector(outputs, selector, runId) {
+  if (isPathSelector(selector)) {
+    const target = normalizeOutputLookupPath(selector.path);
+    if (!target) {
+      throw new RunStateError("downloadOutput: output path must be non-empty", { runId, path: selector.path });
+    }
+    const matches = outputs.filter((output) => {
+      if (typeof output.filename !== "string")
+        return false;
+      const filename = normalizeOutputLookupPath(output.filename);
+      if (selector.match === "suffix") {
+        return filename === target || filename.endsWith(`/${target}`);
+      }
+      return filename === target;
+    });
+    if (matches.length === 1)
+      return matches[0];
+    if (matches.length > 1) {
+      throw new RunStateError(`downloadOutput: output path "${selector.path}" matched multiple files`, { runId, path: selector.path, matches: matches.map((output) => output.filename ?? output.id) });
+    }
+    throw new RunStateError(`downloadOutput: output path "${selector.path}" was not found`, {
+      runId,
+      path: selector.path
+    });
+  }
+  if (typeof selector?.id !== "string" || selector.id.length === 0) {
+    throw new RunStateError("downloadOutput: selector must include an output id or path", { runId });
+  }
+  return { ...selector, id: selector.id };
+}
+async function downloadOutput(http, runId, selector) {
+  const output = isPathSelector(selector) ? resolveOutputFileSelector(await listOutputs(http, runId), selector, runId) : resolveOutputFileSelector([], selector, runId);
+  const { response } = await http.download(`/api/runs/${encodeURIComponent(runId)}/outputs/${encodeURIComponent(output.id)}/download`);
+  return { output, bytes: new Uint8Array(await response.arrayBuffer()) };
+}
+async function cancelRun(http, runId) {
+  await http.request(`/api/runs/${encodeURIComponent(runId)}/cancel`, { method: "POST" });
+}
+async function deleteRun(http, runId) {
+  await http.request(`/api/runs/${encodeURIComponent(runId)}`, { method: "DELETE" });
+}
+async function deleteWorkspaceAsset(http, hash) {
+  const assetId = hash.startsWith("asset_") ? hash : `asset_${hash.startsWith("sha256:") ? hash.slice("sha256:".length) : hash}`;
+  await http.request(`/assets/${encodeURIComponent(assetId)}`, { method: "DELETE" });
+}
+async function whoami(http) {
+  return http.request("/api/whoami");
+}
+async function collectArtifactBytes(http, runId, items, zipPrefix, namespace2) {
+  const entries = [];
+  const captured = [];
+  const errors = [];
+  for (const item of items) {
+    const rel = item.filename ?? item.id;
+    try {
+      const { response } = await http.download(`/api/runs/${encodeURIComponent(runId)}/${namespace2}/${encodeURIComponent(item.id)}/download`);
+      entries.push({
+        path: `${zipPrefix}${rel}`,
+        bytes: new Uint8Array(await response.arrayBuffer()),
+        ...item.contentType !== void 0 ? { contentType: item.contentType } : {},
+        ...namespace2 === "outputs" ? { customerContent: true } : {}
+      });
+      captured.push({
+        id: item.id,
+        filename: item.filename ?? null,
+        ...item.sizeBytes !== void 0 ? { sizeBytes: item.sizeBytes } : {},
+        ...item.contentType !== void 0 ? { contentType: item.contentType } : {}
+      });
+    } catch (err2) {
+      errors.push({ namespace: namespace2, id: item.id, filename: item.filename ?? null, message: err2.message });
+    }
+  }
+  return { entries: Object.freeze(entries), captured, errors };
+}
+function eventsJsonl(events) {
+  return strToU8(events.map((event) => JSON.stringify(event)).join("\n"));
+}
+async function tryListOptionalRunEvents(http, runId, channel) {
+  try {
+    const events = await listRunEvents(http, runId, { channel });
+    if (channel === "log") {
+      return events.length > 0 && events.every(isLogChannelEvent) ? { status: "present", events } : { status: "unavailable", events: [] };
+    }
+    return hasUnifiedStreamEvidence(events) ? { status: "present", events } : { status: "unavailable", events: [] };
+  } catch {
+    return { status: "unavailable", events: [] };
+  }
+}
+function isLogChannelEvent(event) {
+  return event.channel === "log";
+}
+function hasUnifiedStreamEvidence(events) {
+  return events.some((event) => event.channel === "log" || event.channel === "event");
+}
+function isPathSelector(selector) {
+  return Boolean(selector && typeof selector === "object" && "path" in selector);
+}
+function normalizeOutputLookupPath(path) {
+  return path.replace(/\\/g, "/").replace(/^\/+/, "");
+}
+async function download(http, runId) {
+  const [run, events, logEvents, allEvents, outputs, logItems] = await Promise.all([
+    getRun(http, runId),
+    listRunEvents(http, runId),
+    tryListOptionalRunEvents(http, runId, "log"),
+    tryListOptionalRunEvents(http, runId, "all"),
+    listOutputs(http, runId),
+    listLogs(http, runId)
+  ]);
+  const out = await collectArtifactBytes(http, runId, outputs, "outputs/", "outputs");
+  const logs = await collectArtifactBytes(http, runId, logItems, "logs/", "logs");
+  const submissionSnapshot = extractSubmissionSnapshot(run);
+  const costTelemetry = extractCostTelemetry(run);
+  const manifest = buildRunRecordDownloadManifestV1({
+    runId,
+    outputs: out.captured,
+    logs: logs.captured,
+    errors: [...out.errors, ...logs.errors],
+    typedEventCount: events.length,
+    ...submissionSnapshot ? { submission: { status: "present" } } : {},
+    ...costTelemetry ? { cost: { status: "present" } } : {},
+    logEvents: { status: logEvents.status, recordCount: logEvents.events.length },
+    allEvents: { status: allEvents.status, recordCount: allEvents.events.length }
+  });
+  return zipEntries([
+    jsonEntry("metadata/run.json", run),
+    ...submissionSnapshot ? [jsonEntry("metadata/submission.json", submissionSnapshot)] : [],
+    ...costTelemetry ? [jsonEntry("metadata/cost.json", costTelemetry)] : [],
+    jsonlEntry("events/events.jsonl", events),
+    ...logEvents.status === "present" ? [jsonlEntry("events/logs.jsonl", logEvents.events)] : [],
+    ...allEvents.status === "present" ? [jsonlEntry("events/all.jsonl", allEvents.events)] : [],
+    ...out.entries,
+    ...logs.entries,
+    jsonEntry("manifest.json", manifest)
+  ]);
+}
+async function downloadOutputs(http, runId) {
+  const outputs = await listOutputs(http, runId);
+  const { entries, captured, errors } = await collectArtifactBytes(http, runId, outputs, "", "outputs");
+  return zipEntries([
+    ...entries,
+    jsonEntry("manifest.json", { runId, namespace: "outputs", outputs: captured, errors })
+  ]);
+}
+async function downloadLogs(http, runId) {
+  const logItems = await listLogs(http, runId);
+  const { entries, captured, errors } = await collectArtifactBytes(http, runId, logItems, "", "logs");
+  return zipEntries([
+    ...entries,
+    jsonEntry("manifest.json", { runId, namespace: "logs", logs: captured, errors })
+  ]);
+}
+async function downloadEvents(http, runId) {
+  const [events, logEvents, allEvents] = await Promise.all([
+    listRunEvents(http, runId),
+    tryListOptionalRunEvents(http, runId, "log"),
+    tryListOptionalRunEvents(http, runId, "all")
+  ]);
+  return zipEntries([
+    jsonlEntry("events.jsonl", events),
+    ...logEvents.status === "present" ? [jsonlEntry("logs.jsonl", logEvents.events)] : [],
+    ...allEvents.status === "present" ? [jsonlEntry("all.jsonl", allEvents.events)] : []
+  ]);
+}
+async function downloadMetadata(http, runId) {
+  const run = await getRun(http, runId);
+  return zipEntries([jsonEntry("run.json", run)]);
+}
+function zipEntries(entries) {
+  assertRunRecordArchivePublicSafeV1(entries);
+  const files = {};
+  for (const entry of entries) {
+    files[entry.path] = entry.bytes;
+  }
+  return zipSync(files);
+}
+function jsonEntry(path, value) {
+  return {
+    path,
+    bytes: strToU8(JSON.stringify(value, null, 2)),
+    contentType: "application/json; charset=utf-8"
+  };
+}
+function jsonlEntry(path, events) {
+  return {
+    path,
+    bytes: eventsJsonl(events),
+    contentType: "application/jsonl; charset=utf-8"
+  };
+}
+function extractSubmissionSnapshot(run) {
+  const raw = run.submission;
+  if (!isRecord(raw) || raw.kind !== "submission" || !isRecord(raw.submission)) {
+    return void 0;
+  }
+  return {
+    submission: raw.submission
+  };
+}
+function extractCostTelemetry(run) {
+  const raw = run.costTelemetry;
+  return isRecord(raw) ? raw : void 0;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function submitRun(http, request) {
+  return http.request("/api/runs", {
+    method: "POST",
+    body: JSON.stringify(request)
+  });
+}
+async function submitRunMultipart(http, request, bundles, agentsMdParts, fileParts) {
+  const hasBundles = Array.isArray(bundles) && bundles.length > 0;
+  const hasAgentsMd = Array.isArray(agentsMdParts) && agentsMdParts.length > 0;
+  const hasFiles = Array.isArray(fileParts) && fileParts.length > 0;
+  if (!hasBundles && !hasAgentsMd && !hasFiles) {
+    throw new Error("submitRunMultipart: bundles, agentsMdParts, or fileParts must be non-empty");
+  }
+  const form = new FormData();
+  form.append("submission", new Blob([JSON.stringify(request)], { type: "application/json" }), "submission.json");
+  const seen = /* @__PURE__ */ new Set();
+  for (const bundle of bundles) {
+    if (typeof bundle.slot !== "string" || !bundle.slot) {
+      throw new Error("submitRunMultipart: each bundle must have a non-empty slot id");
+    }
+    if (seen.has(bundle.slot)) {
+      throw new Error(`submitRunMultipart: duplicate inline skill slot "${bundle.slot}"`);
+    }
+    seen.add(bundle.slot);
+    const blob = toBlob(bundle.bytes, "application/zip");
+    form.append(`skill:${bundle.slot}`, blob, bundle.filename);
+  }
+  for (const part of agentsMdParts ?? []) {
+    if (typeof part.slot !== "string" || !part.slot) {
+      throw new Error("submitRunMultipart: each agentsMd part must have a non-empty slot id");
+    }
+    const partKey = `agentsmd:${part.slot}`;
+    if (seen.has(partKey)) {
+      throw new Error(`submitRunMultipart: duplicate agentsMd slot "${part.slot}"`);
+    }
+    seen.add(partKey);
+    const blob = new Blob([part.content], { type: "text/plain" });
+    form.append(partKey, blob, part.filename);
+  }
+  for (const part of fileParts ?? []) {
+    if (typeof part.slot !== "string" || !part.slot) {
+      throw new Error("submitRunMultipart: each file part must have a non-empty slot id");
+    }
+    const partKey = `file:${part.slot}`;
+    if (seen.has(partKey)) {
+      throw new Error(`submitRunMultipart: duplicate file slot "${part.slot}"`);
+    }
+    seen.add(partKey);
+    const blob = toBlob(part.bytes, "application/zip");
+    form.append(partKey, blob, part.filename);
+  }
+  return http.request("/api/runs", {
+    method: "POST",
+    body: form
+  });
+}
+async function createSkillBundle(http, args) {
+  const form = new FormData();
+  form.append("name", args.name);
+  const blobBody = toBlob(args.body, args.contentType ?? "application/zip");
+  form.append("bundle", blobBody, args.filename ?? `${args.name}.zip`);
+  const result = await http.request("/api/skills", {
+    method: "POST",
+    body: form
+  });
+  return unwrapSkill(result);
+}
+async function createSkillBundleDirect(http, fetchImpl, args) {
+  let presign;
+  try {
+    presign = await http.request("/api/skills/presign", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ name: args.name, hash: args.contentHash, sizeBytes: args.body.byteLength })
+    });
+  } catch (err2) {
+    const status = err2.status;
+    const code = (err2.details ?? {}).code;
+    if (status === 503 && code === "presign_unconfigured") {
+      return createSkillBundle(http, {
+        name: args.name,
+        body: args.body,
+        ...args.contentType ? { contentType: args.contentType } : {}
+      });
+    }
+    throw err2;
+  }
+  const putRes = await fetchImpl(presign.uploadUrl, {
+    method: "PUT",
+    headers: { "content-type": args.contentType ?? "application/zip", ...presign.requiredHeaders ?? {} },
+    body: args.body
+  });
+  if (!putRes.ok) {
+    const detail = await putRes.text().catch(() => "");
+    throw new Error(`createSkillBundleDirect: direct upload PUT failed (status ${putRes.status})${detail ? `: ${detail.slice(0, 500)}` : ""}`);
+  }
+  const result = await http.request(`/api/skills/${encodeURIComponent(presign.skillId)}/finalize`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ manifest: args.manifest })
+  });
+  return unwrapSkill(result);
+}
+async function listSkills(http) {
+  const result = await http.request("/api/skills");
+  if (Array.isArray(result)) {
+    return result;
+  }
+  return result.skills;
+}
+async function getSkill(http, skillId) {
+  const result = await http.request(`/api/skills/${encodeURIComponent(skillId)}`);
+  return unwrapSkill(result);
+}
+async function deleteSkill(http, skillId) {
+  await http.request(`/api/skills/${encodeURIComponent(skillId)}`, {
+    method: "DELETE"
+  });
+}
+async function findSkillByHash(http, args) {
+  const params = new URLSearchParams({
+    name: args.name,
+    content_hash: args.contentHash
+  });
+  const result = await http.request(`/api/skills/by-hash?${params.toString()}`);
+  return result.skill ?? null;
+}
+async function findSkillByName(http, name) {
+  const skills = await listSkills(http);
+  return skills.find((skill) => skill.name === name) ?? null;
+}
+async function createAgentsMd(http, args) {
+  const form = new FormData();
+  form.append("name", args.name);
+  form.append("content", new Blob([args.content], { type: "text/plain" }), "AGENTS.md");
+  const result = await http.request("/api/agentsmd", { method: "POST", body: form });
+  return unwrapAgentsMd(result);
+}
+async function listAgentsMd(http) {
+  const result = await http.request("/api/agentsmd");
+  if (Array.isArray(result)) {
+    return result;
+  }
+  return result.agentsMd;
+}
+async function getAgentsMd(http, agentsMdId) {
+  const result = await http.request(`/api/agentsmd/${encodeURIComponent(agentsMdId)}`);
+  return unwrapAgentsMd(result);
+}
+async function deleteAgentsMd(http, agentsMdId) {
+  await http.request(`/api/agentsmd/${encodeURIComponent(agentsMdId)}`, {
+    method: "DELETE"
+  });
+}
+function unwrapAgentsMd(result) {
+  if (result && typeof result === "object" && "agentsMd" in result) {
+    return result.agentsMd;
+  }
+  return result;
+}
+async function createFile(http, args) {
+  const form = new FormData();
+  form.append("name", args.name);
+  const blob = toBlob(args.bytes, "application/zip");
+  form.append("bundle", blob, `${args.name}.zip`);
+  const result = await http.request("/api/files", { method: "POST", body: form });
+  return unwrapFile(result);
+}
+async function listFiles(http) {
+  const result = await http.request("/api/files");
+  if (Array.isArray(result)) {
+    return result;
+  }
+  return result.files;
+}
+async function getFile(http, fileId) {
+  const result = await http.request(`/api/files/${encodeURIComponent(fileId)}`);
+  return unwrapFile(result);
+}
+async function deleteFile(http, fileId) {
+  await http.request(`/api/files/${encodeURIComponent(fileId)}`, {
+    method: "DELETE"
+  });
+}
+function unwrapFile(result) {
+  if (result && typeof result === "object" && "file" in result) {
+    return result.file;
+  }
+  return result;
+}
+function unwrapSkill(result) {
+  if (result && typeof result === "object" && "skill" in result) {
+    return result.skill;
+  }
+  return result;
+}
+function toBlob(input, contentType) {
+  if (input instanceof Blob) {
+    return input;
+  }
+  if (input instanceof Uint8Array) {
+    const copy = new Uint8Array(input.byteLength);
+    copy.set(input);
+    return new Blob([copy.buffer], { type: contentType });
+  }
+  return new Blob([input], { type: contentType });
+}
+function hasRun(value) {
+  return Boolean(value && typeof value === "object" && "run" in value);
+}
+async function uploadWorkspaceAsset(http, input) {
+  return http.request("/assets", {
+    method: "POST",
+    headers: {
+      "content-type": input.contentType ?? "application/octet-stream",
+      "content-length": String(input.bytes.byteLength),
+      ...input.contentHash ? { "x-asset-hash": input.contentHash } : {}
+    },
+    body: input.bytes
+  });
+}
+
+// ../contracts/dist/proxy-validation.js
+function validateProxyAuth(endpoints, auth) {
+  const authList = auth ?? [];
+  const endpointNames = new Set(endpoints.map((e) => e.name));
+  const authNames = /* @__PURE__ */ new Set();
+  for (const entry of authList) {
+    if (authNames.has(entry.name)) {
+      throw new Error(`secrets.proxyEndpointAuth contains duplicate name '${entry.name}'`);
+    }
+    authNames.add(entry.name);
+    if (!endpointNames.has(entry.name)) {
+      throw new Error(`secrets.proxyEndpointAuth[].name='${entry.name}' has no matching proxyEndpoints[].name`);
+    }
+  }
+  for (const endpoint of endpoints) {
+    const match = authList.find((a) => a.name === endpoint.name);
+    if (!match) {
+      throw new Error(`proxyEndpoints[].name='${endpoint.name}' is missing a matching secrets.proxyEndpointAuth entry`);
+    }
+    if (match.value.type !== endpoint.authShape.type) {
+      throw new Error(`secrets.proxyEndpointAuth[name='${endpoint.name}'].value.type='${match.value.type}' does not match proxyEndpoints[name='${endpoint.name}'].authShape.type='${endpoint.authShape.type}'`);
+    }
+  }
+}
+
+// dist/internal.js
+var AEX_INDEX_PATH = "/mnt/session/uploads/aex/index.json";
+var AEX_RUN_TOKEN_PATH = "/mnt/session/uploads/aex/run-token";
+
+// dist/host/common.js
+var SUCCESS = { code: 0 };
+var USAGE_ERR = { code: 2 };
+var RUNTIME_ERR = { code: 1 };
+var TIMEOUT_ERR = { code: 3 };
+function parseCommonHostFlags(argv) {
+  let apiToken = null;
+  let aexUrl = null;
+  let debug = false;
+  const rest = [];
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--debug") {
+      debug = true;
+      continue;
+    }
+    if (arg === "--api-token") {
+      const v = argv[++i];
+      if (v === void 0)
+        return { ok: false, reason: "--api-token requires a value" };
+      apiToken = v;
+      continue;
+    }
+    if (arg === "--aex-url") {
+      const v = argv[++i];
+      if (v === void 0)
+        return { ok: false, reason: "--aex-url requires a value" };
+      aexUrl = v;
+      continue;
+    }
+    if (arg === "--workspace" || arg === "--workspace-id") {
+      return {
+        ok: false,
+        reason: `unknown flag ${arg}: workspace is derived from --api-token on the server; drop this flag`
+      };
+    }
+    rest.push(arg);
+  }
+  if (!apiToken)
+    return { ok: false, reason: "--api-token is required" };
+  return {
+    ok: true,
+    flags: { apiToken, aexUrl: aexUrl ?? AEX_DEFAULT_BASE_URL, debug },
+    rest
+  };
+}
+function makeHttpClient(io2, flags) {
+  return new HttpClient({
+    baseUrl: flags.aexUrl,
+    apiToken: flags.apiToken,
+    fetch: io2.fetchImpl,
+    // `--debug`: route the transport's redacted per-request traces to stderr.
+    ...flags.debug ? { debug: (line) => io2.stderr(`${line}
+`) } : {}
+  });
+}
+async function refuseInsideManagedRun(io2, verb) {
+  try {
+    await io2.readFile(AEX_INDEX_PATH);
+    io2.stderr(`\`aex ${verb}\` is a host command and cannot run inside a managed run container.
+Use \`aex proxy ...\` to call your declared upstream endpoints from inside the run.
+`);
+    return true;
+  } catch (err2) {
+    const code = err2?.code;
+    if (code === "ENOENT" || code === "ENOTDIR") {
+      return false;
+    }
+    io2.stderr(`\`aex ${verb}\` could not determine whether it is running inside a managed run container (error reading ${AEX_INDEX_PATH}: ${err2.message ?? "unknown"}). Refusing to proceed.
+`);
+    return true;
+  }
+}
+function emitJsonError(io2, code, message, extra = {}) {
+  io2.stderr(JSON.stringify({ error: code, message, ...extra }) + "\n");
+  return RUNTIME_ERR;
+}
+function collectRepeatedKv(rest, flag) {
+  const entries = {};
+  const remaining = [];
+  for (let i = 0; i < rest.length; i++) {
+    const arg = rest[i];
+    if (arg === flag) {
+      const kv = rest[++i];
+      if (kv === void 0) {
+        return { entries, remaining, error: `${flag} requires a KEY=VALUE argument` };
+      }
+      const eq = kv.indexOf("=");
+      if (eq <= 0) {
+        return { entries, remaining, error: `${flag} must be in the form KEY=VALUE (got: ${kv})` };
+      }
+      entries[kv.slice(0, eq)] = kv.slice(eq + 1);
+      continue;
+    }
+    remaining.push(arg);
+  }
+  return { entries, remaining, error: null };
+}
+function collectRepeated(rest, flag) {
+  const values = [];
+  const remaining = [];
+  for (let i = 0; i < rest.length; i++) {
+    const arg = rest[i];
+    if (arg === flag) {
+      const v = rest[++i];
+      if (v === void 0) {
+        return { values, remaining, error: `${flag} requires a value` };
+      }
+      values.push(v);
+      continue;
+    }
+    remaining.push(arg);
+  }
+  return { values, remaining, error: null };
+}
+function collectRepeatedKvList(rest, flag) {
+  const entries = [];
+  const remaining = [];
+  for (let i = 0; i < rest.length; i++) {
+    const arg = rest[i];
+    if (arg === flag) {
+      const kv = rest[++i];
+      if (kv === void 0) {
+        return { entries, remaining, error: `${flag} requires a KEY=VALUE argument` };
+      }
+      const eq = kv.indexOf("=");
+      if (eq <= 0) {
+        return { entries, remaining, error: `${flag} must be in the form KEY=VALUE (got: ${kv})` };
+      }
+      entries.push([kv.slice(0, eq), kv.slice(eq + 1)]);
+      continue;
+    }
+    remaining.push(arg);
+  }
+  return { entries, remaining, error: null };
+}
+function takeFlagValue(rest, flag) {
+  let value = null;
+  const remaining = [];
+  for (let i = 0; i < rest.length; i++) {
+    const arg = rest[i];
+    if (arg === flag) {
+      const v = rest[++i];
+      if (v === void 0) {
+        return { value, remaining, error: `${flag} requires a value` };
+      }
+      value = v;
+      continue;
+    }
+    remaining.push(arg);
+  }
+  return { value, remaining, error: null };
+}
+function parseDuration(input) {
+  const match = /^(\d+(?:\.\d+)?)(ms|s|m|h)?$/.exec(input.trim());
+  if (!match) {
+    return { ms: null, error: `invalid duration "${input}" (expected e.g. 500ms, 30s, 8m, 1h, or a bare ms integer)` };
+  }
+  const value = Number(match[1]);
+  if (!Number.isFinite(value) || value < 0) {
+    return { ms: null, error: `invalid duration "${input}" (must be a non-negative number)` };
+  }
+  const unit = match[2] ?? "ms";
+  const factor = unit === "h" ? 36e5 : unit === "m" ? 6e4 : unit === "s" ? 1e3 : 1;
+  return { ms: Math.round(value * factor), error: null };
+}
+function takeBooleanFlag(rest, flag) {
+  const remaining = [];
+  let present = false;
+  for (const arg of rest) {
+    if (arg === flag) {
+      present = true;
+      continue;
+    }
+    remaining.push(arg);
+  }
+  return { present, remaining };
+}
+function takeOptionFlag(rest, flag) {
+  const remaining = [];
+  let value;
+  const prefix = `${flag}=`;
+  for (let i = 0; i < rest.length; i++) {
+    const arg = rest[i];
+    if (arg === flag) {
+      const next = rest[++i];
+      if (next !== void 0)
+        value = next;
+      continue;
+    }
+    if (arg.startsWith(prefix)) {
+      value = arg.slice(prefix.length);
+      continue;
+    }
+    remaining.push(arg);
+  }
+  return { value, remaining };
+}
+
+// dist/outputs-sync.js
+async function runOutputsSyncCmd(io2, dirs) {
+  if (dirs.length === 0) {
+    io2.stderr("usage: aex outputs sync <dir> [<dir> ...]\n");
+    return USAGE_ERR;
+  }
+  try {
+    await io2.readFile(AEX_INDEX_PATH);
+  } catch {
+    io2.stderr("`aex outputs sync` is an in-container internal command and cannot run on the host.\n");
+    return USAGE_ERR;
+  }
+  if (!io2.walkDirectory) {
+    io2.stderr("aex outputs sync: walkDirectory IO is not available\n");
+    return RUNTIME_ERR;
+  }
+  let scanned = 0;
+  let missing = 0;
+  for (const dir of dirs) {
+    if (!dir.startsWith("/")) {
+      io2.stderr(JSON.stringify({ dir, error: "non_absolute_path", message: "skipping non-absolute output dir" }) + "\n");
+      missing++;
+      continue;
+    }
+    let entries;
+    try {
+      entries = await io2.walkDirectory(dir);
+    } catch (err2) {
+      io2.stderr(JSON.stringify({ dir, error: "walk_failed", message: err2.message ?? "walk failed" }) + "\n");
+      missing++;
+      continue;
+    }
+    if (entries === null) {
+      io2.stderr(JSON.stringify({ dir, error: "missing_or_unreadable" }) + "\n");
+      missing++;
+      continue;
+    }
+    for (const entry of entries) {
+      io2.stdout(JSON.stringify({ dir, path: entry.path, sizeBytes: entry.sizeBytes }) + "\n");
+      scanned++;
+    }
+  }
+  io2.stdout(JSON.stringify({ summary: { dirs: dirs.length, files: scanned, missing } }) + "\n");
+  return SUCCESS;
+}
+
+// dist/proxy.js
+function parseProxyFlags(rest) {
+  let endpointName = null;
+  let method = "GET";
+  let path = "/";
+  let query = null;
+  const headers = /* @__PURE__ */ new Map();
+  let dataSpec = null;
+  let responseMode = null;
+  let showHelp = false;
+  for (let i = 0; i < rest.length; i++) {
+    const arg = rest[i];
+    if (arg === "--help" || arg === "-h") {
+      showHelp = true;
+      continue;
+    }
+    if (arg === "--method") {
+      method = expect(rest, ++i, "--method");
+      continue;
+    }
+    if (arg === "--path") {
+      path = expect(rest, ++i, "--path");
+      continue;
+    }
+    if (arg === "--query") {
+      query = expect(rest, ++i, "--query");
+      continue;
+    }
+    if (arg === "--header") {
+      const kv = expect(rest, ++i, "--header");
+      const eq = kv.indexOf("=");
+      if (eq <= 0)
+        return { ok: false, reason: "--header must be in the form KEY=VALUE" };
+      headers.set(kv.slice(0, eq).toLowerCase(), kv.slice(eq + 1));
+      continue;
+    }
+    if (arg === "--data") {
+      dataSpec = expect(rest, ++i, "--data");
+      continue;
+    }
+    if (arg === "--response-mode") {
+      responseMode = expect(rest, ++i, "--response-mode");
+      continue;
+    }
+    if (arg.startsWith("--")) {
+      return { ok: false, reason: `unknown flag: ${arg}` };
+    }
+    if (endpointName === null) {
+      endpointName = arg;
+      continue;
+    }
+    return { ok: false, reason: `unexpected positional argument: ${arg}` };
+  }
+  return { ok: true, flags: { endpointName, method, path, query, headers, dataSpec, responseMode, showHelp } };
+}
+function expect(arr, idx, flag) {
+  const v = arr[idx];
+  if (v === void 0) {
+    throw new CliUsageError(`${flag} requires a value`);
+  }
+  return v;
+}
+var CliUsageError = class extends Error {
+};
+async function printProxyHelp(io2) {
+  io2.stdout("aex proxy \u2014 call an upstream HTTP endpoint via the managed proxy.\n\n");
+  io2.stdout("Usage:\n");
+  io2.stdout("  aex proxy <endpoint-name> [flags]\n\n");
+  io2.stdout("Flags:\n");
+  io2.stdout("  --method <verb>          HTTP method (default: GET)\n");
+  io2.stdout("  --path <path>            Caller-supplied path; must match policy prefixes\n");
+  io2.stdout(`  --query <json>           JSON object of query parameters (e.g. '{"q":"x"}')
+`);
+  io2.stdout("  --header K=V             Add a caller header (repeatable)\n");
+  io2.stdout("  --data <value>           Request body. Use '-' for stdin, '@<file>' for file content\n");
+  io2.stdout("  --response-mode <mode>   status_only | headers_only | full (may only narrow policy)\n");
+  io2.stdout("  --help                   Show this message\n\n");
+  const manifest = await tryReadManifest(io2);
+  if (manifest && manifest.endpoints.length > 0) {
+    io2.stdout("Declared endpoints:\n");
+    for (const ep of manifest.endpoints) {
+      io2.stdout(`  \u2022 ${ep.name}: ${ep.allowMethods.join(",")} ${ep.allowPathPrefixes.join(",")} (mode=${ep.responseMode}, budget=${ep.perCallBudget}/run)
+`);
+    }
+  }
+  return SUCCESS;
+}
+async function runProxy(io2, rest) {
+  let parsed;
+  try {
+    parsed = parseProxyFlags(rest);
+  } catch (err2) {
+    if (err2 instanceof CliUsageError) {
+      io2.stderr(`${err2.message}
+`);
+      return USAGE_ERR;
+    }
+    throw err2;
+  }
+  if (!parsed.ok) {
+    io2.stderr(`${parsed.reason}
+`);
+    return USAGE_ERR;
+  }
+  const f = parsed.flags;
+  if (f.showHelp) {
+    return await printProxyHelp(io2);
+  }
+  if (!f.endpointName) {
+    io2.stderr("missing endpoint-name\n");
+    io2.stderr("usage: aex proxy <endpoint-name> [flags]\n");
+    return USAGE_ERR;
+  }
+  if (f.responseMode && !PROXY_RESPONSE_MODES.includes(f.responseMode)) {
+    io2.stderr(`--response-mode must be one of: ${PROXY_RESPONSE_MODES.join(", ")}
+`);
+    return USAGE_ERR;
+  }
+  const manifest = await tryReadManifest(io2);
+  if (!manifest) {
+    emitError(io2, {
+      error: "internal_error",
+      message: "manifest not mounted; this CLI must run inside an aex-managed run"
+    });
+    return RUNTIME_ERR;
+  }
+  if (!manifest.proxyBaseUrl) {
+    emitError(io2, {
+      error: "endpoint_not_found",
+      message: "this run has no proxy endpoints declared",
+      endpointName: f.endpointName
+    });
+    return RUNTIME_ERR;
+  }
+  let token;
+  try {
+    token = (await io2.readFile(AEX_RUN_TOKEN_PATH)).trim();
+  } catch {
+    emitError(io2, {
+      error: "unauthorized",
+      message: "run token file missing; this run has no proxy bearer"
+    });
+    return RUNTIME_ERR;
+  }
+  if (!token) {
+    emitError(io2, { error: "unauthorized", message: "run token is empty" });
+    return RUNTIME_ERR;
+  }
+  let body;
+  if (f.dataSpec !== null) {
+    try {
+      body = await resolveBody(io2, f.dataSpec);
+    } catch (err2) {
+      io2.stderr(`failed to read request body: ${err2.message}
+`);
+      return RUNTIME_ERR;
+    }
+  }
+  const url = `${manifest.proxyBaseUrl.replace(/\/+$/, "")}/${encodeURIComponent(f.endpointName)}`;
+  const requestHeaders = new Headers();
+  requestHeaders.set("authorization", `Bearer ${token}`);
+  requestHeaders.set(PROXY_PROTOCOL_HEADER, PROXY_PROTOCOL_VERSION);
+  requestHeaders.set(PROXY_METHOD_HEADER, f.method.toUpperCase());
+  requestHeaders.set(PROXY_PATH_HEADER, f.path);
+  if (f.query) {
+    requestHeaders.set(PROXY_QUERY_HEADER, f.query);
+  }
+  if (f.headers.size > 0) {
+    requestHeaders.set(PROXY_HEADERS_HEADER, JSON.stringify(Object.fromEntries(f.headers)));
+  }
+  if (f.responseMode) {
+    requestHeaders.set(PROXY_RESPONSE_MODE_HEADER, f.responseMode);
+  }
+  if (body !== void 0) {
+    requestHeaders.set("content-length", String(body.byteLength));
+  }
+  const init = {
+    method: "POST",
+    headers: requestHeaders,
+    redirect: "manual"
+  };
+  if (body !== void 0) {
+    init.body = body;
+  }
+  let response;
+  try {
+    response = await io2.fetchImpl(url, init);
+  } catch (err2) {
+    emitError(io2, {
+      error: "upstream_error",
+      message: `proxy request failed: ${err2.message}`,
+      endpointName: f.endpointName
+    });
+    return RUNTIME_ERR;
+  }
+  const text = await response.text();
+  let parsedBody;
+  try {
+    parsedBody = text ? JSON.parse(text) : {};
+  } catch {
+    const snippet = text.slice(0, 200).replace(/\s+/g, " ").trim();
+    emitError(io2, {
+      error: "internal_error",
+      message: `proxy returned non-JSON response (HTTP ${response.status}, body=${JSON.stringify(snippet)})`,
+      endpointName: f.endpointName
+    });
+    return RUNTIME_ERR;
+  }
+  if (!response.ok) {
+    io2.stderr(JSON.stringify(parsedBody) + "\n");
+    return RUNTIME_ERR;
+  }
+  io2.stdout(JSON.stringify(parsedBody) + "\n");
+  return SUCCESS;
+}
+async function resolveBody(io2, spec) {
+  if (spec === "-") {
+    const data = await io2.readFile("/dev/stdin");
+    return new Uint8Array(Buffer.from(data, "utf8"));
+  }
+  if (spec.startsWith("@")) {
+    const path = spec.slice(1);
+    if (!path)
+      throw new Error("--data @<file> requires a path");
+    const data = await io2.readFile(path);
+    return new Uint8Array(Buffer.from(data, "utf8"));
+  }
+  return new Uint8Array(Buffer.from(spec, "utf8"));
+}
+function emitError(io2, body) {
+  io2.stderr(JSON.stringify(body) + "\n");
+}
+async function tryReadManifest(io2) {
+  try {
+    const raw = await io2.readFile(AEX_INDEX_PATH);
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+// dist/host/run-cmd.js
+import { resolve as resolvePath } from "node:path";
+var TERMINAL_STATUSES = new Set(TERMINAL_RUN_STATUSES);
+async function runRunCmd(io2, argv) {
+  if (await refuseInsideManagedRun(io2, "run"))
+    return USAGE_ERR;
+  const common = parseCommonHostFlags(argv);
+  if (!common.ok) {
+    io2.stderr(`${common.reason}
+`);
+    return USAGE_ERR;
+  }
+  let rest = common.rest;
+  const providerFlag = takeFlagValue(rest, "--provider");
+  if (providerFlag.error) {
+    io2.stderr(`${providerFlag.error}
+`);
+    return USAGE_ERR;
+  }
+  rest = providerFlag.remaining;
+  let provider = DEFAULT_RUN_PROVIDER;
+  if (providerFlag.value !== null) {
+    if (!RUN_PROVIDERS.includes(providerFlag.value)) {
+      io2.stderr(`--provider must be one of: ${RUN_PROVIDERS.join(", ")} (got: ${providerFlag.value})
+`);
+      return USAGE_ERR;
+    }
+    provider = providerFlag.value;
+  }
+  const providerKeyValues = {};
+  for (const p of RUN_PROVIDERS) {
+    const flag = takeFlagValue(rest, `--${p}-api-key`);
+    if (flag.error) {
+      io2.stderr(`${flag.error}
+`);
+      return USAGE_ERR;
+    }
+    rest = flag.remaining;
+    if (flag.value !== null)
+      providerKeyValues[p] = flag.value;
+  }
+  if (!providerKeyValues[provider]) {
+    io2.stderr(`--${provider}-api-key is required when --provider is ${provider} (the platform does not store provider keys on your behalf)
+`);
+    return USAGE_ERR;
+  }
+  for (const p of RUN_PROVIDERS) {
+    if (p === provider)
+      continue;
+    if (providerKeyValues[p] !== void 0) {
+      io2.stderr(`--${p}-api-key is not allowed when --provider is ${provider}
+`);
+      return USAGE_ERR;
+    }
+  }
+  const runtimeFlag = takeFlagValue(rest, "--runtime");
+  if (runtimeFlag.error) {
+    io2.stderr(`${runtimeFlag.error}
+`);
+    return USAGE_ERR;
+  }
+  rest = runtimeFlag.remaining;
+  let runtime;
+  if (runtimeFlag.value !== null) {
+    if (!RUNTIME_KINDS.includes(runtimeFlag.value)) {
+      io2.stderr(`--runtime must be one of: ${RUNTIME_KINDS.join(", ")} (got: ${runtimeFlag.value})
+`);
+      return USAGE_ERR;
+    }
+    runtime = runtimeFlag.value;
+  }
+  const idempotency = takeFlagValue(rest, "--idempotency-key");
+  if (idempotency.error) {
+    io2.stderr(`${idempotency.error}
+`);
+    return USAGE_ERR;
+  }
+  rest = idempotency.remaining;
+  const runtimeSizeFlag = takeFlagValue(rest, "--runtime-size");
+  if (runtimeSizeFlag.error) {
+    io2.stderr(`${runtimeSizeFlag.error}
+`);
+    return USAGE_ERR;
+  }
+  rest = runtimeSizeFlag.remaining;
+  if (runtimeSizeFlag.value && !RUNTIME_SIZES.includes(runtimeSizeFlag.value)) {
+    io2.stderr(`--runtime-size must be one of: ${RUNTIME_SIZES.join(", ")}
+`);
+    return USAGE_ERR;
+  }
+  const runTimeoutFlag = takeFlagValue(rest, "--run-timeout");
+  if (runTimeoutFlag.error) {
+    io2.stderr(`${runTimeoutFlag.error}
+`);
+    return USAGE_ERR;
+  }
+  rest = runTimeoutFlag.remaining;
+  if (runTimeoutFlag.value) {
+    const parsed = parseDuration(runTimeoutFlag.value);
+    if (parsed.error) {
+      io2.stderr(`--run-timeout: ${parsed.error}
+`);
+      return USAGE_ERR;
+    }
+  }
+  const follow = takeBooleanFlag(rest, "--follow");
+  rest = follow.remaining;
+  const timeoutFlag = takeOptionFlag(rest, "--timeout");
+  rest = timeoutFlag.remaining;
+  let followTimeoutMs = null;
+  if (timeoutFlag.value !== void 0) {
+    const parsed = parseDuration(timeoutFlag.value);
+    if (parsed.error) {
+      io2.stderr(`--timeout: ${parsed.error}
+`);
+      return USAGE_ERR;
+    }
+    followTimeoutMs = parsed.ms;
+  }
+  const config = takeFlagValue(rest, "--config");
+  if (config.error) {
+    io2.stderr(`${config.error}
+`);
+    return USAGE_ERR;
+  }
+  rest = config.remaining;
+  const modelFlag = takeFlagValue(rest, "--model");
+  if (modelFlag.error) {
+    io2.stderr(`${modelFlag.error}
+`);
+    return USAGE_ERR;
+  }
+  rest = modelFlag.remaining;
+  const systemFlag = takeFlagValue(rest, "--system");
+  if (systemFlag.error) {
+    io2.stderr(`${systemFlag.error}
+`);
+    return USAGE_ERR;
+  }
+  rest = systemFlag.remaining;
+  const promptFlags = collectRepeated(rest, "--prompt");
+  if (promptFlags.error) {
+    io2.stderr(`${promptFlags.error}
+`);
+    return USAGE_ERR;
+  }
+  rest = promptFlags.remaining;
+  const mcpFlags = collectRepeatedKv(rest, "--mcp");
+  if (mcpFlags.error) {
+    io2.stderr(`${mcpFlags.error}
+`);
+    return USAGE_ERR;
+  }
+  rest = mcpFlags.remaining;
+  const mcpAuthFlags = collectRepeatedKvList(rest, "--mcp-auth");
+  if (mcpAuthFlags.error) {
+    io2.stderr(`${mcpAuthFlags.error}
+`);
+    return USAGE_ERR;
+  }
+  rest = mcpAuthFlags.remaining;
+  const metadataFlags = collectRepeatedKv(rest, "--metadata");
+  if (metadataFlags.error) {
+    io2.stderr(`${metadataFlags.error}
+`);
+    return USAGE_ERR;
+  }
+  rest = metadataFlags.remaining;
+  const proxyEndpointFlags = collectRepeated(rest, "--proxy-endpoint");
+  if (proxyEndpointFlags.error) {
+    io2.stderr(`${proxyEndpointFlags.error}
+`);
+    return USAGE_ERR;
+  }
+  rest = proxyEndpointFlags.remaining;
+  const proxyAuthFlags = collectRepeatedKv(rest, "--proxy-auth");
+  if (proxyAuthFlags.error) {
+    io2.stderr(`${proxyAuthFlags.error}
+`);
+    return USAGE_ERR;
+  }
+  rest = proxyAuthFlags.remaining;
+  const positional = rest.filter((a) => !a.startsWith("--"));
+  const unknownFlags = rest.filter((a) => a.startsWith("--"));
+  if (unknownFlags.length > 0) {
+    io2.stderr(`unknown flag: ${unknownFlags[0]}
+`);
+    return USAGE_ERR;
+  }
+  if (positional.length > 0) {
+    io2.stderr(`aex run takes no positional arguments (got: ${positional.join(" ")})
+`);
+    return USAGE_ERR;
+  }
+  let runConfig;
+  let mcpHeadersFromConfig = /* @__PURE__ */ new Map();
+  if (config.value) {
+    if (modelFlag.value || systemFlag.value || promptFlags.values.length || Object.keys(mcpFlags.entries).length || Object.keys(metadataFlags.entries).length) {
+      io2.stderr("--config cannot be combined with --model/--system/--prompt/--mcp/--metadata\n");
+      return USAGE_ERR;
+    }
+    try {
+      const absPath = resolvePath(io2.cwd(), config.value);
+      const text = await io2.readFile(absPath);
+      const raw = JSON.parse(text);
+      const { mcpHeaders, normalised } = stripMcpHeadersForParsing(raw);
+      mcpHeadersFromConfig = mcpHeaders;
+      runConfig = parseRunRequestConfig(normalised);
+    } catch (err2) {
+      io2.stderr(`failed to load --config: ${err2.message}
+`);
+      return USAGE_ERR;
+    }
+  } else {
+    if (!modelFlag.value) {
+      io2.stderr("--model is required when --config is not provided\n");
+      return USAGE_ERR;
+    }
+    if (promptFlags.values.length === 0) {
+      io2.stderr("--prompt is required (repeatable)\n");
+      return USAGE_ERR;
+    }
+    let resolvedPrompt;
+    try {
+      resolvedPrompt = await Promise.all(promptFlags.values.map((v) => readMaybeFile(io2, v)));
+    } catch (err2) {
+      io2.stderr(`failed to read --prompt file: ${err2.message}
+`);
+      return USAGE_ERR;
+    }
+    let resolvedSystem;
+    if (systemFlag.value !== null) {
+      try {
+        resolvedSystem = await readMaybeFile(io2, systemFlag.value);
+      } catch (err2) {
+        io2.stderr(`failed to read --system file: ${err2.message}
+`);
+        return USAGE_ERR;
+      }
+    }
+    const mcpRefs = [];
+    for (const [name, url] of Object.entries(mcpFlags.entries)) {
+      mcpRefs.push({ name, url });
+    }
+    runConfig = {
+      model: modelFlag.value,
+      ...resolvedSystem ? { system: resolvedSystem } : {},
+      prompt: resolvedPrompt,
+      ...mcpRefs.length > 0 ? { mcpServers: mcpRefs } : {},
+      ...Object.keys(metadataFlags.entries).length > 0 ? { metadata: { ...metadataFlags.entries } } : {}
+    };
+  }
+  const mcpServersForSubmission = [...runConfig.mcpServers ?? []];
+  const mcpServerSecrets = [];
+  const mcpHeaderBag = new Map(mcpHeadersFromConfig);
+  for (const [name, headerSpec] of mcpAuthFlags.entries) {
+    const colon = headerSpec.indexOf(":");
+    if (colon <= 0 || colon >= headerSpec.length - 1) {
+      io2.stderr(`--mcp-auth ${name}: expected 'HeaderName:Value' (got: ${headerSpec})
+`);
+      return USAGE_ERR;
+    }
+    const headerName = headerSpec.slice(0, colon).trim();
+    const headerValue = headerSpec.slice(colon + 1).trim();
+    if (!headerName || !headerValue) {
+      io2.stderr(`--mcp-auth ${name}: header name and value must be non-empty
+`);
+      return USAGE_ERR;
+    }
+    const existing = mcpHeaderBag.get(name) ?? {};
+    if (Object.prototype.hasOwnProperty.call(existing, headerName)) {
+      io2.stderr(`--mcp-auth ${name}: duplicate header "${headerName}" \u2014 each header may be set only once per server
+`);
+      return USAGE_ERR;
+    }
+    existing[headerName] = headerValue;
+    mcpHeaderBag.set(name, existing);
+  }
+  for (const ref of mcpServersForSubmission) {
+    const headers = mcpHeaderBag.get(ref.name);
+    if (headers && Object.keys(headers).length > 0) {
+      mcpServerSecrets.push({ name: ref.name, url: ref.url, headers });
+    }
+  }
+  for (const name of mcpHeaderBag.keys()) {
+    if (!mcpServersForSubmission.some((m) => m.name === name)) {
+      io2.stderr(`--mcp-auth ${name}: no matching --mcp / mcpServers entry declared
+`);
+      return USAGE_ERR;
+    }
+  }
+  let proxyEndpoints = runConfig.proxyEndpoints ?? [];
+  if (proxyEndpointFlags.values.length > 0) {
+    try {
+      proxyEndpoints = proxyEndpointFlags.values.map((raw, i) => parseJsonOrThrow(raw, `--proxy-endpoint[${i}]`));
+    } catch (err2) {
+      io2.stderr(`${err2.message}
+`);
+      return USAGE_ERR;
+    }
+  }
+  const proxyAuth = [];
+  for (const [name, spec] of Object.entries(proxyAuthFlags.entries)) {
+    const parsed = parseProxyAuth(spec);
+    if (!parsed.ok) {
+      io2.stderr(`--proxy-auth ${name}: ${parsed.reason}
+`);
+      return USAGE_ERR;
+    }
+    proxyAuth.push({ name, value: parsed.value });
+  }
+  if (proxyEndpoints.length > 0) {
+    try {
+      validateProxyAuth(proxyEndpoints, proxyAuth);
+    } catch (err2) {
+      io2.stderr(`proxy auth validation failed: ${err2.message}
+`);
+      return USAGE_ERR;
+    }
+  }
+  const promptArray = Array.isArray(runConfig.prompt) ? [...runConfig.prompt] : [runConfig.prompt];
+  const skills = runConfig.skills ? [...runConfig.skills] : [];
+  const submission = {
+    model: runConfig.model,
+    ...runConfig.system ? { system: runConfig.system } : {},
+    prompt: promptArray,
+    skills,
+    agentsMd: [],
+    files: [],
+    mcpServers: mcpServersForSubmission,
+    ...runConfig.environment ? { environment: runConfig.environment } : {},
+    ...runConfig.metadata ? { metadata: runConfig.metadata } : {}
+  };
+  const providerSecrets = {
+    [provider]: { apiKey: providerKeyValues[provider] }
+  };
+  const secrets = {
+    ...providerSecrets,
+    ...mcpServerSecrets.length > 0 ? { mcpServers: mcpServerSecrets } : {},
+    ...proxyAuth.length > 0 ? { proxyEndpointAuth: proxyAuth } : {}
+  };
+  const request = {
+    idempotencyKey: idempotency.value ?? generateIdempotencyKey(),
+    provider,
+    ...runtime ? { runtime } : {},
+    submission,
+    secrets,
+    ...runtimeSizeFlag.value ? { runtimeSize: runtimeSizeFlag.value } : runConfig.runtimeSize ? { runtimeSize: runConfig.runtimeSize } : {},
+    ...runTimeoutFlag.value ? { timeout: runTimeoutFlag.value } : runConfig.timeout ? { timeout: runConfig.timeout } : {},
+    ...proxyEndpoints.length > 0 ? { proxyEndpoints } : {}
+  };
+  const http = makeHttpClient(io2, common.flags);
+  let run;
+  try {
+    run = await operations_exports.submitRun(http, request);
+  } catch (err2) {
+    return emitJsonError(io2, "submit_failed", err2.message ?? "submission failed");
+  }
+  io2.stdout(JSON.stringify(run) + "\n");
+  if (!follow.present)
+    return SUCCESS;
+  let emittedEventCount = 0;
+  let currentStatus = run.status;
+  const deadline = followTimeoutMs === null ? Number.POSITIVE_INFINITY : Date.now() + followTimeoutMs;
+  while (!TERMINAL_STATUSES.has(currentStatus)) {
+    await sleep(2e3);
+    try {
+      const events = await operations_exports.listRunEvents(http, run.id);
+      for (let i = emittedEventCount; i < events.length; i++) {
+        io2.stdout(JSON.stringify(events[i]) + "\n");
+      }
+      emittedEventCount = events.length;
+    } catch (err2) {
+      io2.stderr(`(transient) event poll failed: ${err2.message}
+`);
+    }
+    try {
+      const updated = await operations_exports.getRun(http, run.id);
+      currentStatus = updated.status;
+    } catch (err2) {
+      io2.stderr(`(transient) status poll failed: ${err2.message}
+`);
+    }
+    if (!TERMINAL_STATUSES.has(currentStatus) && Date.now() >= deadline) {
+      emitJsonError(io2, "run_follow_timeout", `timed out after ${followTimeoutMs}ms following run`, { runId: run.id });
+      return TIMEOUT_ERR;
+    }
+  }
+  try {
+    const final = await operations_exports.getRun(http, run.id);
+    io2.stdout(JSON.stringify(final) + "\n");
+    return final.status === "succeeded" ? SUCCESS : RUNTIME_ERR;
+  } catch (err2) {
+    io2.stderr(`final status fetch failed: ${err2.message}
+`);
+    return RUNTIME_ERR;
+  }
+}
+function parseProxyAuth(spec) {
+  const idx = spec.indexOf(":");
+  if (idx <= 0) {
+    return { ok: false, reason: `expected '<type>:<value>' (got: ${spec})` };
+  }
+  const type = spec.slice(0, idx);
+  const restValue = spec.slice(idx + 1);
+  switch (type) {
+    case "bearer":
+      if (!restValue)
+        return { ok: false, reason: "bearer requires a token value" };
+      return { ok: true, value: { type: "bearer", token: restValue } };
+    case "header":
+      if (!restValue)
+        return { ok: false, reason: "header requires a value" };
+      return { ok: true, value: { type: "header", value: restValue } };
+    case "query":
+      if (!restValue)
+        return { ok: false, reason: "query requires a value" };
+      return { ok: true, value: { type: "query", value: restValue } };
+    case "basic": {
+      const sep2 = restValue.indexOf(":");
+      if (sep2 <= 0 || sep2 >= restValue.length - 1) {
+        return { ok: false, reason: "basic requires <username>:<password>" };
+      }
+      return {
+        ok: true,
+        value: { type: "basic", username: restValue.slice(0, sep2), password: restValue.slice(sep2 + 1) }
+      };
+    }
+    default:
+      return { ok: false, reason: `unknown auth type '${type}' (expected bearer|basic|header|query)` };
+  }
+}
+function parseJsonOrThrow(raw, label) {
+  try {
+    return JSON.parse(raw);
+  } catch (err2) {
+    throw new Error(`${label} is not valid JSON: ${err2.message}`);
+  }
+}
+function stripMcpHeadersForParsing(input) {
+  const mcpHeaders = /* @__PURE__ */ new Map();
+  if (input === null || typeof input !== "object" || Array.isArray(input)) {
+    return { normalised: input, mcpHeaders };
+  }
+  const record = input;
+  if (!Array.isArray(record.mcpServers)) {
+    return { normalised: input, mcpHeaders };
+  }
+  const stripped = record.mcpServers.map((entry, i) => {
+    if (!entry || typeof entry !== "object")
+      return entry;
+    const r = entry;
+    if (r.headers && typeof r.headers === "object" && !Array.isArray(r.headers)) {
+      const name = typeof r.name === "string" ? r.name : `__index_${i}__`;
+      const headerObj = {};
+      for (const [k, v] of Object.entries(r.headers)) {
+        if (typeof v !== "string") {
+          throw new Error(`mcpServers[${i}].headers["${k}"] must be a string`);
+        }
+        headerObj[k] = v;
+      }
+      mcpHeaders.set(name, headerObj);
+      const { headers: _omit, ...rest } = r;
+      void _omit;
+      return rest;
+    }
+    return r;
+  });
+  return { normalised: { ...record, mcpServers: stripped }, mcpHeaders };
+}
+async function readMaybeFile(io2, value) {
+  if (value.startsWith("@@")) {
+    return value.slice(1);
+  }
+  if (value.startsWith("@")) {
+    const path = resolvePath(io2.cwd(), value.slice(1));
+    return io2.readFile(path);
+  }
+  return value;
+}
+function generateIdempotencyKey() {
+  const c = globalThis.crypto;
+  if (c?.randomUUID)
+    return c.randomUUID();
+  return `idem-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// dist/host/skills-cmd.js
+import { readFile, readdir, stat } from "node:fs/promises";
+import { basename, join, posix, relative, resolve as resolvePath2, sep } from "node:path";
+async function runSkillsCmd(io2, argv) {
+  if (await refuseInsideManagedRun(io2, "skills"))
+    return USAGE_ERR;
+  const [verb, ...rest] = argv;
+  if (!verb) {
+    io2.stderr("usage: aex skills <upload|list|get|delete> [flags]\n");
+    return USAGE_ERR;
+  }
+  switch (verb) {
+    case "upload":
+      return runSkillsUpload(io2, rest);
+    case "list":
+      return runSkillsList(io2, rest);
+    case "get":
+      return runSkillsGet(io2, rest);
+    case "delete":
+      return runSkillsDelete(io2, rest);
+    default:
+      io2.stderr(`unknown skills verb: ${verb}
+`);
+      return USAGE_ERR;
+  }
+}
+async function runSkillsUpload(io2, argv) {
+  const common = parseCommonHostFlags(argv);
+  if (!common.ok) {
+    io2.stderr(`${common.reason}
+`);
+    return USAGE_ERR;
+  }
+  let rest = common.rest;
+  const nameFlag = takeFlagValue(rest, "--name");
+  if (nameFlag.error) {
+    io2.stderr(`${nameFlag.error}
+`);
+    return USAGE_ERR;
+  }
+  rest = nameFlag.remaining;
+  if (!nameFlag.value) {
+    io2.stderr("--name is required\n");
+    return USAGE_ERR;
+  }
+  const fromPath = takeFlagValue(rest, "--from-path");
+  if (fromPath.error) {
+    io2.stderr(`${fromPath.error}
+`);
+    return USAGE_ERR;
+  }
+  rest = fromPath.remaining;
+  const fileFlags = collectRepeated(rest, "--file");
+  if (fileFlags.error) {
+    io2.stderr(`${fileFlags.error}
+`);
+    return USAGE_ERR;
+  }
+  rest = fileFlags.remaining;
+  const unknown = rest.filter((a) => a.startsWith("--"));
+  if (unknown.length > 0) {
+    io2.stderr(`unknown flag: ${unknown[0]}
+`);
+    return USAGE_ERR;
+  }
+  if (fromPath.value && fileFlags.values.length > 0 || !fromPath.value && fileFlags.values.length === 0) {
+    io2.stderr("aex skills upload requires exactly one of: --from-path <dir> | --file <path> [--file ...]\n");
+    return USAGE_ERR;
+  }
+  let built;
+  try {
+    if (fromPath.value) {
+      built = await zipDirectory(resolvePath2(io2.cwd(), fromPath.value));
+    } else {
+      built = await zipFiles(io2.cwd(), fileFlags.values);
+    }
+  } catch (err2) {
+    io2.stderr(`failed to build skill bundle: ${err2.message}
+`);
+    return USAGE_ERR;
+  }
+  const contentHash = `sha256:${await sha256Hex(built.zip)}`;
+  const http = makeHttpClient(io2, common.flags);
+  try {
+    const skill = await operations_exports.createSkillBundleDirect(http, io2.fetchImpl, {
+      name: nameFlag.value,
+      body: built.zip,
+      contentHash,
+      manifest: built.manifest,
+      contentType: "application/zip"
+    });
+    io2.stdout(JSON.stringify(skill) + "\n");
+    return SUCCESS;
+  } catch (err2) {
+    return emitJsonError(io2, "skill_upload_failed", err2.message ?? "upload failed");
+  }
+}
+async function sha256Hex(bytes) {
+  const subtle = globalThis.crypto?.subtle;
+  if (!subtle)
+    throw new Error("aex skills upload: globalThis.crypto.subtle is required (Node 18+)");
+  const copy = new Uint8Array(bytes.byteLength);
+  copy.set(bytes);
+  const digest = await subtle.digest("SHA-256", copy.buffer);
+  return Array.from(new Uint8Array(digest), (b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function runSkillsList(io2, argv) {
+  const common = parseCommonHostFlags(argv);
+  if (!common.ok) {
+    io2.stderr(`${common.reason}
+`);
+    return USAGE_ERR;
+  }
+  const positional = common.rest.filter((a) => !a.startsWith("--"));
+  const unknown = common.rest.filter((a) => a.startsWith("--"));
+  if (unknown.length > 0) {
+    io2.stderr(`unknown flag: ${unknown[0]}
+`);
+    return USAGE_ERR;
+  }
+  if (positional.length > 0) {
+    io2.stderr(`aex skills list takes no positional arguments
+`);
+    return USAGE_ERR;
+  }
+  const http = makeHttpClient(io2, common.flags);
+  try {
+    const skills = await operations_exports.listSkills(http);
+    for (const s of skills)
+      io2.stdout(JSON.stringify(s) + "\n");
+    return SUCCESS;
+  } catch (err2) {
+    return emitJsonError(io2, "skills_list_failed", err2.message ?? "list failed");
+  }
+}
+async function runSkillsGet(io2, argv) {
+  const common = parseCommonHostFlags(argv);
+  if (!common.ok) {
+    io2.stderr(`${common.reason}
+`);
+    return USAGE_ERR;
+  }
+  const positional = common.rest.filter((a) => !a.startsWith("--"));
+  const unknown = common.rest.filter((a) => a.startsWith("--"));
+  if (unknown.length > 0) {
+    io2.stderr(`unknown flag: ${unknown[0]}
+`);
+    return USAGE_ERR;
+  }
+  if (positional.length !== 1) {
+    io2.stderr("usage: aex skills get <skill-id>\n");
+    return USAGE_ERR;
+  }
+  const skillId = positional[0];
+  const http = makeHttpClient(io2, common.flags);
+  try {
+    const skill = await operations_exports.getSkill(http, skillId);
+    io2.stdout(JSON.stringify(skill) + "\n");
+    return SUCCESS;
+  } catch (err2) {
+    return emitJsonError(io2, "skill_get_failed", err2.message ?? "get failed");
+  }
+}
+async function runSkillsDelete(io2, argv) {
+  const common = parseCommonHostFlags(argv);
+  if (!common.ok) {
+    io2.stderr(`${common.reason}
+`);
+    return USAGE_ERR;
+  }
+  const positional = common.rest.filter((a) => !a.startsWith("--"));
+  const unknown = common.rest.filter((a) => a.startsWith("--"));
+  if (unknown.length > 0) {
+    io2.stderr(`unknown flag: ${unknown[0]}
+`);
+    return USAGE_ERR;
+  }
+  if (positional.length !== 1) {
+    io2.stderr("usage: aex skills delete <skill-id>\n");
+    return USAGE_ERR;
+  }
+  const skillId = positional[0];
+  const http = makeHttpClient(io2, common.flags);
+  try {
+    await operations_exports.deleteSkill(http, skillId);
+    io2.stdout(JSON.stringify({ skillId, deleted: true }) + "\n");
+    return SUCCESS;
+  } catch (err2) {
+    return emitJsonError(io2, "skill_delete_failed", err2.message ?? "delete failed");
+  }
+}
+var ZIP_EPOCH = new Date(Date.UTC(1980, 0, 1));
+function zipEntryFor(bytes) {
+  return [bytes, { mtime: ZIP_EPOCH }];
+}
+async function zipDirectory(rootDir) {
+  const rootStat = await stat(rootDir);
+  if (!rootStat.isDirectory()) {
+    throw new Error(`${rootDir} is not a directory`);
+  }
+  const collected = /* @__PURE__ */ new Map();
+  let totalDecompressed = 0;
+  let hasSkillMd = false;
+  await walk(rootDir, rootDir, async (relPathPosix, bytes) => {
+    const entry = validateSkillBundleEntry({ path: relPathPosix, size: bytes.byteLength });
+    if (entry.path === "SKILL.md")
+      hasSkillMd = true;
+    totalDecompressed += bytes.byteLength;
+    if (totalDecompressed > SKILL_BUNDLE_LIMITS.maxDecompressedBytes) {
+      throw new Error(`skill bundle exceeds decompressed cap of ${SKILL_BUNDLE_LIMITS.maxDecompressedBytes} bytes`);
+    }
+    if (collected.has(entry.path)) {
+      throw new Error(`skill bundle contains duplicate path: ${entry.path}`);
+    }
+    if (collected.size >= SKILL_BUNDLE_LIMITS.maxFiles) {
+      throw new Error(`skill bundle exceeds ${SKILL_BUNDLE_LIMITS.maxFiles} file limit`);
+    }
+    collected.set(entry.path, bytes);
+  });
+  if (collected.size === 0) {
+    throw new Error(`${rootDir} contains no regular files`);
+  }
+  if (!hasSkillMd) {
+    throw new Error('skill bundle must contain a "SKILL.md" file at the root. For AGENTS.md / generic files use the corresponding `aex agentsmd` / `aex files` commands instead.');
+  }
+  const sorted = [...collected.entries()].sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
+  const zippable = {};
+  for (const [path, bytes] of sorted)
+    zippable[path] = zipEntryFor(bytes);
+  const out = zipSync(zippable, { level: 6 });
+  if (out.byteLength > SKILL_BUNDLE_LIMITS.maxCompressedBytes) {
+    throw new Error(`skill bundle exceeds compressed cap of ${SKILL_BUNDLE_LIMITS.maxCompressedBytes} bytes (got ${out.byteLength})`);
+  }
+  return { zip: out, manifest: sorted.map(([path, bytes]) => ({ path, size: bytes.byteLength })) };
+}
+async function zipFiles(cwd, paths) {
+  if (paths.length > SKILL_BUNDLE_LIMITS.maxFiles) {
+    throw new Error(`skill bundle exceeds ${SKILL_BUNDLE_LIMITS.maxFiles} file limit`);
+  }
+  const collected = /* @__PURE__ */ new Map();
+  let totalDecompressed = 0;
+  let hasSkillMd = false;
+  for (const p of paths) {
+    const abs = resolvePath2(cwd, p);
+    const bytes = await readFile(abs);
+    const name = basename(p);
+    const entry = validateSkillBundleEntry({ path: name, size: bytes.byteLength });
+    if (entry.path === "SKILL.md")
+      hasSkillMd = true;
+    totalDecompressed += bytes.byteLength;
+    if (totalDecompressed > SKILL_BUNDLE_LIMITS.maxDecompressedBytes) {
+      throw new Error(`skill bundle exceeds decompressed cap of ${SKILL_BUNDLE_LIMITS.maxDecompressedBytes} bytes`);
+    }
+    if (collected.has(entry.path)) {
+      throw new Error(`skill bundle contains duplicate path (basenames must be unique): ${entry.path}`);
+    }
+    collected.set(entry.path, bytes);
+  }
+  if (!hasSkillMd) {
+    throw new Error('skill bundle must contain a "SKILL.md" file at the root');
+  }
+  const sorted = [...collected.entries()].sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
+  const zippable = {};
+  for (const [path, bytes] of sorted)
+    zippable[path] = zipEntryFor(bytes);
+  const out = zipSync(zippable, { level: 6 });
+  if (out.byteLength > SKILL_BUNDLE_LIMITS.maxCompressedBytes) {
+    throw new Error(`skill bundle exceeds compressed cap of ${SKILL_BUNDLE_LIMITS.maxCompressedBytes} bytes`);
+  }
+  return { zip: out, manifest: sorted.map(([path, bytes]) => ({ path, size: bytes.byteLength })) };
+}
+async function walk(rootDir, currentDir, visit) {
+  const entries = await readdir(currentDir, { withFileTypes: true });
+  for (const dirent of entries) {
+    const full = join(currentDir, dirent.name);
+    if (dirent.isSymbolicLink())
+      continue;
+    if (dirent.isDirectory()) {
+      await walk(rootDir, full, visit);
+      continue;
+    }
+    if (!dirent.isFile())
+      continue;
+    const rel = relative(rootDir, full);
+    const posixPath = sep === "/" ? rel : rel.split(sep).join(posix.sep);
+    const bytes = await readFile(full);
+    await visit(posixPath, bytes);
+  }
+}
+
+// dist/host/status.js
+async function runStatusCmd(io2, argv) {
+  if (await refuseInsideManagedRun(io2, "status"))
+    return USAGE_ERR;
+  const common = parseCommonHostFlags(argv);
+  if (!common.ok) {
+    io2.stderr(`${common.reason}
+`);
+    return USAGE_ERR;
+  }
+  const positional = common.rest.filter((arg) => !arg.startsWith("--"));
+  if (positional.length !== 1) {
+    io2.stderr("usage: aex status <run-id> [common flags]\n");
+    return USAGE_ERR;
+  }
+  const runId = positional[0];
+  const http = makeHttpClient(io2, common.flags);
+  try {
+    const run = await operations_exports.getRun(http, runId);
+    io2.stdout(JSON.stringify(run) + "\n");
+    return SUCCESS;
+  } catch (err2) {
+    return emitJsonError(io2, "status_failed", err2.message ?? "status fetch failed", { runId });
+  }
+}
+
+// dist/host/wait.js
+var TERMINAL_STATUSES2 = new Set(TERMINAL_RUN_STATUSES);
+var DEFAULT_INTERVAL_MS = 2e3;
+async function runWaitCmd(io2, argv) {
+  if (await refuseInsideManagedRun(io2, "wait"))
+    return USAGE_ERR;
+  const common = parseCommonHostFlags(argv);
+  if (!common.ok) {
+    io2.stderr(`${common.reason}
+`);
+    return USAGE_ERR;
+  }
+  const timeoutFlag = takeOptionFlag(common.rest, "--timeout");
+  const intervalFlag = takeOptionFlag(timeoutFlag.remaining, "--interval");
+  let timeoutMs = null;
+  if (timeoutFlag.value !== void 0) {
+    const parsed = parseDuration(timeoutFlag.value);
+    if (parsed.error) {
+      io2.stderr(`--timeout: ${parsed.error}
+`);
+      return USAGE_ERR;
+    }
+    timeoutMs = parsed.ms;
+  }
+  let intervalMs = DEFAULT_INTERVAL_MS;
+  if (intervalFlag.value !== void 0) {
+    const parsed = parseDuration(intervalFlag.value);
+    if (parsed.error) {
+      io2.stderr(`--interval: ${parsed.error}
+`);
+      return USAGE_ERR;
+    }
+    intervalMs = parsed.ms;
+  }
+  const positional = intervalFlag.remaining.filter((arg) => !arg.startsWith("--"));
+  if (positional.length !== 1) {
+    io2.stderr("usage: aex wait <run-id> [--timeout <dur>] [--interval <dur>] [common flags]\n");
+    return USAGE_ERR;
+  }
+  const runId = positional[0];
+  const http = makeHttpClient(io2, common.flags);
+  const deadline = timeoutMs === null ? Number.POSITIVE_INFINITY : Date.now() + timeoutMs;
+  const timeout = (extra) => {
+    emitJsonError(io2, "wait_timeout", `timed out after ${timeoutMs}ms waiting for run to finish`, { runId, ...extra });
+    return TIMEOUT_ERR;
+  };
+  while (true) {
+    let run;
+    try {
+      run = await operations_exports.getRun(http, runId);
+    } catch (err2) {
+      io2.stderr(`(transient) status poll failed: ${err2.message}
+`);
+      if (Date.now() >= deadline)
+        return timeout({});
+      await sleep2(intervalMs);
+      continue;
+    }
+    if (TERMINAL_STATUSES2.has(run.status)) {
+      io2.stdout(JSON.stringify(run) + "\n");
+      return run.status === "succeeded" ? SUCCESS : RUNTIME_ERR;
+    }
+    if (Date.now() >= deadline)
+      return timeout({ lastStatus: run.status });
+    await sleep2(intervalMs);
+  }
+}
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// dist/host/events.js
+var TERMINAL_STATUSES3 = new Set(TERMINAL_RUN_STATUSES);
+async function runEventsCmd(io2, argv) {
+  if (await refuseInsideManagedRun(io2, "events"))
+    return USAGE_ERR;
+  const common = parseCommonHostFlags(argv);
+  if (!common.ok) {
+    io2.stderr(`${common.reason}
+`);
+    return USAGE_ERR;
+  }
+  const followResult = takeBooleanFlag(common.rest, "--follow");
+  const timeoutFlag = takeOptionFlag(followResult.remaining, "--timeout");
+  let timeoutMs = null;
+  if (timeoutFlag.value !== void 0) {
+    const parsed = parseDuration(timeoutFlag.value);
+    if (parsed.error) {
+      io2.stderr(`--timeout: ${parsed.error}
+`);
+      return USAGE_ERR;
+    }
+    timeoutMs = parsed.ms;
+  }
+  const positional = timeoutFlag.remaining.filter((arg) => !arg.startsWith("--"));
+  if (positional.length !== 1) {
+    io2.stderr("usage: aex events <run-id> [--follow] [--timeout <dur>] [common flags]\n");
+    return USAGE_ERR;
+  }
+  const runId = positional[0];
+  const http = makeHttpClient(io2, common.flags);
+  if (!followResult.present) {
+    try {
+      const events = await operations_exports.listRunEvents(http, runId);
+      for (const event of events) {
+        io2.stdout(JSON.stringify(event) + "\n");
+      }
+      return SUCCESS;
+    } catch (err2) {
+      return emitJsonError(io2, "events_failed", err2.message ?? "event fetch failed", { runId });
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const deadline = timeoutMs === null ? Number.POSITIVE_INFINITY : Date.now() + timeoutMs;
+  while (true) {
+    let events;
+    try {
+      events = await operations_exports.listRunEvents(http, runId);
+    } catch (err2) {
+      io2.stderr(`(transient) event poll failed: ${err2.message}
+`);
+      if (Date.now() >= deadline)
+        return emitTimeout(io2, runId, timeoutMs);
+      await sleep3(2e3);
+      continue;
+    }
+    for (const event of events) {
+      if (!seen.has(event.id)) {
+        seen.add(event.id);
+        io2.stdout(JSON.stringify(event) + "\n");
+      }
+    }
+    try {
+      const run = await operations_exports.getRun(http, runId);
+      if (TERMINAL_STATUSES3.has(run.status)) {
+        return SUCCESS;
+      }
+    } catch (err2) {
+      io2.stderr(`(transient) status poll failed: ${err2.message}
+`);
+    }
+    if (Date.now() >= deadline)
+      return emitTimeout(io2, runId, timeoutMs);
+    await sleep3(2e3);
+  }
+}
+function emitTimeout(io2, runId, timeoutMs) {
+  emitJsonError(io2, "events_follow_timeout", `timed out after ${timeoutMs}ms following run events`, { runId });
+  return TIMEOUT_ERR;
+}
+function sleep3(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// dist/host/outputs.js
+async function runOutputsCmd(io2, argv) {
+  if (await refuseInsideManagedRun(io2, "outputs"))
+    return USAGE_ERR;
+  const common = parseCommonHostFlags(argv);
+  if (!common.ok) {
+    io2.stderr(`${common.reason}
+`);
+    return USAGE_ERR;
+  }
+  const positional = common.rest.filter((arg) => !arg.startsWith("--"));
+  if (positional.length !== 1) {
+    io2.stderr("usage: aex outputs <run-id> [common flags]\n");
+    return USAGE_ERR;
+  }
+  const runId = positional[0];
+  const http = makeHttpClient(io2, common.flags);
+  try {
+    const outputs = await operations_exports.listOutputs(http, runId);
+    for (const out of outputs) {
+      io2.stdout(JSON.stringify(out) + "\n");
+    }
+    return SUCCESS;
+  } catch (err2) {
+    return emitJsonError(io2, "outputs_failed", err2.message ?? "outputs fetch failed", { runId });
+  }
+}
+
+// dist/host/download.js
+import { resolve as resolvePath3 } from "node:path";
+var NAMESPACE_DOWNLOADERS = {
+  outputs: operations_exports.downloadOutputs,
+  logs: operations_exports.downloadLogs,
+  events: operations_exports.downloadEvents,
+  metadata: operations_exports.downloadMetadata
+};
+async function runDownloadCmd(io2, argv) {
+  if (await refuseInsideManagedRun(io2, "download"))
+    return USAGE_ERR;
+  const common = parseCommonHostFlags(argv);
+  if (!common.ok) {
+    io2.stderr(`${common.reason}
+`);
+    return USAGE_ERR;
+  }
+  const outFlag = takeFlagValue(common.rest, "--out");
+  if (outFlag.error) {
+    io2.stderr(`${outFlag.error}
+`);
+    return USAGE_ERR;
+  }
+  const onlyFlag = takeFlagValue(outFlag.remaining, "--only");
+  if (onlyFlag.error) {
+    io2.stderr(`${onlyFlag.error}
+`);
+    return USAGE_ERR;
+  }
+  if (onlyFlag.value !== null && !(onlyFlag.value in NAMESPACE_DOWNLOADERS)) {
+    io2.stderr(`--only must be one of: ${Object.keys(NAMESPACE_DOWNLOADERS).join(", ")}
+`);
+    return USAGE_ERR;
+  }
+  const namespace2 = onlyFlag.value;
+  const positional = onlyFlag.remaining.filter((arg) => !arg.startsWith("--"));
+  if (positional.length !== 1) {
+    io2.stderr("usage: aex download <run-id> [--only outputs|logs|events|metadata] [--out path] [common flags]\n");
+    return USAGE_ERR;
+  }
+  const runId = positional[0];
+  const http = makeHttpClient(io2, common.flags);
+  const downloader = namespace2 ? NAMESPACE_DOWNLOADERS[namespace2] : operations_exports.download;
+  let bytes;
+  try {
+    bytes = await downloader(http, runId);
+  } catch (err2) {
+    return emitJsonError(io2, "download_failed", err2.message ?? "download failed", { runId });
+  }
+  const destination = resolveDestination(io2, outFlag.value, runId, namespace2);
+  try {
+    await io2.writeFile(destination, bytes);
+  } catch (err2) {
+    return emitJsonError(io2, "write_failed", `failed to write archive: ${err2.message}`, { destination });
+  }
+  io2.stdout(JSON.stringify({ runId, namespace: namespace2 ?? "all", path: destination, bytes: bytes.byteLength }) + "\n");
+  return SUCCESS;
+}
+function resolveDestination(io2, out, runId, namespace2) {
+  if (out) {
+    return resolvePath3(io2.cwd(), out);
+  }
+  const suffix = namespace2 ? `-${namespace2}` : "";
+  return resolvePath3(io2.cwd(), `aex-run-${runId}${suffix}.zip`);
+}
+
+// dist/host/cancel.js
+async function runCancelCmd(io2, argv) {
+  if (await refuseInsideManagedRun(io2, "cancel"))
+    return USAGE_ERR;
+  const common = parseCommonHostFlags(argv);
+  if (!common.ok) {
+    io2.stderr(`${common.reason}
+`);
+    return USAGE_ERR;
+  }
+  const positional = common.rest.filter((arg) => !arg.startsWith("--"));
+  if (positional.length !== 1) {
+    io2.stderr("usage: aex cancel <run-id> [common flags]\n");
+    return USAGE_ERR;
+  }
+  const runId = positional[0];
+  const http = makeHttpClient(io2, common.flags);
+  try {
+    await operations_exports.cancelRun(http, runId);
+    io2.stdout(JSON.stringify({ runId, status: "cancel_requested" }) + "\n");
+    return SUCCESS;
+  } catch (err2) {
+    return emitJsonError(io2, "cancel_failed", err2.message ?? "cancel failed", { runId });
+  }
+}
+
+// dist/host/delete.js
+async function runDeleteCmd(io2, argv) {
+  if (await refuseInsideManagedRun(io2, "delete"))
+    return USAGE_ERR;
+  const common = parseCommonHostFlags(argv);
+  if (!common.ok) {
+    io2.stderr(`${common.reason}
+`);
+    return USAGE_ERR;
+  }
+  const positional = common.rest.filter((arg) => !arg.startsWith("--"));
+  if (positional.length !== 1) {
+    io2.stderr("usage: aex delete <run-id> [common flags]\n");
+    return USAGE_ERR;
+  }
+  const runId = positional[0];
+  const http = makeHttpClient(io2, common.flags);
+  try {
+    await operations_exports.deleteRun(http, runId);
+    io2.stdout(JSON.stringify({ runId, deleted: true }) + "\n");
+    return SUCCESS;
+  } catch (err2) {
+    return emitJsonError(io2, "delete_failed", err2.message ?? "delete failed", { runId });
+  }
+}
+
+// dist/host/delete-asset.js
+async function runDeleteAssetCmd(io2, argv) {
+  if (await refuseInsideManagedRun(io2, "delete-asset"))
+    return USAGE_ERR;
+  const common = parseCommonHostFlags(argv);
+  if (!common.ok) {
+    io2.stderr(`${common.reason}
+`);
+    return USAGE_ERR;
+  }
+  const positional = common.rest.filter((arg) => !arg.startsWith("--"));
+  if (positional.length !== 1) {
+    io2.stderr("usage: aex delete-asset <hash> [common flags]\n");
+    return USAGE_ERR;
+  }
+  const hash = positional[0];
+  const http = makeHttpClient(io2, common.flags);
+  try {
+    await operations_exports.deleteWorkspaceAsset(http, hash);
+    io2.stdout(JSON.stringify({ hash, deleted: true }) + "\n");
+    return SUCCESS;
+  } catch (err2) {
+    return emitJsonError(io2, "delete_asset_failed", err2.message ?? "delete-asset failed", { hash });
+  }
+}
+
+// dist/host/whoami.js
+async function runWhoamiCmd(io2, argv) {
+  if (await refuseInsideManagedRun(io2, "whoami"))
+    return USAGE_ERR;
+  const common = parseCommonHostFlags(argv);
+  if (!common.ok) {
+    io2.stderr(`${common.reason}
+`);
+    return USAGE_ERR;
+  }
+  if (common.rest.length > 0) {
+    io2.stderr(`unexpected arguments: ${common.rest.join(" ")}
+`);
+    return USAGE_ERR;
+  }
+  const http = makeHttpClient(io2, common.flags);
+  try {
+    const me = await operations_exports.whoami(http);
+    io2.stdout(JSON.stringify(me) + "\n");
+    return SUCCESS;
+  } catch (err2) {
+    return emitJsonError(io2, "whoami_failed", err2.message ?? "whoami failed");
+  }
+}
+
+// dist/run.js
+async function runCli(io2) {
+  const args = io2.argv.slice(2);
+  try {
+    const exit = await dispatch(io2, args);
+    io2.exit(exit.code);
+  } catch (err2) {
+    const body = { error: "internal_error", message: err2.message ?? "unknown error" };
+    io2.stderr(JSON.stringify(body) + "\n");
+    io2.exit(RUNTIME_ERR.code);
+  }
+}
+async function dispatch(io2, args) {
+  if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+    return printGlobalHelp(io2);
+  }
+  const sub = args[0];
+  const rest = args.slice(1);
+  switch (sub) {
+    case "proxy":
+      return runProxy(io2, rest);
+    case "run":
+      return runRunCmd(io2, rest);
+    case "skills":
+      return runSkillsCmd(io2, rest);
+    case "status":
+      return runStatusCmd(io2, rest);
+    case "wait":
+      return runWaitCmd(io2, rest);
+    case "events":
+      return runEventsCmd(io2, rest);
+    case "outputs":
+      if (rest[0] === "sync") {
+        return runOutputsSyncCmd(io2, rest.slice(1));
+      }
+      return runOutputsCmd(io2, rest);
+    case "download":
+      return runDownloadCmd(io2, rest);
+    case "cancel":
+      return runCancelCmd(io2, rest);
+    case "delete":
+      return runDeleteCmd(io2, rest);
+    case "delete-asset":
+      return runDeleteAssetCmd(io2, rest);
+    case "whoami":
+      return runWhoamiCmd(io2, rest);
+    default:
+      io2.stderr(`unknown subcommand: ${sub}
+`);
+      io2.stderr("run `aex --help` for usage\n");
+      return USAGE_ERR;
+  }
+}
+async function printGlobalHelp(io2) {
+  const manifest = await tryReadManifest(io2);
+  if (manifest) {
+    io2.stdout("aex \u2014 in-container CLI for managed run sessions\n\n");
+    io2.stdout("Usage:\n");
+    io2.stdout("  aex proxy <endpoint-name> [flags]\n");
+    io2.stdout("  aex proxy --help\n\n");
+    if (manifest.endpoints.length === 0) {
+      io2.stdout("This run declared no proxy endpoints.\n");
+    } else {
+      io2.stdout("Declared proxy endpoints for this run:\n");
+      for (const ep of manifest.endpoints) {
+        io2.stdout(`  \u2022 ${ep.name}  (${ep.allowMethods.join("/")} ${ep.allowPathPrefixes.join(",")}, mode=${ep.responseMode})
+`);
+      }
+    }
+    io2.stdout(`
+Protocol version: ${manifest.protocolVersion}
+`);
+    return SUCCESS;
+  }
+  io2.stdout("aex \u2014 unified CLI for the aex platform (mirrors the SDK 1:1)\n\n");
+  io2.stdout("Usage:\n");
+  io2.stdout("  aex run --config <run.json> --<provider>-api-key K --api-token T [flags]\n");
+  io2.stdout("  aex run --model M --prompt P [--system S] [--mcp name=url ...] --<provider>-api-key K --api-token T [flags]\n");
+  io2.stdout("  aex skills upload --name N --from-path <dir> --api-token T\n");
+  io2.stdout("  aex skills upload --name N --file <path> [--file <path> ...] --api-token T\n");
+  io2.stdout("  aex skills list --api-token T\n");
+  io2.stdout("  aex skills get <skill-id> --api-token T\n");
+  io2.stdout("  aex skills delete <skill-id> --api-token T\n");
+  io2.stdout("  aex status <run-id> --api-token T\n");
+  io2.stdout("  aex wait <run-id> [--timeout 8m] [--interval 2s] --api-token T\n");
+  io2.stdout("  aex events <run-id> [--follow] [--timeout 8m] --api-token T\n");
+  io2.stdout("  aex outputs <run-id> --api-token T\n");
+  io2.stdout("  aex download <run-id> [--out path] --api-token T\n");
+  io2.stdout("  aex cancel <run-id> --api-token T\n");
+  io2.stdout("  aex delete <run-id> --api-token T\n");
+  io2.stdout("  aex delete-asset <assetId|hash> --api-token T\n");
+  io2.stdout("  aex whoami --api-token T\n");
+  io2.stdout("  aex --help\n\n");
+  io2.stdout("Common flags on every host subcommand:\n");
+  io2.stdout("  --api-token <token>         REQUIRED \u2014 aex SDK API token (workspace is derived from it)\n");
+  io2.stdout("  --aex-url <url>         Optional; defaults to https://api.aex.dev (local/staging/hosted plane)\n");
+  io2.stdout("  --debug                     Optional; print a redacted per-request trace to stderr (uploads nothing)\n\n");
+  io2.stdout("aex run flags:\n");
+  io2.stdout(`  --provider <name>           Optional; one of: ${RUN_PROVIDERS.join(", ")} (default anthropic)
+`);
+  io2.stdout("  --runtime managed           Optional runtime selector; omitted also uses managed\n");
+  for (const provider of RUN_PROVIDERS) {
+    io2.stdout(`  --${provider}-api-key <key>${" ".repeat(Math.max(1, 13 - provider.length))}REQUIRED when --provider ${provider}; never stored
+`);
+  }
+  io2.stdout("  --config <path>             Run-request JSON (mutually exclusive with the flat --model/--prompt flags)\n");
+  io2.stdout("  --model <model-id>          Provider model id (required in flat mode)\n");
+  io2.stdout("  --system @file | <text>     System message; @-prefix reads from file\n");
+  io2.stdout("  --prompt @file | <text>     User message; @-prefix reads from file (repeatable)\n");
+  io2.stdout("  --mcp name=url              MCP server entry (repeatable)\n");
+  io2.stdout("  --mcp-auth name=Hdr:Val     Auth header on the matching --mcp; routed into vaulted secrets (repeatable)\n");
+  io2.stdout("  --metadata key=value        Submission metadata entry (repeatable)\n");
+  io2.stdout("  --proxy-endpoint '<json>'   PlatformProxyEndpoint JSON (repeatable)\n");
+  io2.stdout("  --proxy-auth name=<spec>    bearer:tok | basic:u:p | header:v | query:v (repeatable)\n");
+  io2.stdout("  --runtime-size <size>       managed runtime preset\n");
+  io2.stdout("  --run-timeout <dur>         Server-side run deadline (e.g. 1h); distinct from --timeout\n");
+  io2.stdout("  --idempotency-key <key>     Optional; defaults to a fresh UUID\n");
+  io2.stdout("  --follow                    Poll events to stdout until the run terminates\n");
+  io2.stdout("  --timeout <dur>             With --follow: give up after this long (e.g. 8m, 30s, 500ms); exit code 3\n");
+  return SUCCESS;
+}
+
+// dist/cli.js
+async function walkDirectory(root) {
+  try {
+    const rootStat = await stat2(root);
+    if (!rootStat.isDirectory())
+      return null;
+  } catch {
+    return null;
+  }
+  const out = [];
+  async function visit(dir) {
+    const entries = await readdir2(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = resolvePath4(dir, entry.name);
+      if (entry.isDirectory()) {
+        await visit(full);
+      } else if (entry.isFile()) {
+        const s = await stat2(full);
+        out.push({ path: full, sizeBytes: s.size });
+      }
+    }
+  }
+  await visit(root);
+  return out;
+}
+var io = {
+  readFile: (path) => readFile2(path, "utf8"),
+  writeFile: (path, data) => writeFile(path, data),
+  fetchImpl: fetch,
+  stdout: (chunk) => process.stdout.write(chunk),
+  stderr: (chunk) => process.stderr.write(chunk),
+  exit: (code) => process.exit(code),
+  argv: process.argv,
+  cwd: () => process.cwd(),
+  walkDirectory
+};
+await runCli(io);