@kanyun-ai-infra/agenthub 0.1.0

package/dist/index.js

@@ -0,0 +1,4652 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+
+// ../contracts/dist/chunk-DDAAVRWG.js
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+
+// ../contracts/dist/index.js
+import { z } from "zod";
+import { z as z2 } from "zod";
+import { z as z3 } from "zod";
+import { z as z4 } from "zod";
+import { z as z5 } from "zod";
+import { z as z9 } from "zod";
+import { z as z8 } from "zod";
+import { z as z6 } from "zod";
+import { z as z7 } from "zod";
+import { z as z10 } from "zod";
+import { z as z11 } from "zod";
+import { z as z12 } from "zod";
+import { z as z13 } from "zod";
+import { z as z14 } from "zod";
+import { z as z15 } from "zod";
+import { z as z17 } from "zod";
+import { z as z16 } from "zod";
+import { z as z18 } from "zod";
+import { z as z19 } from "zod";
+import { z as z20 } from "zod";
+import { z as z21 } from "zod";
+import { z as z22 } from "zod";
+import { z as z23 } from "zod";
+import { z as z24 } from "zod";
+import { z as z25 } from "zod";
+import { z as z28 } from "zod";
+import { z as z26 } from "zod";
+import { z as z27 } from "zod";
+import { z as z29 } from "zod";
+import { z as z33 } from "zod";
+import { z as z32 } from "zod";
+import { z as z31 } from "zod";
+import { z as z30 } from "zod";
+import { z as z35 } from "zod";
+import { z as z34 } from "zod";
+import { z as z36 } from "zod";
+import { z as z37 } from "zod";
+import { z as z39 } from "zod";
+import { z as z38 } from "zod";
+import { z as z40 } from "zod";
+import { z as z41 } from "zod";
+import { z as z42 } from "zod";
+import { z as z43 } from "zod";
+import { z as z44 } from "zod";
+import { z as z45 } from "zod";
+import { z as z46 } from "zod";
+var RunStatusSchema = z.enum([
+  "queued",
+  "provisioning",
+  "preparing",
+  "running",
+  "finalizing_prepare",
+  "finalizing_uploading",
+  "finalizing_verifying",
+  "finalizing_metadata_commit",
+  "finalized",
+  "completed",
+  "failed",
+  "worker_unreachable",
+  "finalizing_retryable_failed",
+  "finalizing_timeout",
+  "finalizing_manual_intervention"
+]);
+var RunDeliveryPhaseSchema = z.enum(["in_progress", "completed", "failed"]);
+var TriggerSourceSchema = z.enum([
+  "user",
+  "webhook",
+  "alert",
+  "cron",
+  "wecom_chat",
+  "jira"
+]);
+var ProviderTypeSchema = z.enum([
+  // Legacy runtime keys (do NOT reorder; preserves persisted values).
+  "claude-code",
+  "codex",
+  // ModelGate vendor expansion (names mirror ModelGate `owned_by`).
+  "deepseek",
+  "google",
+  "zhipu",
+  "volcengine",
+  "tencent",
+  "moonshot",
+  "minimax",
+  "dashscope",
+  "xiaomi"
+]);
+var AttachmentMetaSchema = z.object({
+  /** OSS original URL (Agent Worker downloads via this) */
+  ossUrl: z.string().min(1),
+  /** Original filename */
+  filename: z.string().min(1).max(255),
+  /** File size in bytes */
+  size: z.number().int().positive(),
+  /** Media type classification */
+  mediaType: z.enum(["image", "document", "code", "notebook"]),
+  /** MIME type */
+  mimeType: z.string()
+});
+var RunSpecSchema = z.object({
+  prompt: z.string().min(1),
+  projectId: z.string().uuid(),
+  agentId: z.string().uuid().optional(),
+  agentMode: z.enum(["task", "chat"]).optional(),
+  repo: z.string().optional(),
+  ref: z.string().optional(),
+  model: z.string().optional(),
+  provider: ProviderTypeSchema.optional().default("claude-code"),
+  runnerRequired: z.boolean().optional().default(false),
+  triggerSource: TriggerSourceSchema.optional().default("user"),
+  triggerRef: z.string().optional(),
+  githubInstallationId: z.string().optional(),
+  attachments: z.array(AttachmentMetaSchema).max(5).optional(),
+  /**
+   * LDAP of the user whose action created this run. Populated by
+   * Portal / 企微 entry points. Null / undefined for webhook / automation
+   * triggers where we cannot identify a single human, in which case
+   * prepareWorkspace falls back to the service-level Bedrock key.
+   * See specs/features/user-bedrock-credentials.md.
+   */
+  triggerUserLdap: z.string().min(1).optional(),
+  /**
+   * Per-run override for the effective MCP / Skills enable list (spec
+   * §6.3). Either field being present (including `[]`) writes into the
+   * corresponding `runs.enabled_*` column; `undefined` leaves the
+   * column NULL, in which case the runtime resolver falls through to
+   * `agents.enabled_*`.
+   *
+   * Phase 1 has no Portal UI surface for this — the field is reserved
+   * for SDK / webhook automations. See specs/features/mcp-and-skills.md.
+   *
+   * Element shape is validated by the API layer (Zod) — at the
+   * RunService layer we accept already-validated arrays as opaque to
+   * keep the service free of contracts re-imports.
+   */
+  // Element shape validated at the API layer; RunService accepts opaque arrays
+  // (see comment above) so no further runtime check here.
+  enabledMcpServers: z.array(z.any()).optional(),
+  enabledSkills: z.array(z.any()).optional()
+});
+var RunSchema = z.object({
+  id: z.string().uuid(),
+  agentId: z.string().uuid(),
+  parentRunId: z.string().uuid().nullable(),
+  status: RunStatusSchema,
+  prompt: z.string(),
+  projectId: z.string().uuid(),
+  repoUrl: z.string().nullable(),
+  targetRef: z.string().nullable(),
+  modelOverride: z.string().nullable(),
+  runnerRequired: z.boolean(),
+  runtimeProfileVersion: z.number().int().nullable(),
+  runtimeProfileSnapshot: z.record(z.unknown()).nullable(),
+  activeStreamId: z.string().nullable(),
+  agentStreamId: z.string().nullable(),
+  provider: ProviderTypeSchema.default("claude-code"),
+  triggerSource: TriggerSourceSchema,
+  triggerRef: z.string().nullable(),
+  githubInstallationId: z.string().nullable(),
+  retryCount: z.number().int().default(0),
+  maxRetries: z.number().int().default(3),
+  pullRequestUrl: z.string().nullable(),
+  errorMessage: z.string().nullable(),
+  attachmentsJson: z.array(AttachmentMetaSchema).nullable(),
+  /** LDAP of the triggering user; null when unknown (webhook / automation). */
+  triggerUserLdap: z.string().nullable(),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+  startedAt: z.date().nullable(),
+  completedAt: z.date().nullable()
+});
+var LEGACY_MODEL_ALIASES = Object.freeze({
+  opus: "claude-opus-4-7",
+  sonnet: "claude-sonnet-4-6",
+  haiku: "claude-haiku-4-5"
+});
+var BEDROCK_COMPATIBLE_MODEL_IDS = Object.freeze(
+  /* @__PURE__ */ new Set(["opus", "sonnet", "haiku"])
+);
+var MODELGATE_VENDOR_TYPES = [
+  "anthropic",
+  "openai",
+  "deepseek",
+  "google",
+  "zhipu",
+  "volcengine",
+  "tencent",
+  "moonshot",
+  "minimax",
+  "dashscope",
+  "xiaomi"
+];
+var ModelGateVendorTypeSchema = z2.enum(MODELGATE_VENDOR_TYPES);
+var AgentModeSchema = z3.enum(["task", "chat"]);
+var AgentStatusSchema = z3.enum(["active", "closed", "deleted"]);
+var ExternalChatSourceSchema = z3.enum(["wecom"]);
+var AgentSchema = z3.object({
+  id: z3.string().uuid(),
+  projectId: z3.string().uuid(),
+  sandboxId: z3.string().nullable(),
+  agentMode: AgentModeSchema,
+  status: AgentStatusSchema,
+  customTitle: z3.string().max(200).nullable(),
+  /**
+   * Baseline git ref captured at agent (task) creation. Frozen for the
+   * lifetime of the agent so follow-up runs always re-clone from the
+   * branch the user originally selected. Nullable for chat-mode agents
+   * and pre-migration rows; consumers fall back to project.defaultBranch.
+   */
+  baseRef: z3.string().nullable(),
+  /**
+   * Per-agent system prompt (managed_agent profile Phase D). Seeded at
+   * creation from the workload default and frozen for the agent's lifetime.
+   * `null` → control-worker omits `PilotCoderRunConfigV1.systemPrompt` and
+   * agent-worker falls back to the platform-level `SYSTEM_PROMPT`.
+   */
+  systemPrompt: z3.string().nullable(),
+  createdBy: z3.string().nullable(),
+  messagesJson: z3.unknown().nullable(),
+  // JSONB - lightweight snapshot
+  lastCheckpointId: z3.string().uuid().nullable(),
+  activeStreamId: z3.string().nullable(),
+  /** External IM source that created this agent. See specs/features/wecom-chat-integration.md. */
+  externalChatSource: ExternalChatSourceSchema.nullable(),
+  /** External IM user identifier (e.g. WeCom userid). Unique per (project, source, chatid). */
+  externalChatUserid: z3.string().nullable(),
+  /** External IM chat/conversation identifier. NULL for single chats; set to WeCom `chatid`
+   *  for group-chat conversations. Part of the composite uniqueness key (2026-04-22). */
+  externalChatChatid: z3.string().nullable(),
+  createdAt: z3.date(),
+  updatedAt: z3.date(),
+  lastActiveAt: z3.date()
+});
+var ArtifactKindSchema = z4.enum([
+  "diff",
+  "patch",
+  "log",
+  "screenshot",
+  "video",
+  "build",
+  "report"
+]);
+var ArtifactManifestSchema = z4.object({
+  path: z4.string(),
+  kind: ArtifactKindSchema,
+  contentType: z4.string(),
+  size: z4.number().int().nonnegative(),
+  checksum: z4.string(),
+  required: z4.boolean()
+});
+var ArtifactSchema = z4.object({
+  id: z4.string().uuid(),
+  runId: z4.string().uuid(),
+  kind: ArtifactKindSchema,
+  path: z4.string(),
+  storagePath: z4.string(),
+  contentType: z4.string(),
+  size: z4.number().int().nonnegative(),
+  checksum: z4.string(),
+  createdAt: z4.date()
+});
+var CreateRunResponseSchema = z5.object({
+  runId: z5.string().uuid(),
+  agentId: z5.string().uuid(),
+  isNewAgent: z5.boolean()
+});
+var ApiResponseSchema = z5.object({
+  success: z5.boolean(),
+  data: z5.unknown().optional(),
+  error: z5.string().optional(),
+  code: z5.string().optional(),
+  message: z5.string().optional()
+});
+var FollowUpRequestSchema = z5.object({
+  runId: z5.string().uuid(),
+  message: z5.string().min(1)
+});
+var AbortRequestSchema = z5.object({
+  runId: z5.string().uuid(),
+  reason: z5.string().optional()
+});
+var GitProviderSchema = z6.enum(["gitlab", "github"]);
+var ProjectKindSchema = z6.enum(["coding", "general"]);
+var ProjectSchema = z6.object({
+  id: z6.string().uuid(),
+  name: z6.string().min(1),
+  kind: ProjectKindSchema.default("coding"),
+  /**
+   * `true` for the built-in `Platform Default` project (id =
+   * `PLATFORM_DEFAULT_PROJECT_ID`). System projects are visible to every
+   * authenticated user but read-only at the UI layer.
+   *
+   * See plans/admin-ui-project-namespacing.md §L1.1 (C3).
+   */
+  isSystem: z6.boolean().default(false),
+  gitProvider: GitProviderSchema.nullable(),
+  gitlabProjectId: z6.string().nullable(),
+  gitlabProjectPath: z6.string().nullable(),
+  githubRepoFullName: z6.string().nullable(),
+  githubRepoId: z6.string().nullable(),
+  /** Cached installation id for follow-up runs; authoritative value is on runs. */
+  githubInstallationId: z6.string().nullable(),
+  repoUrl: z6.string().nullable(),
+  defaultBranch: z6.string().default("main"),
+  defaultModel: z6.string().nullable(),
+  description: z6.string().nullable(),
+  webhookEnabled: z6.boolean().default(false),
+  webhookTriggerLabel: z6.string().default("pilot"),
+  webhookSecret: z6.string().nullable(),
+  webhookPromptTemplate: z6.string().nullable(),
+  /** WeCom aibot long-connection integration toggle. See specs/features/wecom-chat-integration.md. */
+  wecomEnabled: z6.boolean().default(false),
+  /** WeCom aibot ID; unique across projects, reverse-lookup from incoming messages. */
+  wecomBotId: z6.string().nullable(),
+  /** Reference to `credential_bindings.name` holding the long-connection SDK secret. */
+  wecomSecretRef: z6.string().nullable(),
+  /** Optional prompt prefix prepended to user message when creating a wecom_chat Run. */
+  wecomPromptTemplate: z6.string().nullable(),
+  createdAt: z6.date(),
+  updatedAt: z6.date()
+});
+var WebhookTriggerContextSchema = z7.discriminatedUnion("provider", [
+  z7.object({
+    provider: z7.literal("github"),
+    /** `owner/repo`, e.g. `pilot-ai/pilot` */
+    repoFullName: z7.string().min(1),
+    /** Issue or Pull Request number. */
+    number: z7.number().int().positive(),
+    /** True when the trigger came from a PR (GitHub issue_comment fires for both). */
+    isPr: z7.boolean(),
+    /** Id of the @mention comment that triggered the run (if applicable). */
+    commentId: z7.number().int().positive().optional(),
+    /**
+     * Installation token minted by Control Worker (GitHub App). TTL ≤ 1h;
+     * Agent Worker uses this to back `GitHubClient` directly.
+     */
+    installationToken: z7.string().min(1),
+    /** Custom GitHub API base URL (GitHub Enterprise). */
+    apiUrl: z7.string().url().optional()
+  }),
+  z7.object({
+    provider: z7.literal("gitlab"),
+    /** `group/subgroup/project`. */
+    projectPath: z7.string().min(1),
+    /** Issue IID or Merge Request IID. */
+    iid: z7.number().int().positive(),
+    /** True when the trigger came from an MR note. */
+    isMr: z7.boolean(),
+    /** Id of the note that triggered the run (if applicable). */
+    noteId: z7.number().int().positive().optional(),
+    /** Decrypted OAuth / PAT token used to build `GitLabClient`. */
+    accessToken: z7.string().min(1),
+    /** GitLab instance URL (e.g. `https://gitlab.example.com`). */
+    instanceUrl: z7.string().url()
+  })
+]);
+var CheckpointStatusSchema = z8.enum(["in_progress", "completed", "failed"]);
+var RecoveryTypeSchema = z8.enum([
+  "normal",
+  // 正常恢复（有 checkpoint）
+  "zero_context",
+  // 零起点恢复（无 checkpoint，预期）
+  "context_loss"
+  // 上下文丢失（有 checkpoint 但丢失，异常）
+]);
+var DegradedReasonSchema = z8.enum([
+  "no_checkpoint",
+  // 无 checkpoint
+  "context_mismatch",
+  // 上下文不一致
+  "checkpoint_corrupt",
+  // Checkpoint 损坏
+  "checkpoint_storage_unavailable"
+  // 对象存储 checkpoint 不可用（Phase 2 未实现）
+]);
+var CheckpointTriggerSourceSchema = z8.enum([
+  "finalization",
+  // Run Finalization 后（Phase 1）
+  "turn_count",
+  // Turn 计数触发（Phase 2）
+  "time_interval",
+  // 定时器触发（Phase 2）
+  "critical_tool",
+  // 关键工具调用触发（Phase 2）
+  "idle"
+  // Sandbox idle 前触发（Phase 2）
+]);
+var RunCheckpointSchema = z8.object({
+  id: z8.string().uuid(),
+  agentId: z8.string().uuid(),
+  runId: z8.string().uuid().nullable(),
+  checkpointStatus: CheckpointStatusSchema,
+  messagesSnapshot: z8.array(z8.unknown()).nullable(),
+  messagesSnapshotRef: z8.string().nullable(),
+  lastEventCursor: z8.number().int().nullable(),
+  pendingToolCalls: z8.unknown().nullable(),
+  workspaceDeltaManifestRef: z8.string().nullable(),
+  runtimeProfileSnapshot: z8.record(z8.unknown()).nullable(),
+  triggerSource: CheckpointTriggerSourceSchema.nullable().optional(),
+  degradedRecovery: z8.boolean().default(false),
+  createdAt: z8.date()
+});
+var AgentRestoreRequestSchema = z8.object({
+  runId: z8.string(),
+  agentId: z8.string(),
+  messages: z8.array(z8.unknown()),
+  messagesHash: z8.string(),
+  lastEventId: z8.number().int().optional(),
+  pendingToolCalls: z8.array(z8.unknown()).optional(),
+  workspaceHydrationRef: z8.string().optional(),
+  runtimeProfileSnapshot: z8.record(z8.unknown()).optional(),
+  degradedRecovery: z8.boolean().optional()
+});
+var AgentRestoreResponseSchema = z8.object({
+  success: z8.boolean(),
+  recovered: z8.boolean(),
+  messagesHash: z8.string().optional(),
+  messagesCount: z8.number().int().optional(),
+  degradedRecovery: z8.boolean().optional(),
+  error: z8.string().optional()
+});
+var McpServerEntrySchema = z8.union([
+  // stdio entry
+  z8.object({
+    command: z8.string().min(1),
+    args: z8.array(z8.string()).optional(),
+    env: z8.record(z8.string()).optional()
+  }).passthrough(),
+  // http / sse entry
+  z8.object({
+    type: z8.enum(["http", "sse"]),
+    url: z8.string().url(),
+    headers: z8.record(z8.string()).optional()
+  }).passthrough()
+]);
+var McpServersMapSchema = z8.record(McpServerEntrySchema);
+var PromptRequestSchema = z8.object({
+  runId: z8.string().optional(),
+  agentId: z8.string().optional(),
+  prompt: z8.string().min(1),
+  provider: ProviderTypeSchema.optional(),
+  model: z8.string().optional(),
+  workspacePath: z8.string().optional(),
+  /**
+   * Directory holding the bootstrap-rendered `.mcp.json`. Decoupled from
+   * `workspacePath` (which is the agent CWD = user repo) so MCP config never
+   * lands inside the user's project tree. When omitted, agent-worker falls
+   * back to `workspacePath` for backwards compatibility.
+   */
+  mcpConfigDir: z8.string().optional(),
+  attachments: z8.array(AttachmentMetaSchema).max(5).optional(),
+  /**
+   * Runtime-derived context for webhook-triggered runs. When present, Agent
+   * Worker injects a set of read-only provider tools so the agent can pull
+   * Issue/PR body / history / diff on demand. See `webhook-context.ts`.
+   */
+  triggerContext: WebhookTriggerContextSchema.optional(),
+  /**
+   * Resolved MCP servers to inject directly into the SDK (preferred over
+   * `<mcpConfigDir>/.mcp.json`). When omitted, the agent-worker falls back
+   * to reading `.mcp.json` from `mcpConfigDir` / `workspacePath` (the legacy
+   * bootstrap path).
+   */
+  mcpServers: McpServersMapSchema.optional(),
+  /**
+   * Run-scoped environment variables to inject into the AI CLI subprocess
+   * spawned by agent-worker (e.g. `MCP_<NAME>_BEARER_TOKEN` referenced by
+   * codex `config.toml`'s `bearer_token_env_var`). Pilot keeps these out
+   * of the on-disk config files so tokens never land on the sandbox FS.
+   * Merged into `ProviderConfig.env` by agent-worker.
+   */
+  env: z8.record(z8.string(), z8.string()).optional(),
+  projectKind: ProjectKindSchema.optional().default("coding")
+});
+var FollowupRequestSchema = z8.object({
+  runId: z8.string().optional(),
+  agentId: z8.string().optional(),
+  message: z8.string(),
+  provider: ProviderTypeSchema.optional(),
+  model: z8.string().optional(),
+  workspacePath: z8.string().optional(),
+  /** See `PromptRequestSchema.mcpConfigDir`. */
+  mcpConfigDir: z8.string().optional(),
+  expectedMessagesHash: z8.string().optional(),
+  expectedMessagesCount: z8.number().int().optional(),
+  attachments: z8.array(AttachmentMetaSchema).max(5).optional(),
+  /** See `PromptRequestSchema.mcpServers` — same semantics for follow-ups. */
+  mcpServers: McpServersMapSchema.optional(),
+  /** See `PromptRequestSchema.env` — same semantics for follow-ups. */
+  env: z8.record(z8.string(), z8.string()).optional(),
+  projectKind: ProjectKindSchema.optional().default("coding")
+});
+var RunnerRestorePolicySchema = z8.enum(["restart", "lazy-start", "skip"]);
+var HydrationCategorySchema = z8.enum([
+  "conversation",
+  "workspace",
+  "runtimeEnv",
+  "runner",
+  "attachments",
+  "artifactsRef"
+]);
+var HydrationManifestEntrySchema = z8.object({
+  category: HydrationCategorySchema,
+  ref: z8.string(),
+  checksum: z8.string().optional(),
+  size: z8.number().int().optional()
+});
+var UIMessageChunkTypeSchema = z9.enum([
+  "text-start",
+  "text-delta",
+  "text-end",
+  "reasoning-start",
+  "reasoning-delta",
+  "reasoning-end",
+  "tool-input-start",
+  "tool-input-delta",
+  "tool-input-available",
+  "tool-output-available",
+  "tool-output-error",
+  "start",
+  "finish",
+  "error",
+  "start-step",
+  "finish-step"
+]);
+var UIMessageChunkSchema = z9.object({
+  type: UIMessageChunkTypeSchema,
+  id: z9.string().optional(),
+  content: z9.string().optional(),
+  delta: z9.string().optional(),
+  toolCallId: z9.string().optional(),
+  toolName: z9.string().optional(),
+  input: z9.unknown().optional(),
+  output: z9.string().optional(),
+  errorText: z9.string().optional(),
+  reason: z9.string().optional(),
+  preliminary: z9.boolean().optional()
+});
+var RunEventSchema = z9.object({
+  id: z9.string().uuid(),
+  runId: z9.string().uuid(),
+  eventType: z9.string(),
+  payload: z9.unknown(),
+  cursor: z9.number().int(),
+  createdAt: z9.date()
+});
+var AgentRecoveryStartedEventSchema = z9.object({
+  type: z9.literal("agent_recovery_started"),
+  agentId: z9.string(),
+  sandboxId: z9.string(),
+  degradedRecovery: z9.boolean(),
+  degradedReason: DegradedReasonSchema.optional(),
+  recoveryType: RecoveryTypeSchema
+});
+var AgentRecoveryHydratedEventSchema = z9.object({
+  type: z9.literal("agent_recovery_hydrated"),
+  agentId: z9.string(),
+  checkpointId: z9.string().nullable(),
+  messagesCount: z9.number(),
+  degradedRecovery: z9.boolean()
+});
+var RecoveredFromCheckpointEventSchema = z9.object({
+  type: z9.literal("recovered_from_checkpoint"),
+  checkpointId: z9.string(),
+  lastEventCursor: z9.number().int().nullable()
+});
+var AgentRecoveryCompletedEventSchema = z9.object({
+  type: z9.literal("agent_recovery_completed"),
+  agentId: z9.string(),
+  degradedRecovery: z9.boolean()
+});
+var AgentRecoveryFailedEventSchema = z9.object({
+  type: z9.literal("agent_recovery_failed"),
+  agentId: z9.string(),
+  errorStage: z9.string(),
+  errorMessage: z9.string(),
+  degradedReason: DegradedReasonSchema.optional(),
+  contextExpected: z9.number().optional(),
+  contextActual: z9.number().optional()
+});
+var SandboxStatusSchema = z10.enum([
+  "creating",
+  "running",
+  "idle",
+  "destroying",
+  "destroyed",
+  "error"
+]);
+var SandboxPublicEndpointSchema = z10.object({
+  name: z10.string(),
+  url: z10.string(),
+  host: z10.string(),
+  path: z10.string()
+});
+var SandboxInfoSchema = z10.object({
+  id: z10.string(),
+  status: SandboxStatusSchema,
+  podIp: z10.string().nullable(),
+  agentEndpoint: z10.string().nullable(),
+  createdAt: z10.date(),
+  ttlSeconds: z10.number().int().optional(),
+  templateName: z10.string().optional(),
+  labels: z10.record(z10.string()).optional(),
+  /**
+   * GAP 3 — sandbox-actual public endpoints transited from the provider SDK.
+   * Optional/absent for providers that do not report them (and for legacy
+   * call sites); downstream consumers MUST treat absence as "no transit data"
+   * and fall back to declaration-derived URLs.
+   */
+  publicEndpoints: z10.array(SandboxPublicEndpointSchema).optional()
+});
+var CreateSandboxOptionsSchema = z10.object({
+  templateName: z10.string(),
+  /**
+   * Caller-supplied stable claim name. When omitted, the provider lets the
+   * sandbox control plane generate a per-sandbox id (`claim-<nanoTS>`), which
+   * changes on every create — so the derived public ingress host
+   * (`<hostPrefix>-<claimName>.<baseDomain>`) drifts across recreate.
+   *
+   * Supplying a stable, caller-controlled value (e.g. a project-scoped key)
+   * keeps the ingress host stable across abort→recreate cycles (GAP 1 = B:
+   * scale-to-zero is abort + recreate, not pause/wake). MUST be DNS-label safe
+   * (lowercase alphanumeric + hyphen); the control plane truncates the
+   * `<hostPrefix>-<claimName>` first label to 63 chars, so callers must ensure
+   * the distinguishing portion fits within budget.
+   */
+  claimName: z10.string().optional(),
+  image: z10.string().optional(),
+  env: z10.record(z10.string()).optional(),
+  ttlSeconds: z10.number().int().positive().optional(),
+  metadata: z10.record(z10.string()).optional(),
+  labels: z10.record(z10.string()).optional()
+});
+var ExecResultSchema = z10.object({
+  exitCode: z10.number().int(),
+  stdout: z10.string(),
+  stderr: z10.string()
+});
+var MergeRequestStatusSchema = z11.enum(["creating", "open", "merged", "closed", "failed"]);
+var MergeRequestSchema = z11.object({
+  id: z11.string().uuid(),
+  runId: z11.string().uuid(),
+  projectId: z11.string().uuid(),
+  externalId: z11.string().nullable(),
+  externalUrl: z11.string().nullable(),
+  sourceBranch: z11.string(),
+  targetBranch: z11.string(),
+  title: z11.string(),
+  description: z11.string().nullable(),
+  status: MergeRequestStatusSchema,
+  createdAt: z11.date(),
+  updatedAt: z11.date()
+});
+var HealthCheckConfigSchema = z12.object({
+  type: z12.enum(["http", "tcp", "command"]),
+  port: z12.number().int().optional(),
+  path: z12.string().optional(),
+  command: z12.string().optional(),
+  intervalMs: z12.number().int().positive().default(5e3),
+  timeoutMs: z12.number().int().positive().default(3e3),
+  retries: z12.number().int().nonnegative().default(3)
+});
+var RuntimeProfileSchema = z12.object({
+  id: z12.string().uuid(),
+  projectId: z12.string().uuid(),
+  version: z12.number().int().positive(),
+  env: z12.record(z12.string()).default({}),
+  secretRefs: z12.record(z12.string()).default({}),
+  workingDirectory: z12.string().default("/workspace"),
+  runnerCommand: z12.string().optional(),
+  runnerPorts: z12.array(z12.number().int().positive()).optional(),
+  healthCheck: HealthCheckConfigSchema.optional(),
+  prepareCommands: z12.array(z12.string()).optional(),
+  status: z12.enum(["active", "archived"]).default("active"),
+  createdAt: z12.date(),
+  updatedAt: z12.date()
+});
+var MAX_SUMMARIZE_PROMPT_CHARS = 1e4;
+var SummarizeRequestSchema = z13.object({
+  /** Full diff text (legacy mode). Optional when repoDir is provided. */
+  diff: z13.string().min(1).optional(),
+  /** Workspace repo directory path (agentic mode). Must be an absolute path. */
+  repoDir: z13.string().startsWith("/", { message: "repoDir must be an absolute path" }).optional(),
+  /** Git diff reference, e.g. "--cached" or "origin/main...HEAD". */
+  diffRef: z13.string().regex(/^(--cached|[a-zA-Z0-9_.\-\/~^]+(\.\.\.?[a-zA-Z0-9_.\-\/~^]+)?)$/, {
+    message: "diffRef must be '--cached' or a valid git ref (e.g. 'origin/main..HEAD', 'origin/main...HEAD')"
+  }).optional(),
+  prompt: z13.string().max(MAX_SUMMARIZE_PROMPT_CHARS).optional(),
+  model: z13.string().optional()
+}).refine((data) => data.diff || data.repoDir, {
+  message: "Either 'diff' or 'repoDir' must be provided"
+});
+var SummarizeResponseSchema = z13.object({
+  commitMessage: z13.string().min(1).max(200).describe(
+    "Single-line commit message in conventional commits format: <type>(<scope>): <description>"
+  ),
+  prTitle: z13.string().min(1).max(256).describe(
+    "Pull request title, descriptive. Aim for under 72 characters but the schema accepts up to 256 (GitHub/GitLab hard limit) to tolerate model overshoot."
+  ),
+  prDescription: z13.string().min(1).describe(
+    "Pull request description in markdown. Start with ## Changes, then list key changes as bullet points."
+  )
+});
+var MAX_WORKSPACE_DIFF_BYTES = 20 * 1024 * 1024;
+var WorkspaceDiffStatResponseSchema = z14.object({
+  filesChanged: z14.number().int().nonnegative(),
+  insertions: z14.number().int().nonnegative(),
+  deletions: z14.number().int().nonnegative(),
+  estimatedBytes: z14.number().int().nonnegative()
+});
+var AGENT_PUSH_OUTPUT_TRUNCATE_BYTES = 8 * 1024;
+var AGENT_PUSH_MAX_ATTEMPTS = 3;
+var AgentPushRetryReasonSchema = z15.enum([
+  "gnutls_recv_error",
+  "rpc_failed",
+  "connection_reset",
+  "timeout",
+  "broken_pipe",
+  "early_eof",
+  "dns"
+]);
+var AgentPushAuthSchema = z15.discriminatedUnion("kind", [
+  z15.object({
+    kind: z15.literal("github"),
+    username: z15.string().min(1),
+    token: z15.string().min(1)
+  }),
+  z15.object({
+    kind: z15.literal("gitlab"),
+    token: z15.string().min(1)
+  })
+]);
+var AgentPushRequestSchema = z15.object({
+  /** Absolute path inside the sandbox to the git working directory. */
+  repoDir: z15.string().refine((s) => s.startsWith("/"), {
+    message: "repoDir must be an absolute path"
+  }),
+  /** Remote name, typically `origin`. */
+  remote: z15.string().min(1).default("origin"),
+  /** Branch to push. */
+  branch: z15.string().min(1),
+  /** When true, appends `--force`. Default `false`. */
+  force: z15.boolean().default(false),
+  auth: AgentPushAuthSchema
+});
+var AgentPushResponseSchema = z15.object({
+  /** Convenience flag — equivalent to `exitCode === 0`. */
+  ok: z15.boolean(),
+  /**
+   * Final `git push` process exit code (from the last attempt if
+   * retries happened). `0` on success. Non-zero values follow git's
+   * own conventions (e.g. `128` for fatal errors).
+   */
+  exitCode: z15.number().int(),
+  /** Captured stdout, truncated per AGENT_PUSH_OUTPUT_TRUNCATE_BYTES. */
+  stdout: z15.string(),
+  /** Captured stderr, truncated per AGENT_PUSH_OUTPUT_TRUNCATE_BYTES. */
+  stderr: z15.string(),
+  /** Total wall time across all attempts, in milliseconds. */
+  durationMs: z15.number().int().nonnegative(),
+  /**
+   * Number of attempts actually made. Always ≥ 1 and
+   * ≤ AGENT_PUSH_MAX_ATTEMPTS.
+   */
+  attempts: z15.number().int().min(1).max(AGENT_PUSH_MAX_ATTEMPTS),
+  /**
+   * Reason for the most recent retry. Present only when `attempts > 1`.
+   * Absent when the initial attempt succeeded or when the failure was
+   * classified as non-transient (auth failure, non-fast-forward, etc.).
+   */
+  lastRetryReason: AgentPushRetryReasonSchema.optional()
+});
+var CredentialsBrokerRequestSchema = z16.object({}).strict();
+var GitProviderCredentialSchema = z16.object({
+  /** Git hosting provider name. */
+  provider: z16.enum(["github", "gitlab"]),
+  /**
+   * Short-lived access token. For GitHub App, this is an installation
+   * token (~1 hour TTL). For GitLab OAuth, this is the just-refreshed
+   * access token.
+   */
+  accessToken: z16.string().min(1),
+  /** ISO-8601 expiry; callers MUST NOT use the token beyond this. */
+  expiresAt: z16.string().datetime(),
+  /**
+   * Monotonic rotation counter. The Pod Agent uses this to invalidate
+   * its in-memory cache on refresh; bumps every time the broker hands
+   * out a token (so two consecutive calls return different versions
+   * even if the upstream provider returned the same string).
+   */
+  rotationVersion: z16.number().int().nonnegative(),
+  /** GitLab only: the instance base URL the token was minted for. */
+  instanceUrl: z16.string().url().optional()
+});
+var LlmCredentialSchema = z16.object({
+  /** LLM provider name. `bedrock` covers the per-LDAP AK/SK path. */
+  provider: z16.enum(["bedrock", "anthropic"]),
+  /** Base URL the Worker / proxy should target. */
+  baseUrl: z16.string().url(),
+  /**
+   * HTTP headers the proxy must send upstream. May contain the
+   * Bedrock-related AWS overrides (encoded as headers consumed by the
+   * Pod-Agent local proxy, not as bare AWS sig v4 yet — see proposal in
+   * `docs/proposals/pilot-v2-llm-proxy.md`).
+   */
+  headers: z16.record(z16.string(), z16.string()),
+  /**
+   * Optional expiry. Bedrock AK/SK are long-lived; this is present only
+   * when the underlying credential issuer (e.g. STS-backed Bedrock
+   * adapter in the future) returns a TTL.
+   */
+  expiresAt: z16.string().datetime().optional()
+});
+var OssCredentialSchema = z16.object({
+  /** OSS region (e.g. `oss-cn-beijing`). */
+  region: z16.string().min(1),
+  /** Target bucket. */
+  bucket: z16.string().min(1),
+  /**
+   * Per-session prefix the Worker MUST stay within (the presigned URL
+   * is scoped to a single object key, but the prefix is exposed so the
+   * client can compose multi-key flows by requesting fresh URLs).
+   */
+  prefix: z16.string().min(1),
+  /**
+   * Pre-signed PUT URL for the Session's default artifact object key
+   * (`${prefix}artifact.bin` by convention). Phase 1 fallback in place
+   * of true STS credentials. Single-use semantics: callers needing a
+   * different object key MUST call this endpoint again.
+   */
+  presignedUploadUrl: z16.string().url(),
+  /** ISO-8601 expiry of the presigned URL. */
+  expiresAt: z16.string().datetime(),
+  // Reserved for the future STS variant. Optional today.
+  stsAccessKeyId: z16.string().optional(),
+  stsSecretAccessKey: z16.string().optional(),
+  stsSessionToken: z16.string().optional()
+});
+var CredentialsBrokerErrorCodeSchema = z16.enum([
+  // 401 — authentication failures
+  "MISSING_SESSION_TOKEN",
+  "MISSING_POD_AGENT_TOKEN",
+  "SESSION_TOKEN_INVALID",
+  "SESSION_TOKEN_REVOKED",
+  "SESSION_TOKEN_EXPIRED",
+  "POD_AGENT_TOKEN_INVALID",
+  // 403 — authorization failures
+  "SESSION_TOKEN_SESSION_MISMATCH",
+  // 404 — session does not exist
+  "SESSION_NOT_FOUND",
+  // 503 — upstream credential issuer (GitHub App / Vault / OSS) is down
+  "GIT_PROVIDER_NOT_CONFIGURED",
+  "GIT_TOKEN_UNAVAILABLE",
+  "LLM_CREDENTIAL_UNAVAILABLE",
+  "OSS_STS_UNAVAILABLE",
+  // 500 — fallthrough
+  "INTERNAL_ERROR"
+]);
+var InvalidateKeysRequestSchema = z17.object({
+  sessionId: z17.string().uuid(),
+  runId: z17.string().uuid().optional(),
+  ldap: z17.string().min(1).max(255),
+  provider: z17.enum(["claude-code", "codex"]),
+  observedAt: z17.string().datetime({ offset: true }),
+  reason: z17.string().max(500).optional()
+});
+var InvalidateKeysResponseSchema = z17.object({
+  pushed: z17.boolean(),
+  /** Optional sub-status; useful for clients to surface diagnostic detail
+   *  without parsing prose. */
+  reasonCode: z17.string().max(100).optional()
+});
+var ReloadCredentialsRequestSchema = z17.object({
+  env: z17.record(z17.string().min(1), z17.string()).refine((rec) => Object.keys(rec).length > 0, {
+    message: "env must contain at least one entry"
+  })
+});
+var ReloadCredentialsResponseSchema = z17.object({
+  applied: z17.array(z17.string())
+});
+var PodAgentGitPushRequestSchema = z18.object({
+  /** Lease token issued by pod-agent at worker startup; same value used by clone. */
+  leaseToken: z18.string().min(1),
+  /** Absolute workspace path returned by an earlier `/pilot/workspace/clone`. */
+  workspaceDir: z18.string().refine((s) => s.startsWith("/"), {
+    message: "workspaceDir must be an absolute path"
+  }),
+  /** Remote name. Defaults to `origin`. */
+  remote: z18.string().min(1).default("origin"),
+  /** Branch to push. */
+  branch: z18.string().min(1),
+  /** Whether to add `--force`. Default `false`. */
+  force: z18.boolean().default(false)
+}).strict();
+var PodAgentGitPushResponseSchema = z18.discriminatedUnion("kind", [
+  z18.object({
+    kind: z18.literal("ok"),
+    /** Final `git push` process exit code (0 = success). */
+    exitCode: z18.number().int(),
+    /** Captured stdout, truncated per AGENT_PUSH_OUTPUT_TRUNCATE_BYTES. */
+    stdout: z18.string(),
+    /** Captured stderr, truncated per AGENT_PUSH_OUTPUT_TRUNCATE_BYTES. */
+    stderr: z18.string(),
+    /** Total wall time across all attempts, in milliseconds. */
+    durationMs: z18.number().int().nonnegative(),
+    /** Number of attempts actually made (1..AGENT_PUSH_MAX_ATTEMPTS). */
+    attempts: z18.number().int().min(1).max(AGENT_PUSH_MAX_ATTEMPTS),
+    /** Reason for the most recent retry; present only when attempts > 1. */
+    lastRetryReason: AgentPushRetryReasonSchema.optional()
+  }),
+  z18.object({
+    kind: z18.literal("failed"),
+    /** Human-readable failure reason; safe to surface in delivery audit row. */
+    reason: z18.string().min(1),
+    /** Coarse failure category for caller branching. */
+    code: z18.enum(["AUTH_FETCH_FAILED", "INVALID_WORKSPACE", "INTERNAL", "TRANSPORT_FAILED"]).optional()
+  })
+]);
+var WecomMsgTypeSchema = z19.enum([
+  "text",
+  "image",
+  "file",
+  "mixed",
+  "voice",
+  "video",
+  "stream"
+]);
+var WecomChatTypeSchema = z19.enum(["single", "group"]);
+var WecomSenderSchema = z19.object({
+  userid: z19.string().min(1)
+});
+var WecomTextContentSchema = z19.object({
+  content: z19.string()
+});
+var WecomImageContentSchema = z19.object({
+  url: z19.string().url(),
+  /** AES-256-CBC key (Base64) tied to this specific payload. Present in
+   *  long-connection mode — use with SDK `decryptFile(buffer, aesKey)`. */
+  aeskey: z19.string().optional()
+});
+var WecomFileContentSchema = z19.object({
+  url: z19.string().url(),
+  /** AES-256-CBC key (Base64) tied to this specific payload. */
+  aeskey: z19.string().optional()
+});
+var WecomVoiceContentSchema = z19.object({
+  /** Voice transcribed to text by WeCom (not a URL). */
+  content: z19.string()
+});
+var WecomVideoContentSchema = z19.object({
+  url: z19.string().url(),
+  /** AES-256-CBC key (Base64) tied to this specific payload. */
+  aeskey: z19.string().optional()
+});
+var WecomMixedItemSchema = z19.discriminatedUnion("msgtype", [
+  z19.object({ msgtype: z19.literal("text"), text: WecomTextContentSchema }),
+  z19.object({ msgtype: z19.literal("image"), image: WecomImageContentSchema })
+]);
+var WecomMixedContentSchema = z19.object({
+  msg_item: z19.array(WecomMixedItemSchema).min(1)
+});
+var WecomQuoteSchema = z19.object({
+  msgtype: z19.enum(["text", "image", "mixed", "voice", "file", "video"]),
+  text: WecomTextContentSchema.optional(),
+  image: WecomImageContentSchema.optional(),
+  mixed: WecomMixedContentSchema.optional(),
+  voice: WecomVoiceContentSchema.optional(),
+  file: WecomFileContentSchema.optional(),
+  video: WecomVideoContentSchema.optional()
+});
+var WecomStreamRefSchema = z19.object({
+  id: z19.string().min(1)
+});
+var wecomBasePayload = {
+  /** Unique message id for dedup (potential duplicate delivery). */
+  msgid: z19.string().min(1),
+  /** WeCom aibot id, used to reverse-lookup which Pilot project owns this bot. */
+  aibotid: z19.string().min(1),
+  /** Group chat id; only present when chattype === "group". */
+  chatid: z19.string().optional(),
+  chattype: WecomChatTypeSchema,
+  from: WecomSenderSchema,
+  /** Temporary push URL for active replies (short-lived). Optional in stream frames. */
+  response_url: z19.string().optional(),
+  /** Optional quote reference if the user quoted a prior message. */
+  quote: WecomQuoteSchema.optional()
+};
+var WecomMessagePayloadSchema = z19.discriminatedUnion("msgtype", [
+  z19.object(__spreadProps(__spreadValues({}, wecomBasePayload), {
+    msgtype: z19.literal("text"),
+    text: WecomTextContentSchema
+  })),
+  z19.object(__spreadProps(__spreadValues({}, wecomBasePayload), {
+    msgtype: z19.literal("image"),
+    image: WecomImageContentSchema
+  })),
+  z19.object(__spreadProps(__spreadValues({}, wecomBasePayload), {
+    msgtype: z19.literal("file"),
+    file: WecomFileContentSchema
+  })),
+  z19.object(__spreadProps(__spreadValues({}, wecomBasePayload), {
+    msgtype: z19.literal("mixed"),
+    mixed: WecomMixedContentSchema
+  })),
+  z19.object(__spreadProps(__spreadValues({}, wecomBasePayload), {
+    msgtype: z19.literal("voice"),
+    voice: WecomVoiceContentSchema
+  })),
+  z19.object(__spreadProps(__spreadValues({}, wecomBasePayload), {
+    msgtype: z19.literal("video"),
+    video: WecomVideoContentSchema
+  })),
+  z19.object(__spreadProps(__spreadValues({}, wecomBasePayload), {
+    msgtype: z19.literal("stream"),
+    stream: WecomStreamRefSchema
+  }))
+]);
+var WecomConfigActionSchema = z20.enum(["enable", "update", "disable"]);
+var WecomConfigChangeEventSchema = z20.object({
+  projectId: z20.string().min(1),
+  action: WecomConfigActionSchema,
+  /**
+   * Current bot id post-change. `null` on disable when the operator
+   * cleared it alongside the disable; absent when the patch didn't
+   * touch bot_id.
+   */
+  botId: z20.string().nullable().optional()
+});
+var WecomCredentialLayerSchema = z21.enum(["user", "owner", "project", "service"]);
+var WecomPushTargetSchema = z21.object({
+  /** Project that owns the bot — used by dispatcher subscribers to
+   *  filter messages addressed to bots this pod doesn't lead. */
+  projectId: z21.string().min(1),
+  /** Agent id the run belongs to. Rendered into the card's `card_action`
+   *  Portal link so the user can jump to `/agents/<agentId>` to read
+   *  the result. */
+  agentId: z21.string().min(1),
+  /** "single" or "group" — chooses whether the dispatcher prefixes the
+   *  outbound card with a `<@triggerUserid>` markdown so the original
+   *  sender gets a real @ notification (template_card cannot carry
+   *  inline mentions). */
+  chatType: z21.enum(["single", "group"]),
+  /** Destination passed verbatim to `wsClient.sendMessage`. Userid for
+   *  single chats, chatid for group chats. */
+  chatTarget: z21.string().min(1),
+  /** Userid that triggered the run. Used (a) to build the `<@userid>`
+   *  markdown in group-chat pushes and (b) by future audit / logging. */
+  triggerUserid: z21.string().min(1),
+  /** Layer the layered Git-credential resolver landed on, when the
+   *  resolver was wired and produced a hit. Absent → `null` semantically:
+   *  resolver wired but no tier matched (user should configure a PAT)
+   *  iff `credentialResolverEnabled` is true; otherwise legacy
+   *  pre-resolver deployment (env PAT path). */
+  credentialLayer: WecomCredentialLayerSchema.optional(),
+  /** True iff the resolver was wired into the message handler. Lets
+   *  the dispatcher distinguish "no PAT in any tier → user-actionable
+   *  error card" from "legacy deployment, env PAT was the intended
+   *  path → generic error card". */
+  credentialResolverEnabled: z21.boolean()
+});
+var WecomPushEventSchema = z21.object({
+  runId: z21.string().uuid(),
+  success: z21.boolean(),
+  /** Optional human-readable error reason. Only meaningful when
+   *  `success === false`; ignored otherwise. */
+  reason: z21.string().optional()
+});
+var GitTokenSchema = z22.string().transform((s) => s.trim()).pipe(
+  z22.string().min(1, "token must not be empty").max(1024).regex(
+    /^[\x21-\x7e]+$/,
+    "token must contain only printable ASCII characters (no whitespace or special symbols)"
+  )
+);
+var UserGitCredentialMetadataSchema = z22.object({
+  provider: GitProviderSchema,
+  instanceUrl: z22.string().url(),
+  tokenScope: z22.string().nullable(),
+  expiresAt: z22.coerce.date().nullable(),
+  lastValidatedAt: z22.coerce.date(),
+  createdAt: z22.coerce.date(),
+  updatedAt: z22.coerce.date()
+});
+var UpsertUserGitCredentialSchema = z22.object({
+  provider: GitProviderSchema,
+  instanceUrl: z22.string().url(),
+  token: GitTokenSchema,
+  tokenScope: z22.string().optional(),
+  expiresAt: z22.coerce.date().optional()
+});
+var UserGitCredentialKeySchema = z22.object({
+  provider: GitProviderSchema,
+  instanceUrl: z22.string().url()
+});
+var ProjectSharedCredentialMetadataSchema = z22.object({
+  sharedGitlabTokenConfigured: z22.boolean().default(false),
+  sharedGithubTokenConfigured: z22.boolean().default(false)
+});
+var UpsertProjectSharedCredentialSchema = z22.object({
+  provider: GitProviderSchema,
+  token: GitTokenSchema
+});
+var PlatformScopeSchema = z23.enum([
+  // Project-level (clamped by target_project_ids ∩ ACL)
+  "project:read",
+  "project:settings",
+  "agents:write",
+  "runs:create",
+  "runs:stream",
+  "runs:abort",
+  "runs:merge",
+  "files:upload",
+  "pool:acquire",
+  // User-level (not clamped by project allowlist)
+  "user:credentials",
+  "integrations:git:read",
+  // Admin-only (separate approval)
+  "sessions:terminate",
+  "resources:cleanup",
+  "pool:admin",
+  "admin:bedrock-sync"
+]);
+var ScopeTemplateSchema = z23.enum([
+  "read_only",
+  "ci_automation",
+  "trigger_only",
+  "full_automation",
+  "custom"
+]);
+var PlatformTokenPayloadSchema = z24.object({
+  /** Discriminator. Rejects cross-system JWTs (reskill-api, summarization-api, ...). */
+  type: z24.literal("platform-api"),
+  /** Owner LDAP. */
+  sub: z24.string().min(1),
+  /** Corresponds to `platform_tokens.id`. */
+  jti: z24.string().uuid(),
+  /** Issued-at (seconds). */
+  iat: z24.number().int().nonnegative(),
+  /** Expiry (seconds). Omit for never-expiring tokens. */
+  exp: z24.number().int().positive().optional()
+});
+var SDKMessageTypeSchema = z25.enum([
+  // Assistant text output.
+  "text-delta",
+  // Assistant reasoning (when the model supports it).
+  "reasoning",
+  // A tool invocation by the agent (input available).
+  "tool-use",
+  // A tool result (output available).
+  "tool-result",
+  // A tool failure.
+  "tool-error",
+  // Finalize-stage progress (preparing / uploading / verifying / ...).
+  "finalize-progress",
+  // Terminal error from the run.
+  "error",
+  // Stream completed successfully (run finalized).
+  "done",
+  // Step boundaries (used by multi-step agents).
+  "step-start",
+  "step-end"
+]);
+var SDKMessageSchema = z25.object({
+  type: SDKMessageTypeSchema,
+  /** Monotonically increasing stream cursor from the server. Usable for resume. */
+  cursor: z25.number().int().nonnegative().optional(),
+  /** Stable per-message identifier when the server provides one. */
+  id: z25.string().optional(),
+  /** Raw text for `text-delta` / `reasoning`. */
+  text: z25.string().optional(),
+  /** Tool invocation details when `type === 'tool-use' | 'tool-result' | 'tool-error'`. */
+  tool: z25.object({
+    name: z25.string(),
+    callId: z25.string().optional(),
+    input: z25.unknown().optional(),
+    output: z25.string().optional(),
+    error: z25.string().optional()
+  }).optional(),
+  /** Finalize progress snapshot for `type === 'finalize-progress'`. */
+  progress: z25.object({
+    stage: z25.string(),
+    detail: z25.string().optional()
+  }).optional(),
+  /** Error detail for `type === 'error'`. */
+  error: z25.object({
+    message: z25.string(),
+    code: z25.string().optional()
+  }).optional(),
+  /**
+   * Terminal run status for `type === 'done'`. Mirrors the DB
+   * run-status enum so callers can branch without another fetch.
+   */
+  runStatus: RunStatusSchema.optional()
+}).passthrough();
+var McpStdioConfigSchema = z26.object({
+  type: z26.literal("stdio"),
+  command: z26.string().min(1),
+  args: z26.array(z26.string()).optional(),
+  env: z26.record(z26.string(), z26.string()).optional()
+});
+var McpSseConfigSchema = z26.object({
+  type: z26.literal("sse"),
+  url: z26.string().url(),
+  headers: z26.record(z26.string(), z26.string()).optional()
+});
+var McpHttpConfigSchema = z26.object({
+  type: z26.literal("http"),
+  url: z26.string().url(),
+  headers: z26.record(z26.string(), z26.string()).optional()
+});
+var MCPServerConfigSchema = z26.discriminatedUnion("type", [
+  McpStdioConfigSchema,
+  McpSseConfigSchema,
+  McpHttpConfigSchema
+]);
+var McpTemplateSnapshotSchema = z26.object({
+  transportType: z26.enum(["stdio", "sse", "http"]),
+  serverConfig: MCPServerConfigSchema,
+  requiredVars: z26.array(z26.string()).optional(),
+  version: z26.string().optional()
+});
+var EnabledMcpServerSchema = z26.object({
+  rushMcpId: z26.string().min(1),
+  displayName: z26.string().min(1),
+  templateSnapshot: McpTemplateSnapshotSchema,
+  extraConfigValues: z26.record(z26.string(), z26.string()).optional(),
+  toolFilter: z26.array(z26.string()).optional(),
+  disabled: z26.boolean().optional()
+});
+var EnabledMcpServerListSchema = z26.array(EnabledMcpServerSchema);
+var EnabledMcpRefSchema = z26.object({
+  rushMcpId: z26.string().min(1),
+  disabled: z26.boolean().optional(),
+  extraConfigValuesOverride: z26.record(z26.string(), z26.string()).optional()
+});
+var EnabledMcpRefListSchema = z26.array(EnabledMcpRefSchema);
+var EnabledMcpEntrySchema = z26.union([EnabledMcpServerSchema, EnabledMcpRefSchema]);
+var EnabledMcpEntryListSchema = z26.array(EnabledMcpEntrySchema);
+var SkillSourceTypeSchema = z27.enum([
+  "github",
+  "gitlab",
+  "registry",
+  "local",
+  "oss_url",
+  "custom_url"
+]);
+var ResolvedSkillArtifactSchema = z27.object({
+  sourceType: SkillSourceTypeSchema,
+  /**
+   * Direct repo / file URL for `github` / `gitlab` source types. For
+   * `registry` / `oss_url` / `local` / `custom_url`, rush stores the
+   * actual download artifact in `skill_versions` (different per
+   * version) so this field is empty / unused at install time — the
+   * installer goes through `RushRegistryClient.resolveDownloadUrl`
+   * instead.
+   */
+  sourceUrl: z27.string().optional().default(""),
+  skillPath: z27.string().optional(),
+  integrity: z27.string().optional(),
+  version: z27.string().optional()
+});
+var EnabledSkillSchema = z27.object({
+  rushSkillName: z27.string().min(1),
+  displayName: z27.string().min(1),
+  resolvedArtifact: ResolvedSkillArtifactSchema
+});
+var EnabledSkillListSchema = z27.array(EnabledSkillSchema);
+var EnabledSkillRefSchema = z27.object({
+  rushSkillName: z27.string().min(1)
+});
+var EnabledSkillRefListSchema = z27.array(EnabledSkillRefSchema);
+var EnabledSkillEntrySchema = z27.union([EnabledSkillSchema, EnabledSkillRefSchema]);
+var EnabledSkillEntryListSchema = z27.array(EnabledSkillEntrySchema);
+var SdkAgentSummarySchema = z28.object({
+  agentId: z28.string().uuid(),
+  title: z28.string(),
+  project: z28.object({
+    id: z28.string().uuid(),
+    name: z28.string(),
+    gitProvider: GitProviderSchema.nullable()
+  }),
+  agentMode: z28.enum(["task", "chat"]),
+  productStatus: z28.enum(["idle", "running", "needs_attention", "completed"]),
+  model: z28.string().nullable(),
+  isAutomation: z28.boolean(),
+  latestRun: z28.object({
+    runId: z28.string().uuid(),
+    promptSummary: z28.string(),
+    status: z28.string(),
+    updatedAt: z28.string().datetime(),
+    startedAt: z28.string().datetime().nullable(),
+    completedAt: z28.string().datetime().nullable(),
+    hasArtifacts: z28.boolean(),
+    hasReview: z28.boolean(),
+    hasDiff: z28.boolean(),
+    hasCommits: z28.boolean(),
+    hasPullRequest: z28.boolean()
+  }).nullable(),
+  lastActiveAt: z28.string().datetime()
+});
+var ListAgentsQuerySchema = z28.object({
+  projectId: z28.string().uuid().optional(),
+  limit: z28.number().int().min(1).max(100).optional()
+});
+var ListAgentsResponseSchema = z28.object({
+  items: z28.array(SdkAgentSummarySchema),
+  nextCursor: z28.string().nullable()
+});
+var PilotApiVersionSchema = z28.enum(["v1", "v2"]);
+var SdkCreateAgentRequestSchema = z28.object({
+  projectId: z28.string().uuid().optional(),
+  gitProvider: GitProviderSchema.optional(),
+  gitlabProjectPath: z28.string().trim().min(1).optional(),
+  githubRepoFullName: z28.string().trim().min(1).optional(),
+  repoUrl: z28.string().min(1).optional(),
+  /**
+   * Baseline git ref frozen on the agent for the lifetime of follow-up
+   * runs. Optional — server falls back to project.defaultBranch.
+   */
+  baseRef: z28.string().optional(),
+  prompt: z28.string().min(1),
+  agentMode: z28.enum(["task", "chat"]).optional(),
+  model: z28.string().optional(),
+  provider: ProviderTypeSchema.optional(),
+  githubInstallationId: z28.string().optional(),
+  attachments: z28.array(AttachmentMetaSchema).max(5).optional(),
+  /**
+   * Optional MCP / Skill enable lists frozen on the new agent at
+   * creation time.
+   *
+   * Both fields accept the same union the home-composer
+   * pre-edit and `PUT /api/agents/:id/mcp-skills` accept (see
+   * `EnabledMcpEntrySchema` / `EnabledSkillEntrySchema`):
+   * full snapshot **OR** ref into the global credential store.
+   *
+   * `POST /api/agents` semantics (Pilot Web):
+   * - Omitted lists + no CLI seed header → new agent starts with empty
+   *   `enabled_*` (interactive / SDK default; spec §4.3).
+   * - Omitted lists + Pilot CLI request (`x-pilot-cli-seed-from-project: 1`) →
+   *   server seeds from `projects.enabled_mcp_servers` / `enabled_skills`.
+   * - Either list provided → explicit caller choice; omitted dimension
+   *   still follows the seed rule above; `agents.mcp_skills_customized = true`
+   *   when any list is caller-supplied.
+   *
+   * See `specs/features/mcp-and-skills.md` §4.4.
+   */
+  enabledMcpServers: EnabledMcpEntryListSchema.optional(),
+  enabledSkills: EnabledSkillEntryListSchema.optional(),
+  /**
+   * Caller-explicit per-run lifecycle selector. Same semantics as
+   * `SdkCreateRunRequestSchema.pilotApiVersion` — see `PilotApiVersionSchema`
+   * JSDoc for the three-layer LOCK and routing precedence.
+   *
+   * Three-layer LOCK (agents):
+   *   L1 SDK   `SdkCreateAgentRequestSchema.pilotApiVersion`         — this file
+   *   L2 API   `apps/web/app/api/agents/route.ts`                    — body field
+   *   L3 RT    `packages/control-plane/src/run-service.ts`           — `runs.pilot_api_version`
+   *
+   * Optional; when omitted, server falls through to `decideRoute()` then
+   * default `"v1"`.
+   */
+  pilotApiVersion: PilotApiVersionSchema.optional()
+}).superRefine((data, ctx) => {
+  const hasProjectId = typeof data.projectId === "string" && data.projectId.length > 0;
+  const hasGitlabPath = !!data.gitlabProjectPath;
+  const hasGithubRepo = !!data.githubRepoFullName;
+  const hasGitProvider = !!data.gitProvider;
+  if (hasProjectId) {
+    if (hasGitProvider || hasGitlabPath || hasGithubRepo || data.repoUrl) {
+      ctx.addIssue({
+        code: z28.ZodIssueCode.custom,
+        message: "projectId is exclusive with gitProvider / gitlabProjectPath / githubRepoFullName / repoUrl.",
+        path: ["projectId"]
+      });
+    }
+    return;
+  }
+  if (!hasGitProvider) {
+    ctx.addIssue({
+      code: z28.ZodIssueCode.custom,
+      message: "Provide either projectId, or (gitProvider + gitlabProjectPath) / (gitProvider + githubRepoFullName).",
+      path: ["gitProvider"]
+    });
+    return;
+  }
+  if (data.gitProvider === "gitlab") {
+    if (!hasGitlabPath) {
+      ctx.addIssue({
+        code: z28.ZodIssueCode.custom,
+        message: "gitProvider=gitlab requires gitlabProjectPath.",
+        path: ["gitlabProjectPath"]
+      });
+    }
+    if (hasGithubRepo) {
+      ctx.addIssue({
+        code: z28.ZodIssueCode.custom,
+        message: "gitProvider=gitlab must not carry githubRepoFullName.",
+        path: ["githubRepoFullName"]
+      });
+    }
+  } else if (data.gitProvider === "github") {
+    if (!hasGithubRepo) {
+      ctx.addIssue({
+        code: z28.ZodIssueCode.custom,
+        message: "gitProvider=github requires githubRepoFullName.",
+        path: ["githubRepoFullName"]
+      });
+    }
+    if (hasGitlabPath) {
+      ctx.addIssue({
+        code: z28.ZodIssueCode.custom,
+        message: "gitProvider=github must not carry gitlabProjectPath.",
+        path: ["gitlabProjectPath"]
+      });
+    }
+  }
+});
+var SdkCreateAgentResponseSchema = z28.object({
+  agentId: z28.string().uuid(),
+  runId: z28.string().uuid(),
+  isNewAgent: z28.boolean()
+});
+var SdkMergeAgentRequestSchema = z28.object({
+  /** Optional custom commit message. Server falls back to the model output. */
+  commitMessage: z28.string().min(1).max(200).optional(),
+  /** Optional PR title override. */
+  prTitle: z28.string().min(1).max(256).optional(),
+  /** Optional PR description override. */
+  prDescription: z28.string().optional()
+});
+var SdkMergeAgentResponseSchema = z28.object({
+  mergeRequestId: z28.string().uuid(),
+  externalUrl: z28.string(),
+  externalId: z28.string()
+});
+var SdkPatchAgentRequestSchema = z28.object({
+  customTitle: z28.string().max(200).nullable().optional(),
+  status: z28.enum(["active", "closed"]).optional()
+});
+var SdkCreateRunRequestSchema = z28.object({
+  projectId: z28.string().uuid(),
+  prompt: z28.string().min(1),
+  agentId: z28.string().uuid().optional(),
+  parentRunId: z28.string().uuid().optional(),
+  repo: z28.string().optional(),
+  ref: z28.string().optional(),
+  model: z28.string().optional(),
+  provider: ProviderTypeSchema.optional(),
+  attachments: z28.array(AttachmentMetaSchema).max(5).optional(),
+  /**
+   * Per-run override of the MCP / Skill enable lists.
+   *
+   * When omitted, the run inherits whatever lives on the agent (Portal /
+   * SDK create without MCP/Skill body and without CLI seed header → empty
+   * lists on the agent; see `SdkCreateAgentRequestSchema`).
+   *
+   * Same union shape as the create-agent fields: snapshot OR ref.
+   * Useful for one-off runs that need a different toolset than the
+   * conversational defaults baked onto the agent.
+   *
+   * See `specs/features/mcp-and-skills.md` §6.3 (per-run override).
+   */
+  enabledMcpServers: EnabledMcpEntryListSchema.optional(),
+  enabledSkills: EnabledSkillEntryListSchema.optional(),
+  /**
+   * Caller-explicit Pilot runtime API version override for this run.
+   *
+   * Defaults to **server-decided**: when omitted, the server consults
+   * the traffic-split router (PR-TS-1 D5/D6) for the v1/v2 routing
+   * decision and persists it to `runs.pilot_api_version`. When passed
+   * explicitly, the caller value wins regardless of the router state
+   * (see `run-service.ts` line 99-114 and PR-TS-1 D5 explicit-wins
+   * test `run-service-pilot-api-version.test.ts` line 134-149).
+   *
+   * Use this opt-in carefully — it bypasses the canary / kill-switch
+   * gates. Most callers should leave this unset and trust the router.
+   */
+  pilotApiVersion: PilotApiVersionSchema.optional()
+});
+var SdkCreateRunResponseSchema = z28.object({
+  run: z28.lazy(() => SdkRunSummarySchema)
+});
+var SdkAbortRunRequestSchema = z28.object({
+  reason: z28.string().max(500).optional()
+});
+var SdkAbortRunResponseSchema = z28.object({
+  aborted: z28.boolean(),
+  status: RunStatusSchema
+});
+var SdkRunSummarySchema = z28.object({
+  runId: z28.string().uuid(),
+  agentId: z28.string().uuid(),
+  projectId: z28.string().uuid(),
+  status: RunStatusSchema,
+  prompt: z28.string(),
+  model: z28.string().nullable(),
+  provider: ProviderTypeSchema,
+  triggerSource: TriggerSourceSchema,
+  pullRequestUrl: z28.string().nullable(),
+  errorMessage: z28.string().nullable(),
+  createdAt: z28.string().datetime(),
+  startedAt: z28.string().datetime().nullable(),
+  completedAt: z28.string().datetime().nullable()
+});
+var SdkStreamRunQuerySchema = z28.object({
+  lastCursor: z28.number().int().nonnegative().optional()
+});
+var SdkProjectSummarySchema = z28.object({
+  id: z28.string().uuid(),
+  name: z28.string(),
+  // `kind` is now `NOT NULL DEFAULT 'coding'` in the DB (migration
+  // 0034), so the server always emits a concrete value — `.default()`
+  // would silently mask a missing-field bug instead of surfacing it.
+  // Keep the field strict so SDK consumers can rely on the union
+  // without runtime fallbacks.
+  kind: ProjectKindSchema,
+  gitProvider: GitProviderSchema.nullable(),
+  repoUrl: z28.string().nullable(),
+  gitlabProjectPath: z28.string().nullable(),
+  githubRepoFullName: z28.string().nullable(),
+  webhookEnabled: z28.boolean(),
+  webhookTriggerLabel: z28.string(),
+  jiraEnabled: z28.boolean(),
+  wecomEnabled: z28.boolean(),
+  ownerLdap: z28.string().nullable(),
+  role: z28.enum(["owner", "member", "admin"])
+});
+var ListProjectsRequestSchema = z28.object({
+  kind: ProjectKindSchema.optional()
+});
+var CreateGeneralProjectRequestSchema = z28.object({
+  name: z28.string().trim().min(1).max(255),
+  kind: z28.literal("general"),
+  description: z28.string().trim().max(2e3).optional()
+});
+var CreateGeneralProjectResponseSchema = z28.object({
+  projectId: z28.string().uuid()
+});
+var ListProjectsResponseSchema = z28.object({
+  items: z28.array(SdkProjectSummarySchema)
+});
+var SdkProjectSettingsSchema = z28.object({
+  id: z28.string().uuid(),
+  webhookEnabled: z28.boolean(),
+  webhookTriggerLabel: z28.string(),
+  webhookPromptTemplate: z28.string().nullable(),
+  wecomEnabled: z28.boolean(),
+  wecomBotId: z28.string().nullable(),
+  wecomPromptTemplate: z28.string().nullable(),
+  jiraEnabled: z28.boolean().optional(),
+  jiraBaseUrl: z28.string().nullable().optional(),
+  jiraProjectKey: z28.string().nullable().optional(),
+  jiraTriggerLabel: z28.string().optional(),
+  jiraPromptTemplate: z28.string().nullable().optional()
+});
+var UpdateProjectSettingsRequestSchema = z28.object({
+  webhookEnabled: z28.boolean().optional(),
+  webhookTriggerLabel: z28.string().min(1).max(100).optional(),
+  webhookPromptTemplate: z28.string().nullable().optional(),
+  wecomEnabled: z28.boolean().optional(),
+  wecomBotId: z28.string().min(1).max(100).nullable().optional(),
+  wecomPromptTemplate: z28.string().nullable().optional(),
+  jiraEnabled: z28.boolean().optional(),
+  jiraBaseUrl: z28.string().url().nullable().optional(),
+  jiraProjectKey: z28.string().min(1).max(64).nullable().optional(),
+  jiraTriggerLabel: z28.string().min(1).max(100).optional(),
+  jiraPromptTemplate: z28.string().nullable().optional()
+});
+var SdkAutomationRunSchema = z28.object({
+  runId: z28.string().uuid(),
+  agentId: z28.string().uuid(),
+  projectId: z28.string().uuid(),
+  projectName: z28.string(),
+  gitProvider: GitProviderSchema.nullable(),
+  repoFullName: z28.string().nullable(),
+  status: z28.string(),
+  productStatus: z28.enum(["idle", "running", "needs_attention", "completed"]),
+  promptSummary: z28.string(),
+  triggerRef: z28.string().nullable(),
+  triggerType: z28.enum(["label", "mention", "wecom", "jira"]),
+  issueUrl: z28.string().nullable(),
+  pullRequestUrl: z28.string().nullable(),
+  errorMessage: z28.string().nullable(),
+  createdAt: z28.string().datetime(),
+  updatedAt: z28.string().datetime(),
+  startedAt: z28.string().datetime().nullable(),
+  completedAt: z28.string().datetime().nullable()
+});
+var ListAutomationRunsQuerySchema = z28.object({
+  projectId: z28.string().uuid().optional(),
+  limit: z28.number().int().min(1).max(100).optional(),
+  cursor: z28.string().optional()
+});
+var ListAutomationRunsResponseSchema = z28.object({
+  items: z28.array(SdkAutomationRunSchema),
+  nextCursor: z28.string().nullable()
+});
+var CreatePlatformTokenRequestSchema = z28.object({
+  name: z28.string().min(1).max(200),
+  description: z28.string().max(2e3).optional(),
+  scopes: z28.array(PlatformScopeSchema).min(1),
+  scopeTemplate: ScopeTemplateSchema,
+  /** NULL means "all projects I currently have access to". */
+  targetProjectIds: z28.array(z28.string().uuid()).nullable(),
+  /** ISO-8601 string. Omit for never-expire. */
+  expiresAt: z28.string().datetime().optional()
+});
+var CreatePlatformTokenResponseSchema = z28.object({
+  id: z28.string().uuid(),
+  name: z28.string(),
+  /** The **only** time the full token is returned. */
+  token: z28.string(),
+  tokenPrefix: z28.string(),
+  scopes: z28.array(PlatformScopeSchema),
+  scopeTemplate: ScopeTemplateSchema,
+  targetProjectIds: z28.array(z28.string().uuid()).nullable(),
+  createdAt: z28.string().datetime(),
+  expiresAt: z28.string().datetime().nullable()
+});
+var PlatformTokenInfoSchema = z28.object({
+  id: z28.string().uuid(),
+  name: z28.string(),
+  description: z28.string().nullable(),
+  tokenPrefix: z28.string(),
+  scopes: z28.array(PlatformScopeSchema),
+  scopeTemplate: ScopeTemplateSchema.nullable(),
+  targetProjectIds: z28.array(z28.string().uuid()).nullable(),
+  createdAt: z28.string().datetime(),
+  expiresAt: z28.string().datetime().nullable(),
+  lastUsedAt: z28.string().datetime().nullable(),
+  revokedAt: z28.string().datetime().nullable(),
+  revokedReason: z28.string().nullable()
+});
+var ListPlatformTokensResponseSchema = z28.object({
+  items: z28.array(PlatformTokenInfoSchema)
+});
+var PatchPlatformTokenRequestSchema = z28.object({
+  name: z28.string().min(1).max(200).optional(),
+  description: z28.string().max(2e3).nullable().optional(),
+  /**
+   * Allowed to *shrink* the scope set (for tightening); forbidden to
+   * widen. Server enforces `new_scopes ⊆ old_scopes`.
+   */
+  scopes: z28.array(PlatformScopeSchema).min(1).optional()
+});
+var X_PILOT_API_VERSION_HEADER = "x-pilot-api-version";
+var DeliveryResultPhaseSchema = z29.enum(["in_progress", "completed", "failed"]);
+var DeliveryResultArtifactItemSchema = z29.object({
+  /** Artifact category. Workers MAY add new kinds; storage is opaque. */
+  kind: z29.enum(["diff", "log", "general"]),
+  /**
+   * Logical path inside the sandbox workspace (used as the idempotency
+   * key together with `runId`). Two writes with the same `(runId, path)`
+   * pair collapse to a single row via `ON CONFLICT DO NOTHING`.
+   */
+  path: z29.string().min(1).max(1024),
+  /** Object key inside the OSS bucket where the artifact was uploaded. */
+  storagePath: z29.string().min(1).max(1024),
+  /** Reported byte size of the upload. */
+  size: z29.number().int().nonnegative(),
+  /**
+   * SHA-256 digest in the form `sha256:<hex>`. Workers compute this
+   * before upload so a later integrity check can cross-verify the
+   * stored object. Length cap 128 mirrors the `artifacts.checksum`
+   * column width.
+   */
+  checksum: z29.string().min(1).max(128),
+  /** MIME content type recorded for downloads / preview. */
+  contentType: z29.string().min(1).max(255)
+}).strict();
+var DeliveryResultUpdateSchema = z29.object({
+  /**
+   * The PR / MR URL the agent created. First-write-wins per spec
+   * (`UPDATE ... WHERE pull_request_url IS NULL`); subsequent writes
+   * are recorded in the response as "skipped" rather than as an error
+   * so Worker retries stay idempotent.
+   */
+  pullRequestUrl: z29.string().url().max(1024).optional(),
+  /**
+   * Append-set of artifacts uploaded for this run. Each item is
+   * upserted independently via the `unique(run_id, path)` constraint;
+   * the response indicates how many of the submitted items resulted
+   * in a new row.
+   */
+  artifacts: z29.array(DeliveryResultArtifactItemSchema).max(64).optional(),
+  /**
+   * Drive the `runs.delivery_phase` column via the L1.2
+   * `RunService.recordDeliveryPhase` helper. `failed` requires
+   * `failedReason`; the service throws `INVALID_INPUT` otherwise.
+   */
+  phase: DeliveryResultPhaseSchema.optional(),
+  /** Non-empty failure reason; required iff `phase === "failed"`. */
+  failedReason: z29.string().min(1).max(2048).optional(),
+  /**
+   * When `true`, increment `runs.delivery_attempts` by 1 alongside
+   * the phase write. Workers SHOULD set this on every delivery
+   * (re)attempt so the audit row reflects retry count.
+   */
+  incrementAttempts: z29.boolean().optional()
+}).strict().refine(
+  (data) => data.pullRequestUrl !== void 0 || data.artifacts !== void 0 || data.phase !== void 0 || data.failedReason !== void 0 || data.incrementAttempts !== void 0,
+  {
+    message: "At least one of pullRequestUrl / artifacts / phase / failedReason / incrementAttempts MUST be provided"
+  }
+);
+var DeliveryResultUpdateResponseSchema = z29.object({
+  success: z29.literal(true),
+  data: z29.object({
+    /** Subset of the request fields whose persisted state actually
+     *  changed. `pullRequestUrl` is omitted on second-write (PR URL
+     *  already set) so callers can detect idempotent replays. */
+    applied: z29.array(
+      z29.enum(["pullRequestUrl", "artifacts", "phase", "failedReason", "incrementAttempts"])
+    ),
+    /** Number of newly inserted artifact rows. Always 0 when `artifacts`
+     *  wasn't in the request. */
+    artifactsInserted: z29.number().int().nonnegative()
+  })
+});
+var DeliveryResultErrorCodeSchema = z29.enum([
+  // 400 — request was malformed or schema-invalid
+  "VALIDATION_ERROR",
+  // 401 — Authorization header missing or session token invalid/expired
+  "MISSING_SESSION_TOKEN",
+  "SESSION_TOKEN_INVALID",
+  "SESSION_TOKEN_EXPIRED",
+  "SESSION_TOKEN_REVOKED",
+  // 403 — the session token belongs to a different session than the URL
+  "SESSION_TOKEN_SESSION_MISMATCH",
+  // 404 — the URL session id / corresponding run does not exist
+  "SESSION_NOT_FOUND",
+  "RUN_NOT_FOUND",
+  // 500 — fallthrough
+  "INTERNAL_ERROR"
+]);
+var ResourceProfileSchema = z30.object({
+  cpu: z30.string().min(1),
+  memory: z30.string().min(1),
+  disk: z30.string().min(1).optional(),
+  gpu: z30.string().min(1).optional()
+}).strict();
+var TraceContextSchema = z30.object({
+  traceId: z30.string().min(1),
+  spanId: z30.string().min(1),
+  parentSpanId: z30.string().min(1).optional()
+}).strict();
+var TemplateKindSchema = z30.enum(["claude-code", "codex", "amp"]);
+var RepoCoordinatesSchema = z30.object({
+  repoUrl: z30.string().min(1),
+  targetRef: z30.string().min(1)
+}).strict();
+var ProvisionRequestSchema = z30.object({
+  idempotencyKey: z30.string().min(1),
+  template: TemplateKindSchema,
+  resourceProfile: ResourceProfileSchema,
+  repoCoordinates: RepoCoordinatesSchema.optional(),
+  env: z30.record(z30.string(), z30.string()),
+  trace: TraceContextSchema,
+  deadlineMs: z30.number().int().positive()
+}).strict();
+var WorkerProtocolVersionSchema = z31.enum(["v1"]);
+var SessionRefSchema = z31.object({
+  sessionId: z31.string().min(1),
+  runtimeBindingId: z31.string().min(1)
+}).strict();
+var FORBIDDEN_V1_PRIMITIVE_KEYS = ["runId", "agentId", "projectId", "provider"];
+function forbidV1Primitives(val, ctx) {
+  for (const k of FORBIDDEN_V1_PRIMITIVE_KEYS) {
+    if (k in val) {
+      ctx.addIssue({
+        code: z31.ZodIssueCode.custom,
+        path: [k],
+        message: `R-WP-01: v1 primitive '${k}' is forbidden on v2 dispatch envelopes`
+      });
+    }
+  }
+}
+var WorkerProtocolPromptRequestSchema = z31.object({
+  idempotencyKey: z31.string().min(1),
+  session: SessionRefSchema,
+  protocolVersion: WorkerProtocolVersionSchema,
+  promptText: z31.string().min(1),
+  trace: TraceContextSchema,
+  // Legacy wall-clock deadline. Kept for back-compat with workers/dispatchers
+  // that have not yet adopted the idle/hardCap split. NEW behavior:
+  // - When `idleTimeoutMs` is supplied, framework uses idle-based deadline
+  //   (reset on each ctx.events.append success) plus optional `hardCapMs`
+  //   absolute upper bound; the legacy `deadlineMs` is ignored.
+  // - When only `deadlineMs` is supplied, framework falls back to the
+  //   original wall-clock behavior (single setTimeout = deadlineMs).
+  deadlineMs: z31.number().int().positive(),
+  // Idle timeout: framework fails the turn with `wp_handshake_timeout` if no
+  // `ctx.events.append` succeeds within this many ms. Reset each time the
+  // handler emits a session_event chunk — long-running but actively-streaming
+  // handlers are NOT killed by the wall-clock alone.
+  idleTimeoutMs: z31.number().int().positive().optional(),
+  // Hard upper bound that fires regardless of activity (defense against
+  // infinite-loop handlers that keep emitting). Optional companion to
+  // `idleTimeoutMs`; when omitted, no hard cap is armed.
+  hardCapMs: z31.number().int().positive().optional()
+}).passthrough().superRefine(forbidV1Primitives);
+var WorkerProtocolFollowupRequestSchema = z31.object({
+  idempotencyKey: z31.string().min(1),
+  session: SessionRefSchema,
+  protocolVersion: WorkerProtocolVersionSchema,
+  parentTurnId: z31.string().min(1),
+  followupText: z31.string().min(1),
+  trace: TraceContextSchema,
+  // See `WorkerProtocolPromptRequestSchema.deadlineMs` for the legacy /
+  // idle / hardCap precedence rules; same semantics apply for follow-up.
+  deadlineMs: z31.number().int().positive(),
+  idleTimeoutMs: z31.number().int().positive().optional(),
+  hardCapMs: z31.number().int().positive().optional()
+}).passthrough().superRefine(forbidV1Primitives);
+var WorkerProtocolAbortReasonSchema = z31.discriminatedUnion("kind", [
+  z31.object({ kind: z31.literal("user"), userId: z31.string().min(1).optional() }).strict(),
+  z31.object({ kind: z31.literal("timeout") }).strict(),
+  z31.object({ kind: z31.literal("system"), hint: z31.string().min(1) }).strict()
+]);
+var WorkerProtocolAbortRequestSchema = z31.object({
+  idempotencyKey: z31.string().min(1),
+  session: SessionRefSchema,
+  protocolVersion: WorkerProtocolVersionSchema,
+  turnId: z31.string().min(1),
+  reason: WorkerProtocolAbortReasonSchema,
+  trace: TraceContextSchema
+}).passthrough().superRefine(forbidV1Primitives);
+var WorkerProtocolRestoreRequestSchema = z31.object({
+  idempotencyKey: z31.string().min(1),
+  session: SessionRefSchema,
+  protocolVersion: WorkerProtocolVersionSchema,
+  replayCursor: z31.string().min(1).optional(),
+  trace: TraceContextSchema,
+  // See `WorkerProtocolPromptRequestSchema.deadlineMs` for the legacy /
+  // idle / hardCap precedence rules.
+  deadlineMs: z31.number().int().positive(),
+  idleTimeoutMs: z31.number().int().positive().optional(),
+  hardCapMs: z31.number().int().positive().optional()
+}).passthrough().superRefine(forbidV1Primitives);
+var WP_FAILURE_REASON_KINDS = [
+  "wp_protocol_violation",
+  "wp_handshake_timeout",
+  "wp_unsupported_version",
+  "wp_invalid_envelope",
+  "wp_stream_terminated",
+  "wp_replay_lost"
+];
+var WP_FAILURE_REASON_ENUM = z31.enum(WP_FAILURE_REASON_KINDS);
+var DispatchOutcomeSchema = z31.discriminatedUnion("kind", [
+  z31.object({
+    kind: z31.literal("accepted"),
+    turnId: z31.string().min(1),
+    protocolVersion: WorkerProtocolVersionSchema,
+    observedAt: z31.string().min(1)
+  }).strict(),
+  z31.object({
+    kind: z31.literal("rejected"),
+    reason: WP_FAILURE_REASON_ENUM,
+    observedAt: z31.string().min(1),
+    message: z31.string().min(1).optional()
+  }).strict(),
+  z31.object({
+    kind: z31.literal("idempotent_replay"),
+    turnId: z31.string().min(1),
+    priorOutcome: z31.enum(["accepted", "rejected"]),
+    observedAt: z31.string().min(1)
+  }).strict(),
+  z31.object({
+    kind: z31.literal("transport_failed"),
+    reason: WP_FAILURE_REASON_ENUM,
+    observedAt: z31.string().min(1),
+    message: z31.string().min(1).optional()
+  }).strict()
+]);
+var WorkerProtocolAcceptedPayloadSchema = z32.object({
+  turnId: z32.string().min(1),
+  protocolVersion: WorkerProtocolVersionSchema
+}).strict();
+var WorkerProtocolRejectedPayloadSchema = z32.object({
+  reason: z32.enum(WP_FAILURE_REASON_KINDS),
+  message: z32.string().min(1).optional()
+}).strict();
+var WorkerProtocolFailedReasonSchema = z32.enum([
+  "wp_handshake_timeout",
+  "wp_aborted_by_signal",
+  "wp_protocol_violation",
+  "wp_replay_lost",
+  "wp_session_terminated"
+]);
+var WorkerProtocolFailedPayloadSchema = z32.object({
+  reason: WorkerProtocolFailedReasonSchema,
+  message: z32.string().min(1).optional(),
+  abortContext: z32.object({
+    reason: WorkerProtocolAbortReasonSchema,
+    requestedAt: z32.string().min(1).optional()
+  }).strict().optional()
+}).strict().refine((p) => p.reason !== "wp_aborted_by_signal" || p.abortContext !== void 0, {
+  message: "abortContext required when reason = wp_aborted_by_signal"
+});
+var WorkerProtocolCompletedPayloadSchema = z32.record(z32.unknown());
+var EVENT_TYPE_REGEX = /^([a-z][a-z0-9_]*)\.([a-z][a-z0-9_]*(?:\.[a-z][a-z0-9_]*)?)$/;
+var EventTypeSchema = z33.string().min(1).max(100, "event_type must not exceed SESSION_EVENT_TYPE_MAX_LENGTH (100)").regex(EVENT_TYPE_REGEX, "event_type must be {domain}.{action} in lowercase snake_case");
+var EVENT_DOMAINS = [
+  "user",
+  "agent",
+  "session",
+  "span",
+  "worker_protocol",
+  "vault"
+];
+var EVENT_DOMAIN_SET = new Set(EVENT_DOMAINS);
+var UserMessagePayloadSchema = z33.object({
+  content: z33.array(
+    z33.union([
+      z33.object({ type: z33.literal("text"), text: z33.string() }).strict(),
+      z33.object({ type: z33.literal("image"), source: z33.unknown() }).strict(),
+      z33.object({ type: z33.literal("file"), source: z33.unknown() }).strict()
+    ])
+  )
+}).strict();
+var UserInterruptPayloadSchema = z33.object({}).strict();
+var UserToolConfirmationPayloadSchema = z33.object({
+  toolUseId: z33.string().min(1),
+  result: z33.enum(["allow", "deny"]),
+  denyMessage: z33.string().optional()
+}).strict();
+var UserToolResultPayloadSchema = z33.object({
+  toolUseId: z33.string().min(1),
+  content: z33.array(z33.unknown())
+}).strict();
+var AgentMessagePayloadSchema = z33.object({
+  content: z33.array(
+    z33.union([
+      z33.object({ type: z33.literal("text"), text: z33.string() }).strict(),
+      z33.object({ type: z33.literal("image"), source: z33.unknown() }).strict()
+    ])
+  )
+}).strict();
+var AgentToolUsePayloadSchema = z33.object({
+  toolUseId: z33.string().min(1),
+  toolName: z33.string().min(1),
+  input: z33.record(z33.unknown())
+}).strict();
+var AgentToolResultPayloadSchema = z33.object({
+  toolUseId: z33.string().min(1),
+  content: z33.array(z33.unknown()),
+  isError: z33.boolean().optional()
+}).strict();
+var AgentMcpToolUsePayloadSchema = z33.object({
+  toolUseId: z33.string().min(1),
+  mcpServerName: z33.string().min(1),
+  toolName: z33.string().min(1),
+  input: z33.record(z33.unknown())
+}).strict();
+var AgentCompletedPayloadSchema = z33.object({}).passthrough();
+var AGENT_SESSION_RESET_REASONS = [
+  "session_terminal",
+  // R-ASB-05 dim (a) — session.status === "failed"
+  "session_lifecycle_terminal",
+  // ready session whose lifecycle_phase is terminating/terminated
+  "binding_missing",
+  // dim (b) — no alive runtime_binding row
+  "ttl_expired",
+  // dim (c) — ttl_expires_at within REPROVISION_BUFFER_MS
+  "keepalive_unhealthy",
+  // dim (d) — MF-4 mark-unhealthy latch tripped
+  "max_lifetime",
+  // dim (e) — MF-5 24h+ session age
+  "agent_session_null"
+  // pre-dim — agent.session_id was NULL on dispatch
+];
+var AgentSessionResetReasonSchema = z33.enum(AGENT_SESSION_RESET_REASONS);
+var AgentSessionResetPayloadSchema = z33.object({
+  oldSessionId: z33.string().uuid(),
+  newSessionId: z33.string().uuid(),
+  reason: AgentSessionResetReasonSchema,
+  triggeredByRunId: z33.string().uuid(),
+  triggeredAt: z33.string().datetime()
+}).strict();
+var AGENT_RECOVERY_ERROR_STAGES = ["provision", "startup", "hydrate", "dispatch"];
+var AgentRecoveryErrorStageSchema = z33.enum(AGENT_RECOVERY_ERROR_STAGES);
+var AgentRecoveryStartedV2PayloadSchema = z33.object({
+  /** 1-based attempt counter (first revive of this session = 1). */
+  revivalAttempts: z33.number().int().min(1),
+  /**
+   * REV-INV-7 cap for the chain (typically 3). Optional for backward
+   * compatibility with events emitted before the same-session retry
+   * landed; consumers MUST treat absence as "unknown" rather than
+   * "no cap" — they can fall back to `revivalAttempts >= 3` as the
+   * default budget if they need a UI cue.
+   */
+  maxRevivalAttempts: z33.number().int().min(1).optional(),
+  /** `runtime_bindings.id` of the row this revival is superseding. */
+  predecessorBindingId: z33.string().uuid(),
+  /** UUID of this revival pipeline run; correlates the 4 lifecycle events. */
+  attemptId: z33.string().uuid()
+}).strict();
+var AgentRecoveryHydratedV2PayloadSchema = z33.object({
+  messagesCount: z33.number().int().nonnegative(),
+  /** Canonical SHA-256 hex of restored messages (see `pilot-v2-restore-envelope.md` R-RES-03). */
+  messagesHash: z33.string().min(1),
+  degradedRecovery: z33.boolean()
+}).strict();
+var AgentRecoveryCompletedV2PayloadSchema = z33.object({
+  degradedRecovery: z33.boolean(),
+  /** Raw `session_events` rows scanned before any cap-trim. */
+  eventsSeen: z33.number().int().nonnegative(),
+  attemptId: z33.string().uuid()
+}).strict();
+var AgentRecoveryFailedV2PayloadSchema = z33.object({
+  errorStage: AgentRecoveryErrorStageSchema,
+  /** Human-readable, MUST NOT include credentials / PII. */
+  error: z33.string().min(1),
+  attemptId: z33.string().uuid()
+}).strict();
+var SessionStatusCreatedPayloadSchema = z33.object({ sessionId: z33.string().uuid(), createdAt: z33.string() }).strict();
+var SessionStatusProvisioningPayloadSchema = z33.object({
+  sessionId: z33.string().uuid(),
+  runtimeBindingId: z33.string().optional(),
+  provisionStartedAt: z33.string()
+}).strict();
+var SessionStatusStartingPayloadSchema = z33.object({
+  sessionId: z33.string().uuid(),
+  runtimeBindingId: z33.string(),
+  sandboxId: z33.string(),
+  workerEndpoint: z33.string()
+}).strict();
+var SessionStatusReadyPayloadSchema = z33.object({
+  sessionId: z33.string().uuid(),
+  readyAt: z33.string(),
+  gateAggregate: z33.object({ worker: z33.literal(true) }).passthrough()
+}).strict();
+var SessionStatusFailedPayloadSchema = z33.object({
+  sessionId: z33.string().uuid(),
+  failedAt: z33.string(),
+  primaryFailure: z33.object({
+    source: z33.string(),
+    code: z33.string(),
+    message: z33.string().optional()
+  })
+}).strict();
+var SessionIdlePayloadSchema = z33.object({
+  sessionId: z33.string().uuid(),
+  stopReason: z33.object({
+    type: z33.enum(["requires_action", "end_turn"]),
+    eventIds: z33.array(z33.string()).optional()
+  })
+}).strict();
+var EventTypeSessionStatusSchema = z33.enum([
+  "session.status_created",
+  "session.status_provisioning",
+  "session.status_starting",
+  "session.status_ready",
+  "session.status_failed"
+]);
+var SpanStartPayloadSchema = z33.object({
+  spanId: z33.string().min(1),
+  parentSpanId: z33.string().optional(),
+  name: z33.string().min(1),
+  startedAt: z33.string(),
+  attributes: z33.record(z33.unknown()).optional()
+}).strict();
+var SpanEndPayloadSchema = z33.object({
+  spanId: z33.string().min(1),
+  endedAt: z33.string(),
+  status: z33.enum(["ok", "error"]).optional()
+}).strict();
+var SpanEventPayloadSchema = z33.object({
+  spanId: z33.string().min(1),
+  eventName: z33.string().min(1),
+  attributes: z33.record(z33.unknown()).optional()
+}).strict();
+var VaultArchivedPayloadSchema = z33.object({ vaultId: z33.string().min(1), archivedAt: z33.string() }).strict();
+var VaultDeletedPayloadSchema = z33.object({ vaultId: z33.string().min(1), deletedAt: z33.string() }).strict();
+var VaultCredentialArchivedPayloadSchema = z33.object({
+  vaultId: z33.string().min(1),
+  credentialId: z33.string().min(1),
+  archivedAt: z33.string()
+}).strict();
+var VaultCredentialDeletedPayloadSchema = z33.object({
+  vaultId: z33.string().min(1),
+  credentialId: z33.string().min(1),
+  deletedAt: z33.string()
+}).strict();
+var VaultCredentialRefreshFailedPayloadSchema = z33.object({
+  vaultId: z33.string().min(1),
+  credentialId: z33.string().min(1),
+  failedStatus: z33.enum(["invalid", "unknown"]),
+  lastRefreshedAt: z33.string()
+}).strict();
+var VaultCredentialTargetNotAllowedPayloadSchema = z33.object({
+  sessionId: z33.string().uuid(),
+  vaultId: z33.string().optional(),
+  credentialId: z33.string().optional(),
+  mcpServerUrl: z33.string(),
+  reason: z33.literal("target_not_in_revision_allowlist"),
+  recoverable: z33.literal(false),
+  occurredAt: z33.string()
+}).strict();
+var STANDARD_EVENT_PAYLOAD_SCHEMAS = {
+  "user.message": UserMessagePayloadSchema,
+  "user.interrupt": UserInterruptPayloadSchema,
+  "user.tool_confirmation": UserToolConfirmationPayloadSchema,
+  "user.tool_result": UserToolResultPayloadSchema,
+  "agent.message": AgentMessagePayloadSchema,
+  "agent.tool_use": AgentToolUsePayloadSchema,
+  "agent.tool_result": AgentToolResultPayloadSchema,
+  "agent.mcp_tool_use": AgentMcpToolUsePayloadSchema,
+  "agent.completed": AgentCompletedPayloadSchema,
+  "agent.session_reset": AgentSessionResetPayloadSchema,
+  "agent.recovery_started": AgentRecoveryStartedV2PayloadSchema,
+  "agent.recovery_hydrated": AgentRecoveryHydratedV2PayloadSchema,
+  "agent.recovery_completed": AgentRecoveryCompletedV2PayloadSchema,
+  "agent.recovery_failed": AgentRecoveryFailedV2PayloadSchema,
+  "session.status_created": SessionStatusCreatedPayloadSchema,
+  "session.status_provisioning": SessionStatusProvisioningPayloadSchema,
+  "session.status_starting": SessionStatusStartingPayloadSchema,
+  "session.status_ready": SessionStatusReadyPayloadSchema,
+  "session.status_failed": SessionStatusFailedPayloadSchema,
+  "session.idle": SessionIdlePayloadSchema,
+  "span.start": SpanStartPayloadSchema,
+  "span.end": SpanEndPayloadSchema,
+  "span.event": SpanEventPayloadSchema,
+  "vault.archived": VaultArchivedPayloadSchema,
+  "vault.deleted": VaultDeletedPayloadSchema,
+  "vault.credential_archived": VaultCredentialArchivedPayloadSchema,
+  "vault.credential_deleted": VaultCredentialDeletedPayloadSchema,
+  "vault.credential_refresh_failed": VaultCredentialRefreshFailedPayloadSchema,
+  "vault.credential_target_not_allowed": VaultCredentialTargetNotAllowedPayloadSchema,
+  // §1.5 worker_protocol.* — 4 kinds × 5 suffixes = 20 standard event types
+  "worker_protocol.prompt.dispatched": WorkerProtocolPromptRequestSchema,
+  "worker_protocol.prompt.accepted": WorkerProtocolAcceptedPayloadSchema,
+  "worker_protocol.prompt.rejected": WorkerProtocolRejectedPayloadSchema,
+  "worker_protocol.prompt.completed": WorkerProtocolCompletedPayloadSchema,
+  "worker_protocol.prompt.failed": WorkerProtocolFailedPayloadSchema,
+  "worker_protocol.followup.dispatched": WorkerProtocolFollowupRequestSchema,
+  "worker_protocol.followup.accepted": WorkerProtocolAcceptedPayloadSchema,
+  "worker_protocol.followup.rejected": WorkerProtocolRejectedPayloadSchema,
+  "worker_protocol.followup.completed": WorkerProtocolCompletedPayloadSchema,
+  "worker_protocol.followup.failed": WorkerProtocolFailedPayloadSchema,
+  "worker_protocol.abort.dispatched": WorkerProtocolAbortRequestSchema,
+  "worker_protocol.abort.accepted": WorkerProtocolAcceptedPayloadSchema,
+  "worker_protocol.abort.rejected": WorkerProtocolRejectedPayloadSchema,
+  "worker_protocol.abort.completed": WorkerProtocolCompletedPayloadSchema,
+  "worker_protocol.abort.failed": WorkerProtocolFailedPayloadSchema,
+  "worker_protocol.restore.dispatched": WorkerProtocolRestoreRequestSchema,
+  "worker_protocol.restore.accepted": WorkerProtocolAcceptedPayloadSchema,
+  "worker_protocol.restore.rejected": WorkerProtocolRejectedPayloadSchema,
+  "worker_protocol.restore.completed": WorkerProtocolCompletedPayloadSchema,
+  "worker_protocol.restore.failed": WorkerProtocolFailedPayloadSchema
+};
+var STANDARD_EVENT_TYPES = Object.keys(
+  STANDARD_EVENT_PAYLOAD_SCHEMAS
+);
+var StandardEventTypeSchema = z33.enum(STANDARD_EVENT_TYPES);
+var POD_AGENT_ENDPOINT_PORT = 8790;
+var AgentPortSpecSchema = z34.object({
+  name: z34.string().min(1).max(63),
+  port: z34.number().int().min(1).max(65535),
+  protocol: z34.literal("TCP")
+}).strict();
+var IngressPathTypeSchema = z34.enum(["prefix", "exact"]);
+var IngressSpecSchema = z34.object({
+  name: z34.string().min(1).max(63),
+  backendPort: z34.number().int().min(1).max(65535).refine((p) => p !== POD_AGENT_ENDPOINT_PORT, {
+    message: `backendPort ${POD_AGENT_ENDPOINT_PORT} is reserved for the platform pod-agent endpoint and MUST NOT be exposed via ingress.`
+  }),
+  hostPrefix: z34.string().min(1).max(63),
+  path: z34.string().min(1).startsWith("/"),
+  pathType: IngressPathTypeSchema
+}).strict();
+var AgentPublicEndpointSchema = z34.object({
+  /** Stable name; matches the originating `IngressSpec.name`. */
+  name: z34.string().min(1).max(63),
+  /** TCP port the ingress targets; equals `IngressSpec.backendPort`. */
+  backendPort: z34.number().int().min(1).max(65535),
+  /**
+   * Declaration-derived public URL (`https://{hostPrefix}.{baseDomain}{path}`).
+   * Best-effort — clients MUST validate reachability via standard HTTP
+   * error handling; sandbox-side reconciliation is platform-internal.
+   */
+  url: z34.string().url(),
+  /** Path prefix or exact match; must start with `/`. */
+  path: z34.string().min(1).startsWith("/"),
+  /** Business-facing pathType (lowercase). */
+  pathType: IngressPathTypeSchema
+}).strict();
+var WorkloadKindSchema = z35.enum([
+  "managed_agent",
+  "batch_task",
+  "external_worker",
+  "self_managed"
+]);
+var SessionStatusSchema = z35.enum([
+  "created",
+  "provisioning",
+  "starting",
+  "ready",
+  "failed"
+]);
+var SessionUsageKindSchema = z35.enum(["run_scoped", "conversation", "prewarmed"]);
+var StartupGateStatusSchema = z35.enum(["true", "false", "unknown", "stale"]);
+var FailureReasonSourceSchema = z35.enum([
+  "control_plane",
+  "scheduler",
+  "runtime_provider",
+  "pod_agent",
+  "worker"
+]);
+var FailureReasonCodeSchema = z35.enum([
+  "TEMPLATE_NOT_FOUND",
+  "POOL_NOT_READY",
+  "SANDBOX_CREATE_FAILED",
+  "SANDBOX_CREATE_TIMEOUT",
+  "POD_AGENT_UNREACHABLE",
+  "WORKER_START_FAILED",
+  "WORKER_PROCESS_EXITED",
+  "WORKER_HEALTH_FAILED",
+  "WORKER_INTERNAL_ERROR",
+  "WORKER_HEALTH_TIMEOUT",
+  "GATE_REPORTED_FAILED",
+  "GATE_READY_TIMEOUT",
+  "PERMISSION_DENIED",
+  "UNKNOWN_STARTUP_FAILURE"
+]);
+var WorkerHealthStateSchema = z35.enum(["heartbeat", "ready", "failed"]);
+var WorkerHealthReasonCodeSchema = z35.enum([
+  "WORKER_BOOTING",
+  "WORKER_READY",
+  "WORKER_PROCESS_EXITED",
+  "WORKER_HEALTH_CHECK_FAILED",
+  "WORKER_INTERNAL_ERROR"
+]);
+var WorkerEndpointSpecSchema = z35.object({
+  port: z35.number().int().positive(),
+  basePath: z35.string().optional()
+});
+var WorkerHealthSpecSchema = z35.object({
+  transport: z35.literal("control_plane_pull"),
+  path: z35.literal("/pilot/worker/health"),
+  pollIntervalSeconds: z35.number().int().positive(),
+  requestTimeoutSeconds: z35.number().int().positive(),
+  staleAfterSeconds: z35.number().int().positive(),
+  startupTimeoutSeconds: z35.number().int().positive()
+});
+var P0_WORKER_HEALTH_SPEC = {
+  transport: "control_plane_pull",
+  path: "/pilot/worker/health",
+  pollIntervalSeconds: 5,
+  requestTimeoutSeconds: 3,
+  staleAfterSeconds: 15,
+  startupTimeoutSeconds: 60
+};
+var ImageDigestSchema = z35.string().min(1).regex(/^sha256:[0-9a-fA-F]{64}$/, "Image digest must be a sha256 digest");
+var ImageProvenanceSchema = z35.discriminatedUnion("kind", [
+  z35.object({
+    kind: z35.literal("image_asset"),
+    imageAssetId: z35.string().min(1),
+    imageRef: z35.string().min(1).optional(),
+    imageDigest: ImageDigestSchema,
+    sourceCommit: z35.string().min(1).optional(),
+    sourceRef: z35.string().min(1).optional(),
+    metadata: z35.record(z35.unknown()).optional()
+  }).strict(),
+  z35.object({
+    kind: z35.literal("platform_image"),
+    platformImageId: z35.string().min(1),
+    version: z35.string().min(1),
+    imageRef: z35.string().min(1).optional(),
+    imageDigest: ImageDigestSchema,
+    metadata: z35.record(z35.unknown()).optional()
+  }).strict(),
+  z35.object({
+    kind: z35.literal("legacy_external_template"),
+    providerTemplateName: z35.string().min(1),
+    metadata: z35.record(z35.unknown()).optional()
+  }).strict()
+]);
+var RuntimeTemplateSnapshotSchema = z35.object({
+  provider: z35.literal("kanyun"),
+  providerTemplateName: z35.string().min(1),
+  providerPoolName: z35.string().min(1).optional(),
+  imageProvenance: ImageProvenanceSchema.optional(),
+  defaultWorkerEndpoint: WorkerEndpointSpecSchema,
+  healthSpec: WorkerHealthSpecSchema.default(P0_WORKER_HEALTH_SPEC),
+  /**
+   * PR-E0 / §6 Wave 1 — business worker listen port (`POD_AGENT_WORKER_PORT`).
+   * Defaults to 8787 in the auto-create API; persisted into the snapshot so a
+   * published Revision freezes the value even if the source `runtime_templates`
+   * row is later mutated.
+   */
+  workerPort: z35.number().int().min(1).max(65535).optional(),
+  /**
+   * Internal-only additional business container ports. Strict — does NOT
+   * carry expose/hostPrefix/path; public exposure is declared via `ingresses[]`.
+   */
+  agentPorts: z35.array(AgentPortSpecSchema).optional(),
+  /**
+   * Independent public ingress rules. Each entry's `backendPort` MUST reference
+   * `workerPort` or one of `agentPorts[].port`; cross-field validation is the
+   * caller's responsibility via `validateRuntimeTemplateNetwork()` from
+   * `@pilot/contracts` after `.parse(snapshot)`.
+   */
+  ingresses: z35.array(IngressSpecSchema).optional(),
+  /**
+   * Per-workload sandbox TTL (seconds) — lets each business define how long its
+   * runtime sandbox lives before the provider reclaims it. Read by
+   * `SessionStartupService` when provisioning; when omitted, the platform
+   * `DEFAULT_TTL_SECONDS` applies (backward-compatible). A keep-alive service
+   * extends the TTL while the session is active, so this primarily governs how
+   * long an *idle* sandbox persists. Capped at 30 days to bound resource usage.
+   */
+  ttlSeconds: z35.number().int().positive().max(30 * 24 * 60 * 60).optional(),
+  /**
+   * Selects which set of handlers the agent-worker process registers
+   * (`coder` for the JSON-payload pilot-coder loop, `echo` for the bare-text
+   * managed_agent Default UI demo). Read by control-plane at startWorker
+   * dispatch, forwarded via `PodAgentStartWorkerRequest.agentFlavor`,
+   * eventually injected by pod-agent as `PILOT_AGENT_FLAVOR` env var.
+   * Undefined → agent-worker defaults to coder (existing behavior,
+   * backward-compatible for all existing snapshots).
+   *
+   * Locked enum: extend ONLY after the corresponding `FLAVOR_REGISTRY`
+   * entry exists in `apps/agent-worker/src/v2/init.ts` (otherwise the
+   * worker falls back to coder + console.warn).
+   */
+  agentFlavor: z35.enum(["coder", "echo"]).optional(),
+  metadata: z35.record(z35.unknown()).optional()
+});
+var WorkerContractRefSchema = z35.object({
+  kind: WorkloadKindSchema,
+  name: z35.string().optional(),
+  version: z35.string().optional(),
+  metadata: z35.record(z35.unknown()).optional()
+});
+var SESSION_CONFIG_VALUE_KEY_MAX_LENGTH = 100;
+var SESSION_EVENT_ID_MAX_LENGTH = 100;
+var SESSION_EVENT_TYPE_MAX_LENGTH = 100;
+var RESERVED_SESSION_CONFIG_ENV_PREFIXES = ["PILOT_", "SESSION_", "PLATFORM_"];
+function isReservedSessionConfigEnvKey(key) {
+  return RESERVED_SESSION_CONFIG_ENV_PREFIXES.some((prefix) => key.startsWith(prefix));
+}
+var SessionConfigValuesSchema = z35.record(z35.string()).superRefine((values, ctx) => {
+  for (const key of Object.keys(values)) {
+    if (key.length > SESSION_CONFIG_VALUE_KEY_MAX_LENGTH) {
+      ctx.addIssue({
+        code: z35.ZodIssueCode.too_big,
+        maximum: SESSION_CONFIG_VALUE_KEY_MAX_LENGTH,
+        type: "string",
+        inclusive: true,
+        message: `Config value key must be at most ${SESSION_CONFIG_VALUE_KEY_MAX_LENGTH} characters`,
+        path: [key]
+      });
+    }
+    if (isReservedSessionConfigEnvKey(key)) {
+      ctx.addIssue({
+        code: z35.ZodIssueCode.custom,
+        message: `Config value key ${key} uses a reserved Pilot platform prefix`,
+        path: [key]
+      });
+    }
+  }
+});
+var SessionEventSchema = z35.object({
+  id: z35.string().uuid(),
+  sessionId: z35.string().uuid(),
+  eventId: z35.string().min(1).max(SESSION_EVENT_ID_MAX_LENGTH),
+  eventType: z35.string().min(1).max(SESSION_EVENT_TYPE_MAX_LENGTH),
+  payload: z35.unknown().optional(),
+  createdAt: z35.string()
+});
+var SessionEventAppendRequestSchema = z35.object({
+  eventId: z35.string().min(1).max(SESSION_EVENT_ID_MAX_LENGTH).optional(),
+  eventType: z35.string().min(1).max(SESSION_EVENT_TYPE_MAX_LENGTH),
+  payload: z35.unknown().optional()
+});
+var SessionTokenClaimsSchema = z35.object({
+  type: z35.literal("pilot-session"),
+  jti: z35.string().uuid(),
+  session_id: z35.string().uuid(),
+  workload_id: z35.string().uuid(),
+  revision_id: z35.string().uuid(),
+  tenant_id: z35.string().uuid(),
+  iat: z35.number().int().nonnegative(),
+  exp: z35.number().int().positive().optional()
+});
+var WorkloadIdentityClaimSchema = z35.object({
+  type: z35.literal("pilot-workload-identity"),
+  workload_id: z35.string().uuid(),
+  revision_id: z35.string().uuid(),
+  tenant_id: z35.string().uuid()
+});
+var StartupGatePolicySchema = z35.object({
+  required: z35.array(z35.string().min(1)).min(1),
+  optional: z35.array(z35.string().min(1)).optional()
+});
+var StartupGateConditionSchema = z35.object({
+  gate: z35.string().min(1),
+  status: StartupGateStatusSchema,
+  reasonCode: z35.string().optional(),
+  message: z35.string().optional(),
+  observedAt: z35.string(),
+  lastTransitionAt: z35.string().optional(),
+  metadata: z35.record(z35.unknown()).optional()
+});
+var FailureReasonSchema = z35.object({
+  code: FailureReasonCodeSchema,
+  source: FailureReasonSourceSchema,
+  message: z35.string(),
+  observedAt: z35.string(),
+  metadata: z35.record(z35.unknown()).optional()
+});
+var FailureReasonCandidateSchema = z35.object({
+  code: z35.string().min(1),
+  message: z35.string(),
+  observedAt: z35.string().optional(),
+  metadata: z35.record(z35.unknown()).optional()
+});
+var WorkerReportedConditionSchema = z35.object({
+  gate: z35.string().min(1),
+  status: StartupGateStatusSchema,
+  reasonCode: z35.string().optional(),
+  message: z35.string().optional(),
+  observedAt: z35.string().optional(),
+  metadata: z35.record(z35.unknown()).optional()
+});
+var WorkerHealthObservationSchema = z35.object({
+  state: WorkerHealthStateSchema,
+  reasonCode: WorkerHealthReasonCodeSchema.optional(),
+  message: z35.string().optional(),
+  metadata: z35.record(z35.unknown()).optional(),
+  conditions: z35.array(WorkerReportedConditionSchema).optional()
+});
+var PodAgentHealthResponseSchema = z35.discriminatedUnion("kind", [
+  z35.object({
+    kind: z35.literal("worker_health"),
+    observedAt: z35.string(),
+    worker: WorkerHealthObservationSchema
+  }),
+  z35.object({
+    kind: z35.literal("worker_start_failed"),
+    observedAt: z35.string(),
+    failureCandidate: FailureReasonCandidateSchema
+  })
+]);
+var PodAgentStartWorkerRequestSchema = z35.object({
+  sessionId: z35.string().uuid(),
+  workloadId: z35.string().uuid(),
+  revisionId: z35.string().uuid(),
+  runtimeBindingId: z35.string().uuid(),
+  workerContract: WorkerContractRefSchema,
+  healthSpec: WorkerHealthSpecSchema,
+  env: z35.record(z35.string()).optional(),
+  metadata: z35.record(z35.unknown()).optional(),
+  /**
+   * Pod-Agent-only auth factor for upcoming Pilot v2 internal credentials API
+   * (`POST /api/internal/credentials/*`). The token is generated by control-plane
+   * at session creation time, stored on the session row, and delivered to
+   * pod-agent **once** via this start request. Pod-agent MUST hold it in memory
+   * only and MUST NOT forward it to the supervised worker process (neither via
+   * env, file, nor IPC). See `specs/features/pilot-v2-pod-agent-oci-runtime-layer.md`
+   * § "podAgentToken (Pod-Agent Auth Factor)" for the full contract.
+   *
+   * Backward-compat: optional in P3 Pre-P1 — pre-existing callers (legacy
+   * control-worker, `--smoke` check) may omit it; pod-agent then operates in
+   * `legacy` mode (no `podAgentToken` held, any future internal-credentials
+   * API calls SHALL reject). P3 Phase 1 L1.4 will tighten control-plane to
+   * always send this field; the schema may be promoted to required in a
+   * separate spec PR after the v1 retirement window closes.
+   */
+  podAgentToken: z35.string().min(32).optional(),
+  /**
+   * Optional agent-worker handler flavor selector. Pod-agent forwards this
+   * verbatim into the spawned child as `PILOT_AGENT_FLAVOR` env var (see
+   * `apps/pod-agent/src/process-manager.ts → buildWorkerEnv`). Undefined →
+   * pod-agent omits the env var, agent-worker `resolveFlavor()` falls back
+   * to coder. Source of truth lives in
+   * `RuntimeTemplateSnapshot.agentFlavor`; control-plane is responsible
+   * for projecting that into this field at `startWorker` call time.
+   */
+  agentFlavor: z35.enum(["coder", "echo"]).optional(),
+  /**
+   * Optional agent-worker bundle tarball URL (v2 hot-deploy). When set,
+   * pod-agent downloads + extracts this tarball over the baked
+   * `/opt/pilot/agent-worker` dist BEFORE spawning the worker, so the
+   * running binary matches the latest `apps/agent-worker` build rather
+   * than whatever was baked into the Kanyun pod image. Mirrors the v1
+   * `OrchestrationService.deployAgentWorker` mechanism (which has no v2
+   * equivalent — see
+   * `docs/handoff/2026-06-10-echo-runtime-coordinator-actions.md` §2).
+   *
+   * The URL is resolved by control-worker (`PodAgentHttpClient`) from
+   * `AGENT_WORKER_BUNDLE_OSS_KEY` (presigned) / `AGENT_WORKER_BUNDLE_URL`
+   * env — the same env contract v1 already uses. control-plane stays
+   * OSS-agnostic and does NOT populate this field.
+   *
+   * Backward-compat: optional. Omitted → pod-agent skips hot-deploy and
+   * runs the baked dist (legacy behavior). Old pod-agents that predate
+   * this field ignore it (zod strip), also falling back to baked dist.
+   */
+  agentWorkerBundleUrl: z35.string().url().optional()
+});
+var PodAgentStartWorkerResponseSchema = z35.discriminatedUnion("kind", [
+  z35.object({
+    kind: z35.literal("accepted"),
+    observedAt: z35.string(),
+    metadata: z35.record(z35.unknown()).optional()
+  }),
+  z35.object({
+    kind: z35.literal("worker_start_failed"),
+    observedAt: z35.string(),
+    failureCandidate: FailureReasonCandidateSchema
+  })
+]);
+var CreateSessionRequestSchema = z35.object({
+  /**
+   * P4 Phase 1.5 — optional caller-supplied resource id. When present, the
+   * control-plane uses this UUID as the new Session row's primary key
+   * (caller-controlled pin); when omitted, the control-plane generates a
+   * `randomUUID()` (legacy / backward-compat behavior).
+   *
+   * Naming note: the field is intentionally named `sessionId` (not `id`) to
+   * align with `CreateSessionResponseSchema.sessionId`. Despite the same
+   * name on request and response, the semantics differ:
+   *   - request.sessionId  = caller-supplied PK pin (write-side)
+   *   - response.sessionId = the actual Session row id (read-side, equal to
+   *     the request pin when supplied, or to the control-plane-generated
+   *     UUID when omitted)
+   *
+   * Use case: portal `POST /api/agents` dispatches v2 runs via
+   * `dispatchV2AgentSession` and needs `runId === sessionId ===
+   * runtimeBindingId` per `pilot-v2-managed-agent-handler-contract.md`
+   * § "Managed-agent runtime binding cohort". Caller pins this field to
+   * the freshly created run id so the entire cohort shares one UUID.
+   */
+  sessionId: z35.string().uuid().optional(),
+  projectId: z35.string().uuid(),
+  workloadId: z35.string().uuid(),
+  revisionId: z35.string().uuid().optional(),
+  idempotencyScope: z35.string().min(1).optional(),
+  idempotencyKey: z35.string().min(1).optional(),
+  configValues: SessionConfigValuesSchema.optional(),
+  metadata: z35.record(z35.unknown()).optional(),
+  /**
+   * GAP1-B (rush-app v2 migration) — optional caller-supplied stable runtime
+   * claim name. Forwarded to the runtime provider's `create()` as the sandbox
+   * `claimName`, which the sandbox control plane embeds in the public ingress
+   * host (`<hostPrefix>-<claimName>.<baseDomain>`). Supplying a stable,
+   * project-scoped value keeps preview URLs stable across abort→recreate
+   * (scale-to-zero) cycles; omitted → control plane generates a per-sandbox
+   * `claim-<nanoTS>` (host drifts on every recreate).
+   *
+   * MUST be DNS-label safe (lowercase alphanumeric + hyphen); the sandbox
+   * control plane truncates the `<hostPrefix>-<claimName>` first label to 63
+   * chars, so the distinguishing portion must fit within budget. Callers
+   * (e.g. rush-app) typically derive it from a project-scoped key such as
+   * `rush-<normalizedProjectId>`.
+   */
+  runtimeClaimName: z35.string().min(1).max(48).regex(
+    /^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/,
+    "runtimeClaimName must be DNS-label safe (lowercase alphanumeric and hyphens, no leading/trailing hyphen)"
+  ).optional(),
+  /**
+   * PR-1 / §INV-2.1 — optional list of vault `public_id` values to bind to
+   * this Session. The control plane resolves each `vlt_*` public_id to the
+   * internal uuid, inserts `session_vault_bindings` rows, and freezes an
+   * `allowedMcpTargets` snapshot from the active credentials' MCP URLs.
+   *
+   * Constraints (PR1-E):
+   *   - Each entry MUST match `^vlt_[a-z0-9]+$` (lowercase alphanumeric).
+   *   - Maximum 64 entries per request.
+   *   - Duplicates are rejected at the Zod layer (→ 400).
+   * Requires `vaults:read` (or `vaults:admin`) scope (PR1-B → 403 if absent).
+   */
+  vault_ids: z35.array(z35.string().regex(/^vlt_[a-z0-9]+$/, "vault_id must match vlt_[a-z0-9]+")).max(64, "vault_ids must have at most 64 entries").optional()
+}).strict().refine(
+  (data) => {
+    if (!data.vault_ids) return true;
+    return new Set(data.vault_ids).size === data.vault_ids.length;
+  },
+  {
+    message: "vault_ids must not contain duplicates",
+    path: ["vault_ids"]
+  }
+);
+var CreateSessionResponseSchema = z35.object({
+  sessionId: z35.string().uuid(),
+  status: SessionStatusSchema,
+  /**
+   * PR-1 / §INV-2.1 — MCP target URLs frozen at Session creation time.
+   * Present only when the request supplied `vault_ids`; absent otherwise.
+   * Each entry is a URL string (no internal uuids exposed — INV-1.1).
+   */
+  allowed_mcp_targets: z35.array(z35.string().url()).optional()
+});
+var RESERVED_HEADERS = /* @__PURE__ */ new Set([
+  "authorization",
+  "host",
+  "content-length",
+  "content-encoding",
+  "transfer-encoding",
+  "connection",
+  "upgrade",
+  "cookie",
+  "set-cookie",
+  "server",
+  "date"
+]);
+function isReservedHeader(name) {
+  const lower = name.toLowerCase();
+  return RESERVED_HEADERS.has(lower) || lower.startsWith("x-pilot-");
+}
+var VaultCredentialAuthTypeSchema = z36.enum(["mcp_oauth", "static_bearer"]);
+var VaultCredentialRefreshStatusSchema = z36.enum([
+  "success",
+  "failed_invalid",
+  "failed_unknown"
+]);
+var CustomHeadersSchema = z36.record(z36.string().min(1).max(100), z36.string().min(0).max(2048)).refine((m) => Object.keys(m).length <= 32, {
+  message: "vault_credential_custom_headers_too_many_entries"
+}).refine((m) => Object.keys(m).every((k) => !isReservedHeader(k)), {
+  message: "vault_credential_reserved_header_conflict"
+});
+var McpOAuthCredentialSchema = z36.object({
+  type: z36.literal("mcp_oauth"),
+  mcpServerUrl: z36.string().url(),
+  /**
+   * Initial access token; write-only after create — never returned
+   * by `VaultCredentialRecord` (per INV-3 / Claude write-only
+   * invariant).
+   */
+  accessToken: z36.string().min(1),
+  expiresAt: z36.string().datetime(),
+  customHeaders: CustomHeadersSchema.optional(),
+  refresh: z36.object({
+    tokenEndpoint: z36.string().url(),
+    clientId: z36.string().min(1),
+    scope: z36.string().optional(),
+    /** Write-only; never returned. */
+    refreshToken: z36.string().min(1),
+    tokenEndpointAuth: z36.discriminatedUnion("type", [
+      z36.object({ type: z36.literal("none") }).strict(),
+      z36.object({
+        type: z36.literal("client_secret_basic"),
+        clientSecret: z36.string().min(1)
+      }).strict(),
+      z36.object({
+        type: z36.literal("client_secret_post"),
+        clientSecret: z36.string().min(1)
+      }).strict()
+    ])
+  }).strict()
+}).strict();
+var StaticBearerCredentialSchema = z36.object({
+  type: z36.literal("static_bearer"),
+  mcpServerUrl: z36.string().url(),
+  accessToken: z36.string().min(1),
+  customHeaders: CustomHeadersSchema.optional()
+}).strict();
+var CreateVaultRequestSchema = z36.object({
+  workspaceId: z36.string().uuid(),
+  displayName: z36.string().min(1).max(200),
+  external_user_id: z36.string().min(1).max(200),
+  metadata: z36.record(z36.unknown()).optional()
+}).strict();
+var VaultRecordSchema = z36.object({
+  type: z36.literal("vault"),
+  /** INV-1.1 public_id, `vlt_*` prefix. */
+  id: z36.string().regex(/^vlt_[a-zA-Z0-9]+$/),
+  workspaceId: z36.string().uuid(),
+  /**
+   * INV-1 second ownership layer — Pilot Platform Token actor /
+   * credential owner principal id (IdP-agnostic per spec round 6).
+   * Set server-side at create time from the Platform Token actor
+   * identity; immutable. NOT a terminal user; NOT equivalent to
+   * `external_user_id`.
+   */
+  actorId: z36.string().min(1),
+  /** INV-1 third ownership layer — opaque business-side identifier. */
+  external_user_id: z36.string().min(1),
+  displayName: z36.string().min(1),
+  metadata: z36.record(z36.unknown()).optional(),
+  createdAt: z36.string().datetime(),
+  updatedAt: z36.string().datetime(),
+  archivedAt: z36.string().datetime().nullable()
+}).strict();
+var ListVaultsFilterSchema = z36.object({
+  /**
+   * Business-opaque cohort filter. Pilot does not interpret the
+   * value — it is matched verbatim against the stored
+   * `external_user_id` column.
+   */
+  external_user_id: z36.string().min(1).optional(),
+  /** When true, archived rows are included; default `false`. */
+  includeArchived: z36.boolean().optional()
+}).strict();
+var CreateCredentialRequestSchema = z36.object({
+  displayName: z36.string().min(1).max(200),
+  auth: z36.discriminatedUnion("type", [McpOAuthCredentialSchema, StaticBearerCredentialSchema])
+}).strict();
+var UpdateCredentialRequestSchema = z36.object({
+  displayName: z36.string().min(1).max(200).optional(),
+  customHeaders: CustomHeadersSchema.optional(),
+  auth: z36.object({
+    accessToken: z36.string().min(1).optional(),
+    expiresAt: z36.string().datetime().optional(),
+    refresh: z36.object({
+      refreshToken: z36.string().min(1).optional()
+    }).strict().optional()
+  }).strict().optional()
+}).strict();
+var VaultCredentialRecordSchema = z36.object({
+  type: z36.literal("vault_credential"),
+  /** INV-1.1 public_id, `vcrd_*` prefix. */
+  id: z36.string().regex(/^vcrd_[a-zA-Z0-9]+$/),
+  /** INV-1.1 public_id reference to parent vault. */
+  vaultId: z36.string().regex(/^vlt_[a-zA-Z0-9]+$/),
+  displayName: z36.string().min(1),
+  authType: VaultCredentialAuthTypeSchema,
+  mcpServerUrl: z36.string().url(),
+  expiresAt: z36.string().datetime().nullable(),
+  lastRefreshedAt: z36.string().datetime().nullable(),
+  lastRefreshStatus: VaultCredentialRefreshStatusSchema.nullable(),
+  createdAt: z36.string().datetime(),
+  updatedAt: z36.string().datetime(),
+  archivedAt: z36.string().datetime().nullable()
+}).strict();
+var ListCredentialsFilterSchema = z36.object({
+  /** Filter by upstream MCP server URL. */
+  mcpServerUrl: z36.string().url().optional(),
+  includeArchived: z36.boolean().optional()
+}).strict();
+var ResolvedCredentialSchema = z36.object({
+  vaultId: z36.string().regex(/^vlt_[a-zA-Z0-9]+$/),
+  credentialId: z36.string().regex(/^vcrd_[a-zA-Z0-9]+$/),
+  authType: VaultCredentialAuthTypeSchema,
+  accessToken: z36.string().min(1),
+  expiresAt: z36.string().datetime().nullable(),
+  customHeaders: CustomHeadersSchema
+}).strict();
+var VaultCredentialValidationSchema = z36.object({
+  status: z36.enum(["valid", "invalid", "unknown"]),
+  message: z36.string().optional(),
+  validatedAt: z36.string().datetime()
+}).strict();
+var ScheduleTargetKindSchema = z37.enum(["workload", "agent", "inline_v1", "inline_v2"]);
+var ScheduleApiVersionPreferenceSchema = z37.enum(["v1", "v2"]);
+var ScheduleLifecycleStatusSchema = z37.enum(["active", "disabled", "deleted"]);
+var ScheduleConcurrencyPolicySchema = z37.enum(["allow", "forbid"]);
+var ScheduleMisfirePolicySchema = z37.enum(["skip", "fire_once_immediately"]);
+var ScheduleTriggerSourceSchema = z37.enum(["cron", "manual"]);
+var ScheduleTriggerStatusSchema = z37.enum([
+  "pending",
+  "dispatched",
+  "skipped",
+  "failed_to_dispatch"
+]);
+var ScheduleSkippedReasonSchema = z37.enum([
+  "misfire",
+  "concurrency_forbidden",
+  "schedule_disabled",
+  "out_of_window"
+]);
+var ScheduleFailureReasonCodeSchema = z37.enum([
+  "TARGET_NOT_FOUND",
+  "TARGET_DISABLED",
+  "REVISION_NOT_FOUND",
+  "PERMISSION_DENIED",
+  "UPSTREAM_UNAVAILABLE",
+  "DOWNSTREAM_TIMEOUT",
+  "ORPHANED_PENDING_TRIGGER",
+  "UNKNOWN_DISPATCH_FAILURE"
+]);
+var ScheduleApiErrorCodeSchema = z37.enum([
+  "INVALID_CRON",
+  "INVALID_TIMEZONE",
+  "INVALID_TARGET",
+  "UNSUPPORTED_VERSION_COMBO",
+  "PROJECT_NOT_FOUND",
+  "WORKLOAD_NOT_FOUND",
+  "AGENT_NOT_FOUND",
+  "REVISION_NOT_FOUND",
+  "REVISION_NOT_FOR_TARGET_WORKLOAD",
+  "TARGET_NOT_IN_PROJECT",
+  "SCHEDULE_NOT_FOUND",
+  "SCHEDULE_DISABLED",
+  "CONCURRENCY_FORBIDDEN",
+  "SCHEDULE_TRIGGER_CONFLICT",
+  "FORBIDDEN_FIELD",
+  "PERMISSION_DENIED",
+  // P1.2: inline_v2 schedule references a workload slug that cannot be
+  // resolved to any (workloadId, revisionId). Distinct from
+  // WORKLOAD_NOT_FOUND (which is keyed by ID) — slug resolution is
+  // dispatcher-time and surfaces a different remediation path.
+  "WORKLOAD_SLUG_NOT_FOUND",
+  // P1.2: project-or-owner anchor missing — caller submitted neither
+  // projectId nor ownerLdap (or ownerLdap was empty for an inline
+  // kind). 400.
+  "MISSING_PROJECT_OR_OWNER",
+  // Server-side internal error (DB returned no row, dispatcher failed
+  // synchronously, etc.). Surfaces as HTTP 500 / SDK ScheduleClientError
+  // category=platform_error. Distinct from `PERMISSION_DENIED` which
+  // signals "the user is not authorized" — internal errors are not the
+  // caller's fault. Spec §"API Error Codes".
+  "INTERNAL_ERROR"
+]);
+var SCHEDULE_DISPLAY_NAME_MAX_LENGTH = 200;
+var SCHEDULE_DESCRIPTION_MAX_LENGTH = 1e3;
+var SCHEDULE_FAILURE_REASON_MESSAGE_MAX_LENGTH = 2e3;
+var SCHEDULE_MISFIRE_GRACE_SECONDS_MIN = 0;
+var SCHEDULE_MISFIRE_GRACE_SECONDS_MAX = 3600;
+var SCHEDULE_MISFIRE_GRACE_SECONDS_DEFAULT = 60;
+var SCHEDULE_FAILURE_THRESHOLD_MIN = 1;
+var SCHEDULE_FAILURE_THRESHOLD_MAX = 100;
+var SCHEDULE_FAILURE_THRESHOLD_DEFAULT = 5;
+function isValidIanaTimezone(value) {
+  if (!value || value.length > 100) return false;
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: value });
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+function isCronStructurallyValid(value) {
+  const trimmed = value.trim();
+  if (!trimmed) return false;
+  const segments = trimmed.split(/\s+/);
+  return segments.length === 5 || segments.length === 6;
+}
+var TimezoneStringSchema = z37.string().min(1, "timezone must be a non-empty IANA identifier").refine(isValidIanaTimezone, "timezone must be a valid IANA identifier");
+var CronExpressionSchema = z37.string().min(1, "cronExpression must be non-empty").max(200, "cronExpression must be at most 200 characters").refine(isCronStructurallyValid, "cronExpression must have 5 or 6 whitespace-separated segments");
+var IsoDatetimeSchema = z37.string().datetime({ offset: true });
+var SCHEDULE_PAYLOAD_PROMPT_MAX_LENGTH = 5e4;
+var SchedulePayloadV1Schema = z37.object({
+  /** Required for v1 — `RunService.createRun` rejects empty prompts. */
+  prompt: z37.string().min(1).max(SCHEDULE_PAYLOAD_PROMPT_MAX_LENGTH),
+  repo: z37.string().max(2048).optional(),
+  ref: z37.string().max(255).optional(),
+  model: z37.string().max(255).optional(),
+  /**
+   * P1.6: tightened from `z.string().max(64).optional()` to
+   * `ProviderTypeSchema.optional()`. Catches invalid provider strings
+   * at schedule create / update time rather than letting the
+   * dispatcher cast them through `RunSpec` and surface as a generic
+   * Zod error on fire (P1.3 review [CONSIDER]).
+   */
+  provider: ProviderTypeSchema.optional(),
+  /**
+   * LDAP of the user whose action created this schedule. Forwarded
+   * verbatim to `runs.triggerUserLdap` so per-user Bedrock credentials
+   * (specs/features/user-bedrock-credentials.md) resolve correctly on
+   * cron-triggered runs. Null / undefined falls back to the
+   * service-level Bedrock key.
+   */
+  triggerUserLdap: z37.string().min(1).max(255).optional()
+}).strict();
+var SchedulePayloadV2Schema = z37.object({
+  /**
+   * Sandbox-environment overrides forwarded to
+   * `CreateSessionRequest.configValues`. Reserved-env-key sanitization
+   * is enforced at the SessionStartupService boundary; the schema
+   * here keeps the shape opaque to avoid duplicating that policy.
+   */
+  configValues: z37.record(z37.string(), z37.string()).optional(),
+  /** Free-form audit metadata; non-functional. */
+  metadata: z37.record(z37.string(), z37.unknown()).optional()
+}).strict();
+var ScheduleInlineV1PayloadSchema = z37.object({
+  prompt: z37.string().min(1).max(SCHEDULE_PAYLOAD_PROMPT_MAX_LENGTH),
+  repo: z37.string().min(1).max(2048).optional(),
+  ref: z37.string().min(1).max(255).optional(),
+  model: z37.string().max(255).optional(),
+  /**
+   * P1.6: see `SchedulePayloadV1Schema.provider` — same rationale.
+   * Closes the unsafe `as RunSpec["provider"]` cast in
+   * `schedule-dispatcher.ts dispatchInlineV1` (P1.3 review [CONSIDER]).
+   */
+  provider: ProviderTypeSchema.optional(),
+  triggerUserLdap: z37.string().min(1).max(255).optional(),
+  /**
+   * Per-fire MCP / Skills enable lists — same wire shape the home
+   * composer sends to `POST /api/agents` (run-level override, spec
+   * §4.3 "对话级别"). The dispatcher forwards these onto the
+   * synthesised `RunSpec` so each cron-created Run resolves the same
+   * MCPs / skills the user would get by clicking "新建任务" with the
+   * same toggles. Omitted ⇒ no customization (empty resolution).
+   *
+   * Stored verbatim in `payload_json`; refs are resolved against the
+   * owner's global credential store at run start, so a schedule keeps
+   * working as long as the owner keeps the referenced MCP/skill
+   * installed.
+   */
+  enabledMcpServers: EnabledMcpEntryListSchema.optional(),
+  enabledSkills: EnabledSkillEntryListSchema.optional(),
+  /**
+   * User-uploaded attachments — same wire shape the home composer
+   * sends to `POST /api/agents` (`RunSpec.attachments`). Files are
+   * uploaded once at schedule-authoring time to the owner's project
+   * OSS space; the dispatcher forwards the stored `ossUrl` references
+   * onto every synthesised `RunSpec`, so each cron-created Run sees
+   * the same attachments. Capped at 5 to match `RunSpec.attachments`.
+   */
+  attachments: z37.array(AttachmentMetaSchema).max(5).optional()
+}).strict();
+var SCHEDULE_INLINE_V2_WORKLOAD_SLUG_REGEX = /^[a-z0-9][a-z0-9-]{0,127}$/;
+var ScheduleInlineV2PayloadSchema = z37.object({
+  workloadSlug: z37.string().min(1).max(128).refine(
+    (s) => SCHEDULE_INLINE_V2_WORKLOAD_SLUG_REGEX.test(s),
+    "workloadSlug must be lowercase alphanumeric / dashes (1..128 chars)"
+  ),
+  /** Default `"latest"`; UUID strings are treated as revision pin. */
+  revisionSelector: z37.union([z37.literal("latest"), z37.string().uuid()]).default("latest"),
+  configValues: z37.record(z37.string(), z37.string()).optional(),
+  metadata: z37.record(z37.string(), z37.unknown()).optional()
+}).strict();
+var RawPayloadSchema = z37.record(z37.string(), z37.unknown());
+var ADMISSIBLE_TARGET_VERSION_COMBOS = ["workload:v2", "agent:v1", "inline_v1:v1", "inline_v1:v2", "inline_v2:v2"];
+function refineTargetFields(schema) {
+  return schema.superRefine((value, ctx) => {
+    switch (value.targetKind) {
+      case "workload": {
+        if (!value.targetWorkloadId) {
+          ctx.addIssue({
+            code: z37.ZodIssueCode.custom,
+            message: "targetWorkloadId is required when targetKind is 'workload'",
+            path: ["targetWorkloadId"]
+          });
+        }
+        if (value.targetAgentId) {
+          ctx.addIssue({
+            code: z37.ZodIssueCode.custom,
+            message: "targetAgentId must be omitted when targetKind is 'workload'",
+            path: ["targetAgentId"]
+          });
+        }
+        break;
+      }
+      case "agent": {
+        if (!value.targetAgentId) {
+          ctx.addIssue({
+            code: z37.ZodIssueCode.custom,
+            message: "targetAgentId is required when targetKind is 'agent'",
+            path: ["targetAgentId"]
+          });
+        }
+        if (value.targetWorkloadId) {
+          ctx.addIssue({
+            code: z37.ZodIssueCode.custom,
+            message: "targetWorkloadId must be omitted when targetKind is 'agent'",
+            path: ["targetWorkloadId"]
+          });
+        }
+        if (value.targetRevisionId) {
+          ctx.addIssue({
+            code: z37.ZodIssueCode.custom,
+            message: "targetRevisionId is only allowed when targetKind is 'workload'",
+            path: ["targetRevisionId"]
+          });
+        }
+        break;
+      }
+      case "inline_v1":
+      case "inline_v2": {
+        if (value.targetWorkloadId) {
+          ctx.addIssue({
+            code: z37.ZodIssueCode.custom,
+            message: `targetWorkloadId must be omitted when targetKind is '${value.targetKind}'`,
+            path: ["targetWorkloadId"]
+          });
+        }
+        if (value.targetAgentId) {
+          ctx.addIssue({
+            code: z37.ZodIssueCode.custom,
+            message: `targetAgentId must be omitted when targetKind is '${value.targetKind}'`,
+            path: ["targetAgentId"]
+          });
+        }
+        if (value.targetRevisionId) {
+          ctx.addIssue({
+            code: z37.ZodIssueCode.custom,
+            message: `targetRevisionId must be omitted when targetKind is '${value.targetKind}' (use payload.revisionSelector for inline_v2)`,
+            path: ["targetRevisionId"]
+          });
+        }
+        break;
+      }
+    }
+    const combo = `${value.targetKind}:${value.pilotApiVersionPreference}`;
+    if (!ADMISSIBLE_TARGET_VERSION_COMBOS.includes(combo)) {
+      ctx.addIssue({
+        code: z37.ZodIssueCode.custom,
+        message: `Unsupported (targetKind, pilotApiVersionPreference) combination. Admissible: ${ADMISSIBLE_TARGET_VERSION_COMBOS.join(
+          ", "
+        )}`,
+        path: ["pilotApiVersionPreference"]
+      });
+    }
+    const isInline = value.targetKind === "inline_v1" || value.targetKind === "inline_v2";
+    if (!isInline && !value.projectId) {
+      ctx.addIssue({
+        code: z37.ZodIssueCode.custom,
+        message: `projectId is required when targetKind is '${value.targetKind}'`,
+        path: ["projectId"]
+      });
+    }
+    const hasProject = Boolean(value.projectId);
+    const hasOwner = Boolean(value.ownerLdap && value.ownerLdap.length > 0);
+    if (!hasProject && !hasOwner) {
+      ctx.addIssue({
+        code: z37.ZodIssueCode.custom,
+        message: "At least one of projectId / ownerLdap must be present (project-or-owner anchor)",
+        path: ["ownerLdap"]
+      });
+    }
+  });
+}
+function refineLifecycleWindow(schema) {
+  return schema.superRefine((value, ctx) => {
+    if (value.startAt && value.endAt) {
+      const start = Date.parse(value.startAt);
+      const end = Date.parse(value.endAt);
+      if (Number.isFinite(start) && Number.isFinite(end) && end <= start) {
+        ctx.addIssue({
+          code: z37.ZodIssueCode.custom,
+          message: "endAt must be strictly later than startAt",
+          path: ["endAt"]
+        });
+      }
+    }
+  });
+}
+var CreateScheduleRequestBaseSchema = z37.object({
+  /**
+   * Host project. Required for `targetKind ∈ {workload, agent}` (P0
+   * shape); MAY be null for `inline_v1` / `inline_v2`. When null, the
+   * `ownerLdap` field becomes the sole authorization anchor.
+   */
+  projectId: z37.string().uuid().nullable().optional(),
+  /**
+   * LDAP of the schedule owner (P1.2). Distinct from the implicit
+   * `createdBy` which is captured server-side from the auth context.
+   * MUST be non-empty when `projectId` is null. The route handler is
+   * authoritative for enforcing "createdBy === ownerLdap" on create
+   * (delegation / ownership transfer is an explicit follow-up).
+   */
+  ownerLdap: z37.string().min(1).max(255).optional(),
+  displayName: z37.string().min(1, "displayName must be non-empty").max(SCHEDULE_DISPLAY_NAME_MAX_LENGTH),
+  description: z37.string().max(SCHEDULE_DESCRIPTION_MAX_LENGTH).optional(),
+  cronExpression: CronExpressionSchema,
+  timezone: TimezoneStringSchema,
+  targetKind: ScheduleTargetKindSchema,
+  targetWorkloadId: z37.string().uuid().optional(),
+  targetRevisionId: z37.string().uuid().optional(),
+  targetAgentId: z37.string().uuid().optional(),
+  pilotApiVersionPreference: ScheduleApiVersionPreferenceSchema,
+  concurrencyPolicy: ScheduleConcurrencyPolicySchema.default("allow"),
+  misfirePolicy: ScheduleMisfirePolicySchema.default("skip"),
+  misfireGraceSeconds: z37.number().int().min(SCHEDULE_MISFIRE_GRACE_SECONDS_MIN).max(SCHEDULE_MISFIRE_GRACE_SECONDS_MAX).default(SCHEDULE_MISFIRE_GRACE_SECONDS_DEFAULT),
+  consecutiveFailureThreshold: z37.number().int().min(SCHEDULE_FAILURE_THRESHOLD_MIN).max(SCHEDULE_FAILURE_THRESHOLD_MAX).default(SCHEDULE_FAILURE_THRESHOLD_DEFAULT),
+  startAt: IsoDatetimeSchema.optional(),
+  endAt: IsoDatetimeSchema.optional(),
+  /**
+   * Dispatch parameter payload. Shape is determined by
+   * `pilotApiVersionPreference` and validated by `refinePayload` (see
+   * below). Stored verbatim into `schedule_definitions.payload_json`.
+   */
+  payload: RawPayloadSchema
+}).strict();
+function refinePayload(schema) {
+  return schema.superRefine((value, ctx) => {
+    let payloadSchema;
+    switch (value.targetKind) {
+      case "workload":
+        payloadSchema = SchedulePayloadV2Schema;
+        break;
+      case "agent":
+        payloadSchema = SchedulePayloadV1Schema;
+        break;
+      case "inline_v1":
+        payloadSchema = ScheduleInlineV1PayloadSchema;
+        break;
+      case "inline_v2":
+        payloadSchema = ScheduleInlineV2PayloadSchema;
+        break;
+    }
+    const result = payloadSchema.safeParse(value.payload);
+    if (!result.success) {
+      for (const issue of result.error.issues) {
+        ctx.addIssue({
+          code: z37.ZodIssueCode.custom,
+          message: issue.message,
+          path: ["payload", ...issue.path]
+        });
+      }
+    }
+  });
+}
+var CreateScheduleRequestSchema = refinePayload(
+  refineLifecycleWindow(refineTargetFields(CreateScheduleRequestBaseSchema))
+);
+var UpdateScheduleRequestBaseSchema = z37.object({
+  displayName: z37.string().min(1).max(SCHEDULE_DISPLAY_NAME_MAX_LENGTH).optional(),
+  description: z37.string().max(SCHEDULE_DESCRIPTION_MAX_LENGTH).nullable().optional(),
+  /**
+   * Convenience field — `true` ⇒ lifecycle_status='active',
+   * `false` ⇒ lifecycle_status='disabled'. Cannot reach `deleted`
+   * via PATCH (use DELETE).
+   */
+  enabled: z37.boolean().optional(),
+  cronExpression: CronExpressionSchema.optional(),
+  timezone: TimezoneStringSchema.optional(),
+  concurrencyPolicy: ScheduleConcurrencyPolicySchema.optional(),
+  misfirePolicy: ScheduleMisfirePolicySchema.optional(),
+  misfireGraceSeconds: z37.number().int().min(SCHEDULE_MISFIRE_GRACE_SECONDS_MIN).max(SCHEDULE_MISFIRE_GRACE_SECONDS_MAX).optional(),
+  consecutiveFailureThreshold: z37.number().int().min(SCHEDULE_FAILURE_THRESHOLD_MIN).max(SCHEDULE_FAILURE_THRESHOLD_MAX).optional(),
+  endAt: IsoDatetimeSchema.nullable().optional(),
+  /**
+   * Replaces the entire dispatch payload. Null is forbidden — to
+   * "clear" optional sub-fields, send a payload object that omits
+   * them. Payload shape (v1 vs v2) is fixed at create time per
+   * INV-5; the route handler validates against the schedule's
+   * stored `pilotApiVersionPreference` before persisting.
+   */
+  payload: RawPayloadSchema.optional()
+}).strict();
+var UpdateScheduleRequestSchema = UpdateScheduleRequestBaseSchema.refine(
+  (data) => Object.keys(data).length > 0,
+  { message: "PATCH body must contain at least one field" }
+);
+var ScheduleViewBaseSchema = z37.object({
+  id: z37.string().uuid(),
+  /**
+   * Nullable since P1.2 — only inline kinds may have null projectId in
+   * persisted form; workload / agent kinds keep it set (enforced at
+   * create time and by DB shape CHECK).
+   */
+  projectId: z37.string().uuid().nullable(),
+  /**
+   * Owner LDAP (P1.2). NOT NULL in DB; the read shape exposes it for
+   * UI to render "owned by" labels and for permission checks on
+   * project-less schedules.
+   */
+  ownerLdap: z37.string(),
+  displayName: z37.string(),
+  description: z37.string().nullable(),
+  cronExpression: z37.string(),
+  timezone: z37.string(),
+  targetKind: ScheduleTargetKindSchema,
+  targetWorkloadId: z37.string().uuid().nullable(),
+  targetRevisionId: z37.string().uuid().nullable(),
+  targetAgentId: z37.string().uuid().nullable(),
+  pilotApiVersionPreference: ScheduleApiVersionPreferenceSchema,
+  lifecycleStatus: ScheduleLifecycleStatusSchema,
+  concurrencyPolicy: ScheduleConcurrencyPolicySchema,
+  misfirePolicy: ScheduleMisfirePolicySchema,
+  misfireGraceSeconds: z37.number().int().nonnegative(),
+  startAt: IsoDatetimeSchema.nullable(),
+  endAt: IsoDatetimeSchema.nullable(),
+  payload: RawPayloadSchema,
+  consecutiveFailureCount: z37.number().int().nonnegative(),
+  consecutiveFailureThreshold: z37.number().int().positive(),
+  lastTriggerAt: IsoDatetimeSchema.nullable(),
+  nextFireAt: IsoDatetimeSchema.nullable(),
+  createdBy: z37.string(),
+  createdAt: IsoDatetimeSchema,
+  updatedAt: IsoDatetimeSchema,
+  deletedAt: IsoDatetimeSchema.nullable()
+});
+var ScheduleViewSchema = refineTargetFields(
+  ScheduleViewBaseSchema
+);
+var ScheduleListItemSchema = ScheduleViewBaseSchema.pick({
+  id: true,
+  projectId: true,
+  ownerLdap: true,
+  displayName: true,
+  cronExpression: true,
+  timezone: true,
+  targetKind: true,
+  targetWorkloadId: true,
+  targetAgentId: true,
+  pilotApiVersionPreference: true,
+  lifecycleStatus: true,
+  lastTriggerAt: true,
+  nextFireAt: true,
+  createdAt: true,
+  updatedAt: true
+});
+var ScheduleListResponseSchema = z37.object({
+  items: z37.array(ScheduleListItemSchema),
+  nextCursor: z37.string().optional()
+});
+var ScheduleTriggerViewSchema = z37.object({
+  id: z37.string().uuid(),
+  scheduleId: z37.string().uuid(),
+  firedAt: IsoDatetimeSchema,
+  triggerSource: ScheduleTriggerSourceSchema,
+  status: ScheduleTriggerStatusSchema,
+  dispatchedAt: IsoDatetimeSchema.nullable(),
+  dispatchedRunId: z37.string().uuid().nullable(),
+  dispatchedSessionId: z37.string().uuid().nullable(),
+  /**
+   * Owning agent of the dispatched Run / Session, when one exists.
+   * Resolved by joining `runs.agent_id` on the dispatched run/session id
+   * (cohort invariant: `run.id === session.id`). Lets the UI deep-link
+   * the trigger to `/agents/:agentId`. Null for pure-workload v2
+   * dispatches (no agent) and for non-dispatched triggers.
+   */
+  dispatchedAgentId: z37.string().uuid().nullable(),
+  skippedReason: ScheduleSkippedReasonSchema.nullable(),
+  failureReasonCode: ScheduleFailureReasonCodeSchema.nullable(),
+  failureReasonMessage: z37.string().max(SCHEDULE_FAILURE_REASON_MESSAGE_MAX_LENGTH).nullable(),
+  idempotencyKey: z37.string(),
+  attemptCount: z37.number().int().nonnegative(),
+  blockingTriggerId: z37.string().uuid().nullable(),
+  createdAt: IsoDatetimeSchema
+}).superRefine((trigger, ctx) => {
+  if (trigger.status === "dispatched") {
+    if (!trigger.dispatchedAt) {
+      ctx.addIssue({
+        code: z37.ZodIssueCode.custom,
+        message: "dispatchedAt is required when status is 'dispatched'",
+        path: ["dispatchedAt"]
+      });
+    }
+    const hasRun = trigger.dispatchedRunId !== null;
+    const hasSession = trigger.dispatchedSessionId !== null;
+    if (hasRun === hasSession) {
+      ctx.addIssue({
+        code: z37.ZodIssueCode.custom,
+        message: "Exactly one of dispatchedRunId / dispatchedSessionId must be set when status is 'dispatched'",
+        path: ["dispatchedRunId"]
+      });
+    }
+  } else {
+    if (trigger.dispatchedAt !== null) {
+      ctx.addIssue({
+        code: z37.ZodIssueCode.custom,
+        message: "dispatchedAt must be null when status is not 'dispatched'",
+        path: ["dispatchedAt"]
+      });
+    }
+  }
+  if (trigger.status === "skipped" && trigger.skippedReason === null) {
+    ctx.addIssue({
+      code: z37.ZodIssueCode.custom,
+      message: "skippedReason is required when status is 'skipped'",
+      path: ["skippedReason"]
+    });
+  }
+  if (trigger.status !== "skipped" && trigger.skippedReason !== null) {
+    ctx.addIssue({
+      code: z37.ZodIssueCode.custom,
+      message: "skippedReason must be null when status is not 'skipped'",
+      path: ["skippedReason"]
+    });
+  }
+  if (trigger.status === "failed_to_dispatch" && trigger.failureReasonCode === null) {
+    ctx.addIssue({
+      code: z37.ZodIssueCode.custom,
+      message: "failureReasonCode is required when status is 'failed_to_dispatch'",
+      path: ["failureReasonCode"]
+    });
+  }
+  if (trigger.status !== "failed_to_dispatch" && trigger.failureReasonCode !== null) {
+    ctx.addIssue({
+      code: z37.ZodIssueCode.custom,
+      message: "failureReasonCode must be null when status is not 'failed_to_dispatch'",
+      path: ["failureReasonCode"]
+    });
+  }
+  if (trigger.blockingTriggerId !== null && !(trigger.status === "skipped" && trigger.skippedReason === "concurrency_forbidden")) {
+    ctx.addIssue({
+      code: z37.ZodIssueCode.custom,
+      message: "blockingTriggerId is only meaningful for skipped+concurrency_forbidden rows",
+      path: ["blockingTriggerId"]
+    });
+  }
+});
+var ScheduleTriggerListResponseSchema = z37.object({
+  items: z37.array(ScheduleTriggerViewSchema),
+  nextCursor: z37.string().optional()
+});
+var RunScheduleResponseSchema = z37.object({
+  triggerId: z37.string().uuid(),
+  dispatchedRunId: z37.string().uuid().optional(),
+  dispatchedSessionId: z37.string().uuid().optional()
+}).superRefine((value, ctx) => {
+  const hasRun = value.dispatchedRunId !== void 0;
+  const hasSession = value.dispatchedSessionId !== void 0;
+  if (hasRun === hasSession) {
+    ctx.addIssue({
+      code: z37.ZodIssueCode.custom,
+      message: "Exactly one of dispatchedRunId / dispatchedSessionId must be present in run-now response"
+    });
+  }
+});
+var ScheduleApiErrorBodySchema = z37.object({
+  error: z37.object({
+    code: ScheduleApiErrorCodeSchema,
+    message: z37.string(),
+    details: z37.record(z37.unknown()).optional()
+  })
+});
+var RevisionWorkerContractRefSchema = WorkerContractRefSchema.pick({
+  kind: true,
+  name: true,
+  version: true
+}).strict();
+var PILOT_WORKLOAD_MANIFEST_API_VERSION = "pilot.zhenguanyu.com/v0alpha1";
+var PILOT_WORKLOAD_MANIFEST_LEGACY_API_VERSION = "pilot.kanyun.ai/v0alpha1";
+var PILOT_WORKLOAD_MANIFEST_API_VERSIONS = [
+  PILOT_WORKLOAD_MANIFEST_API_VERSION,
+  PILOT_WORKLOAD_MANIFEST_LEGACY_API_VERSION
+];
+var PilotWorkloadManifestApiVersionSchema = z38.enum(PILOT_WORKLOAD_MANIFEST_API_VERSIONS);
+var WORKLOAD_MANIFEST_NAME_MAX_LENGTH = 100;
+var WORKLOAD_MANIFEST_DISPLAY_NAME_MAX_LENGTH = 255;
+var WORKLOAD_MANIFEST_REF_NAME_MAX_LENGTH = 255;
+var WorkloadManifestErrorCodeSchema = z38.enum([
+  "MANIFEST_UNSUPPORTED_API_VERSION",
+  "MANIFEST_UNSUPPORTED_KIND",
+  "MANIFEST_VALIDATION_ERROR",
+  "WORKLOAD_KIND_UNSUPPORTED",
+  "WORKLOAD_NOT_FOUND",
+  "WORKLOAD_KIND_MISMATCH",
+  "PROJECT_DEFAULT_RUNTIME_MISSING",
+  "RUNTIME_TEMPLATE_NOT_FOUND",
+  "REVISION_REGISTRATION_CONFLICT",
+  // Cross-project safety: thrown when `applyRevisionManifest` resolves a
+  // workload and a runtime template that live in different projects.
+  // Mirrors the `revisions_project_consistency` DB trigger; the
+  // application-layer check exits early with a friendlier error code
+  // before the trigger fires raw `check_violation` SQLSTATE 23514.
+  // Plan: plans/admin-ui-project-namespacing.md §C2.
+  "REVISION_CROSS_PROJECT",
+  "IMAGE_PROVENANCE_REQUIRED",
+  "IMAGE_PROVENANCE_INVALID",
+  "LEGACY_PROVENANCE_NOT_ALLOWED"
+]);
+var ActiveWorkloadKindSchema = z38.enum(["managed_agent", "self_managed"]);
+var DeferredWorkloadKindSchema = z38.enum(["external_worker", "batch_task"]);
+var DNS_LABEL_STYLE_PATTERN = /^[a-z0-9]([-a-z0-9]*[a-z0-9])?$/;
+var WorkloadManifestNameSchema = z38.string().min(1).max(WORKLOAD_MANIFEST_NAME_MAX_LENGTH).regex(DNS_LABEL_STYLE_PATTERN, "Name must be DNS-label-style");
+var WorkloadManifestDisplayNameSchema = z38.string().min(1).max(WORKLOAD_MANIFEST_DISPLAY_NAME_MAX_LENGTH);
+var WorkloadManifestRefNameSchema = z38.string().min(1).max(WORKLOAD_MANIFEST_REF_NAME_MAX_LENGTH);
+var WorkloadManifestObjectRefSchema = z38.object({
+  name: WorkloadManifestRefNameSchema
+}).strict();
+var WorkloadManifestMetadataBaseSchema = z38.object({
+  name: WorkloadManifestNameSchema,
+  labels: z38.record(z38.string()).optional(),
+  annotations: z38.record(z38.string()).optional()
+}).strict();
+var WorkloadManifestMetadataSchema = WorkloadManifestMetadataBaseSchema.extend({
+  displayName: WorkloadManifestDisplayNameSchema
+}).strict();
+var RevisionManifestMetadataSchema = WorkloadManifestMetadataBaseSchema.extend({
+  workload: WorkloadManifestNameSchema
+}).strict();
+var WorkloadManifestCapabilityRefsSchema = z38.object({
+  modelRef: WorkloadManifestObjectRefSchema.optional(),
+  toolRefs: z38.array(WorkloadManifestObjectRefSchema).optional(),
+  mcpRefs: z38.array(WorkloadManifestObjectRefSchema).optional()
+}).strict();
+var WorkloadManifestPolicyRefsSchema = z38.object({
+  credentialPolicyRef: WorkloadManifestObjectRefSchema.optional(),
+  readinessPolicyRef: WorkloadManifestObjectRefSchema.optional(),
+  actionPolicyRef: WorkloadManifestObjectRefSchema.optional(),
+  trafficPolicyRef: WorkloadManifestObjectRefSchema.optional()
+}).strict();
+var WorkloadManifestWorkerContractDefaultsSchema = z38.object({
+  name: WorkloadManifestRefNameSchema.optional(),
+  version: z38.string().min(1).max(WORKLOAD_MANIFEST_NAME_MAX_LENGTH).optional()
+}).strict();
+var WORKLOAD_MANIFEST_MODEL_MAX_LENGTH = 255;
+var WorkloadManifestModelSchema = z38.string().min(1).max(WORKLOAD_MANIFEST_MODEL_MAX_LENGTH);
+var WORKLOAD_MANIFEST_SYSTEM_PROMPT_MAX_LENGTH = 32768;
+var WorkloadManifestSystemPromptSchema = z38.string().min(1).max(WORKLOAD_MANIFEST_SYSTEM_PROMPT_MAX_LENGTH);
+var ManagedAgentProfileSnapshotSchema = z38.object({
+  model: WorkloadManifestModelSchema.optional(),
+  systemPrompt: WorkloadManifestSystemPromptSchema.optional(),
+  enabledSkills: EnabledSkillEntryListSchema.optional(),
+  enabledMcpServers: EnabledMcpEntryListSchema.optional(),
+  configValues: SessionConfigValuesSchema.optional()
+}).strict();
+var ManagedAgentOverridesSchema = z38.object({
+  model: WorkloadManifestModelSchema.nullable().optional(),
+  systemPrompt: WorkloadManifestSystemPromptSchema.nullable().optional(),
+  enabledSkills: EnabledSkillEntryListSchema.optional(),
+  enabledMcpServers: EnabledMcpEntryListSchema.optional()
+}).strict();
+var WorkloadManifestDefaultsSchema = z38.object({
+  runtimeTemplateRef: WorkloadManifestObjectRefSchema.optional(),
+  workerContract: WorkloadManifestWorkerContractDefaultsSchema.optional(),
+  capabilityRefs: WorkloadManifestCapabilityRefsSchema.optional(),
+  configValues: SessionConfigValuesSchema.optional(),
+  model: WorkloadManifestModelSchema.optional(),
+  /**
+   * Workload-level **default system prompt** (managed_agent profile
+   * Phase D). Seeded onto `agents.system_prompt` at agent creation and
+   * forwarded per-run as `PilotCoderRunConfigV1.systemPrompt`. See
+   * `specs/features/pilot-v2-managed-agent-profile.md` §"Phase D".
+   */
+  systemPrompt: WorkloadManifestSystemPromptSchema.optional(),
+  /**
+   * Workload-level **default enabled skills** (managed_agent profile
+   * Phase C). Persisted into `workloads.manifest_defaults_json` and
+   * seeded into `agents.enabled_skills` at agent creation when the
+   * caller does not supply explicit skills. Accepts the snapshot-or-ref
+   * union (same write contract as `projects.enabled_skills`); the
+   * `POST /api/workloads` route resolves any refs into full
+   * `EnabledSkill` snapshots via the rush registry before persisting so
+   * the workload default is self-contained (no per-user install
+   * dependency). See `specs/features/pilot-v2-managed-agent-profile.md`
+   * §"Phase C".
+   */
+  enabledSkills: EnabledSkillEntryListSchema.optional(),
+  /**
+   * Workload-level **default enabled MCP servers** (managed_agent
+   * profile Phase C2). Persisted into `workloads.manifest_defaults_json`
+   * and seeded into `agents.enabled_mcp_servers` at agent creation when
+   * the caller does not supply explicit MCP servers. Accepts the
+   * snapshot-or-ref union (same write contract as
+   * `projects.enabled_mcp_servers`); the `POST /api/workloads` route
+   * resolves any refs into full `EnabledMcpServer` snapshots via the
+   * rush registry before persisting so the workload default is
+   * self-contained.
+   *
+   * Resolution at `POST /api/workloads` produces a mix:
+   *   - **credential-free** MCP (rush `requiredVars` empty, Phase C2) →
+   *     frozen `EnabledMcpServer` snapshot (self-contained, cross-user
+   *     identical).
+   *   - **credentialed** MCP (rush `requiredVars` non-empty, Phase C3) →
+   *     bare `EnabledMcpRef { rushMcpId }`; the credential is NOT frozen
+   *     here, it resolves per running user from `user_mcp_installs` at
+   *     bootstrap (ref-resolver), with per-MCP failure isolation when an
+   *     install is missing (`mcp-and-skills.md` §4.2).
+   *
+   * Inline plaintext credentials (`extraConfigValues` /
+   * `extraConfigValuesOverride`) are rejected at resolution — a
+   * cross-user workload default never stores one user's secret. See
+   * `specs/features/pilot-v2-managed-agent-profile.md` §"Phase C".
+   */
+  enabledMcpServers: EnabledMcpEntryListSchema.optional()
+}).strict();
+var WORKLOAD_MANIFEST_UI_DISPLAY_NAME_MAX_LENGTH = 255;
+var WORKLOAD_MANIFEST_UI_PROMPT_PLACEHOLDER_MAX_LENGTH = 500;
+var WorkloadManifestUiHintSchema = z38.object({
+  displayName: z38.string().min(1).max(WORKLOAD_MANIFEST_UI_DISPLAY_NAME_MAX_LENGTH).optional(),
+  promptPlaceholder: z38.string().min(1).max(WORKLOAD_MANIFEST_UI_PROMPT_PLACEHOLDER_MAX_LENGTH).optional(),
+  enableAttachments: z38.boolean().optional(),
+  artifactsView: z38.enum(["none", "panel"]).optional()
+}).strict();
+var WorkloadManifestSchema = z38.object({
+  apiVersion: PilotWorkloadManifestApiVersionSchema,
+  kind: z38.literal("Workload"),
+  metadata: WorkloadManifestMetadataSchema,
+  spec: z38.object({
+    contract: z38.object({
+      kind: WorkloadKindSchema
+    }).strict(),
+    defaults: WorkloadManifestDefaultsSchema.optional(),
+    policyRefs: WorkloadManifestPolicyRefsSchema.optional(),
+    ui: WorkloadManifestUiHintSchema.optional()
+  }).strict()
+}).strict();
+var RevisionManifestStartupSchema = z38.object({
+  requiredGates: z38.array(z38.string().min(1)).optional(),
+  optionalGates: z38.array(z38.string().min(1)).optional()
+}).strict();
+var RevisionManifestPublishSchema = z38.object({
+  setDefault: z38.boolean().default(true)
+}).strict();
+var RevisionRuntimeEnvironmentInputSchema = RuntimeTemplateSnapshotSchema.omit({
+  defaultWorkerEndpoint: true
+}).strict();
+var RevisionRuntimeEnvironmentOverridesSchema = RevisionRuntimeEnvironmentInputSchema.partial().strict();
+var RevisionRuntimeSchema = z38.object({
+  /**
+   * Complete publish-time Runtime Environment input. Control-plane resolves
+   * and freezes this into `revisions.runtime_template_snapshot_json`; DB
+   * compatibility still records a runtime source/profile id separately.
+   */
+  environment: RevisionRuntimeEnvironmentInputSchema.optional(),
+  /**
+   * Runtime source/profile reference. During the RuntimeTemplate
+   * compatibility window this maps to `runtime_templates.name`.
+   */
+  profileRef: WorkloadManifestObjectRefSchema.optional(),
+  /**
+   * Publish-time overrides applied to `profileRef`'s resolved environment.
+   */
+  overrides: RevisionRuntimeEnvironmentOverridesSchema.optional()
+}).strict().superRefine((runtime, ctx) => {
+  if (!runtime.environment && !runtime.profileRef) {
+    ctx.addIssue({
+      code: z38.ZodIssueCode.custom,
+      path: ["environment"],
+      message: "runtime must provide environment or profileRef"
+    });
+  }
+  if (runtime.environment && runtime.overrides) {
+    ctx.addIssue({
+      code: z38.ZodIssueCode.custom,
+      path: ["overrides"],
+      message: "runtime.overrides is only allowed with runtime.profileRef"
+    });
+  }
+  if (runtime.overrides && !runtime.profileRef) {
+    ctx.addIssue({
+      code: z38.ZodIssueCode.custom,
+      path: ["profileRef"],
+      message: "runtime.profileRef is required when runtime.overrides is provided"
+    });
+  }
+});
+var RevisionManifestSpecSchema = z38.object({
+  runtimeTemplateRef: WorkloadManifestObjectRefSchema.optional(),
+  runtime: RevisionRuntimeSchema.optional(),
+  workerContract: RevisionWorkerContractRefSchema,
+  capabilityRefs: WorkloadManifestCapabilityRefsSchema.optional(),
+  startup: RevisionManifestStartupSchema.optional(),
+  publish: RevisionManifestPublishSchema.default({ setDefault: true }),
+  configValues: SessionConfigValuesSchema.optional(),
+  policyRefs: WorkloadManifestPolicyRefsSchema.optional(),
+  managedAgentProfileSnapshot: ManagedAgentProfileSnapshotSchema.optional()
+}).strict().superRefine((spec, ctx) => {
+  var _a, _b, _c;
+  const profileRefName = (_b = (_a = spec.runtime) == null ? void 0 : _a.profileRef) == null ? void 0 : _b.name;
+  const legacyRuntimeTemplateRefName = (_c = spec.runtimeTemplateRef) == null ? void 0 : _c.name;
+  if (profileRefName && legacyRuntimeTemplateRefName && profileRefName !== legacyRuntimeTemplateRefName) {
+    ctx.addIssue({
+      code: z38.ZodIssueCode.custom,
+      path: ["runtimeTemplateRef"],
+      message: "runtimeTemplateRef must match runtime.profileRef when both compatibility refs are provided"
+    });
+  }
+  if (spec.managedAgentProfileSnapshot !== void 0 && spec.workerContract.kind !== "managed_agent") {
+    ctx.addIssue({
+      code: z38.ZodIssueCode.custom,
+      path: ["managedAgentProfileSnapshot"],
+      message: "managedAgentProfileSnapshot is only allowed for managed_agent revisions"
+    });
+  }
+});
+var RevisionManifestSchema = z38.object({
+  apiVersion: PilotWorkloadManifestApiVersionSchema,
+  kind: z38.literal("Revision"),
+  metadata: RevisionManifestMetadataSchema,
+  spec: RevisionManifestSpecSchema
+}).strict();
+var PilotWorkloadManifestSchema = z38.discriminatedUnion("kind", [
+  WorkloadManifestSchema,
+  RevisionManifestSchema
+]);
+var MANAGED_AGENT_PROFILE_KIND = "ManagedAgentProfile";
+var ManagedAgentProfileMetadataSchema = z39.object({
+  name: WorkloadManifestNameSchema,
+  displayName: WorkloadManifestDisplayNameSchema,
+  labels: z39.record(z39.string()).optional(),
+  annotations: z39.record(z39.string()).optional()
+}).strict();
+var ManagedAgentProfileSpecSchema = z39.object({
+  runtimeTemplateRef: WorkloadManifestObjectRefSchema,
+  env: SessionConfigValuesSchema.optional(),
+  ui: WorkloadManifestUiHintSchema.optional(),
+  // Phase B (🟡): workload-level default model id. Projected to
+  // `manifest.spec.defaults.model`, persisted in
+  // `workloads.manifest_defaults_json`, and read at session creation as
+  // the default for `sessions.metadata.model` when the caller does not
+  // pin one. See `specs/features/pilot-v2-managed-agent-profile.md`
+  // §"Phase B" for the resolution order.
+  model: WorkloadManifestModelSchema.optional(),
+  // Phase C (🟡): workload-level default enabled skills as friendly rush
+  // skill names (e.g. `@kanyun/data-analysis-skills`). Projected to
+  // `manifest.spec.defaults.enabledSkills` as `EnabledSkillRef[]`,
+  // resolved to full snapshots at `POST /api/workloads`, and seeded into
+  // `agents.enabled_skills` at agent creation when the caller omits
+  // skills. See `specs/features/pilot-v2-managed-agent-profile.md`
+  // §"Phase C".
+  skills: z39.array(z39.string().min(1)).optional(),
+  // Phase C2/C3 (🟡): workload-level default MCP servers as friendly rush
+  // MCP ids (e.g. `github`). Projected to
+  // `manifest.spec.defaults.enabledMcpServers` as `EnabledMcpRef[]`. At
+  // `POST /api/workloads` each ref resolves by credential need:
+  // credential-free templates freeze into `EnabledMcpServer` snapshots
+  // (C2); credentialed templates persist as bare refs resolved per running
+  // user at bootstrap (C3). Seeded into `agents.enabled_mcp_servers` at
+  // agent creation when the caller omits MCP servers. See
+  // `specs/features/pilot-v2-managed-agent-profile.md` §"Phase C".
+  mcpServers: z39.array(z39.string().min(1)).optional(),
+  // Phase D: workload-level default system prompt. Projected to
+  // `manifest.spec.defaults.systemPrompt`, seeded onto
+  // `agents.system_prompt` at agent creation, and forwarded per-run as
+  // `PilotCoderRunConfigV1.systemPrompt`. agent-worker uses it instead of
+  // the platform-level `SYSTEM_PROMPT` fallback. See
+  // `specs/features/pilot-v2-managed-agent-profile.md` §"Phase D".
+  systemPrompt: WorkloadManifestSystemPromptSchema.optional()
+}).strict();
+var ManagedAgentProfileSchema = z39.object({
+  apiVersion: PilotWorkloadManifestApiVersionSchema,
+  kind: z39.literal(MANAGED_AGENT_PROFILE_KIND),
+  metadata: ManagedAgentProfileMetadataSchema,
+  spec: ManagedAgentProfileSpecSchema
+}).strict();
+var PlatformProjectSchema = z40.object({
+  id: z40.string().uuid(),
+  slug: WorkloadManifestNameSchema,
+  displayName: WorkloadManifestDisplayNameSchema,
+  description: z40.string().nullable().optional(),
+  defaultRuntimeTemplateRefName: WorkloadManifestRefNameSchema.nullable().optional(),
+  createdAt: z40.string().optional(),
+  updatedAt: z40.string().optional()
+}).strict();
+var CreatePlatformProjectRequestSchema = z40.object({
+  slug: WorkloadManifestNameSchema,
+  displayName: WorkloadManifestDisplayNameSchema,
+  description: z40.string().max(2e3).optional(),
+  defaultRuntimeTemplateRefName: WorkloadManifestRefNameSchema.optional()
+}).strict();
+var ListPlatformProjectsResponseSchema = z40.object({
+  projects: z40.array(PlatformProjectSchema)
+}).strict();
+var PlatformWorkloadDefaultsSchema = z40.object({
+  workerContract: WorkloadManifestWorkerContractDefaultsSchema.optional(),
+  configValues: SessionConfigValuesSchema.optional(),
+  model: z40.string().min(1).max(255).optional(),
+  systemPrompt: z40.string().min(1).max(32768).optional(),
+  enabledSkills: EnabledSkillEntryListSchema.optional(),
+  enabledMcpServers: EnabledMcpEntryListSchema.optional()
+}).strict();
+var CreatePlatformWorkloadRequestSchema = z40.object({
+  projectId: z40.string().uuid(),
+  slug: WorkloadManifestNameSchema,
+  displayName: WorkloadManifestDisplayNameSchema,
+  kind: ActiveWorkloadKindSchema,
+  defaults: PlatformWorkloadDefaultsSchema.optional(),
+  ui: WorkloadManifestUiHintSchema.optional()
+}).strict();
+var PlatformWorkloadSchema = z40.object({
+  id: z40.string().uuid(),
+  projectId: z40.string().uuid(),
+  slug: WorkloadManifestNameSchema,
+  displayName: WorkloadManifestDisplayNameSchema,
+  kind: ActiveWorkloadKindSchema,
+  defaultRevisionId: z40.string().uuid().nullable().optional(),
+  createdAt: z40.string().optional(),
+  updatedAt: z40.string().optional()
+}).strict();
+var PublishPlatformRevisionWorkerContractSchema = z40.object({
+  kind: ActiveWorkloadKindSchema,
+  name: WorkloadManifestRefNameSchema.optional(),
+  version: z40.string().min(1).max(100).optional()
+}).strict();
+var PublishPlatformRevisionRequestSchema = z40.object({
+  projectId: z40.string().uuid(),
+  workloadSlug: WorkloadManifestNameSchema,
+  version: WorkloadManifestNameSchema,
+  workerContract: PublishPlatformRevisionWorkerContractSchema,
+  setDefault: z40.boolean().default(true),
+  startup: z40.object({
+    requiredGates: z40.array(z40.string().min(1)).optional(),
+    optionalGates: z40.array(z40.string().min(1)).optional()
+  }).strict().optional(),
+  configValues: SessionConfigValuesSchema.optional(),
+  managedAgentProfileSnapshot: ManagedAgentProfileSnapshotSchema.optional(),
+  runtime: RevisionRuntimeSchema.optional()
+}).strict();
+var PlatformRevisionSchema = z40.object({
+  id: z40.string().uuid(),
+  projectId: z40.string().uuid(),
+  workloadId: z40.string().uuid(),
+  workloadSlug: WorkloadManifestNameSchema.optional(),
+  version: WorkloadManifestNameSchema,
+  runtimeSnapshotHash: z40.string().nullable().optional(),
+  createdAt: z40.string().optional()
+}).strict();
+var GetPlatformSessionResponseSchema = z40.object({
+  id: z40.string().uuid(),
+  projectId: z40.string().uuid(),
+  workloadId: z40.string().uuid(),
+  revisionId: z40.string().uuid(),
+  status: SessionStatusSchema,
+  createdAt: z40.string().optional(),
+  updatedAt: z40.string().optional()
+}).strict();
+var CreatePlatformSessionRequestSchema = CreateSessionRequestSchema;
+var CreatePlatformSessionResponseSchema = CreateSessionResponseSchema;
+function platformWorkloadCreateToManifest(input) {
+  const defaults = input.defaults ? omitUndefined(input.defaults) : void 0;
+  return WorkloadManifestSchema.parse({
+    apiVersion: PILOT_WORKLOAD_MANIFEST_API_VERSION,
+    kind: "Workload",
+    metadata: {
+      name: input.slug,
+      displayName: input.displayName
+    },
+    spec: __spreadValues(__spreadValues({
+      contract: { kind: input.kind }
+    }, defaults ? { defaults } : {}), input.ui ? { ui: input.ui } : {})
+  });
+}
+function omitUndefined(input) {
+  return Object.fromEntries(
+    Object.entries(input).filter((entry) => entry[1] !== void 0)
+  );
+}
+function platformRevisionPublishToManifest(input) {
+  return RevisionManifestSchema.parse({
+    apiVersion: PILOT_WORKLOAD_MANIFEST_API_VERSION,
+    kind: "Revision",
+    metadata: {
+      name: input.version,
+      workload: input.workloadSlug
+    },
+    spec: __spreadValues(__spreadValues(__spreadValues(__spreadProps(__spreadValues({}, input.runtime ? { runtime: input.runtime } : {}), {
+      workerContract: input.workerContract,
+      publish: RevisionManifestPublishSchema.parse({ setDefault: input.setDefault })
+    }), input.startup ? { startup: input.startup } : {}), input.configValues ? { configValues: input.configValues } : {}), input.managedAgentProfileSnapshot ? { managedAgentProfileSnapshot: input.managedAgentProfileSnapshot } : {})
+  });
+}
+var PilotCoderSkillsInstallSchema = z41.object({
+  gitlabDomain: z41.string().optional(),
+  gitlabToken: z41.string().optional(),
+  githubToken: z41.string().optional()
+}).strict();
+var PilotCoderTriggerRefSchema = z41.discriminatedUnion("type", [
+  z41.object({
+    type: z41.literal("github_issue"),
+    number: z41.number().int().positive(),
+    commentId: z41.number().int().positive().optional()
+  }).strict(),
+  z41.object({
+    type: z41.literal("github_pr"),
+    number: z41.number().int().positive(),
+    commentId: z41.number().int().positive().optional()
+  }).strict(),
+  z41.object({
+    type: z41.literal("gitlab_issue"),
+    iid: z41.number().int().positive(),
+    noteId: z41.number().int().positive().optional()
+  }).strict(),
+  z41.object({
+    type: z41.literal("gitlab_mr"),
+    iid: z41.number().int().positive(),
+    noteId: z41.number().int().positive().optional()
+  }).strict(),
+  z41.object({
+    type: z41.literal("jira_issue"),
+    key: z41.string().min(1)
+  }).strict(),
+  z41.object({
+    type: z41.literal("schedule"),
+    scheduleId: z41.string().min(1)
+  }).strict(),
+  z41.object({
+    type: z41.literal("opaque"),
+    value: z41.string().min(1)
+  }).strict()
+]);
+var PilotCoderRunConfigV1Schema = z41.object({
+  runId: z41.string().min(1),
+  agentId: z41.string().min(1),
+  provider: ProviderTypeSchema.optional(),
+  model: z41.string().optional(),
+  /**
+   * Phase D — per-agent system prompt. Sourced by control-worker from
+   * `agents.system_prompt` (seeded from a managed_agent profile's
+   * `spec.systemPrompt` workload default). When present, agent-worker
+   * uses it verbatim as the LLM `system` prompt **instead of** the
+   * platform-level `SYSTEM_PROMPT` / `SYSTEM_PROMPT_GENERAL` fallback
+   * (`getSystemPrompt(projectKind)`); when absent the platform default
+   * is used, so v1 payloads stay backward-compatible.
+   *
+   * Routed per-run via the dispatch payload (not worker env) so multiple
+   * workloads sharing a pod stay cleanly isolated. Deployment ordering:
+   * contracts ship first (both control-worker and agent-worker must
+   * recognize this key before control-worker starts populating it), since
+   * `PilotCoderRunConfigV1Schema` is `.strict()`.
+   */
+  systemPrompt: z41.string().min(1).optional(),
+  workspacePath: z41.string().optional(),
+  mcpConfigDir: z41.string().optional(),
+  attachments: z41.array(AttachmentMetaSchema).max(5).optional(),
+  triggerContext: WebhookTriggerContextSchema.optional(),
+  mcpServers: McpServersMapSchema.optional(),
+  env: z41.record(z41.string(), z41.string()).optional(),
+  projectKind: ProjectKindSchema.optional(),
+  /**
+   * v2-only — resolved skill artifact list, populated by
+   * control-plane `v2McpResolve` (see `apps/control-worker/src/worker.ts`).
+   * Each entry MUST be fully resolved (i.e. the legacy `EnabledSkill`
+   * shape with `resolvedArtifact`) — refs (`EnabledSkillRef`) are
+   * lookup-time-only and never travel on the wire.
+   *
+   * Agent-worker `run-agent-loop.ts` consumes this list and invokes
+   * `@pilot/skills` `ensureSkillsInstalled` to materialize each
+   * skill under `$HOME/.claude/skills/<dir>/` (claude-code provider)
+   * or `$HOME/.codex/skills/<dir>/` (codex provider) before the LLM
+   * loop spins up.
+   *
+   * In v1 this work was done by `mcpSkillsBootstrap` against the
+   * sandbox SDK; v2 sandboxes live in a separate namespace and that
+   * SDK 404s on them, so installation moved into the in-sandbox
+   * agent-worker process. See `specs/features/pilot-v2-sdk-worker-substrate-api.md`
+   * for the namespace rationale.
+   */
+  skills: z41.array(EnabledSkillSchema).optional(),
+  skillsInstall: PilotCoderSkillsInstallSchema.optional(),
+  /**
+   * P3 L3.3 — delivery-related fields populated by control-worker from
+   * `runs.*` / `agents.*` columns so the worker delivery loop can act
+   * without re-querying control-plane. All fields are optional: v1
+   * payloads predate L3.3 and senders without delivery (e.g. interactive
+   * chat sessions) MUST still encode successfully.
+   *
+   * `repoUrl` mirrors `runs.repo_url` (nullable; omitted when null).
+   * `baseBranch` is the PR/MR target branch (sourced from
+   * `agents.base_ref` or `runs.target_ref` per dispatch site choice).
+   * `triggerSource` mirrors `runs.trigger_source`. `triggerRef` is the
+   * structured / parsed form of `runs.trigger_ref`. `prTitle` /
+   * `prTemplate` are user / trigger-source specified overrides for the
+   * delivery PR description; if neither column / setting exists yet on
+   * the v1 data model, the dispatcher omits them (forward-compat).
+   */
+  repoUrl: z41.string().min(1).optional(),
+  baseBranch: z41.string().min(1).optional(),
+  triggerSource: TriggerSourceSchema.optional(),
+  triggerRef: PilotCoderTriggerRefSchema.optional(),
+  prTitle: z41.string().min(1).optional(),
+  prTemplate: z41.string().min(1).optional()
+}).strict();
+var PilotCoderPromptPayloadV1Schema = z41.object({
+  schemaVersion: z41.literal("v1"),
+  kind: z41.literal("prompt"),
+  prompt: z41.string().min(1),
+  config: PilotCoderRunConfigV1Schema
+}).strict();
+var PilotCoderFollowupPayloadV1Schema = z41.object({
+  schemaVersion: z41.literal("v1"),
+  kind: z41.literal("followup"),
+  message: z41.string().min(1),
+  config: PilotCoderRunConfigV1Schema,
+  expectedMessagesHash: z41.string().optional(),
+  expectedMessagesCount: z41.number().int().nonnegative().optional()
+}).strict();
+var PilotCoderRestorePayloadV1Schema = z41.object({
+  schemaVersion: z41.literal("v1"),
+  kind: z41.literal("restore"),
+  config: PilotCoderRunConfigV1Schema,
+  messages: z41.array(z41.unknown()),
+  messagesHash: z41.string().min(1),
+  lastEventId: z41.number().int().nonnegative().optional(),
+  pendingToolCalls: z41.array(z41.unknown()).optional(),
+  workspaceHydrationRef: z41.string().optional(),
+  runtimeProfileSnapshot: z41.record(z41.unknown()).optional(),
+  degradedRecovery: z41.boolean().optional()
+}).strict();
+var GatewayErrorCodeSchema = z42.enum([
+  "gateway_invalid_session_token",
+  "gateway_session_not_found",
+  "gateway_missing_mcp_target",
+  "gateway_invalid_mcp_target",
+  "gateway_invalid_mcp_method",
+  "gateway_not_a_mcp_path",
+  "gateway_mcp_target_not_allowed",
+  "gateway_vault_unreachable",
+  "gateway_credential_refresh_failed",
+  "gateway_credential_refresh_timeout",
+  "gateway_upstream_unreachable",
+  "gateway_upstream_error",
+  "gateway_upstream_timeout",
+  "gateway_request_too_large",
+  "gateway_response_too_large"
+]);
+var WebhookEventTypeSchema = z43.enum([
+  /** v1/v2 Run reached terminal `completed`. */
+  "run.completed",
+  /** v1/v2 Run reached terminal `failed`. */
+  "run.failed",
+  /** v2 Session startup reached terminal `ready`. */
+  "session.status_ready",
+  /** v2 Session startup reached terminal `failed`. */
+  "session.status_failed",
+  /** v2 Session post-ready lifecycle entered `idle`. */
+  "session.lifecycle_idle",
+  /** v2 Session post-ready lifecycle entered `terminating`. */
+  "session.lifecycle_terminating",
+  /** v2 Session post-ready lifecycle reached `terminated`. */
+  "session.lifecycle_terminated"
+]);
+var WEBHOOK_EVENT_TYPES = WebhookEventTypeSchema.options;
+var WebhookEventPayloadSchema = z43.object({
+  event_id: z43.string().min(1).max(255),
+  event_type: WebhookEventTypeSchema,
+  /** ISO-8601 instant at which the transition was recorded. */
+  occurred_at: z43.string(),
+  project_id: z43.string().uuid(),
+  run_id: z43.string().uuid().optional(),
+  agent_id: z43.string().uuid().optional(),
+  session_id: z43.string().uuid().optional(),
+  lifecycle_phase: z43.enum(["idle", "terminating", "terminated"]).optional(),
+  lifecycle_transition_id: z43.string().uuid().optional(),
+  idle_since: z43.string().optional(),
+  grace_deadline: z43.string().optional(),
+  reason: z43.string().optional(),
+  terminate_deadline: z43.string().optional()
+}).strict();
+var WebhookSubscriptionStatusSchema = z43.enum(["active", "disabled"]);
+var CreateWebhookSubscriptionRequestSchema = z43.object({
+  projectId: z43.string().uuid(),
+  /** Subscriber endpoint. https required outside dev; SSRF-validated. */
+  url: z43.string().url().max(1024),
+  /** Event types to deliver. At least one. */
+  events: z43.array(WebhookEventTypeSchema).min(1).max(WEBHOOK_EVENT_TYPES.length),
+  /** Optional operator note shown in list responses. */
+  description: z43.string().max(512).optional()
+}).strict();
+var UpdateWebhookSubscriptionRequestSchema = z43.object({
+  url: z43.string().url().max(1024).optional(),
+  events: z43.array(WebhookEventTypeSchema).min(1).max(WEBHOOK_EVENT_TYPES.length).optional(),
+  description: z43.string().max(512).nullable().optional(),
+  /**
+   * `active` re-enables a subscription that was auto-disabled after
+   * consecutive failures (resets the failure counter); `disabled`
+   * pauses delivery without deleting history.
+   */
+  status: WebhookSubscriptionStatusSchema.optional()
+}).strict().refine(
+  (data) => data.url !== void 0 || data.events !== void 0 || data.description !== void 0 || data.status !== void 0,
+  { message: "At least one of url / events / description / status MUST be provided" }
+);
+var WebhookSubscriptionSchema = z43.object({
+  id: z43.string().uuid(),
+  projectId: z43.string().uuid(),
+  url: z43.string(),
+  events: z43.array(WebhookEventTypeSchema),
+  description: z43.string().nullable(),
+  status: WebhookSubscriptionStatusSchema,
+  consecutiveFailures: z43.number().int().nonnegative(),
+  createdBy: z43.string(),
+  createdAt: z43.string(),
+  updatedAt: z43.string()
+});
+var WebhookSubscriptionWithSecretSchema = z43.object({
+  subscription: WebhookSubscriptionSchema,
+  secret: z43.string()
+});
+var WebhookSubscriptionErrorCodeSchema = z43.enum([
+  // 400
+  "VALIDATION_ERROR",
+  /** URL failed SSRF policy (non-https, private/loopback/link-local IP…). */
+  "WEBHOOK_URL_FORBIDDEN",
+  // 404
+  "SUBSCRIPTION_NOT_FOUND",
+  "PROJECT_NOT_FOUND",
+  // 409
+  "SUBSCRIPTION_LIMIT_EXCEEDED",
+  // 500
+  "INTERNAL_ERROR"
+]);
+var SessionPrewarmingIdentitySchema = z44.object({
+  projectIdGenerator: z44.literal("nanoid"),
+  claimNameTemplate: z44.string().min(1),
+  idempotencyScopePrefix: z44.string().min(1)
+}).strict();
+var SessionPrewarmingSessionTemplateSchema = z44.object({
+  configValues: z44.record(z44.string(), z44.string()),
+  metadata: z44.record(z44.string(), z44.unknown()).optional()
+}).strict();
+var BusinessReadyProbeSchema = z44.object({
+  endpointName: z44.enum(["api", "preview"]),
+  path: z44.string().min(1),
+  successCodes: z44.array(z44.number().int().min(100).max(599)).min(1),
+  timeoutMs: z44.number().int().min(500).max(3e4)
+}).strict();
+var SessionPrewarmingSpecSchema = z44.object({
+  targetReadyCount: z44.number().int().min(1).max(50),
+  reVerifyIntervalSeconds: z44.number().int().min(60).max(3600),
+  warmingTimeoutSeconds: z44.number().int().min(60).max(600),
+  claimingLeaseTtlSeconds: z44.number().int().min(10).max(120),
+  replenishIntervalSeconds: z44.number().int().min(5).max(300),
+  maxConcurrentWarming: z44.number().int().min(1).max(10),
+  identity: SessionPrewarmingIdentitySchema,
+  sessionTemplate: SessionPrewarmingSessionTemplateSchema,
+  businessReadyProbe: BusinessReadyProbeSchema.optional()
+}).strict();
+var AcquireSessionRequestSchema = z44.object({
+  workloadId: z44.string().uuid(),
+  clientMutationId: z44.string().min(1).max(255)
+}).strict();
+var AcquireSessionResponseSchema = z44.object({
+  leaseToken: z44.string().min(1),
+  leaseExpiresAt: z44.string().datetime(),
+  sessionId: z44.string().uuid(),
+  projectId: z44.string().min(1),
+  runtimeClaimName: z44.string().min(1),
+  configValues: z44.record(z44.string(), z44.string()),
+  apiUrl: z44.string().url(),
+  previewUrl: z44.string().url().optional()
+}).strict();
+var FinalizeAcquireRequestSchema = z44.object({
+  leaseToken: z44.string().min(1),
+  sessionId: z44.string().uuid(),
+  clientMutationId: z44.string().min(1).max(255).optional()
+}).strict();
+var AbortAcquireRequestSchema = z44.object({
+  leaseToken: z44.string().min(1),
+  sessionId: z44.string().uuid()
+}).strict();
+var WorkloadLifecycleKindSchema = z45.enum(["managed_agent", "self_managed"]);
+var WorkloadLifecycleConfigSchema = z45.object({
+  idleEnabled: z45.boolean().nullable(),
+  idleAfterSeconds: z45.number().int().min(300).max(86400).nullable(),
+  idleGraceSeconds: z45.number().int().min(60).max(3600).nullable(),
+  maxSessionLifetimeMs: z45.number().int().min(36e5).max(6048e5).nullable()
+}).strict();
+var WorkloadLifecycleConfigUpdateSchema = WorkloadLifecycleConfigSchema.partial().strict();
+var EffectiveWorkloadLifecycleConfigSchema = z45.object({
+  idleEnabled: z45.boolean(),
+  idleAfterSeconds: z45.number().int().min(300).max(86400),
+  idleGraceSeconds: z45.number().int().min(60).max(3600),
+  maxSessionLifetimeMs: z45.number().int().min(36e5).max(6048e5)
+}).strict();
+var WorkloadLifecycleConfigResponseSchema = z45.object({
+  workloadId: z45.string().uuid(),
+  kind: WorkloadLifecycleKindSchema,
+  config: WorkloadLifecycleConfigSchema,
+  effective: EffectiveWorkloadLifecycleConfigSchema
+}).strict();
+var UuidSchema = z46.string().uuid();
+var NonEmptyUuidArraySchema = z46.array(UuidSchema).min(1).max(200);
+var CleanupPrefixSchema = z46.string().trim().min(5).max(128).regex(
+  /^(?:e2e|tmp|test|cc)-[A-Za-z0-9][A-Za-z0-9._:-]*$/,
+  "prefix must start with an allowed cleanup namespace: e2e-, tmp-, test-, or cc-"
+);
+var SessionTerminateRequestSchema = z46.object({
+  reason: z46.string().trim().min(1).max(50).default("api"),
+  deadlineAt: z46.string().datetime().optional(),
+  requireNoActiveWork: z46.boolean().default(true)
+}).strict();
+var ResourceCleanupSelectorSchema = z46.object({
+  projectId: UuidSchema,
+  prefix: CleanupPrefixSchema.optional(),
+  workloadIds: NonEmptyUuidArraySchema.optional(),
+  runtimeTemplateIds: NonEmptyUuidArraySchema.optional(),
+  sessionIds: NonEmptyUuidArraySchema.optional()
+}).strict().superRefine((value, ctx) => {
+  var _a, _b, _c;
+  if (!value.prefix && !((_a = value.workloadIds) == null ? void 0 : _a.length) && !((_b = value.runtimeTemplateIds) == null ? void 0 : _b.length) && !((_c = value.sessionIds) == null ? void 0 : _c.length)) {
+    ctx.addIssue({
+      code: z46.ZodIssueCode.custom,
+      message: "cleanup selector must include prefix or explicit ids",
+      path: ["prefix"]
+    });
+  }
+});
+var ResourceCleanupPlanRequestSchema = z46.object({
+  selector: ResourceCleanupSelectorSchema
+}).strict();
+var ResourceCleanupExecuteRequestSchema = z46.object({
+  selector: ResourceCleanupSelectorSchema,
+  expectedCleanupId: z46.string().min(16).max(64),
+  confirm: z46.literal(true),
+  terminateActiveSessions: z46.boolean().default(true),
+  requireNoActiveWork: z46.boolean().default(true)
+}).strict();
+var ResourceCleanupResourceTypeSchema = z46.enum([
+  "agents_session_refs",
+  "runs_session_refs",
+  "session_pool_slots",
+  "session_pool_configs",
+  "worker_protocol_jobs",
+  "schedule_triggers",
+  "schedule_definitions",
+  "session_vault_bindings",
+  "session_config_values",
+  "session_tokens",
+  "session_events",
+  "session_startup_jobs",
+  "session_failure_reasons",
+  "startup_gate_conditions",
+  "runtime_bindings",
+  "sessions",
+  "revision_config_values",
+  "revisions",
+  "workloads",
+  "runtime_templates"
+]);
+var ResourceCleanupBlockerSchema = z46.object({
+  code: z46.string(),
+  resourceType: z46.string(),
+  resourceId: z46.string(),
+  message: z46.string()
+}).strict();
+var ResourceCleanupStepSchema = z46.object({
+  resourceType: ResourceCleanupResourceTypeSchema,
+  action: z46.enum(["delete", "update_null"]),
+  count: z46.number().int().nonnegative(),
+  ids: z46.array(z46.string())
+}).strict();
+var ResourceCleanupResourceIdsSchema = z46.object({
+  workloadIds: z46.array(UuidSchema),
+  runtimeTemplateIds: z46.array(UuidSchema),
+  revisionIds: z46.array(UuidSchema),
+  sessionIds: z46.array(UuidSchema),
+  runtimeBindingIds: z46.array(UuidSchema),
+  sessionPoolSlotIds: z46.array(UuidSchema),
+  sessionPoolConfigWorkloadIds: z46.array(UuidSchema),
+  scheduleDefinitionIds: z46.array(UuidSchema),
+  scheduleTriggerIds: z46.array(UuidSchema),
+  runSessionRefIds: z46.array(UuidSchema),
+  agentSessionRefIds: z46.array(UuidSchema),
+  workerProtocolJobIds: z46.array(UuidSchema)
+}).strict();
+var ResourceCleanupPlanSchema = z46.object({
+  cleanupId: z46.string(),
+  generatedAt: z46.string().datetime(),
+  selector: ResourceCleanupSelectorSchema,
+  resources: ResourceCleanupResourceIdsSchema,
+  counts: z46.record(ResourceCleanupResourceTypeSchema, z46.number().int().nonnegative()),
+  steps: z46.array(ResourceCleanupStepSchema),
+  blockers: z46.array(ResourceCleanupBlockerSchema)
+}).strict();
+var ResourceCleanupExecuteResultSchema = z46.object({
+  cleanupId: z46.string(),
+  deletedCounts: z46.record(ResourceCleanupResourceTypeSchema, z46.number().int().nonnegative()),
+  updatedCounts: z46.record(ResourceCleanupResourceTypeSchema, z46.number().int().nonnegative()),
+  terminatedSessions: z46.array(UuidSchema),
+  readback: ResourceCleanupPlanSchema
+}).strict();
+
+// src/errors.ts
+var PilotPlatformApiError = class extends Error {
+  constructor(options) {
+    super(options.message ?? `${options.code} (HTTP ${options.status})`, {
+      cause: options.cause
+    });
+    this.name = "PilotPlatformApiError";
+    this.status = options.status;
+    this.code = options.code;
+    this.requestId = options.requestId;
+  }
+};
+var PilotPlatformUnauthenticatedError = class extends PilotPlatformApiError {
+  constructor(options) {
+    super({ ...options, status: 401 });
+    this.name = "PilotPlatformUnauthenticatedError";
+  }
+};
+var PilotPlatformForbiddenError = class extends PilotPlatformApiError {
+  constructor(options) {
+    super({ ...options, status: 403 });
+    this.name = "PilotPlatformForbiddenError";
+  }
+};
+var PilotPlatformNotFoundError = class extends PilotPlatformApiError {
+  constructor(options) {
+    super({ ...options, status: 404 });
+    this.name = "PilotPlatformNotFoundError";
+  }
+};
+var PilotPlatformServerError = class extends PilotPlatformApiError {
+  constructor(options) {
+    super(options);
+    this.name = "PilotPlatformServerError";
+  }
+};
+function pilotPlatformErrorFromResponse(params) {
+  const parsed = extractErrorBody(params.body);
+  const code = parsed.code ?? defaultCodeForStatus(params.status);
+  const message = parsed.message ?? parsed.error;
+  const base = { code, message, requestId: params.requestId };
+  if (params.status === 401) return new PilotPlatformUnauthenticatedError(base);
+  if (params.status === 403) return new PilotPlatformForbiddenError(base);
+  if (params.status === 404) return new PilotPlatformNotFoundError(base);
+  if (params.status >= 500 && params.status < 600) {
+    return new PilotPlatformServerError({ ...base, status: params.status });
+  }
+  return new PilotPlatformApiError({ ...base, status: params.status });
+}
+function extractErrorBody(body) {
+  if (!body || typeof body !== "object") return {};
+  const record = body;
+  return {
+    error: typeof record.error === "string" ? record.error : void 0,
+    code: typeof record.code === "string" ? record.code : void 0,
+    message: typeof record.message === "string" ? record.message : void 0
+  };
+}
+function defaultCodeForStatus(status) {
+  if (status === 401) return "UNAUTHENTICATED";
+  if (status === 403) return "FORBIDDEN";
+  if (status === 404) return "NOT_FOUND";
+  if (status >= 500) return "SERVER_ERROR";
+  return "REQUEST_FAILED";
+}
+
+// src/resources/projects.ts
+var ProjectsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async create(request, options = {}) {
+    const body = CreatePlatformProjectRequestSchema.parse(request);
+    const response = await this.client.request("/api/projects", {
+      method: "POST",
+      body,
+      signal: options.signal
+    });
+    return PlatformProjectSchema.parse(response);
+  }
+  async list(options = {}) {
+    const response = await this.client.request("/api/projects", {
+      method: "GET",
+      signal: options.signal
+    });
+    return ListPlatformProjectsResponseSchema.parse(response).projects;
+  }
+  async get(projectId, options = {}) {
+    const response = await this.client.request(
+      `/api/projects/${encodeURIComponent(projectId)}`,
+      {
+        method: "GET",
+        signal: options.signal,
+        cache: "no-store"
+      }
+    );
+    return PlatformProjectSchema.parse(response);
+  }
+};
+
+// src/resources/sessions.ts
+var SessionsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async create(request, options = {}) {
+    const body = CreatePlatformSessionRequestSchema.parse(request);
+    const envelope = await this.client.request("/api/sessions", {
+      method: "POST",
+      body,
+      signal: options.signal
+    });
+    return CreatePlatformSessionResponseSchema.parse(envelope?.data);
+  }
+  async get(sessionId, options = {}) {
+    const envelope = await this.client.request(
+      `/api/sessions/${encodeURIComponent(sessionId)}`,
+      {
+        method: "GET",
+        signal: options.signal,
+        cache: "no-store",
+        headers: {
+          "Cache-Control": "no-cache",
+          Pragma: "no-cache"
+        }
+      }
+    );
+    if (!envelope?.data || typeof envelope.data !== "object") {
+      throw new PilotPlatformApiError({
+        status: 0,
+        code: "MALFORMED_SESSION_RESPONSE",
+        message: "GET /api/sessions/:id did not return a {data: ...} envelope."
+      });
+    }
+    return envelope.data;
+  }
+  async wait(sessionId, options = {}) {
+    const intervalMs = options.intervalMs ?? 1e3;
+    const timeoutMs = options.timeoutMs ?? 12e4;
+    const startedAt = Date.now();
+    while (true) {
+      if (options.signal?.aborted) throw options.signal.reason;
+      const snapshot = await this.get(sessionId, { signal: options.signal });
+      const status = snapshot.session?.status;
+      if (status === "ready") return snapshot;
+      if (status === "failed") {
+        throw new PilotPlatformApiError({
+          status: 0,
+          code: "SESSION_FAILED",
+          message: `Session ${sessionId} failed while waiting for readiness.`
+        });
+      }
+      if (Date.now() - startedAt >= timeoutMs) {
+        throw new PilotPlatformApiError({
+          status: 0,
+          code: "SESSION_WAIT_TIMEOUT",
+          message: `Timed out waiting for session ${sessionId} to become ready.`
+        });
+      }
+      await sleep(intervalMs, options.signal);
+    }
+  }
+};
+function sleep(ms, signal) {
+  if (ms <= 0) return Promise.resolve();
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(resolve, ms);
+    signal?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timer);
+        reject(signal.reason);
+      },
+      { once: true }
+    );
+  });
+}
+
+// src/resources/workloads.ts
+var WorkloadsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async create(request, options = {}) {
+    const body = CreatePlatformWorkloadRequestSchema.parse(request);
+    const envelope = await this.client.request("/api/workloads", {
+      method: "POST",
+      body,
+      signal: options.signal,
+      query: options.dryRun ? { dryRun: true } : void 0
+    });
+    return unwrapEnvelope(envelope, "POST /api/workloads", ["status", "workload"]);
+  }
+  async publishRevision(request, options = {}) {
+    const body = PublishPlatformRevisionRequestSchema.parse(request);
+    const path = `/api/workloads/${encodeURIComponent(body.workloadSlug)}/revisions`;
+    const envelope = await this.client.request(path, {
+      method: "POST",
+      body,
+      signal: options.signal,
+      query: options.dryRun ? { dryRun: true } : void 0
+    });
+    return unwrapEnvelope(envelope, `POST ${path}`, [
+      "status",
+      "workloadId",
+      "runtimeTemplateId",
+      "resolved"
+    ]);
+  }
+  async applyManifest(options) {
+    const envelope = await this.client.request(
+      "/api/workloads",
+      buildManifestRequest(options.manifest, options)
+    );
+    return unwrapEnvelope(envelope, "POST /api/workloads", ["status", "workload"]);
+  }
+  async applyRevisionManifest(options) {
+    const path = `/api/workloads/${encodeURIComponent(options.workloadSlug)}/revisions`;
+    const envelope = await this.client.request(
+      path,
+      buildManifestRequest(options.manifest, options)
+    );
+    return unwrapEnvelope(envelope, `POST ${path}`, [
+      "status",
+      "workloadId",
+      "runtimeTemplateId",
+      "resolved"
+    ]);
+  }
+};
+function buildManifestRequest(manifest, options) {
+  const init = {
+    method: "POST",
+    signal: options.signal,
+    query: {
+      projectId: options.projectId,
+      ...options.dryRun ? { dryRun: true } : {}
+    }
+  };
+  if (isYamlInput(manifest)) {
+    init.rawBody = manifest.yaml;
+    init.headers = { "Content-Type": "application/yaml" };
+  } else if (isJsonStringInput(manifest)) {
+    init.rawBody = manifest.json;
+    init.headers = { "Content-Type": "application/json" };
+  } else {
+    init.body = manifest;
+  }
+  return init;
+}
+function isYamlInput(value) {
+  return typeof value === "object" && value !== null && "yaml" in value && typeof value.yaml === "string";
+}
+function isJsonStringInput(value) {
+  return typeof value === "object" && value !== null && "json" in value && typeof value.json === "string";
+}
+function unwrapEnvelope(envelope, routeLabel, requiredKeys) {
+  const data = envelope?.data;
+  if (!data) {
+    throw new PilotPlatformApiError({
+      status: 0,
+      code: "MALFORMED_PLATFORM_RESPONSE",
+      message: `${routeLabel} did not return a {data: ...} envelope.`
+    });
+  }
+  for (const key of requiredKeys) {
+    if (!(key in data)) {
+      throw new PilotPlatformApiError({
+        status: 0,
+        code: "MALFORMED_PLATFORM_RESPONSE",
+        message: `${routeLabel} response is missing required field '${String(key)}'.`
+      });
+    }
+  }
+  return data;
+}
+
+// src/client.ts
+var AGENTHUB_SDK_USER_AGENT = "@kanyun-ai-infra/agenthub/0.1.0";
+var _token;
+var PilotPlatformClient = class {
+  constructor(config = {}) {
+    __privateAdd(this, _token);
+    const controlPlaneUrl = config.controlPlaneUrl ?? readEnv("PILOT_CONTROL_PLANE_URL") ?? readEnv("KANYUN_PILOT_CONTROL_PLANE_URL");
+    const token = config.token ?? readEnv("PILOT_TOKEN");
+    if (!controlPlaneUrl) {
+      throw new PilotPlatformApiError({
+        status: 0,
+        code: "CONFIG_MISSING_CONTROL_PLANE_URL",
+        message: "PilotPlatformClient requires `controlPlaneUrl` or PILOT_CONTROL_PLANE_URL."
+      });
+    }
+    if (!token) {
+      throw new PilotPlatformUnauthenticatedError({
+        code: "CONFIG_MISSING_TOKEN",
+        message: "PilotPlatformClient requires `token` or PILOT_TOKEN."
+      });
+    }
+    const normalizedControlPlaneUrl = stripTrailingSlash(controlPlaneUrl);
+    try {
+      const parsed = new URL(normalizedControlPlaneUrl);
+      if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new Error(`Unsupported protocol: ${parsed.protocol}`);
+      }
+    } catch (error) {
+      throw new PilotPlatformApiError({
+        status: 0,
+        code: "CONFIG_INVALID_CONTROL_PLANE_URL",
+        message: `controlPlaneUrl is not a valid http(s) URL: ${controlPlaneUrl}`,
+        cause: error
+      });
+    }
+    this.controlPlaneUrl = normalizedControlPlaneUrl;
+    __privateSet(this, _token, token);
+    this.fetchImpl = config.fetch ?? globalThis.fetch.bind(globalThis);
+    this.defaultHeaders = { ...config.defaultHeaders ?? {} };
+    this.defaultSignal = config.signal;
+    this.userAgent = config.userAgent ?? AGENTHUB_SDK_USER_AGENT;
+    this.pilotApiVersion = config.pilotApiVersion ?? "v2";
+    this.projects = new ProjectsResource(this);
+    this.workloads = new WorkloadsResource(this);
+    this.sessions = new SessionsResource(this);
+  }
+  async request(path, init = {}) {
+    const res = await this.rawRequest(path, init);
+    if (init.raw) return res;
+    const text = await res.text();
+    if (!text) return void 0;
+    try {
+      return JSON.parse(text);
+    } catch (error) {
+      throw new PilotPlatformApiError({
+        status: res.status,
+        code: "INVALID_JSON_RESPONSE",
+        message: `Control Plane returned non-JSON body: ${text.slice(0, 200)}`,
+        requestId: res.headers.get("x-request-id") ?? void 0,
+        cause: error
+      });
+    }
+  }
+  async rawRequest(path, init = {}) {
+    if (init.rawBody !== void 0 && init.body !== void 0) {
+      throw new PilotPlatformApiError({
+        status: 0,
+        code: "INVALID_REQUEST_BODY",
+        message: "body and rawBody are mutually exclusive."
+      });
+    }
+    const headers = new Headers();
+    addHeaders(headers, { Accept: "application/json", "User-Agent": this.userAgent });
+    addHeaders(headers, this.defaultHeaders);
+    addHeaders(headers, init.headers);
+    headers.delete("authorization");
+    headers.set("Authorization", `Bearer ${__privateGet(this, _token)}`);
+    headers.set(X_PILOT_API_VERSION_HEADER, this.pilotApiVersion);
+    let body;
+    if (init.rawBody !== void 0) {
+      body = init.rawBody;
+    } else if (init.body !== void 0) {
+      body = JSON.stringify(init.body);
+      headers.set("Content-Type", "application/json");
+    }
+    let res;
+    const url = this.composeUrl(path, init.query);
+    try {
+      res = await this.fetchImpl(url, {
+        method: init.method ?? "GET",
+        headers,
+        body,
+        signal: mergeSignals(this.defaultSignal, init.signal),
+        cache: init.cache
+      });
+    } catch (error) {
+      if (isAbortError(error)) throw error;
+      throw new PilotPlatformApiError({
+        status: 0,
+        code: "NETWORK_ERROR",
+        message: `Request to ${url} failed: ${error?.message ?? String(error)}`,
+        cause: error
+      });
+    }
+    if (res.ok) return res;
+    const text = await res.text();
+    let parsed = void 0;
+    if (text) {
+      try {
+        parsed = JSON.parse(text);
+      } catch {
+        parsed = { error: text };
+      }
+    }
+    throw pilotPlatformErrorFromResponse({
+      status: res.status,
+      body: parsed,
+      requestId: res.headers.get("x-request-id") ?? void 0
+    });
+  }
+  composeUrl(path, query) {
+    const base = new URL(`${this.controlPlaneUrl}/`);
+    const normalized = path.startsWith("//") || /^[a-z][a-z0-9+.-]*:/i.test(path) ? path : path.startsWith("/") ? path : `/${path}`;
+    let full;
+    try {
+      full = new URL(normalized, base);
+    } catch (error) {
+      throw new PilotPlatformApiError({
+        status: 0,
+        code: "INVALID_REQUEST_URL",
+        message: `Could not resolve path "${path}" against controlPlaneUrl.`,
+        cause: error
+      });
+    }
+    if (full.origin !== base.origin) {
+      throw new PilotPlatformApiError({
+        status: 0,
+        code: "CROSS_ORIGIN_REQUEST_BLOCKED",
+        message: `Refusing to send Bearer token to foreign origin ${full.origin}.`
+      });
+    }
+    if (query) {
+      for (const [key, value] of Object.entries(query)) {
+        if (value === void 0 || value === null) continue;
+        full.searchParams.set(key, String(value));
+      }
+    }
+    return full.toString();
+  }
+};
+_token = new WeakMap();
+function stripTrailingSlash(url) {
+  return url.endsWith("/") ? url.slice(0, -1) : url;
+}
+function addHeaders(target, source) {
+  if (!source) return;
+  for (const [key, value] of Object.entries(source)) {
+    if (value === void 0 || value === null) continue;
+    target.set(key, value);
+  }
+}
+function readEnv(key) {
+  const env = globalThis.process?.env;
+  const value = env?.[key];
+  return value && value.length > 0 ? value : void 0;
+}
+function isAbortError(error) {
+  return error instanceof Error && (error.name === "AbortError" || error.code === "ABORT_ERR");
+}
+function mergeSignals(...signals) {
+  const active = signals.filter((signal) => !!signal);
+  if (active.length === 0) return void 0;
+  if (active.length === 1) return active[0];
+  const anyFn = AbortSignal.any;
+  if (typeof anyFn === "function") return anyFn(active);
+  const controller = new AbortController();
+  for (const signal of active) {
+    if (signal.aborted) {
+      controller.abort(signal.reason);
+      break;
+    }
+    signal.addEventListener("abort", () => controller.abort(signal.reason), { once: true });
+  }
+  return controller.signal;
+}
+export {
+  AGENTHUB_SDK_USER_AGENT,
+  CreatePlatformProjectRequestSchema,
+  CreatePlatformSessionRequestSchema,
+  CreatePlatformSessionResponseSchema,
+  CreatePlatformWorkloadRequestSchema,
+  ListPlatformProjectsResponseSchema,
+  PILOT_WORKLOAD_MANIFEST_API_VERSION,
+  PILOT_WORKLOAD_MANIFEST_LEGACY_API_VERSION,
+  PilotPlatformApiError,
+  PilotPlatformClient,
+  PilotPlatformForbiddenError,
+  PilotPlatformNotFoundError,
+  PilotPlatformServerError,
+  PilotPlatformUnauthenticatedError,
+  PlatformProjectSchema,
+  PlatformRevisionSchema,
+  PlatformWorkloadSchema,
+  ProjectsResource,
+  PublishPlatformRevisionRequestSchema,
+  SessionsResource,
+  WorkloadsResource,
+  pilotPlatformErrorFromResponse,
+  platformRevisionPublishToManifest,
+  platformWorkloadCreateToManifest
+};
+//# sourceMappingURL=index.js.map