@kanyun-ai-infra/agenthub 1.5.2 → 1.7.0

package/dist/index.cjs

@@ -107,10 +107,20 @@ __export(index_exports, {
   SessionFileResourceSchema: () => SessionFileResourceSchema,
   SessionMemorySubjectDeclarationSchema: () => SessionMemorySubjectDeclarationSchema,
   SessionResourcesSchema: () => SessionResourcesSchema,
+  SessionTurnsResource: () => SessionTurnsResource,
   SessionsResource: () => SessionsResource,
   StageSchema: () => StageSchema,
   StageSlotViewSchema: () => StageSlotViewSchema,
   StoredMemorySubjectPolicySchema: () => StoredMemorySubjectPolicySchema,
+  TERMINAL_TURN_STATUSES: () => TERMINAL_TURN_STATUSES,
+  TURN_LIST_DEFAULT_LIMIT: () => TURN_LIST_DEFAULT_LIMIT,
+  TURN_LIST_MAX_LIMIT: () => TURN_LIST_MAX_LIMIT,
+  TurnAssistantPartSchema: () => TurnAssistantPartSchema,
+  TurnKindSchema: () => TurnKindSchema,
+  TurnListQuerySchema: () => TurnListQuerySchema,
+  TurnListResponseDataSchema: () => TurnListResponseDataSchema,
+  TurnSchema: () => TurnSchema,
+  TurnStatusSchema: () => TurnStatusSchema,
   UpdateEnvironmentInputSchema: () => UpdateEnvironmentInputSchema,
   WorkbenchDTOSchema: () => WorkbenchDTOSchema,
   WorkloadStageCanaryResource: () => WorkloadStageCanaryResource,
@@ -120,9 +130,12 @@ __export(index_exports, {
   WriteMemoriesRequestSchema: () => WriteMemoriesRequestSchema,
   WriteMemoriesResultSchema: () => WriteMemoriesResultSchema,
   WriteMemoryItemSchema: () => WriteMemoryItemSchema,
+  isTerminalTurnStatus: () => isTerminalTurnStatus,
   pilotPlatformErrorFromResponse: () => pilotPlatformErrorFromResponse,
   platformRevisionPublishToManifest: () => platformRevisionPublishToManifest,
-  platformWorkloadCreateToManifest: () => platformWorkloadCreateToManifest
+  platformWorkloadCreateToManifest: () => platformWorkloadCreateToManifest,
+  toUIMessages: () => toUIMessages,
+  turnMessageIds: () => turnMessageIds
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -219,6 +232,8 @@ var import_zod68 = require("zod");
 var import_zod69 = require("zod");
 var import_zod70 = require("zod");
 var import_zod71 = require("zod");
+var import_zod72 = require("zod");
+var import_zod73 = require("zod");
 var MODELGATE_VENDOR_TYPES = [
   "anthropic",
   "openai",
@@ -4920,9 +4935,18 @@ var DeliveryResultArtifactItemSchema = import_zod42.z.object({
   /** Artifact category. Workers MAY add new kinds; storage is opaque. */
   kind: import_zod42.z.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`.
+   * Logical path inside the sandbox workspace, and the idempotency key of
+   * the artifact row: `(runId, path)` on the run plane, `(sessionId, path)`
+   * on the session plane. Two writes with the same pair collapse to a single
+   * row — the run plane keeps the first (`ON CONFLICT DO NOTHING`), the
+   * session plane keeps the newest bytes and moves `turn_id` to the newest
+   * ATTRIBUTED writer (`ON CONFLICT DO UPDATE`, T-INV-5).
+   *
+   * Two items with the SAME path inside one request body are legal wire but
+   * a single artifact: the session plane de-duplicates them before the
+   * insert, last one wins, and `artifactsInserted` counts the de-duplicated
+   * items. Not a 400 — see `turnId` below on why an artifact-shaped problem
+   * must not be the reason a delivery result is lost.
    */
   path: import_zod42.z.string().min(1).max(1024),
   /** Object key inside the OSS bucket where the artifact was uploaded. */
@@ -4940,6 +4964,26 @@ var DeliveryResultArtifactItemSchema = import_zod42.z.object({
   contentType: import_zod42.z.string().min(1).max(255)
 }).strict();
 var DeliveryResultUpdateSchema = import_zod42.z.object({
+  /**
+   * The turn this delivery result belongs to — `ctx.turnId` on the worker
+   * side (`deriveWorkerTurnId`, uuid v5). Drives `artifacts.turn_id`; see
+   * `specs/features/pilot-v2-session-turns.md` §Projection 6.
+   *
+   * Optional through the migration window: a sandbox image predating P2
+   * omits it, and the control plane then INFERS the turn and records an
+   * anomaly rather than rejecting the write. Delivery attribution must not
+   * become a reason a delivery fails — which is also why an id that names no
+   * turn of THIS session degrades to the same inference (plus a warn log and
+   * the anomaly naming the rejected id) instead of failing the request. The
+   * id is still never honoured across sessions: `artifacts.turn_id` has no
+   * foreign key, so a foreign id would attach these artifacts to a turn
+   * another session's `GET /turns` serves.
+   *
+   * Deliberately NOT part of the `.refine()` below: it qualifies the other
+   * fields rather than mutating anything, so a body carrying only `turnId`
+   * is still the empty request it looks like, and still a 400.
+   */
+  turnId: import_zod42.z.string().uuid().optional(),
   /**
    * The PR / MR URL the agent created. First-write-wins per spec
    * (`UPDATE ... WHERE pull_request_url IS NULL`); subsequent writes
@@ -4948,10 +4992,11 @@ var DeliveryResultUpdateSchema = import_zod42.z.object({
    */
   pullRequestUrl: import_zod42.z.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.
+   * Append-set of artifacts uploaded for this run. Each item is upserted
+   * independently via the `unique(run_id, path)` / `unique(session_id, path)`
+   * constraint; the response indicates how many of the submitted items
+   * resulted in a new row. Items are keyed by `path` — see the field's own
+   * doc for what a repeated path inside one body means.
    */
   artifacts: import_zod42.z.array(DeliveryResultArtifactItemSchema).max(64).optional(),
   /**
@@ -5172,7 +5217,45 @@ var WorkerProtocolFailedPayloadSchema = import_zod44.z.object({
 }).strict().refine((p) => p.reason !== "wp_aborted_by_signal" || p.abortContext !== void 0, {
   message: "abortContext required when reason = wp_aborted_by_signal"
 });
+var TurnUsageSchema = import_zod44.z.object({
+  /** Whether the provider reported any token counts for this turn. */
+  usageSource: import_zod44.z.enum(["provider", "missing"]),
+  /** Prompt tokens, cache reads/writes included. */
+  inputTokens: import_zod44.z.number().int().nonnegative().optional(),
+  outputTokens: import_zod44.z.number().int().nonnegative().optional(),
+  /** `inputTokens + outputTokens`. */
+  totalTokens: import_zod44.z.number().int().nonnegative().optional(),
+  /** Breakdown of `inputTokens` — cached prompt tokens read back. */
+  cacheReadInputTokens: import_zod44.z.number().int().nonnegative().optional(),
+  /** Breakdown of `inputTokens` — prompt tokens written into the cache. */
+  cacheWriteInputTokens: import_zod44.z.number().int().nonnegative().optional(),
+  /** Provider-stream duration; see the timing note above. */
+  durationMs: import_zod44.z.number().int().nonnegative().optional(),
+  timeToFirstTokenMs: import_zod44.z.number().int().nonnegative().optional(),
+  /** AI SDK `finishReason` of the last step ("stop" / "tool-calls" / …). */
+  finishReason: import_zod44.z.string().min(1).optional(),
+  /** Absent whenever `usageSource === "missing"`. */
+  costUsd: import_zod44.z.number().nonnegative().optional(),
+  /** Which upstream reported `costUsd`; paired with it, absent without it. */
+  costSource: import_zod44.z.literal("claude_code_cli").optional(),
+  /** Provider steps observed in the turn — 2 after a mid-turn stream resume. */
+  stepCount: import_zod44.z.number().int().nonnegative().optional()
+});
 var WorkerProtocolCompletedPayloadSchema = import_zod44.z.record(import_zod44.z.string(), import_zod44.z.unknown());
+var SessionUsageSummarySchema = import_zod44.z.object({
+  turnsWithUsage: import_zod44.z.number().int().nonnegative(),
+  turnsMissingUsage: import_zod44.z.number().int().nonnegative(),
+  inputTokens: import_zod44.z.number().int().nonnegative(),
+  outputTokens: import_zod44.z.number().int().nonnegative(),
+  totalTokens: import_zod44.z.number().int().nonnegative(),
+  cacheReadInputTokens: import_zod44.z.number().int().nonnegative(),
+  cacheWriteInputTokens: import_zod44.z.number().int().nonnegative(),
+  /** `null` when no contributing turn reported a cost. */
+  costUsd: import_zod44.z.number().nonnegative().nullable(),
+  costSource: import_zod44.z.literal("claude_code_cli").nullable(),
+  /** ISO timestamp of the latest completed turn that contributed usage. */
+  lastUpdatedAt: import_zod44.z.string().nullable()
+});
 var EVENT_TYPE_REGEX = /^([a-z][a-z0-9_]*)\.([a-z][a-z0-9_]*(?:\.[a-z][a-z0-9_]*)?)$/;
 var EventTypeSchema = import_zod43.z.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 = [
@@ -5599,7 +5682,28 @@ var RecordWorkspaceSnapshotRequestSchema = import_zod50.z.object({
    * parts may be null ("nothing to restore" — a valid no-op snapshot, NOT
    * a failure, per 已定方案 决策②).
    */
-  snapshot: WorkspaceSnapshotSchema
+  snapshot: WorkspaceSnapshotSchema,
+  /**
+   * The turn whose end produced this snapshot (`ctx.turnId`, uuid v5 from
+   * `deriveWorkerTurnId`). The control plane stamps
+   * `session_turns.workspace_snapshot_captured_at` on that row; the stored
+   * snapshot JSON and its session-level latest-wins semantics are unchanged.
+   *
+   * **It lives on the ENVELOPE, not inside `snapshot`** (T-INV-6).
+   * `WorkspaceSnapshotSchema` is `.strict()` and is re-used verbatim as
+   * `PodAgentStartWorkerRequestSchema.workspaceSnapshot`, which travels
+   * control-plane → pod-agent: a key added there makes every pod-agent
+   * older than the change reject `POST /pilot/worker/start`. The contract
+   * test in `__tests__/pilot-v2-workspace-snapshot.test.ts` pins this.
+   *
+   * Optional for one migration window. This envelope is `.strict()`, so a
+   * worker that sends `turnId` to a control plane predating this field gets
+   * a 400 and loses the snapshot entirely — **control-plane and agent-hub
+   * MUST ship before the sandbox image**. Until the window closes the
+   * control plane infers the turn (most recent completed one) when it is
+   * absent; after it, this becomes required.
+   */
+  turnId: import_zod50.z.string().uuid().optional()
 }).strict();
 var RecordWorkspaceSnapshotResponseSchema = import_zod50.z.object({
   success: import_zod50.z.literal(true),
@@ -5632,44 +5736,54 @@ var WorkspaceExportPartSchema = WorkspaceSnapshotPartSchema.extend({
 var WorkspaceExportDataSchema = import_zod50.z.object({
   version: import_zod50.z.literal("v1"),
   /**
-   * Opaque monotonic cursor identifying this capture. **Not a turn ordinal**
+   * **Internal ordering cursor. Prefer {@link WorkspaceExportDataSchema.shape.turnId}.**
+   *
+   * Opaque monotonic value identifying this capture. **Not a turn ordinal**
    * despite the name: the capture side sets it to `capturedAt.getTime()`
    * (epoch milliseconds, sandbox clock). The name is fixed by the stored
    * `WorkspaceSnapshot` envelope. Never render it as "turn N".
    *
-   * Its one job for a caller is deciding **whether the snapshot is this turn's
-   * or the previous turn's**. The worker emits the turn's terminal event
-   * BEFORE it captures and uploads, so an export issued the moment a turn
-   * completes races the capture: it returns either 404 or the PRIOR turn's
-   * snapshot. Compare against `completedAt` from the terminal event payload —
-   * both come from the same in-sandbox clock, and the capture is ordered after
-   * the terminal append — and poll until
-   * `capturedAtTurn >= Date.parse(completedAt)`, with a bounded timeout.
-   *
-   * **`>=`, not `>`.** The two readings are `ctx.now()` calls in one process
-   * separated by a single `await`, at millisecond resolution, so they can land
-   * on the SAME millisecond. Under a strict `>` that turn's own snapshot never
-   * satisfies the test, and the caller polls out the timeout and concludes "no
-   * files" for a turn that did produce them — a wrong answer that looks like a
-   * normal one.
-   *
-   * `>=` cannot admit the previous turn's snapshot: that capture happens in the
-   * tail of turn N-1, before turn N is dispatched at all, so it precedes turn
-   * N's `completedAt` by a whole turn (turns are serial per session — a second
-   * concurrent turn is refused with `SESSION_TURN_IN_PROGRESS`). Equality is
-   * only reachable within one turn, between its own terminal and its own
-   * capture.
-   *
-   * Residual limit, deliberately not papered over: if the sandbox clock steps
-   * BACKWARDS between the terminal append and the capture (NTP correction),
-   * `capturedAtTurn` lands before `completedAt` and neither `>` nor `>=`
-   * accepts it. The poll then times out, and the caller cannot distinguish that
-   * from "nothing was produced". Anchoring the snapshot to a turn identity
-   * rather than a timestamp is the real fix — see the spec's follow-ups.
+   * Its remaining job is the platform's own latest-wins comparison on the
+   * recording path. The freshness question it used to answer for callers —
+   * "is this snapshot my turn's or the previous turn's?" — is now answered
+   * directly by `turnId`: compare it against the turn you dispatched instead
+   * of comparing timestamps. The old recipe (poll until
+   * `capturedAtTurn >= Date.parse(completedAt)`, `>=` and not `>` because the
+   * two `ctx.now()` readings can land on the same millisecond) still works and
+   * is the only option against a sandbox image predating P2, but it carries a
+   * failure mode `turnId` does not: a BACKWARD sandbox clock step (NTP
+   * correction) between the terminal append and the capture puts
+   * `capturedAtTurn` before `completedAt`, and neither `>` nor `>=` accepts
+   * it — the poll then times out and looks exactly like "nothing was
+   * produced".
+   *
+   * The race itself is unchanged either way: the worker emits the turn's
+   * terminal event BEFORE it captures and uploads, so an export issued the
+   * moment a turn completes returns either 404 or the PRIOR turn's snapshot.
+   * Poll with a bounded timeout; with `turnId` the predicate is equality
+   * against your own turn, so there is nothing to reason about clocks.
    */
   capturedAtTurn: import_zod50.z.number().int().nonnegative(),
   /** ISO-8601 capture time — the field to show a human. */
   capturedAt: import_zod50.z.string().min(1),
+  /**
+   * The turn whose end produced this snapshot, when the platform knows it.
+   * This is the field a caller polls on: the export is this turn's iff
+   * `turnId` equals the turn id it dispatched — no clock comparison, and
+   * immune to the backward-clock-step hole in `capturedAtTurn`.
+   *
+   * Absent (or attributed to an earlier turn than you expect) in three cases,
+   * all of which mean "not yours yet", not "broken":
+   *   1. the snapshot was recorded by a sandbox image predating the envelope
+   *      `turnId` — the platform then attributes it to the most recent
+   *      completed turn and flags the inference;
+   *   2. the turn's projection had not materialized its `session_turns` row
+   *      when the snapshot landed, so there was no row to stamp;
+   *   3. the session predates this field entirely.
+   * Keep the `capturedAtTurn` fallback for those; do not treat a missing
+   * `turnId` as an error.
+   */
+  turnId: import_zod50.z.string().uuid().nullable().optional(),
   parts: import_zod50.z.object({
     repoBundle: WorkspaceExportPartSchema.nullable(),
     externalArchive: WorkspaceExportPartSchema.nullable()
@@ -7358,17 +7472,301 @@ var SessionTurnRequestSchema = import_zod57.z.object({
 }).strict();
 var SessionTurnDispatchedResponseSchema = import_zod57.z.object({
   success: import_zod57.z.literal(true),
-  data: import_zod57.z.object({ outcome: DispatchOutcomeSchema })
+  data: import_zod57.z.object({
+    outcome: DispatchOutcomeSchema,
+    turn: import_zod57.z.object({
+      turnId: import_zod57.z.string().min(1),
+      status: import_zod57.z.literal("dispatched")
+    }).optional()
+  })
 });
 var SessionTurnRevivalResponseSchema = import_zod57.z.object({
   success: import_zod57.z.literal(false),
   revivalInProgress: import_zod57.z.literal(true),
   sessionId: import_zod57.z.string(),
   attemptId: import_zod57.z.string(),
-  alreadyReviving: import_zod57.z.boolean().optional(),
   turnId: import_zod57.z.string().optional()
 });
-var GatewayErrorCodeSchema = import_zod58.z.enum([
+var TurnStatusSchema = import_zod58.z.enum([
+  "dispatched",
+  "running",
+  "completed",
+  "failed",
+  "rejected",
+  "aborted",
+  "interrupted"
+]);
+var TERMINAL_TURN_STATUSES = [
+  "completed",
+  "failed",
+  "rejected",
+  "aborted",
+  "interrupted"
+];
+function isTerminalTurnStatus(status) {
+  return TERMINAL_TURN_STATUSES.includes(status);
+}
+var TurnKindSchema = import_zod58.z.enum(["prompt", "followup"]);
+var TurnPhaseSchema = import_zod58.z.enum(["generating", "delivering"]);
+var AssistantMessageStateSchema = import_zod58.z.enum(["streaming", "complete", "truncated"]);
+var DeliveryStateSchema = import_zod58.z.enum([
+  "not_started",
+  "in_progress",
+  "completed",
+  "failed",
+  "interrupted"
+]);
+var ArtifactBundleStateSchema = import_zod58.z.enum([
+  "collecting",
+  "available",
+  "superseded_by_retry",
+  "rejected"
+]);
+var DELIVERY_PROGRESS_STEPS = ["git_push", "create_mr", "upload_artifact"];
+var DeliveryProgressStepSchema = import_zod58.z.enum(DELIVERY_PROGRESS_STEPS);
+var TurnAnomalySchema = import_zod58.z.object({
+  code: import_zod58.z.string().min(1),
+  /** `session_events.id` of the row that triggered it, when there is one. */
+  eventId: import_zod58.z.string().optional(),
+  detail: import_zod58.z.string().optional()
+});
+var TurnAssistantPartStateSchema = import_zod58.z.enum(["streaming", "done"]);
+var TurnToolPartStateSchema = import_zod58.z.enum([
+  "input-streaming",
+  "input-available",
+  "output-available",
+  "output-error"
+]);
+var TurnAssistantTextPartSchema = import_zod58.z.object({
+  type: import_zod58.z.literal("text"),
+  text: import_zod58.z.string(),
+  state: TurnAssistantPartStateSchema.optional()
+});
+var TurnAssistantReasoningPartSchema = import_zod58.z.object({
+  type: import_zod58.z.literal("reasoning"),
+  text: import_zod58.z.string(),
+  state: TurnAssistantPartStateSchema.optional()
+});
+var TurnAssistantToolPartSchema = import_zod58.z.object({
+  type: import_zod58.z.literal("dynamic-tool"),
+  toolName: import_zod58.z.string(),
+  toolCallId: import_zod58.z.string(),
+  state: TurnToolPartStateSchema,
+  input: import_zod58.z.unknown().optional(),
+  output: import_zod58.z.unknown().optional(),
+  errorText: import_zod58.z.string().optional()
+});
+var TurnAssistantStepPartSchema = import_zod58.z.object({
+  type: import_zod58.z.literal("step-start")
+});
+var TurnAssistantPartSchema = import_zod58.z.discriminatedUnion("type", [
+  TurnAssistantTextPartSchema,
+  TurnAssistantReasoningPartSchema,
+  TurnAssistantToolPartSchema,
+  TurnAssistantStepPartSchema
+]);
+var TurnUserMessageSchema = import_zod58.z.object({
+  messageId: import_zod58.z.string(),
+  text: import_zod58.z.string(),
+  attachments: import_zod58.z.array(AttachmentMetaSchema),
+  createdAt: import_zod58.z.string()
+});
+var TurnAssistantMessageSchema = import_zod58.z.object({
+  messageId: import_zod58.z.string(),
+  state: AssistantMessageStateSchema,
+  parts: import_zod58.z.array(TurnAssistantPartSchema),
+  /** Chunks the fold could not interpret. Non-zero means data loss. */
+  droppedChunks: import_zod58.z.number().int().nonnegative(),
+  /**
+   * `retained` marks an assistant message whose source chunks were deleted by
+   * the event retention sweep: this row IS the record now, and a projection
+   * re-run may add to it but must never blank it (T-INV-9).
+   */
+  source: import_zod58.z.literal("retained").optional()
+});
+var TurnDeliverySchema = import_zod58.z.object({
+  state: DeliveryStateSchema,
+  /** Last observed wire step; `z.string()` so an unknown value still reads. */
+  step: import_zod58.z.string().optional(),
+  attempts: import_zod58.z.number().int().nonnegative(),
+  pullRequestUrl: import_zod58.z.string().optional(),
+  failedReason: import_zod58.z.string().optional(),
+  failedAt: import_zod58.z.string().optional()
+});
+var TurnArtifactBundleSchema = import_zod58.z.object({
+  /** Absent for a `rejected` bundle — nothing was uploaded, so there is no row. */
+  artifactId: import_zod58.z.string().optional(),
+  state: ArtifactBundleStateSchema,
+  /**
+   * MUST STAY A PLAIN `number` — widening it to `.nullable()` is a wire break,
+   * not an additive change. `@kanyun-ai-infra/agenthub` bundles contracts into
+   * its published artifact (`noExternal: ["@pilot/contracts"]`), so SDK 1.6.0
+   * carries a FROZEN copy of this schema with `entryCount` a required number.
+   * Old readers tolerate keys they have never heard of (every envelope on the
+   * turn read path is a non-strict `z.object`, which strips them) but not a
+   * value outside the type they froze: a `null` here makes 1.6.0's
+   * `sessions.turns.get` / `.list` throw `MALFORMED_PLATFORM_RESPONSE` for
+   * every turn that has any artifact row at all.
+   *
+   * So "not counted" travels as `0` plus {@link entryCountKnown} `false`
+   * rather than as `null`. The real count lives in the manifest inside the zip
+   * in object storage, and the read path that produces a `Turn` does not fan
+   * out to object storage to get it; to see the actual entries, follow
+   * `TurnArtifacts.incrementalHref` / `cumulativeHref` on the parent object.
+   */
+  entryCount: import_zod58.z.number().int().nonnegative(),
+  /**
+   * Is {@link entryCount} a measurement? Absent or `false` means it is not —
+   * the `0` above is a placeholder, NOT an empty bundle. Optional so the key
+   * itself is additive: a reader frozen before it existed drops it and still
+   * parses, and one that has it must treat "absent" as "unknown" too, because
+   * that is exactly what a pre-P2 control plane sends.
+   *
+   * `true` is reserved for a build that really counts the manifest entries.
+   * Nothing sets it today.
+   */
+  entryCountKnown: import_zod58.z.boolean().optional(),
+  createdAt: import_zod58.z.string(),
+  reason: import_zod58.z.string().optional()
+});
+var TurnArtifactsSchema = import_zod58.z.object({
+  bundles: import_zod58.z.array(TurnArtifactBundleSchema),
+  incrementalHref: import_zod58.z.string(),
+  cumulativeHref: import_zod58.z.string()
+});
+var TurnStatusReasonSchema = import_zod58.z.object({
+  code: import_zod58.z.string(),
+  message: import_zod58.z.string()
+});
+var TurnAbortRequestSchema = import_zod58.z.object({
+  requestedAt: import_zod58.z.string(),
+  eventId: import_zod58.z.string()
+});
+var TurnSeqRangeSchema = import_zod58.z.object({
+  start: import_zod58.z.number().int().nullable(),
+  end: import_zod58.z.number().int().nullable()
+});
+var TurnContextStateSchema = import_zod58.z.enum(["live", "compacted"]);
+var TurnMemoryRecallStateSchema = import_zod58.z.enum([
+  "selected",
+  "empty",
+  "recall_failed",
+  "unavailable",
+  "legacy"
+]);
+var TurnSchema = import_zod58.z.object({
+  turnId: import_zod58.z.string(),
+  kind: TurnKindSchema,
+  parentTurnId: import_zod58.z.string().nullable(),
+  /** Pairs the turn with `${kind}:${idempotencyKey}`-shaped side events. */
+  idempotencyKey: import_zod58.z.string(),
+  status: TurnStatusSchema,
+  revival: import_zod58.z.object({ attemptId: import_zod58.z.string() }).optional(),
+  phase: TurnPhaseSchema.optional(),
+  statusReason: TurnStatusReasonSchema.optional(),
+  user: TurnUserMessageSchema,
+  assistant: TurnAssistantMessageSchema.nullable(),
+  delivery: TurnDeliverySchema.nullable(),
+  /**
+   * Returned from P2 on, once `artifacts.turn_id` exists — attribution before
+   * that column is a path regex, and shipping a guessed answer would teach
+   * consumers to trust it. Absent means "not populated yet", never "no
+   * artifacts".
+   */
+  artifacts: TurnArtifactsSchema.optional(),
+  /**
+   * Returned from P2 on, with the `POST /workspace-snapshot` envelope's
+   * `turnId` (T-INV-6). Absent means "not populated yet"; `null` means this
+   * turn is not the source of the session's current snapshot.
+   */
+  workspaceSnapshot: import_zod58.z.object({ capturedAt: import_zod58.z.string() }).nullable().optional(),
+  context: import_zod58.z.object({ state: TurnContextStateSchema }),
+  memoryRecall: import_zod58.z.object({ state: TurnMemoryRecallStateSchema }).optional(),
+  abort: TurnAbortRequestSchema.nullable(),
+  seqRange: TurnSeqRangeSchema,
+  traceId: import_zod58.z.string().nullable(),
+  anomalies: import_zod58.z.array(TurnAnomalySchema),
+  dispatchedAt: import_zod58.z.string(),
+  acceptedAt: import_zod58.z.string().optional(),
+  completedAt: import_zod58.z.string().optional()
+});
+var TurnListResponseDataSchema = import_zod58.z.object({
+  turns: import_zod58.z.array(TurnSchema),
+  hasMore: import_zod58.z.boolean(),
+  nextCursor: import_zod58.z.string().nullable(),
+  prevCursor: import_zod58.z.string().nullable(),
+  /** Session-wide `max(__seq)`; usable directly as `Last-Event-ID`. */
+  streamCursor: import_zod58.z.number().int().nullable()
+});
+var TURN_LIST_DEFAULT_LIMIT = 20;
+var TURN_LIST_MAX_LIMIT = 100;
+var TurnListQuerySchema = import_zod58.z.object({
+  limit: import_zod58.z.coerce.number().int().min(1).max(TURN_LIST_MAX_LIMIT).default(TURN_LIST_DEFAULT_LIMIT),
+  order: import_zod58.z.enum(["desc", "asc"]).default("desc"),
+  before: import_zod58.z.string().min(1).optional(),
+  after: import_zod58.z.string().min(1).optional(),
+  /**
+   * Comma-separated status filter, e.g. `status=completed,failed`. Same wire
+   * form as `SessionEventsQuerySchema.types`: every route mount parses its
+   * query via `Object.fromEntries(new URL(url).searchParams)`, which keeps
+   * only the LAST value of a repeated key, so `status=a&status=b` would
+   * silently filter for `b` alone. Each item must be a `TurnStatus`.
+   */
+  status: import_zod58.z.string().optional().transform((value, ctx) => {
+    if (value === void 0) return void 0;
+    const items = value.split(",").filter((s) => s.length > 0);
+    const parsed = import_zod58.z.array(TurnStatusSchema).safeParse(items);
+    if (!parsed.success) {
+      ctx.addIssue({ code: "custom", message: `unknown turn status in: ${value}` });
+      return import_zod58.z.NEVER;
+    }
+    return parsed.data;
+  }),
+  revivalAttemptId: import_zod58.z.string().uuid().optional()
+}).refine((q) => !(q.before !== void 0 && q.after !== void 0), {
+  message: "before and after are mutually exclusive",
+  path: ["before"]
+});
+function turnMessageIds(turnId) {
+  return { user: `${turnId}:u`, assistant: `${turnId}:a` };
+}
+var SESSION_EVENTS_DEFAULT_LIMIT = 100;
+var SESSION_EVENTS_MAX_LIMIT = 500;
+var SessionEventsQuerySchema = import_zod59.z.object({
+  afterEventId: import_zod59.z.string().min(1).optional(),
+  limit: import_zod59.z.coerce.number().int().min(1).max(SESSION_EVENTS_MAX_LIMIT).default(SESSION_EVENTS_DEFAULT_LIMIT),
+  turnId: import_zod59.z.string().uuid().optional(),
+  /**
+   * Comma-separated `event_type` values, e.g.
+   * `types=worker_protocol.prompt.dispatched,pilot_coder.chunk`.
+   *
+   * NOT `types=a&types=b` (repeated keys): every route mount parses its
+   * query string via `Object.fromEntries(new URL(request.url).searchParams)`,
+   * which keeps only the LAST value for a repeated key — a `types=a&types=b`
+   * request would silently filter for `b` alone. Comma-separated is the one
+   * form that survives that parsing unchanged.
+   */
+  types: import_zod59.z.string().optional().transform(
+    (value) => value === void 0 ? void 0 : value.split(",").filter((t) => t.length > 0)
+  )
+});
+var SessionEventsPageDataSchema = import_zod59.z.object({
+  events: import_zod59.z.array(SessionEventSchema),
+  hasMore: import_zod59.z.boolean(),
+  /**
+   * Set `true` only when `afterEventId` was given but matched neither the
+   * `event_id` column nor a row's primary key (e.g. the referenced chunk
+   * was pruned by retention) — the response falls back to the first page
+   * instead of the pre-existing silent fallback. Omitted (not `false`)
+   * otherwise.
+   */
+  cursorReset: import_zod59.z.boolean().optional()
+});
+var SessionEventsPageResponseSchema = import_zod59.z.object({
+  success: import_zod59.z.literal(true),
+  data: SessionEventsPageDataSchema
+});
+var GatewayErrorCodeSchema = import_zod60.z.enum([
   "gateway_invalid_session_token",
   "gateway_session_not_found",
   "gateway_missing_mcp_target",
@@ -7411,7 +7809,7 @@ var GatewayErrorCodeSchema = import_zod58.z.enum([
   "gateway_request_too_large",
   "gateway_response_too_large"
 ]);
-var WebhookEventTypeSchema = import_zod59.z.enum([
+var WebhookEventTypeSchema = import_zod61.z.enum([
   /** v1/v2 Run reached terminal `completed`. */
   "run.completed",
   /** v1/v2 Run reached terminal `failed`. */
@@ -7444,43 +7842,43 @@ var WebhookEventTypeSchema = import_zod59.z.enum([
 ]);
 var WEBHOOK_EVENT_TYPES = WebhookEventTypeSchema.options;
 var MAX_WEBHOOK_EVENT_ID_LENGTH = 255;
-var WebhookEventPayloadSchema = import_zod59.z.object({
-  event_id: import_zod59.z.string().min(1).max(MAX_WEBHOOK_EVENT_ID_LENGTH),
+var WebhookEventPayloadSchema = import_zod61.z.object({
+  event_id: import_zod61.z.string().min(1).max(MAX_WEBHOOK_EVENT_ID_LENGTH),
   event_type: WebhookEventTypeSchema,
   /** ISO-8601 instant at which the transition was recorded. */
-  occurred_at: import_zod59.z.string(),
-  project_id: import_zod59.z.string().uuid(),
-  run_id: import_zod59.z.string().uuid().optional(),
-  agent_id: import_zod59.z.string().uuid().optional(),
-  session_id: import_zod59.z.string().uuid().optional(),
+  occurred_at: import_zod61.z.string(),
+  project_id: import_zod61.z.string().uuid(),
+  run_id: import_zod61.z.string().uuid().optional(),
+  agent_id: import_zod61.z.string().uuid().optional(),
+  session_id: import_zod61.z.string().uuid().optional(),
   /**
    * Worker turn id of a `turn.*` event, paired with `session_id`.
    * NOT a uuid: `deriveWorkerTurnId` yields a uuid-v5, but other
    * emitters use composite forms (`${kind}:${idempotencyKey}`), so the
    * wire type stays an opaque string.
    */
-  turn_id: import_zod59.z.string().min(1).optional(),
-  lifecycle_phase: import_zod59.z.enum(["idle", "terminating", "terminated"]).optional(),
-  lifecycle_transition_id: import_zod59.z.string().uuid().optional(),
-  idle_since: import_zod59.z.string().optional(),
-  grace_deadline: import_zod59.z.string().optional(),
-  reason: import_zod59.z.string().optional(),
-  terminate_deadline: import_zod59.z.string().optional()
-}).strict();
-var WebhookSubscriptionStatusSchema = import_zod59.z.enum(["active", "disabled"]);
-var CreateWebhookSubscriptionRequestSchema = import_zod59.z.object({
-  projectId: import_zod59.z.string().uuid(),
+  turn_id: import_zod61.z.string().min(1).optional(),
+  lifecycle_phase: import_zod61.z.enum(["idle", "terminating", "terminated"]).optional(),
+  lifecycle_transition_id: import_zod61.z.string().uuid().optional(),
+  idle_since: import_zod61.z.string().optional(),
+  grace_deadline: import_zod61.z.string().optional(),
+  reason: import_zod61.z.string().optional(),
+  terminate_deadline: import_zod61.z.string().optional()
+}).strict();
+var WebhookSubscriptionStatusSchema = import_zod61.z.enum(["active", "disabled"]);
+var CreateWebhookSubscriptionRequestSchema = import_zod61.z.object({
+  projectId: import_zod61.z.string().uuid(),
   /** Subscriber endpoint. https required outside dev; SSRF-validated. */
-  url: import_zod59.z.string().url().max(1024),
+  url: import_zod61.z.string().url().max(1024),
   /** Event types to deliver. At least one. */
-  events: import_zod59.z.array(WebhookEventTypeSchema).min(1).max(WEBHOOK_EVENT_TYPES.length),
+  events: import_zod61.z.array(WebhookEventTypeSchema).min(1).max(WEBHOOK_EVENT_TYPES.length),
   /** Optional operator note shown in list responses. */
-  description: import_zod59.z.string().max(512).optional()
+  description: import_zod61.z.string().max(512).optional()
 }).strict();
-var UpdateWebhookSubscriptionRequestSchema = import_zod59.z.object({
-  url: import_zod59.z.string().url().max(1024).optional(),
-  events: import_zod59.z.array(WebhookEventTypeSchema).min(1).max(WEBHOOK_EVENT_TYPES.length).optional(),
-  description: import_zod59.z.string().max(512).nullable().optional(),
+var UpdateWebhookSubscriptionRequestSchema = import_zod61.z.object({
+  url: import_zod61.z.string().url().max(1024).optional(),
+  events: import_zod61.z.array(WebhookEventTypeSchema).min(1).max(WEBHOOK_EVENT_TYPES.length).optional(),
+  description: import_zod61.z.string().max(512).nullable().optional(),
   /**
    * `active` re-enables a subscription that was auto-disabled after
    * consecutive failures (resets the failure counter); `disabled`
@@ -7491,23 +7889,23 @@ var UpdateWebhookSubscriptionRequestSchema = import_zod59.z.object({
   (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 = import_zod59.z.object({
-  id: import_zod59.z.string().uuid(),
-  projectId: import_zod59.z.string().uuid(),
-  url: import_zod59.z.string(),
-  events: import_zod59.z.array(WebhookEventTypeSchema),
-  description: import_zod59.z.string().nullable(),
+var WebhookSubscriptionSchema = import_zod61.z.object({
+  id: import_zod61.z.string().uuid(),
+  projectId: import_zod61.z.string().uuid(),
+  url: import_zod61.z.string(),
+  events: import_zod61.z.array(WebhookEventTypeSchema),
+  description: import_zod61.z.string().nullable(),
   status: WebhookSubscriptionStatusSchema,
-  consecutiveFailures: import_zod59.z.number().int().nonnegative(),
-  createdBy: import_zod59.z.string(),
-  createdAt: import_zod59.z.string(),
-  updatedAt: import_zod59.z.string()
+  consecutiveFailures: import_zod61.z.number().int().nonnegative(),
+  createdBy: import_zod61.z.string(),
+  createdAt: import_zod61.z.string(),
+  updatedAt: import_zod61.z.string()
 });
-var WebhookSubscriptionWithSecretSchema = import_zod59.z.object({
+var WebhookSubscriptionWithSecretSchema = import_zod61.z.object({
   subscription: WebhookSubscriptionSchema,
-  secret: import_zod59.z.string()
+  secret: import_zod61.z.string()
 });
-var WebhookSubscriptionErrorCodeSchema = import_zod59.z.enum([
+var WebhookSubscriptionErrorCodeSchema = import_zod61.z.enum([
   // 400
   "VALIDATION_ERROR",
   /** URL failed SSRF policy (non-https, private/loopback/link-local IP…). */
@@ -7520,125 +7918,125 @@ var WebhookSubscriptionErrorCodeSchema = import_zod59.z.enum([
   // 500
   "INTERNAL_ERROR"
 ]);
-var SessionPrewarmingIdentitySchema = import_zod60.z.object({
-  projectIdGenerator: import_zod60.z.literal("nanoid"),
-  claimNameTemplate: import_zod60.z.string().min(1),
-  idempotencyScopePrefix: import_zod60.z.string().min(1)
-}).strict();
-var SessionPrewarmingSessionTemplateSchema = import_zod60.z.object({
-  configValues: import_zod60.z.record(import_zod60.z.string(), import_zod60.z.string()),
-  metadata: import_zod60.z.record(import_zod60.z.string(), import_zod60.z.unknown()).optional()
-}).strict();
-var BusinessReadyProbeSchema = import_zod60.z.object({
-  endpointName: import_zod60.z.enum(["api", "preview"]),
-  path: import_zod60.z.string().min(1),
-  successCodes: import_zod60.z.array(import_zod60.z.number().int().min(100).max(599)).min(1),
-  timeoutMs: import_zod60.z.number().int().min(500).max(3e4)
-}).strict();
-var SessionPrewarmingSpecSchema = import_zod60.z.object({
-  targetReadyCount: import_zod60.z.number().int().min(1).max(50),
-  reVerifyIntervalSeconds: import_zod60.z.number().int().min(60).max(3600),
-  warmingTimeoutSeconds: import_zod60.z.number().int().min(60).max(600),
-  claimingLeaseTtlSeconds: import_zod60.z.number().int().min(10).max(120),
-  replenishIntervalSeconds: import_zod60.z.number().int().min(5).max(300),
-  maxConcurrentWarming: import_zod60.z.number().int().min(1).max(10),
+var SessionPrewarmingIdentitySchema = import_zod62.z.object({
+  projectIdGenerator: import_zod62.z.literal("nanoid"),
+  claimNameTemplate: import_zod62.z.string().min(1),
+  idempotencyScopePrefix: import_zod62.z.string().min(1)
+}).strict();
+var SessionPrewarmingSessionTemplateSchema = import_zod62.z.object({
+  configValues: import_zod62.z.record(import_zod62.z.string(), import_zod62.z.string()),
+  metadata: import_zod62.z.record(import_zod62.z.string(), import_zod62.z.unknown()).optional()
+}).strict();
+var BusinessReadyProbeSchema = import_zod62.z.object({
+  endpointName: import_zod62.z.enum(["api", "preview"]),
+  path: import_zod62.z.string().min(1),
+  successCodes: import_zod62.z.array(import_zod62.z.number().int().min(100).max(599)).min(1),
+  timeoutMs: import_zod62.z.number().int().min(500).max(3e4)
+}).strict();
+var SessionPrewarmingSpecSchema = import_zod62.z.object({
+  targetReadyCount: import_zod62.z.number().int().min(1).max(50),
+  reVerifyIntervalSeconds: import_zod62.z.number().int().min(60).max(3600),
+  warmingTimeoutSeconds: import_zod62.z.number().int().min(60).max(600),
+  claimingLeaseTtlSeconds: import_zod62.z.number().int().min(10).max(120),
+  replenishIntervalSeconds: import_zod62.z.number().int().min(5).max(300),
+  maxConcurrentWarming: import_zod62.z.number().int().min(1).max(10),
   identity: SessionPrewarmingIdentitySchema,
   sessionTemplate: SessionPrewarmingSessionTemplateSchema,
   businessReadyProbe: BusinessReadyProbeSchema.optional()
 }).strict();
-var AcquireSessionRequestSchema = import_zod60.z.object({
-  workloadId: import_zod60.z.string().uuid(),
-  clientMutationId: import_zod60.z.string().min(1).max(255)
-}).strict();
-var AcquireSessionResponseSchema = import_zod60.z.object({
-  leaseToken: import_zod60.z.string().min(1),
-  leaseExpiresAt: import_zod60.z.string().datetime(),
-  sessionId: import_zod60.z.string().uuid(),
-  projectId: import_zod60.z.string().min(1),
-  runtimeClaimName: import_zod60.z.string().min(1),
-  configValues: import_zod60.z.record(import_zod60.z.string(), import_zod60.z.string()),
+var AcquireSessionRequestSchema = import_zod62.z.object({
+  workloadId: import_zod62.z.string().uuid(),
+  clientMutationId: import_zod62.z.string().min(1).max(255)
+}).strict();
+var AcquireSessionResponseSchema = import_zod62.z.object({
+  leaseToken: import_zod62.z.string().min(1),
+  leaseExpiresAt: import_zod62.z.string().datetime(),
+  sessionId: import_zod62.z.string().uuid(),
+  projectId: import_zod62.z.string().min(1),
+  runtimeClaimName: import_zod62.z.string().min(1),
+  configValues: import_zod62.z.record(import_zod62.z.string(), import_zod62.z.string()),
   // Optional: outbox-protocol workloads (`managed_agent`) expose no public HTTP
   // endpoint, so a ready slot is claimable with no `apiUrl`. self_managed
   // (rush-app) slots always carry it. Omitted (not null) when absent — mirrors
   // `previewUrl`. See `pilot-v2-managed-agent-prewarming.md` § Readiness and
   // `SessionPoolService.buildAcquireResponse`.
-  apiUrl: import_zod60.z.string().url().optional(),
-  previewUrl: import_zod60.z.string().url().optional()
+  apiUrl: import_zod62.z.string().url().optional(),
+  previewUrl: import_zod62.z.string().url().optional()
 }).strict();
-var FinalizeAcquireRequestSchema = import_zod60.z.object({
-  leaseToken: import_zod60.z.string().min(1),
-  sessionId: import_zod60.z.string().uuid(),
-  clientMutationId: import_zod60.z.string().min(1).max(255).optional()
+var FinalizeAcquireRequestSchema = import_zod62.z.object({
+  leaseToken: import_zod62.z.string().min(1),
+  sessionId: import_zod62.z.string().uuid(),
+  clientMutationId: import_zod62.z.string().min(1).max(255).optional()
 }).strict();
-var AbortAcquireRequestSchema = import_zod60.z.object({
-  leaseToken: import_zod60.z.string().min(1),
-  sessionId: import_zod60.z.string().uuid()
+var AbortAcquireRequestSchema = import_zod62.z.object({
+  leaseToken: import_zod62.z.string().min(1),
+  sessionId: import_zod62.z.string().uuid()
 }).strict();
-var WorkloadLifecycleKindSchema = import_zod61.z.enum(["managed_agent", "self_managed"]);
-var WorkloadLifecycleConfigSchema = import_zod61.z.object({
-  idleEnabled: import_zod61.z.boolean().nullable(),
-  idleAfterSeconds: import_zod61.z.number().int().min(300).max(86400).nullable(),
-  idleGraceSeconds: import_zod61.z.number().int().min(60).max(3600).nullable(),
-  maxSessionLifetimeMs: import_zod61.z.number().int().min(36e5).max(6048e5).nullable()
+var WorkloadLifecycleKindSchema = import_zod63.z.enum(["managed_agent", "self_managed"]);
+var WorkloadLifecycleConfigSchema = import_zod63.z.object({
+  idleEnabled: import_zod63.z.boolean().nullable(),
+  idleAfterSeconds: import_zod63.z.number().int().min(300).max(86400).nullable(),
+  idleGraceSeconds: import_zod63.z.number().int().min(60).max(3600).nullable(),
+  maxSessionLifetimeMs: import_zod63.z.number().int().min(36e5).max(6048e5).nullable()
 }).strict();
 var WorkloadLifecycleConfigUpdateSchema = WorkloadLifecycleConfigSchema.partial().strict();
-var EffectiveWorkloadLifecycleConfigSchema = import_zod61.z.object({
-  idleEnabled: import_zod61.z.boolean(),
-  idleAfterSeconds: import_zod61.z.number().int().min(300).max(86400),
-  idleGraceSeconds: import_zod61.z.number().int().min(60).max(3600),
-  maxSessionLifetimeMs: import_zod61.z.number().int().min(36e5).max(6048e5)
-}).strict();
-var WorkloadLifecycleConfigResponseSchema = import_zod61.z.object({
-  workloadId: import_zod61.z.string().uuid(),
+var EffectiveWorkloadLifecycleConfigSchema = import_zod63.z.object({
+  idleEnabled: import_zod63.z.boolean(),
+  idleAfterSeconds: import_zod63.z.number().int().min(300).max(86400),
+  idleGraceSeconds: import_zod63.z.number().int().min(60).max(3600),
+  maxSessionLifetimeMs: import_zod63.z.number().int().min(36e5).max(6048e5)
+}).strict();
+var WorkloadLifecycleConfigResponseSchema = import_zod63.z.object({
+  workloadId: import_zod63.z.string().uuid(),
   kind: WorkloadLifecycleKindSchema,
   config: WorkloadLifecycleConfigSchema,
   effective: EffectiveWorkloadLifecycleConfigSchema
 }).strict();
-var OtelJobContextSchema = import_zod62.z.object({
+var OtelJobContextSchema = import_zod64.z.object({
   /** W3C Trace Context `traceparent` header value. */
-  traceparent: import_zod62.z.string().optional(),
+  traceparent: import_zod64.z.string().optional(),
   /** W3C Trace Context `tracestate` header value. */
-  tracestate: import_zod62.z.string().optional(),
+  tracestate: import_zod64.z.string().optional(),
   /** W3C Baggage header value. */
-  baggage: import_zod62.z.string().optional()
+  baggage: import_zod64.z.string().optional()
 }).passthrough();
-var LifecycleStageNameSchema = import_zod63.z.enum(["test", "production"]);
-var SlotCanarySummarySchema = import_zod63.z.object({
+var LifecycleStageNameSchema = import_zod65.z.enum(["test", "production"]);
+var SlotCanarySummarySchema = import_zod65.z.object({
   /** canary 臂 revision id。 */
-  revisionId: import_zod63.z.string(),
+  revisionId: import_zod65.z.string(),
   /** canary revision 的人可读版本短名;revision 行缺失时 null(降级显示 id 前缀)。 */
-  revisionLabel: import_zod63.z.string().nullable(),
+  revisionLabel: import_zod65.z.string().nullable(),
   /** 0..99;0 = 冻结观察态(仅名单命中仍入 canary)。 */
-  percentage: import_zod63.z.number().int(),
+  percentage: import_zod65.z.number().int(),
   /** ldap 名单人数(徽章"名单 N 人";0 = 无名单)。 */
-  userAllowlistCount: import_zod63.z.number().int(),
+  userAllowlistCount: import_zod65.z.number().int(),
   /** 本轮灰度开始时间(ISO);存量行无记录时 null。 */
-  startedAt: import_zod63.z.string().nullable()
+  startedAt: import_zod65.z.string().nullable()
 });
-var SlotSummarySchema = import_zod63.z.object({
-  revisionId: import_zod63.z.string().nullable(),
+var SlotSummarySchema = import_zod65.z.object({
+  revisionId: import_zod65.z.string().nullable(),
   /** 人可读的版本标识(revision name/number);无部署时 null。 */
-  revisionLabel: import_zod63.z.string().nullable(),
-  environmentId: import_zod63.z.string().nullable(),
-  environmentName: import_zod63.z.string().nullable(),
-  environmentVersion: import_zod63.z.number().int().nullable(),
+  revisionLabel: import_zod65.z.string().nullable(),
+  environmentId: import_zod65.z.string().nullable(),
+  environmentName: import_zod65.z.string().nullable(),
+  environmentVersion: import_zod65.z.number().int().nullable(),
   /**
    * 槽位所指 revision 自带的运行环境(`revisions.runtime_template_id` 及其名字)。
    * 槽位 `environmentId` 为 NULL(存量未绑定行)时会话实际跑的就是它——读侧用
    * 它兜底显示,不再渲染「内置于版本」伪状态(ENV-R1a)。发布板读模型必带;
    * 工作台等其它 SlotSummary 生产方可省略(省略 = 未报告)。
    */
-  revisionEnvironmentId: import_zod63.z.string().nullable().optional(),
-  revisionEnvironmentName: import_zod63.z.string().nullable().optional(),
+  revisionEnvironmentId: import_zod65.z.string().nullable().optional(),
+  revisionEnvironmentName: import_zod65.z.string().nullable().optional(),
   /** 槽位最近一次变更时间(ISO);数据缺口约定:仅当前指针,无历史流水。 */
-  updatedAt: import_zod63.z.string().nullable(),
+  updatedAt: import_zod65.z.string().nullable(),
   /**
    * 活跃灰度摘要(#1214)。目前仅发布板读模型的槽位显式带出(null = 无灰度);
    * 工作台等其它 SlotSummary 生产方不带(optional,省略 = 未报告)。
    */
   canary: SlotCanarySummarySchema.nullable().optional()
 });
-var WorkbenchStageDriftKindSchema = import_zod63.z.enum([
+var WorkbenchStageDriftKindSchema = import_zod65.z.enum([
   /** test 指向新于 production(待晋级)。 */
   "test_ahead",
   /** 只有 test 有部署(从未上过 production)。 */
@@ -7661,27 +8059,27 @@ var WorkbenchStageDriftKindSchema = import_zod63.z.enum([
    */
   "diverged"
 ]);
-var WorkbenchStageDriftItemSchema = import_zod63.z.object({
-  workloadId: import_zod63.z.string(),
-  workloadName: import_zod63.z.string(),
-  workloadSlug: import_zod63.z.string().nullable(),
+var WorkbenchStageDriftItemSchema = import_zod65.z.object({
+  workloadId: import_zod65.z.string(),
+  workloadName: import_zod65.z.string(),
+  workloadSlug: import_zod65.z.string().nullable(),
   kind: WorkbenchStageDriftKindSchema,
   test: SlotSummarySchema.nullable(),
   production: SlotSummarySchema.nullable(),
   /** 差异开始的近似时间 = 领先侧槽位的 updatedAt(ISO)。 */
-  since: import_zod63.z.string().nullable()
+  since: import_zod65.z.string().nullable()
 });
-var WorkbenchRecentChangeKindSchema = import_zod63.z.enum([
+var WorkbenchRecentChangeKindSchema = import_zod65.z.enum([
   "stage_updated",
   "revision_published",
   "environment_version_created"
 ]);
-var WorkbenchRecentChangeSchema = import_zod63.z.object({
+var WorkbenchRecentChangeSchema = import_zod65.z.object({
   kind: WorkbenchRecentChangeKindSchema,
   /** 变更主体的可读标题(如 workload 名 / 环境名)。 */
-  subject: import_zod63.z.string(),
+  subject: import_zod65.z.string(),
   /** 主体 id(workloadId / environmentId),用于前端拼详情链接。 */
-  subjectId: import_zod63.z.string(),
+  subjectId: import_zod65.z.string(),
   /**
    * workload 类变更(stage_updated / revision_published)的 slug——详情路由
    * UUID / slug 双形态均可达,前端优先用可读的 slug 拼链接,缺失时回退
@@ -7692,26 +8090,26 @@ var WorkbenchRecentChangeSchema = import_zod63.z.object({
    * agenthub-sdk 对 WorkbenchDTO 的硬 parse)在滚动发版遇到旧产出时
    * 降级为无 slug,而不是整个 DTO 校验失败。
    */
-  subjectSlug: import_zod63.z.string().nullable().optional(),
+  subjectSlug: import_zod65.z.string().nullable().optional(),
   /** 一句话变更描述(如 "production → rev-12" / "环境 v3 创建")。 */
-  detail: import_zod63.z.string(),
-  occurredAt: import_zod63.z.string()
+  detail: import_zod65.z.string(),
+  occurredAt: import_zod65.z.string()
 });
-var WorkbenchSessionStatsSchema = import_zod63.z.object({
-  running: import_zod63.z.number().int(),
-  failed24h: import_zod63.z.number().int(),
-  total24h: import_zod63.z.number().int()
+var WorkbenchSessionStatsSchema = import_zod65.z.object({
+  running: import_zod65.z.number().int(),
+  failed24h: import_zod65.z.number().int(),
+  total24h: import_zod65.z.number().int()
 });
-var WorkbenchDTOSchema = import_zod63.z.object({
-  workloadCount: import_zod63.z.number().int(),
+var WorkbenchDTOSchema = import_zod65.z.object({
+  workloadCount: import_zod65.z.number().int(),
   sessionStats: WorkbenchSessionStatsSchema,
-  stageDrift: import_zod63.z.array(WorkbenchStageDriftItemSchema),
-  recentChanges: import_zod63.z.array(WorkbenchRecentChangeSchema)
+  stageDrift: import_zod65.z.array(WorkbenchStageDriftItemSchema),
+  recentChanges: import_zod65.z.array(WorkbenchRecentChangeSchema)
 });
-var ReleaseBoardRowSchema = import_zod63.z.object({
-  workloadId: import_zod63.z.string(),
-  workloadName: import_zod63.z.string(),
-  workloadSlug: import_zod63.z.string().nullable(),
+var ReleaseBoardRowSchema = import_zod65.z.object({
+  workloadId: import_zod65.z.string(),
+  workloadName: import_zod65.z.string(),
+  workloadSlug: import_zod65.z.string().nullable(),
   /**
    * @deprecated Workload 当前默认指针(`default_revision_id`,production 部署
    * 从写)。指针收敛(2026-08-02)后发布 UI 不再移动它,本字段随删列窗口结束
@@ -7720,7 +8118,7 @@ var ReleaseBoardRowSchema = import_zod63.z.object({
    * 新消费方一律读 `latestRevision`(前端回退链 latestRevision ?? defaultRevision
    * 只为兼容旧服务端缺字段,不表示两者同义)。
    */
-  defaultRevision: import_zod63.z.object({ id: import_zod63.z.string(), version: import_zod63.z.string(), createdAt: import_zod63.z.string() }).nullable(),
+  defaultRevision: import_zod65.z.object({ id: import_zod65.z.string(), version: import_zod65.z.string(), createdAt: import_zod65.z.string() }).nullable(),
   /**
    * Workload 最近发布的 Revision(createdAt 最新;并列时 id 大者,保证确定性)。
    * 发布板用它判断"有新版本尚未部署到 test"(latestRevision.id ≠
@@ -7733,12 +8131,12 @@ var ReleaseBoardRowSchema = import_zod63.z.object({
    * pendingRevision)一直想要的一致。**optional**:旧服务端的响应没有此字段,
    * 新 client 解析须容忍(双向滚动窗口兼容),缺席时回退读 defaultRevision。
    */
-  latestRevision: import_zod63.z.object({
-    id: import_zod63.z.string(),
-    version: import_zod63.z.string(),
-    createdAt: import_zod63.z.string(),
+  latestRevision: import_zod65.z.object({
+    id: import_zod65.z.string(),
+    version: import_zod65.z.string(),
+    createdAt: import_zod65.z.string(),
     /** 真实发布时间；optional 仅用于新旧服务端滚动窗口兼容。 */
-    publishedAt: import_zod63.z.string().optional()
+    publishedAt: import_zod65.z.string().optional()
   }).nullable().optional(),
   /**
    * 用户当前有理由继续使用的 Revision（latestRevision、test、production）中，
@@ -7746,7 +8144,7 @@ var ReleaseBoardRowSchema = import_zod63.z.object({
    * latestRevision；具体复制哪份配置由升级弹窗显式选择。optional 仅用于
    * 新旧服务端滚动窗口兼容。
    */
-  runtimeUpgradeAvailable: import_zod63.z.boolean().optional(),
+  runtimeUpgradeAvailable: import_zod65.z.boolean().optional(),
   test: SlotSummarySchema.nullable(),
   production: SlotSummarySchema.nullable(),
   /**
@@ -7755,26 +8153,26 @@ var ReleaseBoardRowSchema = import_zod63.z.object({
    * 都显式绑定时参与比较——任一侧是兜底态(槽位未绑、跑版本自带环境)时
    * 没有可比的版本钉。发布板展开面板的环境行高亮与本字段同口径。
    */
-  drift: import_zod63.z.boolean(),
+  drift: import_zod65.z.boolean(),
   /** 两槽位 updatedAt 的较新者(ISO);均空则 null。 */
-  lastChangedAt: import_zod63.z.string().nullable()
-});
-var ReleaseBoardDTOSchema = import_zod63.z.object({
-  rows: import_zod63.z.array(ReleaseBoardRowSchema)
-});
-var SessionDiagnosisSessionSchema = import_zod63.z.object({
-  id: import_zod63.z.string(),
-  workloadId: import_zod63.z.string().nullable(),
-  workloadName: import_zod63.z.string().nullable(),
-  workloadSlug: import_zod63.z.string().nullable(),
-  status: import_zod63.z.string(),
-  lifecyclePhase: import_zod63.z.string().nullable(),
-  model: import_zod63.z.string().nullable(),
-  createdAt: import_zod63.z.string(),
-  readyAt: import_zod63.z.string().nullable(),
-  endedAt: import_zod63.z.string().nullable(),
+  lastChangedAt: import_zod65.z.string().nullable()
+});
+var ReleaseBoardDTOSchema = import_zod65.z.object({
+  rows: import_zod65.z.array(ReleaseBoardRowSchema)
+});
+var SessionDiagnosisSessionSchema = import_zod65.z.object({
+  id: import_zod65.z.string(),
+  workloadId: import_zod65.z.string().nullable(),
+  workloadName: import_zod65.z.string().nullable(),
+  workloadSlug: import_zod65.z.string().nullable(),
+  status: import_zod65.z.string(),
+  lifecyclePhase: import_zod65.z.string().nullable(),
+  model: import_zod65.z.string().nullable(),
+  createdAt: import_zod65.z.string(),
+  readyAt: import_zod65.z.string().nullable(),
+  endedAt: import_zod65.z.string().nullable(),
   /** 会话创建链路 trace(Octopus 深链"启动 Trace"数据源)。 */
-  rootTraceId: import_zod63.z.string().nullable(),
+  rootTraceId: import_zod65.z.string().nullable(),
   /**
    * 该会话能不能点进对话面(`/p/<pid>/s/<sid>`)。**由服务端算好下发,前端不要
    * 自己按 `usageKind` 重推** —— `usage_kind` 是会话创建时写死的名字、认领后
@@ -7782,37 +8180,37 @@ var SessionDiagnosisSessionSchema = import_zod63.z.object({
    * `packages/control-plane/src/session-lifecycle/session-chat-entry.ts`,
    * 排障列表的 `chatHref` 走的是同一个函数。
    */
-  canOpenChat: import_zod63.z.boolean()
+  canOpenChat: import_zod65.z.boolean()
 });
-var SessionDiagnosisFailureSchema = import_zod63.z.object({
-  kind: import_zod63.z.string().nullable(),
-  message: import_zod63.z.string().nullable(),
-  occurredAt: import_zod63.z.string().nullable()
+var SessionDiagnosisFailureSchema = import_zod65.z.object({
+  kind: import_zod65.z.string().nullable(),
+  message: import_zod65.z.string().nullable(),
+  occurredAt: import_zod65.z.string().nullable()
 });
-var SessionDiagnosisEventSchema = import_zod63.z.object({
-  id: import_zod63.z.string(),
-  type: import_zod63.z.string(),
+var SessionDiagnosisEventSchema = import_zod65.z.object({
+  id: import_zod65.z.string(),
+  type: import_zod65.z.string(),
   /** 该轮 dispatch trace(每条用户消息的 Octopus 深链数据源);非 dispatch 事件为 null。 */
-  traceId: import_zod63.z.string().nullable(),
-  summary: import_zod63.z.string().nullable(),
-  occurredAt: import_zod63.z.string()
+  traceId: import_zod65.z.string().nullable(),
+  summary: import_zod65.z.string().nullable(),
+  occurredAt: import_zod65.z.string()
 });
-var SessionDiagnosisSandboxSchema = import_zod63.z.object({
-  id: import_zod63.z.string(),
-  status: import_zod63.z.string(),
-  expiresAt: import_zod63.z.string().nullable(),
-  createdAt: import_zod63.z.string().nullable()
+var SessionDiagnosisSandboxSchema = import_zod65.z.object({
+  id: import_zod65.z.string(),
+  status: import_zod65.z.string(),
+  expiresAt: import_zod65.z.string().nullable(),
+  createdAt: import_zod65.z.string().nullable()
 });
-var SessionDiagnosisDTOSchema = import_zod63.z.object({
+var SessionDiagnosisDTOSchema = import_zod65.z.object({
   session: SessionDiagnosisSessionSchema,
   failure: SessionDiagnosisFailureSchema.nullable(),
-  events: import_zod63.z.array(SessionDiagnosisEventSchema).nullable(),
+  events: import_zod65.z.array(SessionDiagnosisEventSchema).nullable(),
   sandbox: SessionDiagnosisSandboxSchema.nullable(),
   // zod v4 infers `z.record(enum, string)` as a FULL `Record` (all keys
   // present) instead of v3's `Partial` — but only failing blocks appear here.
   // Explicit partial object keeps the v3 inference; runtime behavior matches
   // the record form (any key subset accepted, extras rejected).
-  blockErrors: import_zod63.z.object({ failure: import_zod63.z.string(), events: import_zod63.z.string(), sandbox: import_zod63.z.string() }).partial().optional()
+  blockErrors: import_zod65.z.object({ failure: import_zod65.z.string(), events: import_zod65.z.string(), sandbox: import_zod65.z.string() }).partial().optional()
 });
 var PIPELINE_TRIGGERS = ["push", "merge", "manual", "env_change", "rebake"];
 var PIPELINE_RUN_STATUSES = [
@@ -7854,12 +8252,12 @@ var PIPELINE_FULL_FACE_TRIGGERS = Object.keys(PIPELINE_TRIGGER_STAGES).filter((t
   return set.length === PIPELINE_STEPS.length && PIPELINE_STEPS.every((s) => set.includes(s));
 });
 var IMAGE_FINGERPRINT_RE = /^fp_[0-9a-f]{64}$/;
-var BakeInputsSchema = import_zod64.z.object({
-  v: import_zod64.z.literal(1),
-  fingerprint: import_zod64.z.string().regex(IMAGE_FINGERPRINT_RE),
-  baseImage: import_zod64.z.string().min(1),
+var BakeInputsSchema = import_zod66.z.object({
+  v: import_zod66.z.literal(1),
+  fingerprint: import_zod66.z.string().regex(IMAGE_FINGERPRINT_RE),
+  baseImage: import_zod66.z.string().min(1),
   packages: EnvironmentPackagesSchema.nullable(),
-  generatorVersion: import_zod64.z.number().int().positive()
+  generatorVersion: import_zod66.z.number().int().positive()
 }).strict();
 var BAKE_IMAGE_BUILD_TIMEOUT_MS = 45 * 60 * 1e3;
 var BAKE_MATERIALIZE_WAIT_MS = 30 * 60 * 1e3;
@@ -7877,7 +8275,7 @@ var FILE_AGENT_REFERENCE_NAME_MAX_LENGTH = 200;
 var FILE_AGENT_REFERENCE_LIST_MAX_LENGTH = 100;
 var FILE_AGENT_PACKAGE_FILE_CHAR_WHITELIST = /^[A-Za-z0-9._/-]+$/;
 function packageFilePathSchema(fieldName) {
-  return import_zod65.z.string().min(1).max(FILE_AGENT_PACKAGE_FILE_PATH_MAX_LENGTH).refine((value) => FILE_AGENT_PACKAGE_FILE_CHAR_WHITELIST.test(value), {
+  return import_zod67.z.string().min(1).max(FILE_AGENT_PACKAGE_FILE_PATH_MAX_LENGTH).refine((value) => FILE_AGENT_PACKAGE_FILE_CHAR_WHITELIST.test(value), {
     message: `${fieldName} may only contain [A-Za-z0-9._/-]`
   }).refine((value) => !value.startsWith("/"), {
     message: `${fieldName} must be a relative path`
@@ -7893,11 +8291,11 @@ function packageFilePathSchema(fieldName) {
 var FileAgentSystemPromptFileSchema = packageFilePathSchema("systemPromptFile");
 var FileAgentSetupScriptFileSchema = packageFilePathSchema("setupScriptFile");
 var FILE_AGENT_RUSH_NAME_WHITELIST = /^(@[A-Za-z0-9][A-Za-z0-9._-]*\/)?[A-Za-z0-9][A-Za-z0-9._-]*$/;
-var FileAgentReferenceNameSchema = import_zod65.z.string().min(1).max(FILE_AGENT_REFERENCE_NAME_MAX_LENGTH).refine((value) => FILE_AGENT_RUSH_NAME_WHITELIST.test(value), {
+var FileAgentReferenceNameSchema = import_zod67.z.string().min(1).max(FILE_AGENT_REFERENCE_NAME_MAX_LENGTH).refine((value) => FILE_AGENT_RUSH_NAME_WHITELIST.test(value), {
   message: "rush registry name must match (@scope/)?name using only [A-Za-z0-9._-] (no spaces or invisible characters)"
 });
 function platformEntityNameSchema(fieldName) {
-  return import_zod65.z.string().min(1).max(FILE_AGENT_REFERENCE_NAME_MAX_LENGTH).refine((value) => value.trim() === value, {
+  return import_zod67.z.string().min(1).max(FILE_AGENT_REFERENCE_NAME_MAX_LENGTH).refine((value) => value.trim() === value, {
     message: `${fieldName} name must not have leading or trailing whitespace`
   }).refine((value) => !/[\p{Cc}\p{Cf}]/u.test(value), {
     message: `${fieldName} name must not contain control or invisible format characters`
@@ -7905,30 +8303,30 @@ function platformEntityNameSchema(fieldName) {
 }
 var FileAgentEnvironmentNameSchema = platformEntityNameSchema("environment");
 var FileAgentModelServiceNameSchema = platformEntityNameSchema("modelService");
-var FileAgentMcpServerEntrySchema = import_zod65.z.union([
+var FileAgentMcpServerEntrySchema = import_zod67.z.union([
   ManagedMcpIdSchema,
-  import_zod65.z.object({
+  import_zod67.z.object({
     id: ManagedMcpIdSchema,
-    disabled: import_zod65.z.boolean().optional()
+    disabled: import_zod67.z.boolean().optional()
   }).strict()
 ]);
 function mcpEntryId(entry) {
   return typeof entry === "string" ? entry : entry.id;
 }
-var FileAgentMcpServerListSchema = import_zod65.z.array(FileAgentMcpServerEntrySchema).max(FILE_AGENT_REFERENCE_LIST_MAX_LENGTH).refine(
+var FileAgentMcpServerListSchema = import_zod67.z.array(FileAgentMcpServerEntrySchema).max(FILE_AGENT_REFERENCE_LIST_MAX_LENGTH).refine(
   (list) => {
     const ids = list.map(mcpEntryId);
     return new Set(ids).size === ids.length;
   },
   { message: "must not contain duplicate mcpServers entries (compared by id)" }
 );
-var FileAgentClaudeCodeSectionSchema = import_zod65.z.object({
+var FileAgentClaudeCodeSectionSchema = import_zod67.z.object({
   entryCommand: ClaudeCodeAgentPackageEntryCommandSchema.optional()
 }).strict();
 var FileAgentMemorySchema = WorkloadManifestMemorySchema.pick({ enabled: true }).strict();
-var FileAgentClaudeCodeDefinitionSchema = import_zod65.z.object({
-  apiVersion: import_zod65.z.literal(FILE_AGENT_API_VERSION),
-  format: import_zod65.z.literal("claude_code"),
+var FileAgentClaudeCodeDefinitionSchema = import_zod67.z.object({
+  apiVersion: import_zod67.z.literal(FILE_AGENT_API_VERSION),
+  format: import_zod67.z.literal("claude_code"),
   model: WorkloadManifestModelSchema.optional(),
   /**
    * **待退场旧入口**（owner 2026-08-11 拍板，见
@@ -8009,23 +8407,23 @@ var FileAgentClaudeCodeDefinitionSchema = import_zod65.z.object({
   memory: FileAgentMemorySchema.optional(),
   claudeCode: FileAgentClaudeCodeSectionSchema.optional()
 }).strict();
-var FileAgentDefinitionSchema = import_zod65.z.discriminatedUnion("format", [FileAgentClaudeCodeDefinitionSchema]).superRefine((definition, ctx) => {
+var FileAgentDefinitionSchema = import_zod67.z.discriminatedUnion("format", [FileAgentClaudeCodeDefinitionSchema]).superRefine((definition, ctx) => {
   if (definition.systemPrompt !== void 0 && definition.systemPromptFile !== void 0) {
     ctx.addIssue({
-      code: import_zod65.z.ZodIssueCode.custom,
+      code: import_zod67.z.ZodIssueCode.custom,
       path: ["systemPromptFile"],
       message: "systemPrompt and systemPromptFile are mutually exclusive (D18)"
     });
   }
   if (definition.setupScript !== void 0 && definition.setupScriptFile !== void 0) {
     ctx.addIssue({
-      code: import_zod65.z.ZodIssueCode.custom,
+      code: import_zod67.z.ZodIssueCode.custom,
       path: ["setupScriptFile"],
       message: "setupScript and setupScriptFile are mutually exclusive (D21)"
     });
   }
 });
-var FileAgentErrorCodeSchema = import_zod65.z.enum([
+var FileAgentErrorCodeSchema = import_zod67.z.enum([
   /** agent.yaml failed schema validation (unknown/reserved key, apiVersion boundary, field shape). */
   "FILE_AGENT_INVALID",
   /**
@@ -8071,7 +8469,7 @@ var FileAgentErrorCodeSchema = import_zod65.z.enum([
   /** Converted output failed `RevisionManifestSchema` — a pipeline-context input is invalid (e.g. a non-endorsed package URL). */
   "FILE_AGENT_REVISION_INVALID"
 ]);
-var BindProjectRepoRequestSchema = import_zod66.z.object({
+var BindProjectRepoRequestSchema = import_zod68.z.object({
   /**
    * Project uuid — the ONLY form accepted (#1635). Slugs used to be
    * resolved here (exact `slug` column, then derived-from-`name` fallback
@@ -8080,8 +8478,8 @@ var BindProjectRepoRequestSchema = import_zod66.z.object({
    * scan was a full-table fallback with no ordering. Identity is uuid-only;
    * slugs are display-only and never resolve.
    */
-  project: import_zod66.z.string().uuid(),
-  repoUrl: import_zod66.z.string().min(1).max(1024),
+  project: import_zod68.z.string().uuid(),
+  repoUrl: import_zod68.z.string().min(1).max(1024),
   /**
    * Repoint a project that already names a DIFFERENT repo.
    *
@@ -8090,53 +8488,53 @@ var BindProjectRepoRequestSchema = import_zod66.z.object({
    * next release publish agent definitions from another repository, under
    * the same project, with no visible signal.
    */
-  allowRebind: import_zod66.z.boolean().optional()
+  allowRebind: import_zod68.z.boolean().optional()
 }).strict();
-var BindProjectRepoResponseSchema = import_zod66.z.discriminatedUnion("outcome", [
-  import_zod66.z.object({ outcome: import_zod66.z.literal("bound"), projectId: import_zod66.z.string().uuid(), repoUrl: import_zod66.z.string() }).strict(),
+var BindProjectRepoResponseSchema = import_zod68.z.discriminatedUnion("outcome", [
+  import_zod68.z.object({ outcome: import_zod68.z.literal("bound"), projectId: import_zod68.z.string().uuid(), repoUrl: import_zod68.z.string() }).strict(),
   /** Idempotent re-run: already bound to this repo, nothing written. */
-  import_zod66.z.object({ outcome: import_zod66.z.literal("unchanged"), projectId: import_zod66.z.string().uuid(), repoUrl: import_zod66.z.string() }).strict()
+  import_zod68.z.object({ outcome: import_zod68.z.literal("unchanged"), projectId: import_zod68.z.string().uuid(), repoUrl: import_zod68.z.string() }).strict()
 ]);
-var FileAgentRefKindSchema = import_zod66.z.enum(["environment", "modelService", "managedMcp"]);
-var CheckFileAgentRefsQuerySchema = import_zod66.z.object({
-  projectId: import_zod66.z.string().uuid(),
-  environment: import_zod66.z.string().min(1).max(200).optional(),
-  modelService: import_zod66.z.string().min(1).max(200).optional(),
+var FileAgentRefKindSchema = import_zod68.z.enum(["environment", "modelService", "managedMcp"]);
+var CheckFileAgentRefsQuerySchema = import_zod68.z.object({
+  projectId: import_zod68.z.string().uuid(),
+  environment: import_zod68.z.string().min(1).max(200).optional(),
+  modelService: import_zod68.z.string().min(1).max(200).optional(),
   /**
    * `agent.yaml` `mcpServers:` —— 托管 MCP id（`vcrd_*`），已经是 id 而不是名字，
    * 所以这里问的是「它在这个项目里存在吗」。上限对齐 `mcpServers` 的列表上限。
    */
-  managedMcpIds: import_zod66.z.array(ManagedMcpIdSchema).max(64).optional()
+  managedMcpIds: import_zod68.z.array(ManagedMcpIdSchema).max(64).optional()
 }).strict();
-var FileAgentRefProblemSchema = import_zod66.z.object({
+var FileAgentRefProblemSchema = import_zod68.z.object({
   kind: FileAgentRefKindSchema,
-  name: import_zod66.z.string(),
+  name: import_zod68.z.string(),
   /** Existing names in the project, for a "did you mean" hint (server-capped). */
-  available: import_zod66.z.array(import_zod66.z.string())
+  available: import_zod68.z.array(import_zod68.z.string())
 }).strict();
-var CheckFileAgentRefsResponseSchema = import_zod66.z.object({
-  environmentId: import_zod66.z.string().optional(),
-  llmProviderRef: import_zod66.z.string().optional(),
+var CheckFileAgentRefsResponseSchema = import_zod68.z.object({
+  environmentId: import_zod68.z.string().optional(),
+  llmProviderRef: import_zod68.z.string().optional(),
   /** 解析到的 `managedMcpId → 展示名`（发布侧要把名字冻进快照；check 只看 problems）。 */
-  managedMcpDisplayNames: import_zod66.z.record(import_zod66.z.string(), import_zod66.z.string()).optional(),
-  problems: import_zod66.z.array(FileAgentRefProblemSchema)
+  managedMcpDisplayNames: import_zod68.z.record(import_zod68.z.string(), import_zod68.z.string()).optional(),
+  problems: import_zod68.z.array(FileAgentRefProblemSchema)
 }).strict();
-var IssueMcpDevTicketRequestSchema = import_zod67.z.object({
-  projectId: import_zod67.z.string().uuid(),
+var IssueMcpDevTicketRequestSchema = import_zod69.z.object({
+  projectId: import_zod69.z.string().uuid(),
   /**
    * 人可读的用途标记（典型值：`<agent slug>@<主机名>`）。只为审计与自助排查
    * （"我还有几张票在外面"），不参与鉴权。
    */
-  label: import_zod67.z.string().min(1).max(200).optional(),
+  label: import_zod69.z.string().min(1).max(200).optional(),
   /** 省略 = 服务端默认（一个开发日）。服务端另有 24h 上限。 */
-  ttlSeconds: import_zod67.z.number().int().positive().max(24 * 60 * 60).optional()
+  ttlSeconds: import_zod69.z.number().int().positive().max(24 * 60 * 60).optional()
 }).strict();
-var McpDevTicketTargetSchema = import_zod67.z.object({
+var McpDevTicketTargetSchema = import_zod69.z.object({
   managedMcpId: ManagedMcpIdSchema,
   /** 展示名 —— 给人看的（提示、报错）。**不是** `.mcp.json` 的键。 */
-  displayName: import_zod67.z.string(),
+  displayName: import_zod69.z.string(),
   /** 真实上游 URL。作为 `X-Pilot-MCP-Target` 头传给 gateway（**不是**凭据）。 */
-  mcpServerUrl: import_zod67.z.string(),
+  mcpServerUrl: import_zod69.z.string(),
   /**
    * `.mcp.json` 的**键名**，平台侧创建期定死（`pilot_v2_vault_credentials.
    * server_key`）。CLI 必须用它，不许从 `displayName` 现造：LLM 看到的工具名是
@@ -8151,37 +8549,37 @@ var McpDevTicketTargetSchema = import_zod67.z.object({
    * 版本 skew 面（老服务端可能回 null → 新 SDK parse 抛错），而收益只是类型更
    * 诚实。CLI 侧不该再有 null 分支——那个分支正是这条修复要消灭的东西。
    */
-  serverKey: import_zod67.z.string().nullable()
+  serverKey: import_zod69.z.string().nullable()
 }).strict();
-var McpDevTicketStdioTargetSchema = import_zod67.z.object({
+var McpDevTicketStdioTargetSchema = import_zod69.z.object({
   managedMcpId: ManagedMcpIdSchema,
   /**
    * `.mcp.json` 的键名。与 remote 的 `serverKey` 在**同一个命名空间**里分配：
    * `.mcp.json` 是一张表，stdio 与 remote 的键撞了就是互相覆盖（沙箱冻结侧同
    * 此约束，见 `vault-snapshot-freezer`）。
    */
-  serverKey: import_zod67.z.string().min(1).max(200),
+  serverKey: import_zod69.z.string().min(1).max(200),
   /** 展示名 —— 给人看的。**不是**键。 */
-  displayName: import_zod67.z.string(),
-  command: import_zod67.z.string().min(1).max(500),
-  args: import_zod67.z.array(import_zod67.z.string().max(500)).max(64).optional(),
+  displayName: import_zod69.z.string(),
+  command: import_zod69.z.string().min(1).max(500),
+  args: import_zod69.z.array(import_zod69.z.string().max(500)).max(64).optional(),
   /** 变量名 → 已渲染的值（`${MCP_...}` 占位符或字面量）。**绝不含明文凭据。** */
-  env: import_zod67.z.record(import_zod67.z.string(), import_zod67.z.string()).optional()
+  env: import_zod69.z.record(import_zod69.z.string(), import_zod69.z.string()).optional()
 }).strict();
-var IssueMcpDevTicketResponseSchema = import_zod67.z.object({
+var IssueMcpDevTicketResponseSchema = import_zod69.z.object({
   /**
    * 写进 `.mcp.json` 的 `Authorization: Bearer <token>`。
    * **只在这一次响应里出现**，服务端不留明文。
    */
-  token: import_zod67.z.string(),
+  token: import_zod69.z.string(),
   /** 票据的 public id —— 撤销时用它。 */
-  ticketId: import_zod67.z.string(),
+  ticketId: import_zod69.z.string(),
   /** ISO 时间串。 */
-  expiresAt: import_zod67.z.string(),
+  expiresAt: import_zod69.z.string(),
   /** gateway URL（CLI 不该自己猜环境）。 */
-  gatewayUrl: import_zod67.z.string(),
+  gatewayUrl: import_zod69.z.string(),
   /** `remote` 形态 —— 经 gateway 代理，白名单即 `allowedMcpTargets`。 */
-  targets: import_zod67.z.array(McpDevTicketTargetSchema),
+  targets: import_zod69.z.array(McpDevTicketTargetSchema),
   /**
    * `stdio` 形态 —— 本机子进程，不经 gateway、不进白名单。上限与
    * `FrozenStdioMcpListSchema` 对齐（64），两侧同一个上限才不会出现
@@ -8196,20 +8594,20 @@ var IssueMcpDevTicketResponseSchema = import_zod67.z.object({
    * 注意输出类型仍是**非可选数组**（`z.infer` 取的是 default 之后的形态），所以
    * 消费方不需要写 `?? []` 分支。
    */
-  stdioTargets: import_zod67.z.array(McpDevTicketStdioTargetSchema).max(64).default([])
+  stdioTargets: import_zod69.z.array(McpDevTicketStdioTargetSchema).max(64).default([])
 }).strict();
-var RevokeMcpDevTicketResponseSchema = import_zod67.z.object({
+var RevokeMcpDevTicketResponseSchema = import_zod69.z.object({
   /** `false` = 本来就不活跃（已撤销/不存在）。撤销是幂等的，两种都算成功。 */
-  revoked: import_zod67.z.boolean()
+  revoked: import_zod69.z.boolean()
 }).strict();
-var DevSecretEnvKeySchema = import_zod68.z.string().min(1).max(100).regex(/^[A-Z_][A-Z0-9_]*$/, "env key must match ^[A-Z_][A-Z0-9_]*$");
-var ResolveMcpDevSecretsRequestSchema = import_zod68.z.object({
-  projectId: import_zod68.z.string().uuid(),
+var DevSecretEnvKeySchema = import_zod70.z.string().min(1).max(100).regex(/^[A-Z_][A-Z0-9_]*$/, "env key must match ^[A-Z_][A-Z0-9_]*$");
+var ResolveMcpDevSecretsRequestSchema = import_zod70.z.object({
+  projectId: import_zod70.z.string().uuid(),
   /**
    * 这个 agent 声明的托管 MCP id。服务端据此推导要解哪些 `sec_*` ——
    * 只有 `stdio` 形态有凭据要下发（`remote` 走 gateway，明文不出平台）。
    */
-  managedMcpIds: import_zod68.z.array(ManagedMcpIdSchema).max(64).optional(),
+  managedMcpIds: import_zod70.z.array(ManagedMcpIdSchema).max(64).optional(),
   /**
    * `agent.yaml` 的 `env:` 里指向 secret 的条目：`envKey → sec_*`。
    *
@@ -8218,16 +8616,16 @@ var ResolveMcpDevSecretsRequestSchema = import_zod68.z.object({
    * `secrets:resolve` 的调用方本来就被授权读本项目任意 secret，所以这不扩大权限；
    * 上限在这里是为了让一次请求不能变成"把整个项目扫一遍"的批量导出工具。
    */
-  envSecretRefs: import_zod68.z.record(DevSecretEnvKeySchema, SecretPublicIdSchema).refine((refs) => Object.keys(refs).length <= 64, {
+  envSecretRefs: import_zod70.z.record(DevSecretEnvKeySchema, SecretPublicIdSchema).refine((refs) => Object.keys(refs).length <= 64, {
     message: "envSecretRefs must have at most 64 entries"
   }).optional()
 }).strict();
-var ResolveMcpDevSecretsResponseSchema = import_zod68.z.object({
+var ResolveMcpDevSecretsResponseSchema = import_zod70.z.object({
   /**
    * env 变量名 → **明文**。CLI 只把它放进子进程 env（`.mcp.json` 与 env 文件里
    * 都只写 `${VAR}` 占位符），不落盘。
    */
-  values: import_zod68.z.record(DevSecretEnvKeySchema, import_zod68.z.string()),
+  values: import_zod70.z.record(DevSecretEnvKeySchema, import_zod70.z.string()),
   /**
    * 声明了但解不出来的 env key（不存在 / 已归档 / 不属于本项目）。
    *
@@ -8235,7 +8633,7 @@ var ResolveMcpDevSecretsResponseSchema = import_zod68.z.object({
    * `${VAR}` 字面量原样传给 MCP server，于是上游报"token 无效"，排查方向被带到
    * 上游去，而真实原因是这里少了一个值。
    */
-  missing: import_zod68.z.array(import_zod68.z.string())
+  missing: import_zod70.z.array(import_zod70.z.string())
 }).strict();
 var EVAL_SUITE_API_VERSION = "agenthub/v1alpha1";
 var EVAL_SUITE_KIND = "EvalSuite";
@@ -8245,7 +8643,7 @@ var EVAL_MAX_RETRIES = 2;
 var EVAL_MAX_TURN_BYTES = 32 * 1024;
 var EVAL_MAX_FIXTURE_FILE_BYTES = 64 * 1024;
 var EVAL_MAX_FIXTURE_TOTAL_BYTES = 512 * 1024;
-var EvalRunStatusSchema = import_zod69.z.enum([
+var EvalRunStatusSchema = import_zod71.z.enum([
   "pending",
   "running",
   "passed",
@@ -8253,20 +8651,20 @@ var EvalRunStatusSchema = import_zod69.z.enum([
   "errored",
   "cancelled"
 ]);
-var EvalCaseVerdictSchema = import_zod69.z.enum(["passed", "failed", "errored"]);
-var EvalGraderStatusSchema = import_zod69.z.enum(["passed", "failed", "errored", "skipped"]);
-var EvalErrorClassSchema = import_zod69.z.enum([
+var EvalCaseVerdictSchema = import_zod71.z.enum(["passed", "failed", "errored"]);
+var EvalGraderStatusSchema = import_zod71.z.enum(["passed", "failed", "errored", "skipped"]);
+var EvalErrorClassSchema = import_zod71.z.enum([
   "capability_unavailable",
   "infrastructure_error",
   "indeterminate",
   "invalid_definition"
 ]);
-var EvalErrorCodeSchema = import_zod69.z.enum([
+var EvalErrorCodeSchema = import_zod71.z.enum([
   "EVAL_GRADER_CAPABILITY_UNAVAILABLE",
   "EVAL_SELF_EVAL_FORBIDDEN"
 ]);
 var EVAL_SCRIPT_STDOUT_TAIL_MAX_BYTES = 64 * 1024;
-var EvalTriggerSchema = import_zod69.z.enum([
+var EvalTriggerSchema = import_zod71.z.enum([
   "manual",
   "promote_gate",
   "cli",
@@ -8276,51 +8674,51 @@ var EvalTriggerSchema = import_zod69.z.enum([
   "replay",
   "pipeline"
 ]);
-var EvalSeveritySchema = import_zod69.z.enum(["gate", "soft"]);
-var EvalGraderTypeSchema = import_zod69.z.enum(["transcript", "file", "llm", "script"]);
-var EvalPassPolicySchema = import_zod69.z.enum(["all", "any"]);
-var EvalSuitePurposeSchema = import_zod69.z.enum(["regression", "capability"]);
+var EvalSeveritySchema = import_zod71.z.enum(["gate", "soft"]);
+var EvalGraderTypeSchema = import_zod71.z.enum(["transcript", "file", "llm", "script"]);
+var EvalPassPolicySchema = import_zod71.z.enum(["all", "any"]);
+var EvalSuitePurposeSchema = import_zod71.z.enum(["regression", "capability"]);
 var EVAL_SKIP_REASON_MAX = 2048;
-var EvalSuiteSkipSchema = import_zod69.z.object({ reason: import_zod69.z.string().min(1).max(EVAL_SKIP_REASON_MAX) }).strict();
-var EvalSkippedSuiteSchema = import_zod69.z.object({ path: import_zod69.z.string().min(1), reason: import_zod69.z.string().min(1) }).strict();
-var EvalConclusionStatusSchema = import_zod69.z.enum(["passed", "failed", "errored", "unassessed"]);
+var EvalSuiteSkipSchema = import_zod71.z.object({ reason: import_zod71.z.string().min(1).max(EVAL_SKIP_REASON_MAX) }).strict();
+var EvalSkippedSuiteSchema = import_zod71.z.object({ path: import_zod71.z.string().min(1), reason: import_zod71.z.string().min(1) }).strict();
+var EvalConclusionStatusSchema = import_zod71.z.enum(["passed", "failed", "errored", "unassessed"]);
 var isSafeRelativePath = (p) => !p.startsWith("/") && !p.split("/").includes("..") && !p.split("/").includes(".");
-var EvalRelativePathSchema = import_zod69.z.string().min(1).max(255).refine(isSafeRelativePath, {
+var EvalRelativePathSchema = import_zod71.z.string().min(1).max(255).refine(isSafeRelativePath, {
   message: "path must be a relative path without '.' or '..' segments"
 });
-var EvalSlugSchema = import_zod69.z.string().regex(/^[a-z0-9-]{1,64}$/, {
+var EvalSlugSchema = import_zod71.z.string().regex(/^[a-z0-9-]{1,64}$/, {
   message: "must be a slug matching [a-z0-9-]{1,64}"
 });
-var EvalTimesExprSchema = import_zod69.z.string().regex(/^(>=|<=|=|>|<)?\d+$/, {
+var EvalTimesExprSchema = import_zod71.z.string().regex(/^(>=|<=|=|>|<)?\d+$/, {
   message: 'times must match an operator + integer, e.g. ">=1", "=3", "2"'
 });
-var EvalMarkerSchema = import_zod69.z.object({
-  evalRunId: import_zod69.z.string().min(1),
+var EvalMarkerSchema = import_zod71.z.object({
+  evalRunId: import_zod71.z.string().min(1),
   caseId: EvalSlugSchema,
-  trial: import_zod69.z.number().int().nonnegative()
-}).strict();
-var EvalPatternRulesSchema = import_zod69.z.object({
-  required: import_zod69.z.array(import_zod69.z.string()).optional(),
-  forbidden: import_zod69.z.array(import_zod69.z.string()).optional()
-}).strict();
-var EvalTranscriptExpectSchema = import_zod69.z.object({
-  completed: import_zod69.z.boolean().optional(),
-  calledTool: import_zod69.z.object({ name: import_zod69.z.string().min(1), times: EvalTimesExprSchema.optional() }).strict().optional(),
-  toolOrder: import_zod69.z.array(import_zod69.z.string().min(1)).optional(),
-  forbiddenTools: import_zod69.z.array(import_zod69.z.string().min(1)).optional(),
-  calledSubagent: import_zod69.z.object({ name: import_zod69.z.string().min(1).optional(), times: EvalTimesExprSchema.optional() }).strict().optional(),
-  usedNoTools: import_zod69.z.boolean().optional(),
-  loadedSkill: import_zod69.z.string().min(1).optional(),
-  maxToolCalls: import_zod69.z.number().int().positive().optional(),
+  trial: import_zod71.z.number().int().nonnegative()
+}).strict();
+var EvalPatternRulesSchema = import_zod71.z.object({
+  required: import_zod71.z.array(import_zod71.z.string()).optional(),
+  forbidden: import_zod71.z.array(import_zod71.z.string()).optional()
+}).strict();
+var EvalTranscriptExpectSchema = import_zod71.z.object({
+  completed: import_zod71.z.boolean().optional(),
+  calledTool: import_zod71.z.object({ name: import_zod71.z.string().min(1), times: EvalTimesExprSchema.optional() }).strict().optional(),
+  toolOrder: import_zod71.z.array(import_zod71.z.string().min(1)).optional(),
+  forbiddenTools: import_zod71.z.array(import_zod71.z.string().min(1)).optional(),
+  calledSubagent: import_zod71.z.object({ name: import_zod71.z.string().min(1).optional(), times: EvalTimesExprSchema.optional() }).strict().optional(),
+  usedNoTools: import_zod71.z.boolean().optional(),
+  loadedSkill: import_zod71.z.string().min(1).optional(),
+  maxToolCalls: import_zod71.z.number().int().positive().optional(),
   commandPatterns: EvalPatternRulesSchema.optional(),
   toolInputPatterns: EvalPatternRulesSchema.optional()
 }).strict();
-var EvalTranscriptGraderSchema = import_zod69.z.object({
-  type: import_zod69.z.literal("transcript"),
+var EvalTranscriptGraderSchema = import_zod71.z.object({
+  type: import_zod71.z.literal("transcript"),
   label: EvalSlugSchema.optional(),
   severity: EvalSeveritySchema.optional(),
   // 缺省 gate
-  online: import_zod69.z.boolean().optional(),
+  online: import_zod71.z.boolean().optional(),
   /**
    * T2 真·多轮：只对第 `turn` 轮（0-based，指向 `case.turns` 的下标）的轨迹
    * 断言——可以表达"第二轮才调用 run_sql"。缺省 = 整个 trial 的合并轨迹
@@ -8332,79 +8730,79 @@ var EvalTranscriptGraderSchema = import_zod69.z.object({
    * turns 上下文；单 parse 一个 grader 不带上界，越界到 gradeTranscript
    * 才 errored——已知取舍）。
    */
-  turn: import_zod69.z.number().int().min(0).optional(),
+  turn: import_zod71.z.number().int().min(0).optional(),
   expect: EvalTranscriptExpectSchema
 }).strict();
-var EvalFileEntrySchema = import_zod69.z.object({
+var EvalFileEntrySchema = import_zod71.z.object({
   path: EvalRelativePathSchema,
-  mustMatch: import_zod69.z.array(import_zod69.z.string()).optional(),
-  mustNotMatch: import_zod69.z.array(import_zod69.z.string()).optional()
+  mustMatch: import_zod71.z.array(import_zod71.z.string()).optional(),
+  mustNotMatch: import_zod71.z.array(import_zod71.z.string()).optional()
 }).strict();
-var EvalFileShorthandExpectSchema = import_zod69.z.object({
-  includes: import_zod69.z.string().optional(),
-  equals: import_zod69.z.string().optional(),
-  matches: import_zod69.z.string().optional()
+var EvalFileShorthandExpectSchema = import_zod71.z.object({
+  includes: import_zod71.z.string().optional(),
+  equals: import_zod71.z.string().optional(),
+  matches: import_zod71.z.string().optional()
   // 正则字符串
 }).strict();
-var EvalFileGraderSchema = import_zod69.z.object({
-  type: import_zod69.z.literal("file"),
+var EvalFileGraderSchema = import_zod71.z.object({
+  type: import_zod71.z.literal("file"),
   label: EvalSlugSchema.optional(),
   severity: EvalSeveritySchema.optional(),
   // 缺省 gate
-  online: import_zod69.z.boolean().optional(),
+  online: import_zod71.z.boolean().optional(),
   // 多文件形式
-  files: import_zod69.z.array(EvalFileEntrySchema).min(1).optional(),
+  files: import_zod71.z.array(EvalFileEntrySchema).min(1).optional(),
   // 简写形式
   path: EvalRelativePathSchema.optional(),
   expect: EvalFileShorthandExpectSchema.optional()
 }).strict();
-var EvalLlmGraderSchema = import_zod69.z.object({
-  type: import_zod69.z.literal("llm"),
+var EvalLlmGraderSchema = import_zod71.z.object({
+  type: import_zod71.z.literal("llm"),
   label: EvalSlugSchema.optional(),
   severity: EvalSeveritySchema.optional(),
   // 缺省 soft
-  online: import_zod69.z.boolean().optional(),
+  online: import_zod71.z.boolean().optional(),
   rubric: EvalRelativePathSchema.refine((p) => p.endsWith(".md"), {
     message: "rubric must be a relative .md path within the suite"
   }),
-  dimensions: import_zod69.z.array(import_zod69.z.string().min(1)).optional(),
-  threshold: import_zod69.z.number().min(0).max(1),
-  graderVersion: import_zod69.z.number().int().positive()
+  dimensions: import_zod71.z.array(import_zod71.z.string().min(1)).optional(),
+  threshold: import_zod71.z.number().min(0).max(1),
+  graderVersion: import_zod71.z.number().int().positive()
 }).strict();
-var EvalScriptExpectSchema = import_zod69.z.object({
-  exitCode: import_zod69.z.number().int().optional(),
+var EvalScriptExpectSchema = import_zod71.z.object({
+  exitCode: import_zod71.z.number().int().optional(),
   // 缺省 0
-  stdoutIncludes: import_zod69.z.array(import_zod69.z.string()).optional()
+  stdoutIncludes: import_zod71.z.array(import_zod71.z.string()).optional()
 }).strict();
-var EvalScriptGraderSchema = import_zod69.z.object({
-  type: import_zod69.z.literal("script"),
+var EvalScriptGraderSchema = import_zod71.z.object({
+  type: import_zod71.z.literal("script"),
   label: EvalSlugSchema.optional(),
   severity: EvalSeveritySchema.optional(),
   // 缺省 gate
-  online: import_zod69.z.boolean().optional(),
-  run: import_zod69.z.string().min(1),
-  timeout: import_zod69.z.number().int().positive().max(EVAL_MAX_TIMEOUT_SECONDS).optional(),
+  online: import_zod71.z.boolean().optional(),
+  run: import_zod71.z.string().min(1),
+  timeout: import_zod71.z.number().int().positive().max(EVAL_MAX_TIMEOUT_SECONDS).optional(),
   expect: EvalScriptExpectSchema.optional()
 }).strict();
-var EvalGraderSpecSchema = import_zod69.z.discriminatedUnion("type", [
+var EvalGraderSpecSchema = import_zod71.z.discriminatedUnion("type", [
   EvalTranscriptGraderSchema,
   EvalFileGraderSchema,
   EvalLlmGraderSchema,
   EvalScriptGraderSchema
 ]);
-var EvalFixtureWorkspaceSchema = import_zod69.z.object({
-  repo: import_zod69.z.string().url(),
-  ref: import_zod69.z.string().min(1)
+var EvalFixtureWorkspaceSchema = import_zod71.z.object({
+  repo: import_zod71.z.string().url(),
+  ref: import_zod71.z.string().min(1)
 }).strict();
-var EvalFixtureFileSchema = import_zod69.z.object({
+var EvalFixtureFileSchema = import_zod71.z.object({
   path: EvalRelativePathSchema,
-  content: import_zod69.z.string()
+  content: import_zod71.z.string()
 }).strict();
-var EvalFixturesSchema = import_zod69.z.object({
+var EvalFixturesSchema = import_zod71.z.object({
   workspace: EvalFixtureWorkspaceSchema.optional(),
-  files: import_zod69.z.array(EvalFixtureFileSchema).optional()
+  files: import_zod71.z.array(EvalFixtureFileSchema).optional()
 }).strict();
-var EvalAgentOverridesSchema = import_zod69.z.object({
+var EvalAgentOverridesSchema = import_zod71.z.object({
   /**
    * 覆盖被测 agent 的模型。**被测 model 是 case 级可变的**：最终生效值 =
    * `agentOverrides.model ?? agent 默认 model`，故同一份卷不同 case 的被测
@@ -8417,7 +8815,7 @@ var EvalAgentOverridesSchema = import_zod69.z.object({
    * 先经 ModelGate 归一为 canonical id 再比较——**需运行时上下文，故不在本零依赖
    * 契约层做，留给 T3/T4 resolve 层的 400**。
    */
-  model: import_zod69.z.string().min(1).optional(),
+  model: import_zod71.z.string().min(1).optional(),
   /**
    * T1 语义（减法白名单）：把 revision 解析出的 skills **收窄**为名单内的
    * 子集（按 `EnabledSkill.rushSkillName` 匹配——即 agent skills.json 里写的
@@ -8426,42 +8824,42 @@ var EvalAgentOverridesSchema = import_zod69.z.object({
    * agent，是假红灯）。**不能加塞** revision 未声明的 skill——eval 测的是
    * 「已发布的 agent」，不是「一个不存在的配置」。
    */
-  skills: import_zod69.z.array(import_zod69.z.string().min(1)).optional(),
+  skills: import_zod71.z.array(import_zod71.z.string().min(1)).optional(),
   /**
    * T1 语义（减法白名单）：把 revision 解析出的 mcpServers **收窄**为名单内
    * 的子集（按 runtime `.mcp.json` 的 server 键名匹配，即 agent 实际运行的
    * server 名）。匹配规则与 fail-loud 姿态同 `skills`。stdio transport 的
    * server 仍受 `allowStdioMcp` 总闸约束（默认不注入）。
    */
-  mcpServers: import_zod69.z.array(import_zod69.z.string().min(1)).optional(),
+  mcpServers: import_zod71.z.array(import_zod71.z.string().min(1)).optional(),
   /**
    * T1 语义：追加在被测 agent 冻结 systemPrompt 之后的指令块（`\n\n` 拼接），
    * 例如注入 case 特有的输出格式要求。不能替换（替换 = 测别的 agent）。
    */
-  systemPromptAppend: import_zod69.z.string().optional()
+  systemPromptAppend: import_zod71.z.string().optional()
 }).strict();
-var EvalCaseOriginSchema = import_zod69.z.object({
-  sessionId: import_zod69.z.string().min(1),
-  capturedAt: import_zod69.z.string().min(1)
+var EvalCaseOriginSchema = import_zod71.z.object({
+  sessionId: import_zod71.z.string().min(1),
+  capturedAt: import_zod71.z.string().min(1)
 }).strict();
-var EvalCaseSchema = import_zod69.z.object({
+var EvalCaseSchema = import_zod71.z.object({
   id: EvalSlugSchema,
-  description: import_zod69.z.string().optional(),
-  turns: import_zod69.z.array(import_zod69.z.object({ user: import_zod69.z.string().min(1) }).strict()).min(1),
+  description: import_zod71.z.string().optional(),
+  turns: import_zod71.z.array(import_zod71.z.object({ user: import_zod71.z.string().min(1) }).strict()).min(1),
   fixtures: EvalFixturesSchema.optional(),
   agentOverrides: EvalAgentOverridesSchema.optional(),
-  timeout: import_zod69.z.number().int().positive().max(EVAL_MAX_TIMEOUT_SECONDS).optional(),
-  maxRetries: import_zod69.z.number().int().min(0).max(EVAL_MAX_RETRIES).optional(),
-  trials: import_zod69.z.number().int().min(1).max(EVAL_MAX_TRIALS).optional(),
+  timeout: import_zod71.z.number().int().positive().max(EVAL_MAX_TIMEOUT_SECONDS).optional(),
+  maxRetries: import_zod71.z.number().int().min(0).max(EVAL_MAX_RETRIES).optional(),
+  trials: import_zod71.z.number().int().min(1).max(EVAL_MAX_TRIALS).optional(),
   // U1，默认 1
   passPolicy: EvalPassPolicySchema.optional(),
   // U1，缺省按 purpose
   origin: EvalCaseOriginSchema.optional(),
-  allowStdioMcp: import_zod69.z.boolean().optional(),
+  allowStdioMcp: import_zod71.z.boolean().optional(),
   // 默认 false（§2.1.1 副作用面）
-  graders: import_zod69.z.array(EvalGraderSpecSchema).min(1)
+  graders: import_zod71.z.array(EvalGraderSpecSchema).min(1)
 }).strict();
-var EvalSuiteDefaultsSchema = import_zod69.z.object({
+var EvalSuiteDefaultsSchema = import_zod71.z.object({
   /**
    * llm grader 的裁判模型。**仅 suite 级、不可 case/grader 级覆盖**（也不在
    * `EvalAgentOverridesSchema` 白名单里）。
@@ -8483,27 +8881,27 @@ var EvalSuiteDefaultsSchema = import_zod69.z.object({
    * 兑现留给 T7（llm grader 实现），届时大概率取当时最合适的 judge 且做成运行面
    * 可配置，而非硬编码进契约。
    */
-  judgeModel: import_zod69.z.string().min(1).optional(),
-  timeout: import_zod69.z.number().int().positive().max(EVAL_MAX_TIMEOUT_SECONDS).optional(),
-  maxConcurrency: import_zod69.z.number().int().positive().optional()
+  judgeModel: import_zod71.z.string().min(1).optional(),
+  timeout: import_zod71.z.number().int().positive().max(EVAL_MAX_TIMEOUT_SECONDS).optional(),
+  maxConcurrency: import_zod71.z.number().int().positive().optional()
 }).strict();
 var byteLen = (s) => new TextEncoder().encode(s).length;
-var EvalSuiteSchema = import_zod69.z.object({
-  apiVersion: import_zod69.z.literal(EVAL_SUITE_API_VERSION),
-  kind: import_zod69.z.literal(EVAL_SUITE_KIND),
+var EvalSuiteSchema = import_zod71.z.object({
+  apiVersion: import_zod71.z.literal(EVAL_SUITE_API_VERSION),
+  kind: import_zod71.z.literal(EVAL_SUITE_KIND),
   purpose: EvalSuitePurposeSchema.optional(),
   // U2，默认 regression
   skip: EvalSuiteSkipSchema.optional(),
   // §4 声明跳过（带必填理由）
   defaults: EvalSuiteDefaultsSchema.optional(),
-  cases: import_zod69.z.array(EvalCaseSchema).min(1)
+  cases: import_zod71.z.array(EvalCaseSchema).min(1)
 }).strict().superRefine((suite, ctx) => {
   const seen = /* @__PURE__ */ new Set();
   suite.cases.forEach((c, ci) => {
     var _a, _b;
     if (seen.has(c.id)) {
       ctx.addIssue({
-        code: import_zod69.z.ZodIssueCode.custom,
+        code: import_zod71.z.ZodIssueCode.custom,
         path: ["cases", ci, "id"],
         message: `duplicate case id "${c.id}" (must be unique within suite)`
       });
@@ -8512,7 +8910,7 @@ var EvalSuiteSchema = import_zod69.z.object({
     c.turns.forEach((t, ti) => {
       if (byteLen(t.user) > EVAL_MAX_TURN_BYTES) {
         ctx.addIssue({
-          code: import_zod69.z.ZodIssueCode.custom,
+          code: import_zod71.z.ZodIssueCode.custom,
           path: ["cases", ci, "turns", ti, "user"],
           message: `turn exceeds ${EVAL_MAX_TURN_BYTES} bytes`
         });
@@ -8524,7 +8922,7 @@ var EvalSuiteSchema = import_zod69.z.object({
       fixtureTotal += size;
       if (size > EVAL_MAX_FIXTURE_FILE_BYTES) {
         ctx.addIssue({
-          code: import_zod69.z.ZodIssueCode.custom,
+          code: import_zod71.z.ZodIssueCode.custom,
           path: ["cases", ci, "fixtures", "files", fi, "content"],
           message: `fixture file exceeds ${EVAL_MAX_FIXTURE_FILE_BYTES} bytes`
         });
@@ -8532,7 +8930,7 @@ var EvalSuiteSchema = import_zod69.z.object({
     });
     if (fixtureTotal > EVAL_MAX_FIXTURE_TOTAL_BYTES) {
       ctx.addIssue({
-        code: import_zod69.z.ZodIssueCode.custom,
+        code: import_zod71.z.ZodIssueCode.custom,
         path: ["cases", ci, "fixtures", "files"],
         message: `fixture files total exceeds ${EVAL_MAX_FIXTURE_TOTAL_BYTES} bytes`
       });
@@ -8543,7 +8941,7 @@ var EvalSuiteSchema = import_zod69.z.object({
         const hasShorthand = g.path != null && g.expect != null;
         if (hasFiles === hasShorthand) {
           ctx.addIssue({
-            code: import_zod69.z.ZodIssueCode.custom,
+            code: import_zod71.z.ZodIssueCode.custom,
             path: ["cases", ci, "graders", gi],
             message: "file grader must use either `files[]` or `{path, expect}`, not both/neither"
           });
@@ -8551,7 +8949,7 @@ var EvalSuiteSchema = import_zod69.z.object({
       }
       if (g.type === "transcript" && g.turn != null && g.turn >= c.turns.length) {
         ctx.addIssue({
-          code: import_zod69.z.ZodIssueCode.custom,
+          code: import_zod71.z.ZodIssueCode.custom,
           path: ["cases", ci, "graders", gi, "turn"],
           message: `transcript grader turn=${g.turn} is out of range (case has ${c.turns.length} turn(s); 0-based)`
         });
@@ -8559,90 +8957,90 @@ var EvalSuiteSchema = import_zod69.z.object({
     });
   });
 });
-var ScriptEvidenceSchema = import_zod69.z.discriminatedUnion("kind", [
-  import_zod69.z.object({
-    kind: import_zod69.z.literal("executed"),
+var ScriptEvidenceSchema = import_zod71.z.discriminatedUnion("kind", [
+  import_zod71.z.object({
+    kind: import_zod71.z.literal("executed"),
     // A1
-    exitCode: import_zod69.z.number().int(),
-    stdoutTailRef: import_zod69.z.string().optional(),
+    exitCode: import_zod71.z.number().int(),
+    stdoutTailRef: import_zod71.z.string().optional(),
     // 超限内容走 OSS ref
-    durationMs: import_zod69.z.number().int().nonnegative()
+    durationMs: import_zod71.z.number().int().nonnegative()
   }).strict(),
-  import_zod69.z.object({
-    kind: import_zod69.z.literal("capability_unavailable"),
+  import_zod71.z.object({
+    kind: import_zod71.z.literal("capability_unavailable"),
     // A0
-    capability: import_zod69.z.literal("script_grader"),
-    phase: import_zod69.z.literal("A0")
+    capability: import_zod71.z.literal("script_grader"),
+    phase: import_zod71.z.literal("A0")
   }).strict()
 ]);
-var EvalGraderEvidenceSchema = import_zod69.z.discriminatedUnion("type", [
-  import_zod69.z.object({
-    type: import_zod69.z.literal("transcript"),
-    matchedEventIds: import_zod69.z.array(import_zod69.z.string()).optional(),
-    violatedCheck: import_zod69.z.string().optional()
+var EvalGraderEvidenceSchema = import_zod71.z.discriminatedUnion("type", [
+  import_zod71.z.object({
+    type: import_zod71.z.literal("transcript"),
+    matchedEventIds: import_zod71.z.array(import_zod71.z.string()).optional(),
+    violatedCheck: import_zod71.z.string().optional()
   }).strict(),
-  import_zod69.z.object({
-    type: import_zod69.z.literal("file"),
-    path: import_zod69.z.string(),
-    excerpt: import_zod69.z.string().max(2048).optional()
+  import_zod71.z.object({
+    type: import_zod71.z.literal("file"),
+    path: import_zod71.z.string(),
+    excerpt: import_zod71.z.string().max(2048).optional()
     // ≤2KB
   }).strict(),
-  import_zod69.z.object({
-    type: import_zod69.z.literal("llm"),
-    judgeModel: import_zod69.z.string(),
-    rubricSha: import_zod69.z.string(),
+  import_zod71.z.object({
+    type: import_zod71.z.literal("llm"),
+    judgeModel: import_zod71.z.string(),
+    rubricSha: import_zod71.z.string(),
     // U5：离散档位 + 锚点文本（不是换算后小数）
-    dimensionScores: import_zod69.z.record(import_zod69.z.string(), import_zod69.z.unknown()).optional(),
-    judgeOutputRef: import_zod69.z.string().optional()
+    dimensionScores: import_zod71.z.record(import_zod71.z.string(), import_zod71.z.unknown()).optional(),
+    judgeOutputRef: import_zod71.z.string().optional()
     // judge 原始输出 OSS ref
   }).strict(),
-  import_zod69.z.object({ type: import_zod69.z.literal("script"), evidence: ScriptEvidenceSchema }).strict()
+  import_zod71.z.object({ type: import_zod71.z.literal("script"), evidence: ScriptEvidenceSchema }).strict()
 ]);
-var GraderVerdictSchema = import_zod69.z.object({
-  graderIndex: import_zod69.z.number().int().nonnegative(),
-  graderKey: import_zod69.z.string(),
+var GraderVerdictSchema = import_zod71.z.object({
+  graderIndex: import_zod71.z.number().int().nonnegative(),
+  graderKey: import_zod71.z.string(),
   type: EvalGraderTypeSchema,
   severity: EvalSeveritySchema,
   // resolve 后终值
-  label: import_zod69.z.string().optional(),
+  label: import_zod71.z.string().optional(),
   status: EvalGraderStatusSchema,
   errorClass: EvalErrorClassSchema.optional(),
   // status=errored 时
   errorCode: EvalErrorCodeSchema.optional(),
   // status=errored 时
-  score: import_zod69.z.number().nullable(),
+  score: import_zod71.z.number().nullable(),
   // llm=0~1；二值 grader=null
-  threshold: import_zod69.z.number().optional(),
-  reason: import_zod69.z.string(),
+  threshold: import_zod71.z.number().optional(),
+  reason: import_zod71.z.string(),
   evidence: EvalGraderEvidenceSchema.optional(),
-  graderVersion: import_zod69.z.number().int().optional(),
-  engineVersion: import_zod69.z.string(),
+  graderVersion: import_zod71.z.number().int().optional(),
+  engineVersion: import_zod71.z.string(),
   // 平台 grader 实现版本，基线口径用
-  durationMs: import_zod69.z.number().int().nonnegative().optional()
+  durationMs: import_zod71.z.number().int().nonnegative().optional()
 }).strict();
-var EvalCaseResultSchema = import_zod69.z.object({
-  caseId: import_zod69.z.string(),
-  trial: import_zod69.z.number().int().nonnegative(),
+var EvalCaseResultSchema = import_zod71.z.object({
+  caseId: import_zod71.z.string(),
+  trial: import_zod71.z.number().int().nonnegative(),
   // U1，online_sample 恒 0
-  attempt: import_zod69.z.number().int().nonnegative(),
+  attempt: import_zod71.z.number().int().nonnegative(),
   // 基础设施重试序
-  sessionId: import_zod69.z.string().optional(),
+  sessionId: import_zod71.z.string().optional(),
   verdict: EvalCaseVerdictSchema,
-  caseDefinitionDigest: import_zod69.z.string(),
+  caseDefinitionDigest: import_zod71.z.string(),
   errorClass: EvalErrorClassSchema.optional(),
   errorCode: EvalErrorCodeSchema.optional(),
-  softMisses: import_zod69.z.array(import_zod69.z.string()),
-  softIncomplete: import_zod69.z.array(import_zod69.z.string()),
-  graders: import_zod69.z.array(GraderVerdictSchema),
-  resolvedRef: import_zod69.z.string().optional()
+  softMisses: import_zod71.z.array(import_zod71.z.string()),
+  softIncomplete: import_zod71.z.array(import_zod71.z.string()),
+  graders: import_zod71.z.array(GraderVerdictSchema),
+  resolvedRef: import_zod71.z.string().optional()
   // fixtures.workspace.ref → commit SHA
 }).strict();
-var EvalRunSummarySchema = import_zod69.z.object({
-  total: import_zod69.z.number().int().nonnegative(),
-  passed: import_zod69.z.number().int().nonnegative(),
-  failed: import_zod69.z.number().int().nonnegative(),
-  errored: import_zod69.z.number().int().nonnegative(),
-  gatePass: import_zod69.z.boolean(),
+var EvalRunSummarySchema = import_zod71.z.object({
+  total: import_zod71.z.number().int().nonnegative(),
+  passed: import_zod71.z.number().int().nonnegative(),
+  failed: import_zod71.z.number().int().nonnegative(),
+  errored: import_zod71.z.number().int().nonnegative(),
+  gatePass: import_zod71.z.boolean(),
   // 正向断言：全部 case 的全部 gate grader 显式 passed
   /**
    * v1.2：本 run 参与门禁的 grader 总数。零 gate grader 时 `gatePass` 按「真空为真」
@@ -8650,116 +9048,116 @@ var EvalRunSummarySchema = import_zod69.z.object({
    * 本字段让使用者一眼分辨「真的全部通过」与「压根没有门禁断言」。
    * optional：老数据无此字段。
    */
-  gateGraderCount: import_zod69.z.number().int().nonnegative().optional(),
+  gateGraderCount: import_zod71.z.number().int().nonnegative().optional(),
   /**
    * v1.2：有多少 case 一个 gate grader 都没有（各自「真空为真」）。`gateGraderCount`
    * 是 sum，只能答「全 run 有没有任何门禁断言」；本字段答「是否每个 case 都有」——
    * `gatePass=true` 但本值 > 0 = 有 case 无门禁却被算作通过（case 级假绿）。optional：老数据无。
    */
-  casesWithoutGateGrader: import_zod69.z.number().int().nonnegative().optional(),
-  errorSummary: import_zod69.z.object({
-    capabilityUnavailable: import_zod69.z.number().int().nonnegative(),
-    infrastructureError: import_zod69.z.number().int().nonnegative(),
+  casesWithoutGateGrader: import_zod71.z.number().int().nonnegative().optional(),
+  errorSummary: import_zod71.z.object({
+    capabilityUnavailable: import_zod71.z.number().int().nonnegative(),
+    infrastructureError: import_zod71.z.number().int().nonnegative(),
     /** v1.2：judge 未能给出结论（gate llm UNKNOWN）。optional：老数据无此字段。 */
-    indeterminate: import_zod69.z.number().int().nonnegative().optional(),
+    indeterminate: import_zod71.z.number().int().nonnegative().optional(),
     /** v1.2：定义写错（自评防护 EVAL_SELF_EVAL_FORBIDDEN）。optional：老数据无此字段。 */
-    invalidDefinition: import_zod69.z.number().int().nonnegative().optional()
+    invalidDefinition: import_zod71.z.number().int().nonnegative().optional()
   }).loose().optional()
 }).loose();
 var EvalRunSummaryWriteSchema = EvalRunSummarySchema.extend({
   errorSummary: EvalRunSummarySchema.shape.errorSummary.unwrap().strict().optional()
 }).strict();
-var EvalSuiteRefSchema = import_zod69.z.object({
-  source: import_zod69.z.enum(["package", "repo"]),
-  digest: import_zod69.z.string().min(1),
-  path: import_zod69.z.string().min(1)
+var EvalSuiteRefSchema = import_zod71.z.object({
+  source: import_zod71.z.enum(["package", "repo"]),
+  digest: import_zod71.z.string().min(1),
+  path: import_zod71.z.string().min(1)
 }).strict();
-var CreateEvalRunRequestSchema = import_zod69.z.object({
-  agent: import_zod69.z.string().min(1),
+var CreateEvalRunRequestSchema = import_zod71.z.object({
+  agent: import_zod71.z.string().min(1),
   // A0 只打 test stage（§9 非目标：不做 prod 直评）。用 enum 而非 literal——
   // 将来放开 staging/prod 时「enum 加值」是非破坏性变更，literal 变 enum 才是
   // 破坏性变更（T1 评审建议，见设计文档 §2.1.6）。
-  stage: import_zod69.z.enum(["test"]),
+  stage: import_zod71.z.enum(["test"]),
   suiteRef: EvalSuiteRefSchema.optional(),
   // 缺省=目标 Revision 绑定的 suite
-  caseIds: import_zod69.z.array(EvalSlugSchema).optional(),
-  strict: import_zod69.z.boolean().optional()
+  caseIds: import_zod71.z.array(EvalSlugSchema).optional(),
+  strict: import_zod71.z.boolean().optional()
 }).strict();
-var CreateEvalRunResponseSchema = import_zod69.z.object({ runId: import_zod69.z.string().min(1) }).strict();
-var CancelEvalRunResponseSchema = import_zod69.z.object({ runId: import_zod69.z.string().min(1), cancelled: import_zod69.z.boolean() }).strict();
-var EvalRunViewSchema = import_zod69.z.object({
-  runId: import_zod69.z.string(),
+var CreateEvalRunResponseSchema = import_zod71.z.object({ runId: import_zod71.z.string().min(1) }).strict();
+var CancelEvalRunResponseSchema = import_zod71.z.object({ runId: import_zod71.z.string().min(1), cancelled: import_zod71.z.boolean() }).strict();
+var EvalRunViewSchema = import_zod71.z.object({
+  runId: import_zod71.z.string(),
   status: EvalRunStatusSchema,
-  agent: import_zod69.z.string(),
-  revisionId: import_zod69.z.string(),
-  stage: import_zod69.z.string(),
+  agent: import_zod71.z.string(),
+  revisionId: import_zod71.z.string(),
+  stage: import_zod71.z.string(),
   suiteRef: EvalSuiteRefSchema,
-  strict: import_zod69.z.boolean(),
+  strict: import_zod71.z.boolean(),
   trigger: EvalTriggerSchema,
-  startedAt: import_zod69.z.string().optional(),
-  completedAt: import_zod69.z.string().optional(),
-  cases: import_zod69.z.array(EvalCaseResultSchema),
+  startedAt: import_zod71.z.string().optional(),
+  completedAt: import_zod71.z.string().optional(),
+  cases: import_zod71.z.array(EvalCaseResultSchema),
   summary: EvalRunSummarySchema
 }).strict();
-var EvalRunListItemSchema = import_zod69.z.object({
-  runId: import_zod69.z.string(),
+var EvalRunListItemSchema = import_zod71.z.object({
+  runId: import_zod71.z.string(),
   status: EvalRunStatusSchema,
-  agent: import_zod69.z.string(),
-  revisionId: import_zod69.z.string(),
-  stage: import_zod69.z.string(),
+  agent: import_zod71.z.string(),
+  revisionId: import_zod71.z.string(),
+  stage: import_zod71.z.string(),
   trigger: EvalTriggerSchema,
-  startedAt: import_zod69.z.string().optional(),
-  completedAt: import_zod69.z.string().optional(),
+  startedAt: import_zod71.z.string().optional(),
+  completedAt: import_zod71.z.string().optional(),
   summary: EvalRunSummarySchema
 }).strict();
-var EvalRunListResponseSchema = import_zod69.z.object({
-  items: import_zod69.z.array(EvalRunListItemSchema),
-  nextCursor: import_zod69.z.string().optional()
+var EvalRunListResponseSchema = import_zod71.z.object({
+  items: import_zod71.z.array(EvalRunListItemSchema),
+  nextCursor: import_zod71.z.string().optional()
 }).strict();
 var PIPELINE_COMMIT_SHA_RE = /^[0-9a-f]{7,64}$/i;
-var CommitShaSchema = import_zod70.z.string().regex(PIPELINE_COMMIT_SHA_RE, {
+var CommitShaSchema = import_zod72.z.string().regex(PIPELINE_COMMIT_SHA_RE, {
   message: "commitSha must be 7-64 hexadecimal characters"
 });
 var PIPELINE_FULL_COMMIT_SHA_RE = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/i;
-var FullCommitShaSchema = import_zod70.z.string().regex(PIPELINE_FULL_COMMIT_SHA_RE, {
+var FullCommitShaSchema = import_zod72.z.string().regex(PIPELINE_FULL_COMMIT_SHA_RE, {
   message: "commitSha must be a full 40- or 64-character hexadecimal SHA (short prefixes cannot anchor a release)"
 });
 var PIPELINE_TRIGGERED_REF_MAX_LENGTH = 512;
-var TriggeredRefSchema = import_zod70.z.string().min(1).max(PIPELINE_TRIGGERED_REF_MAX_LENGTH);
-var IsoTimestampSchema = import_zod70.z.string().datetime({ offset: true });
+var TriggeredRefSchema = import_zod72.z.string().min(1).max(PIPELINE_TRIGGERED_REF_MAX_LENGTH);
+var IsoTimestampSchema = import_zod72.z.string().datetime({ offset: true });
 var NullableIsoTimestampSchema = IsoTimestampSchema.nullable();
-var PipelineTriggerSchema = import_zod70.z.enum(PIPELINE_TRIGGERS);
-var PipelineRunStatusSchema = import_zod70.z.enum(PIPELINE_RUN_STATUSES);
-var PipelineStepSchema = import_zod70.z.enum(PIPELINE_STEPS);
-var PipelineStepStatusSchema = import_zod70.z.enum(PIPELINE_STEP_STATUSES);
-var PipelineErrorCodeSchema = import_zod70.z.string().min(1).nullable();
-var ListPipelineRunsQuerySchema = import_zod70.z.object({
-  projectId: import_zod70.z.string().uuid(),
-  limit: import_zod70.z.coerce.number().int().min(1).max(200).default(50)
-}).strict();
-var NullableTriggeredRefSchema = import_zod70.z.string().nullable().optional();
-var PipelineRunListItemSchema = import_zod70.z.object({
-  id: import_zod70.z.string().uuid(),
-  commitSha: import_zod70.z.string(),
-  commitMessage: import_zod70.z.string().nullable(),
+var PipelineTriggerSchema = import_zod72.z.enum(PIPELINE_TRIGGERS);
+var PipelineRunStatusSchema = import_zod72.z.enum(PIPELINE_RUN_STATUSES);
+var PipelineStepSchema = import_zod72.z.enum(PIPELINE_STEPS);
+var PipelineStepStatusSchema = import_zod72.z.enum(PIPELINE_STEP_STATUSES);
+var PipelineErrorCodeSchema = import_zod72.z.string().min(1).nullable();
+var ListPipelineRunsQuerySchema = import_zod72.z.object({
+  projectId: import_zod72.z.string().uuid(),
+  limit: import_zod72.z.coerce.number().int().min(1).max(200).default(50)
+}).strict();
+var NullableTriggeredRefSchema = import_zod72.z.string().nullable().optional();
+var PipelineRunListItemSchema = import_zod72.z.object({
+  id: import_zod72.z.string().uuid(),
+  commitSha: import_zod72.z.string(),
+  commitMessage: import_zod72.z.string().nullable(),
   trigger: PipelineTriggerSchema,
   status: PipelineRunStatusSchema,
-  stagesKey: import_zod70.z.string(),
-  attempt: import_zod70.z.number().int().nonnegative(),
-  agentSlugs: import_zod70.z.array(import_zod70.z.string()),
-  createdBy: import_zod70.z.string().nullable(),
+  stagesKey: import_zod72.z.string(),
+  attempt: import_zod72.z.number().int().nonnegative(),
+  agentSlugs: import_zod72.z.array(import_zod72.z.string()),
+  createdBy: import_zod72.z.string().nullable(),
   createdAt: IsoTimestampSchema,
   startedAt: NullableIsoTimestampSchema,
   completedAt: NullableIsoTimestampSchema,
   errorCode: PipelineErrorCodeSchema,
   triggeredRef: NullableTriggeredRefSchema
 }).strict();
-var ListPipelineRunsResponseSchema = import_zod70.z.object({
-  enabled: import_zod70.z.boolean(),
-  items: import_zod70.z.array(PipelineRunListItemSchema)
+var ListPipelineRunsResponseSchema = import_zod72.z.object({
+  enabled: import_zod72.z.boolean(),
+  items: import_zod72.z.array(PipelineRunListItemSchema)
 }).strict();
-var CreatePipelineRunRequestSchema = import_zod70.z.object({
-  projectId: import_zod70.z.string().uuid(),
+var CreatePipelineRunRequestSchema = import_zod72.z.object({
+  projectId: import_zod72.z.string().uuid(),
   commitSha: FullCommitShaSchema,
   /**
    * Explicit re-run: mint `attempt+1` even when the latest run for this
@@ -8768,7 +9166,7 @@ var CreatePipelineRunRequestSchema = import_zod70.z.object({
    * against servers that predate it (`.strict()` on their side). Non-passed
    * terminal runs re-run automatically without this flag (§4).
    */
-  rerun: import_zod70.z.boolean().optional(),
+  rerun: import_zod72.z.boolean().optional(),
   /**
    * The ref the caller resolved `commitSha` from, recorded for display only
    * (see `TriggeredRefSchema`). Optional: a caller that has just a SHA and no
@@ -8781,54 +9179,54 @@ var CreatePipelineRunRequestSchema = import_zod70.z.object({
    */
   triggeredRef: TriggeredRefSchema.optional()
 }).strict();
-var CreatePipelineRunResponseSchema = import_zod70.z.object({
-  runId: import_zod70.z.string().uuid(),
-  deduplicated: import_zod70.z.boolean(),
-  attempt: import_zod70.z.number().int().nonnegative().optional(),
+var CreatePipelineRunResponseSchema = import_zod72.z.object({
+  runId: import_zod72.z.string().uuid(),
+  deduplicated: import_zod72.z.boolean(),
+  attempt: import_zod72.z.number().int().nonnegative().optional(),
   status: PipelineRunStatusSchema.optional()
 });
-var PipelineRunDetailRunSchema = import_zod70.z.object({
-  id: import_zod70.z.string().uuid(),
-  projectId: import_zod70.z.string().uuid(),
-  repoUrl: import_zod70.z.string(),
-  commitSha: import_zod70.z.string(),
-  commitMessage: import_zod70.z.string().nullable(),
+var PipelineRunDetailRunSchema = import_zod72.z.object({
+  id: import_zod72.z.string().uuid(),
+  projectId: import_zod72.z.string().uuid(),
+  repoUrl: import_zod72.z.string(),
+  commitSha: import_zod72.z.string(),
+  commitMessage: import_zod72.z.string().nullable(),
   trigger: PipelineTriggerSchema,
   status: PipelineRunStatusSchema,
-  stagesRequested: import_zod70.z.array(PipelineStepSchema).nullable(),
-  stagesKey: import_zod70.z.string(),
-  attempt: import_zod70.z.number().int().nonnegative(),
-  planJson: import_zod70.z.unknown().nullable(),
+  stagesRequested: import_zod72.z.array(PipelineStepSchema).nullable(),
+  stagesKey: import_zod72.z.string(),
+  attempt: import_zod72.z.number().int().nonnegative(),
+  planJson: import_zod72.z.unknown().nullable(),
   errorCode: PipelineErrorCodeSchema,
-  errorMessage: import_zod70.z.string().nullable(),
-  createdBy: import_zod70.z.string().nullable(),
+  errorMessage: import_zod72.z.string().nullable(),
+  createdBy: import_zod72.z.string().nullable(),
   createdAt: IsoTimestampSchema,
   startedAt: NullableIsoTimestampSchema,
   completedAt: NullableIsoTimestampSchema,
   triggeredRef: NullableTriggeredRefSchema
 }).strict();
-var PipelineRunStepSchema = import_zod70.z.object({
+var PipelineRunStepSchema = import_zod72.z.object({
   step: PipelineStepSchema,
   status: PipelineStepStatusSchema,
-  attempt: import_zod70.z.number().int().nonnegative(),
-  resultJson: import_zod70.z.unknown().nullable(),
+  attempt: import_zod72.z.number().int().nonnegative(),
+  resultJson: import_zod72.z.unknown().nullable(),
   errorCode: PipelineErrorCodeSchema,
-  errorMessage: import_zod70.z.string().nullable(),
+  errorMessage: import_zod72.z.string().nullable(),
   startedAt: NullableIsoTimestampSchema,
   completedAt: NullableIsoTimestampSchema
 }).strict();
-var PipelineRunWorkloadSchema = import_zod70.z.object({
-  agentSlug: import_zod70.z.string(),
-  affectedReason: import_zod70.z.string().nullable(),
-  workloadId: import_zod70.z.string().nullable(),
-  revisionId: import_zod70.z.string().nullable(),
-  repointStatus: import_zod70.z.string().nullable(),
-  freezeStatus: import_zod70.z.string().nullable(),
-  frozenPackageOssUrl: import_zod70.z.string().nullable(),
-  frozenPackageSha256: import_zod70.z.string().nullable(),
-  frozenPackageWarnings: import_zod70.z.array(import_zod70.z.string()).nullable(),
-  evalRunId: import_zod70.z.string().nullable(),
-  evalVerdict: import_zod70.z.string().nullable(),
+var PipelineRunWorkloadSchema = import_zod72.z.object({
+  agentSlug: import_zod72.z.string(),
+  affectedReason: import_zod72.z.string().nullable(),
+  workloadId: import_zod72.z.string().nullable(),
+  revisionId: import_zod72.z.string().nullable(),
+  repointStatus: import_zod72.z.string().nullable(),
+  freezeStatus: import_zod72.z.string().nullable(),
+  frozenPackageOssUrl: import_zod72.z.string().nullable(),
+  frozenPackageSha256: import_zod72.z.string().nullable(),
+  frozenPackageWarnings: import_zod72.z.array(import_zod72.z.string()).nullable(),
+  evalRunId: import_zod72.z.string().nullable(),
+  evalVerdict: import_zod72.z.string().nullable(),
   /**
    * joined | skipped_no_base_revision | skipped_no_image_change | failed.
    *
@@ -8837,7 +9235,7 @@ var PipelineRunWorkloadSchema = import_zod70.z.object({
    * so a client parsing a response from a control-plane that predates these
    * fields must not throw. Absent and null both read as "not reported".
    */
-  joinStatus: import_zod70.z.string().nullable().optional(),
+  joinStatus: import_zod72.z.string().nullable().optional(),
   /**
    * Per-workload failure, so a client can say WHICH agent failed and why —
    * the run/step level only ever counts failures. Deliberately NOT
@@ -8849,16 +9247,16 @@ var PipelineRunWorkloadSchema = import_zod70.z.object({
    * `.max()`-ed here — a schema cap would upgrade "the error text is long"
    * into "the whole response fails to parse".
    */
-  errorCode: import_zod70.z.string().nullable().optional(),
-  errorMessage: import_zod70.z.string().nullable().optional()
+  errorCode: import_zod72.z.string().nullable().optional(),
+  errorMessage: import_zod72.z.string().nullable().optional()
 }).strict();
-var PipelineRunDetailResponseSchema = import_zod70.z.object({
+var PipelineRunDetailResponseSchema = import_zod72.z.object({
   run: PipelineRunDetailRunSchema,
-  steps: import_zod70.z.array(PipelineRunStepSchema),
-  workloads: import_zod70.z.array(PipelineRunWorkloadSchema)
+  steps: import_zod72.z.array(PipelineRunStepSchema),
+  workloads: import_zod72.z.array(PipelineRunWorkloadSchema)
 }).strict();
-var GetPipelinePlanQuerySchema = import_zod70.z.object({
-  projectId: import_zod70.z.string().uuid(),
+var GetPipelinePlanQuerySchema = import_zod72.z.object({
+  projectId: import_zod72.z.string().uuid(),
   commitSha: CommitShaSchema,
   fromSha: CommitShaSchema.optional(),
   /**
@@ -8866,20 +9264,20 @@ var GetPipelinePlanQuerySchema = import_zod70.z.object({
    * Accepted as the STRING "false" because it arrives as a query param; any
    * other value (including absent) means "compute if missing".
    */
-  enqueue: import_zod70.z.enum(["true", "false"]).optional().transform((value) => value !== "false")
+  enqueue: import_zod72.z.enum(["true", "false"]).optional().transform((value) => value !== "false")
 }).strict();
-var PipelinePlanResponseSchema = import_zod70.z.discriminatedUnion("source", [
-  import_zod70.z.object({ source: import_zod70.z.literal("cache"), plan: import_zod70.z.unknown() }).strict(),
-  import_zod70.z.object({
-    source: import_zod70.z.literal("computing"),
-    enqueued: import_zod70.z.boolean(),
+var PipelinePlanResponseSchema = import_zod72.z.discriminatedUnion("source", [
+  import_zod72.z.object({ source: import_zod72.z.literal("cache"), plan: import_zod72.z.unknown() }).strict(),
+  import_zod72.z.object({
+    source: import_zod72.z.literal("computing"),
+    enqueued: import_zod72.z.boolean(),
     // 上一次计算的失败摘要（若有）。默认 enqueue=true 会不断重算，plan 一直
     // "computing" 时失败原本被吞——带上它让轮询者看到「在重试，但上次失败：…」
     // 而不是无限"计算中"（#1346 D4）。
     // 长度上游已有界（plan-cache fail() 落库前截断 2000），这里刻意不设
     // .max()：schema 硬上限会把"错误信息超长"升级成"整个响应 parse 失败"，
     // 让错误路径反过来炸掉主功能。
-    lastError: import_zod70.z.string().nullable().optional()
+    lastError: import_zod72.z.string().nullable().optional()
   }).strict()
 ]);
 var PIPELINE_API_ERROR_CODES = [
@@ -8890,23 +9288,23 @@ var PIPELINE_API_ERROR_CODES = [
   "PIPELINE_RUN_NOT_FOUND",
   "PLAN_NOT_CACHED"
 ];
-var PipelineApiErrorCodeSchema = import_zod70.z.enum(PIPELINE_API_ERROR_CODES);
+var PipelineApiErrorCodeSchema = import_zod72.z.enum(PIPELINE_API_ERROR_CODES);
 var SKILL_NAME_MAX_LENGTH = 200;
 var SKILL_SOURCE_REF_MAX_LENGTH = 512;
 var SKILL_NAME_WHITELIST = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
-var SkillNameSchema = import_zod71.z.string().min(1).max(SKILL_NAME_MAX_LENGTH).refine((value) => SKILL_NAME_WHITELIST.test(value), {
+var SkillNameSchema = import_zod73.z.string().min(1).max(SKILL_NAME_MAX_LENGTH).refine((value) => SKILL_NAME_WHITELIST.test(value), {
   message: "skill name must start with [A-Za-z0-9] and contain only [A-Za-z0-9._-] (no path separators, spaces or invisible characters)"
 }).refine((value) => value !== "." && value !== "..", {
   message: "skill name must not be '.' or '..'"
 });
-var SkillSourceRefSchema = import_zod71.z.string().min(1).max(SKILL_SOURCE_REF_MAX_LENGTH);
-var SkillManifestSourceTypeSchema = import_zod71.z.enum(["rush", "github", "gitlab"]);
-var SkillsManifestDefaultsSchema = import_zod71.z.object({
-  installDir: import_zod71.z.string().min(1).max(SKILL_SOURCE_REF_MAX_LENGTH).optional(),
-  targetAgents: import_zod71.z.array(import_zod71.z.string().min(1)).optional(),
-  installMode: import_zod71.z.string().min(1).optional()
+var SkillSourceRefSchema = import_zod73.z.string().min(1).max(SKILL_SOURCE_REF_MAX_LENGTH);
+var SkillManifestSourceTypeSchema = import_zod73.z.enum(["rush", "github", "gitlab"]);
+var SkillsManifestDefaultsSchema = import_zod73.z.object({
+  installDir: import_zod73.z.string().min(1).max(SKILL_SOURCE_REF_MAX_LENGTH).optional(),
+  targetAgents: import_zod73.z.array(import_zod73.z.string().min(1)).optional(),
+  installMode: import_zod73.z.string().min(1).optional()
 }).passthrough();
-var SkillsManifestSchema = import_zod71.z.object({
+var SkillsManifestSchema = import_zod73.z.object({
   /**
    * **必填，刻意不做 `.optional().default({})`**（评审提过，权衡后维持）：
    * 本 schema 是 passthrough 的，若 `skills` 可省略，一个拼错的顶层 key
@@ -8915,27 +9313,27 @@ var SkillsManifestSchema = import_zod71.z.object({
    * 看到一条报错、补上 `"skills": {}`：响的、可恢复的。空清单请显式写
    * `{"skills": {}}`（脚手架生成的就是这个形态）。
    */
-  skills: import_zod71.z.record(SkillNameSchema, SkillSourceRefSchema),
-  registries: import_zod71.z.record(import_zod71.z.string().min(1), import_zod71.z.string().min(1)).optional(),
+  skills: import_zod73.z.record(SkillNameSchema, SkillSourceRefSchema),
+  registries: import_zod73.z.record(import_zod73.z.string().min(1), import_zod73.z.string().min(1)).optional(),
   defaults: SkillsManifestDefaultsSchema.optional()
 }).passthrough();
-var SkillsLockEntrySchema = import_zod71.z.object({
-  source: import_zod71.z.string().min(1).max(SKILL_SOURCE_REF_MAX_LENGTH),
+var SkillsLockEntrySchema = import_zod73.z.object({
+  source: import_zod73.z.string().min(1).max(SKILL_SOURCE_REF_MAX_LENGTH),
   /** 注册表源的精确版本；git 源这里是可读注记（实测常为 `main`）。 */
-  version: import_zod71.z.string().optional(),
+  version: import_zod73.z.string().optional(),
   /** 浮动 ref 的人类可读注记——**绝不参与安装**（D23）。 */
-  ref: import_zod71.z.string().optional(),
-  resolved: import_zod71.z.string().optional(),
+  ref: import_zod73.z.string().optional(),
+  resolved: import_zod73.z.string().optional(),
   /** git 源的钉死点。实测可能为 `""`（缺 commit），由校验层硬拒。 */
-  commit: import_zod71.z.string().optional(),
-  integrity: import_zod71.z.string().optional(),
-  installedAt: import_zod71.z.string().optional()
+  commit: import_zod73.z.string().optional(),
+  integrity: import_zod73.z.string().optional(),
+  installedAt: import_zod73.z.string().optional()
 }).passthrough();
-var SkillsLockSchema = import_zod71.z.object({
-  lockfileVersion: import_zod71.z.number().int().nonnegative().optional(),
-  skills: import_zod71.z.record(SkillNameSchema, SkillsLockEntrySchema)
+var SkillsLockSchema = import_zod73.z.object({
+  lockfileVersion: import_zod73.z.number().int().nonnegative().optional(),
+  skills: import_zod73.z.record(SkillNameSchema, SkillsLockEntrySchema)
 }).passthrough();
-var SkillsManifestErrorCodeSchema = import_zod71.z.enum([
+var SkillsManifestErrorCodeSchema = import_zod73.z.enum([
   /** `skills.json` 语法/结构非法。 */
   "SKILLS_MANIFEST_INVALID",
   /** `skills.lock` 语法/结构非法。 */
@@ -9071,7 +9469,7 @@ var BindingsResource = class {
 };
 
 // src/resources/environments.ts
-var import_zod72 = require("zod");
+var import_zod74 = require("zod");
 
 // src/agent-vocab.ts
 function resolveExclusiveAlias(canonicalKey, canonicalValue, aliasKey, aliasValue) {
@@ -9095,24 +9493,24 @@ function attachAgentAliases(data) {
 }
 
 // src/resources/environments.ts
-var EnvironmentVersionHistorySchema = import_zod72.z.object({
-  versions: import_zod72.z.array(EnvironmentVersionSchema),
-  repoints: import_zod72.z.array(EnvironmentRepointRecordSchema)
+var EnvironmentVersionHistorySchema = import_zod74.z.object({
+  versions: import_zod74.z.array(EnvironmentVersionSchema),
+  repoints: import_zod74.z.array(EnvironmentRepointRecordSchema)
 }).strict();
-var RepointedSlotResultSchema = import_zod72.z.object({
-  workloadId: import_zod72.z.string().uuid(),
+var RepointedSlotResultSchema = import_zod74.z.object({
+  workloadId: import_zod74.z.string().uuid(),
   stage: StageSchema,
-  fromVersion: import_zod72.z.number().int().positive().nullable()
+  fromVersion: import_zod74.z.number().int().positive().nullable()
 }).strict();
-var RepointEnvironmentResultSchema = import_zod72.z.object({
-  toVersion: import_zod72.z.number().int().positive(),
-  repointedSlotCount: import_zod72.z.number().int().nonnegative(),
-  repointedSlots: import_zod72.z.array(RepointedSlotResultSchema)
+var RepointEnvironmentResultSchema = import_zod74.z.object({
+  toVersion: import_zod74.z.number().int().positive(),
+  repointedSlotCount: import_zod74.z.number().int().nonnegative(),
+  repointedSlots: import_zod74.z.array(RepointedSlotResultSchema)
 }).strict();
-var UpdateEnvironmentResultSchema = import_zod72.z.object({
+var UpdateEnvironmentResultSchema = import_zod74.z.object({
   environment: EnvironmentSchema,
-  createdVersion: import_zod72.z.number().int().positive().nullable(),
-  repointedSlotCount: import_zod72.z.number().int().nonnegative()
+  createdVersion: import_zod74.z.number().int().positive().nullable(),
+  repointedSlotCount: import_zod74.z.number().int().nonnegative()
 }).strict();
 function attachAgentAliasesToEach(items) {
   return items.map((item) => attachAgentAliases(item));
@@ -9433,14 +9831,14 @@ var McpDevTicketsResource = class {
 };
 
 // src/resources/memories.ts
-var import_zod73 = require("zod");
+var import_zod75 = require("zod");
 var ListedMemorySchema = AgentMemorySchema.extend({
-  createdAt: import_zod73.z.string(),
-  updatedAt: import_zod73.z.string()
+  createdAt: import_zod75.z.string(),
+  updatedAt: import_zod75.z.string()
 });
-var ListMemoriesResponseSchema = import_zod73.z.object({
-  items: import_zod73.z.array(ListedMemorySchema),
-  nextCursor: import_zod73.z.string().nullish()
+var ListMemoriesResponseSchema = import_zod75.z.object({
+  items: import_zod75.z.array(ListedMemorySchema),
+  nextCursor: import_zod75.z.string().nullish()
 });
 function parseEnvelopeData2(envelope, routeLabel, schema) {
   if (envelope?.data === void 0) {
@@ -9911,7 +10309,7 @@ var ProjectsResource = class {
 };
 
 // src/resources/sessions.ts
-var import_zod74 = require("zod");
+var import_zod76 = require("zod");
 function normalizeSessionRequest(request) {
   const { agentId, versionId, ...rest } = request;
   const workloadId = resolveExclusiveAlias("workloadId", rest.workloadId, "agentId", agentId);
@@ -9936,33 +10334,181 @@ function normalizeSessionRequest(request) {
     ...revisionId !== void 0 ? { revisionId } : {}
   };
 }
-var ListSessionEventsEnvelopeSchema = import_zod74.z.object({
-  data: import_zod74.z.object({ events: import_zod74.z.array(SessionEventSchema) })
-});
-var DeliveryResultEnvelopeSchema = import_zod74.z.object({
-  data: import_zod74.z.object({ delivery: SessionDeliveryEnvelopeSchema.nullable() })
-});
-var SessionArtifactsListEnvelopeSchema = import_zod74.z.object({
-  data: import_zod74.z.object({
-    items: import_zod74.z.array(
-      import_zod74.z.object({
-        id: import_zod74.z.string(),
-        artifactId: import_zod74.z.string().optional(),
-        filename: import_zod74.z.string(),
-        path: import_zod74.z.string(),
-        contentType: import_zod74.z.string(),
-        size: import_zod74.z.number(),
-        turnId: import_zod74.z.string().optional(),
-        messageId: import_zod74.z.string().optional()
+var ListSessionEventsEnvelopeSchema = import_zod76.z.object({
+  data: import_zod76.z.object({
+    events: import_zod76.z.array(SessionEventSchema),
+    // Optional so a pre-P1 server's `{ events }` body still parses.
+    hasMore: import_zod76.z.boolean().optional(),
+    cursorReset: import_zod76.z.boolean().optional()
+  })
+});
+var TurnListEnvelopeSchema = import_zod76.z.object({ data: TurnListResponseDataSchema });
+var TurnEnvelopeSchema = import_zod76.z.object({ data: TurnSchema });
+var DispatchOutcomeEnvelopeSchema = import_zod76.z.object({
+  data: import_zod76.z.object({ outcome: DispatchOutcomeSchema })
+});
+var SendTurnTurnRefEnvelopeSchema = import_zod76.z.object({
+  data: import_zod76.z.object({
+    turn: import_zod76.z.object({ turnId: import_zod76.z.string(), status: TurnStatusSchema }).optional()
+  })
+});
+var SessionRuntimeBindingEnvelopeSchema = import_zod76.z.object({
+  runtimeBinding: import_zod76.z.object({ id: import_zod76.z.string().min(1) }).nullish()
+});
+var DeliveryResultEnvelopeSchema = import_zod76.z.object({
+  data: import_zod76.z.object({ delivery: SessionDeliveryEnvelopeSchema.nullable() })
+});
+var SessionArtifactsListEnvelopeSchema = import_zod76.z.object({
+  data: import_zod76.z.object({
+    items: import_zod76.z.array(
+      import_zod76.z.object({
+        id: import_zod76.z.string(),
+        artifactId: import_zod76.z.string().optional(),
+        filename: import_zod76.z.string(),
+        path: import_zod76.z.string(),
+        contentType: import_zod76.z.string(),
+        size: import_zod76.z.number(),
+        turnId: import_zod76.z.string().optional(),
+        messageId: import_zod76.z.string().optional()
       })
     ),
-    partial: import_zod74.z.boolean().optional(),
-    skippedBundles: import_zod74.z.array(import_zod74.z.object({ artifactId: import_zod74.z.string(), reason: import_zod74.z.string() })).optional()
+    partial: import_zod76.z.boolean().optional(),
+    skippedBundles: import_zod76.z.array(import_zod76.z.object({ artifactId: import_zod76.z.string(), reason: import_zod76.z.string() })).optional()
   })
 });
+var SessionTurnsResource = class {
+  constructor(client, sessions) {
+    this.client = client;
+    this.sessions = sessions;
+  }
+  /**
+   * `GET /api/sessions/:id/turns` — one keyset page of turns, newest first by
+   * default. Requires scope `runs:stream`.
+   *
+   * Page forward with `after: nextCursor` / back with `before: prevCursor`;
+   * there is no `page`/`offset`.
+   *
+   * "Forward" is relative to the ORDER YOU ASKED FOR, not to time: under the
+   * default `order: "desc"` it means toward OLDER turns. `hasMore` describes
+   * that same forward direction, so the loop that walks a whole history is
+   * `after: nextCursor` until `hasMore` is false. Pairing `hasMore` with
+   * `before`/`prevCursor` reads a flag about the direction you are NOT
+   * walking and will not terminate correctly — `before` is for picking up
+   * turns that arrived on the other side of your page, not for draining.
+   *
+   * `streamCursor` is the session's highest `__seq` and can be handed
+   * straight to {@link SessionsResource.streamEvents} as `lastEventId` to
+   * resume live streaming without replaying what this page already covers.
+   */
+  async list(sessionId, options = {}) {
+    const path = `/api/sessions/${encodeURIComponent(sessionId)}/turns`;
+    const envelope = await this.client.request(path, {
+      method: "GET",
+      query: {
+        limit: options.limit,
+        order: options.order,
+        before: options.before,
+        after: options.after,
+        status: options.status && options.status.length > 0 ? options.status.join(",") : void 0,
+        revivalAttemptId: options.revivalAttemptId
+      },
+      signal: options.signal,
+      cache: "no-store"
+    });
+    const parsed = TurnListEnvelopeSchema.safeParse(envelope);
+    if (!parsed.success) {
+      throw new PilotPlatformApiError({
+        status: 0,
+        code: "MALFORMED_PLATFORM_RESPONSE",
+        message: `GET ${path} did not return a {data: {turns: [...]}} envelope.`,
+        cause: parsed.error
+      });
+    }
+    return parsed.data.data;
+  }
+  /**
+   * `GET /api/sessions/:id/turns/:turnId` — one turn. Requires scope
+   * `runs:stream`.
+   *
+   * Throws `PilotPlatformNotFoundError` with `code` `TURN_NOT_FOUND` (404)
+   * for an id this session has no turn for. A prompt that is waiting on
+   * Agent Recovery has NOT become a turn yet and reads as that same 404 —
+   * check `sessions.get(id)`'s `pendingRevival` before treating it as a bad
+   * id.
+   */
+  async get(sessionId, turnId, options = {}) {
+    const path = `/api/sessions/${encodeURIComponent(sessionId)}/turns/${encodeURIComponent(turnId)}`;
+    const envelope = await this.client.request(path, {
+      method: "GET",
+      signal: options.signal,
+      cache: "no-store"
+    });
+    const parsed = TurnEnvelopeSchema.safeParse(envelope);
+    if (!parsed.success) {
+      throw new PilotPlatformApiError({
+        status: 0,
+        code: "MALFORMED_PLATFORM_RESPONSE",
+        message: `GET ${path} did not return a {data: <Turn>} envelope.`,
+        cause: parsed.error
+      });
+    }
+    return parsed.data.data;
+  }
+  /**
+   * `POST /api/sessions/:id/abort` — ask the worker to stop `turnId`.
+   * Requires scope **`runs:abort`** (not `runs:stream`, unlike every other
+   * method here).
+   *
+   * Requires a control-plane that declares `tokenAudience: "agenthub"` on the
+   * abort dispatch binding. Against an older one, an AgentHub token
+   * (`aud=agenthub` — the only kind this SDK sends) is rejected with 403
+   * `TOKEN_AUDIENCE_MISMATCH` before the scope check.
+   *
+   * Idempotent: the request key is derived from the session and turn, so
+   * re-issuing it — including from the portal's Stop button — collapses onto
+   * the one abort rather than stacking.
+   *
+   * The returned `DispatchOutcome` is the dispatch result, NOT proof the turn
+   * stopped: a `rejected` / `transport_failed` outcome comes back as a VALUE
+   * with 200 (branch on `outcome.kind`, and on `priorOutcome` for
+   * `idempotent_replay`), and even an `accepted` abort only means the worker
+   * received the signal. Whether it landed is read off the turn:
+   * `(await turns.get(sessionId, turnId)).status === "aborted"`.
+   */
+  async abort(sessionId, turnId, options = {}) {
+    const runtimeBindingId = options.runtimeBindingId ?? await resolveRuntimeBindingId(this.sessions, sessionId, options.signal);
+    const path = `/api/sessions/${encodeURIComponent(sessionId)}/abort`;
+    const envelope = await this.client.request(path, {
+      method: "POST",
+      body: {
+        // Byte-identical to the portal Stop button's key
+        // (`use-session-revival.ts`), so a user click and an SDK abort for the
+        // same turn dedupe against each other instead of racing.
+        idempotencyKey: `abort:session:${sessionId}:turn:${turnId}`,
+        session: { sessionId, runtimeBindingId },
+        protocolVersion: "v1",
+        turnId,
+        reason: options.reason ?? { kind: "user" },
+        trace: { traceId: newTraceId(), spanId: newTraceId() }
+      },
+      signal: options.signal
+    });
+    const parsed = DispatchOutcomeEnvelopeSchema.safeParse(envelope);
+    if (!parsed.success) {
+      throw new PilotPlatformApiError({
+        status: 0,
+        code: "MALFORMED_PLATFORM_RESPONSE",
+        message: `POST ${path} did not return a {data: {outcome: ...}} envelope.`,
+        cause: parsed.error
+      });
+    }
+    return parsed.data.data.outcome;
+  }
+};
 var SessionsResource = class {
   constructor(client) {
     this.client = client;
+    this.turns = new SessionTurnsResource(client, this);
   }
   async create(request, options = {}) {
     const body = CreatePlatformSessionRequestSchema.parse(normalizeSessionRequest(request));
@@ -10080,7 +10626,10 @@ var SessionsResource = class {
    *
    * Requires scope `runs:create`. The session must be `ready`
    * (`sessions.wait`) and have no turn in flight — a prior running turn
-   * throws `SESSION_TURN_IN_PROGRESS` (409), it is never queued.
+   * throws `SESSION_TURN_IN_PROGRESS` (409), it is never queued. A turn sent
+   * while an Agent Recovery started by someone else is running throws
+   * `SESSION_REVIVING` (409): nothing was dispatched, so re-send it once
+   * `lifecyclePhase` is back to `"active"` (see {@link SendTurnResult}).
    */
   async sendTurn(sessionId, input, options = {}) {
     const path = `/api/sessions/${encodeURIComponent(sessionId)}/turns`;
@@ -10106,16 +10655,15 @@ var SessionsResource = class {
       return {
         kind: "revival_in_progress",
         attemptId: revival.attemptId,
-        ...revival.turnId !== void 0 && { turnId: revival.turnId },
-        ...revival.alreadyReviving !== void 0 && {
-          alreadyReviving: revival.alreadyReviving
-        }
+        ...revival.turnId !== void 0 && { turnId: revival.turnId }
       };
     }
     const dispatched = SessionTurnDispatchedResponseSchema.parse(json);
     const outcome = dispatched.data.outcome;
     if (outcome.kind === "accepted" || outcome.kind === "idempotent_replay") {
-      return { kind: outcome.kind, turnId: outcome.turnId, outcome };
+      const turnRef = SendTurnTurnRefEnvelopeSchema.safeParse(json);
+      const turn = turnRef.success ? turnRef.data.data.turn : void 0;
+      return { kind: outcome.kind, turnId: outcome.turnId, outcome, ...turn && { turn } };
     }
     throw new PilotPlatformApiError({
       status: res.status,
@@ -10136,7 +10684,9 @@ var SessionsResource = class {
       method: "GET",
       query: {
         afterEventId: options.afterEventId,
-        limit: options.limit
+        limit: options.limit,
+        turnId: options.turnId,
+        types: options.types && options.types.length > 0 ? options.types.join(",") : void 0
       },
       signal: options.signal,
       cache: "no-store"
@@ -10150,7 +10700,8 @@ var SessionsResource = class {
         cause: parsed.error
       });
     }
-    return parsed.data.data.events;
+    const { events, hasMore, cursorReset } = parsed.data.data;
+    return attachPageFields(events, { hasMore, cursorReset });
   }
   /**
    * `GET /api/sessions/:id/delivery-result` — the session-plane delivery
@@ -10192,14 +10743,14 @@ var SessionsResource = class {
    * **`waitForTurn` resolving does NOT mean the snapshot is ready.** The worker
    * emits the turn's terminal event and only then bundles, uploads and reports.
    * Exporting the instant a turn completes therefore returns either a 404 or —
-   * worse, because it is silent — the PREVIOUS turn's snapshot. Poll for
-   * freshness instead of calling once:
+   * worse, because it is silent — the PREVIOUS turn's snapshot. Poll until the
+   * export names your turn instead of calling once:
    *
    * ```ts
    * const { terminalEvent } = await agenthub.sessions.waitForTurn(sessionId, turnId);
-   * // `completedAt` exists ONLY on a success terminal, and is the same
-   * // in-sandbox clock as capturedAtTurn (capture is strictly ordered after the
-   * // terminal append). `payload` is typed `unknown`, hence the cast.
+   * // `completedAt` exists ONLY on a success terminal. Its value is the
+   * // fallback cursor below; its PRESENCE is what tells you the turn succeeded.
+   * // `payload` is typed `unknown`, hence the cast.
    * const completedAtRaw = (terminalEvent.payload as { completedAt?: string })?.completedAt;
    * if (!completedAtRaw) {
    *   // Failed / aborted turn: nothing was captured, and polling would just
@@ -10212,11 +10763,24 @@ var SessionsResource = class {
    * while (Date.now() < deadline) {
    *   try {
    *     const candidate = await agenthub.sessions.exportWorkspace(sessionId);
-   *     // `>=`, not `>`: both timestamps are `ctx.now()` in the same sandbox
-   *     // process, one `await` apart, at millisecond resolution — so they can
-   *     // be EQUAL, and a strict `>` would then never accept this turn's own
-   *     // snapshot and report "no files" after the full timeout.
-   *     if (candidate.capturedAtTurn >= completedAt) { exported = candidate; break; }
+   *     // The snapshot names its own turn — compare ids, no clock reasoning.
+   *     if (candidate.turnId === turnId) { exported = candidate; break; }
+   *     // Fallback: `turnId` didn't match — either it's absent (session
+   *     // predates the field, or the turn's `session_turns` row hadn't
+   *     // materialized yet when the snapshot landed) or it's present but
+   *     // WRONG: a sandbox image older than this field makes the platform
+   *     // infer "most recent completed turn", which can land on a turn you
+   *     // didn't dispatch. Either way `turnId` cannot tell you "not mine" —
+   *     // only the timestamp can, so any non-match falls through to it, not
+   *     // just a null one. `>=`, not `>`: both timestamps are `ctx.now()` in
+   *     // the same sandbox process, one `await` apart, at millisecond
+   *     // resolution — so they can be EQUAL, and a strict `>` would never
+   *     // accept this turn's own snapshot, reporting "no files" after the
+   *     // full timeout.
+   *     if (candidate.capturedAtTurn >= completedAt) {
+   *       exported = candidate;
+   *       break;
+   *     }
    *   } catch (err) {
    *     // Discriminate on `code`, NOT on status: SESSION_NOT_FOUND is a 404 too,
    *     // and a bad id / deleted session / lost access must surface immediately
@@ -10233,6 +10797,20 @@ var SessionsResource = class {
    * // exported === null → this turn produced no files. Normal, not a failure.
    * ```
    *
+   * **`turnId` is the primary check; the timestamp branch is only a fallback.**
+   * They are not equivalent. `turnId` is an equality test against an id you
+   * already hold — but a non-matching `turnId` does not mean "not my turn": it
+   * can be null, or it can be a DIFFERENT turn the platform inferred during the
+   * migration window, and nothing in the response distinguishes the two. Treat
+   * every non-match the same way and fall back to the timestamp rather than
+   * special-casing "absent." `capturedAtTurn` is an internal epoch-ms cursor
+   * with a failure mode `turnId` does not have: a BACKWARD sandbox clock step
+   * (NTP correction) between the terminal append and the capture puts it before
+   * `completedAt`, no comparison accepts it, and the poll times out —
+   * reporting "no files" for a turn that produced them, which reads like a
+   * normal result. Never display either value; `capturedAt` is the
+   * human-facing field.
+   *
    * **404 `WORKSPACE_SNAPSHOT_NOT_FOUND` is not by itself an error.** It throws
    * (a `PilotPlatformApiError`, so "this session never ran" is never silently
    * flattened to an empty result), and you MUST catch it inside the polling
@@ -10456,21 +11034,39 @@ var SessionsResource = class {
     }
   }
   /**
-   * Convenience poller: after `sendTurn`, poll `listEvents` until the
-   * worker-protocol TERMINAL event for `turnId` arrives, then resolve with
-   * it. Purely client-side — no extra server capability.
-   *
-   * Matching: a terminal event whose `payload.turnId` equals `turnId` always
-   * matches. Terminal events that omit `payload.turnId` (workers stamp the
-   * derived turn id on `worker_protocol.*.accepted` but may omit it on the
-   * terminal — observed in the baseline e2e worker) match ONLY after this
-   * turn's marker — any event whose `payload.turnId` equals `turnId`,
-   * normally the `.accepted` row — has been observed in the stream: turns
-   * dispatch serially per session, so the first turnId-less terminal after
-   * OUR accepted is this turn's, while stale pre-dispatch legacy terminals
-   * can never resolve the wait early. Callers resuming with an
-   * `afterEventId` cursor past the accepted marker get exact-turnId
-   * matching only.
+   * Convenience poller: after `sendTurn`, poll the TURN (`turns.get`) until
+   * its `status` is terminal, then resolve with the turn and — when one
+   * exists — its terminal worker-protocol event.
+   *
+   * It polls the turn rather than draining `listEvents` because the cost of
+   * the old form scaled with the CONVERSATION, not with the wait: a session
+   * with thousands of streamed chunk rows spent its first polls paging
+   * through history it did not care about, and an `interrupted` turn (worker
+   * died, so no terminal event was ever written) could only ever time out.
+   * A turn's status answers both in one request.
+   *
+   * `terminalEvent` is fetched with a SINGLE `listEvents` call after the
+   * status settles, windowed to this turn and to the terminal event types —
+   * it stays on the result because callers read its payload (e.g.
+   * `completedAt`, which {@link exportWorkspace} needs). It is `undefined`
+   * for an `interrupted` turn, which by construction has no terminal event.
+   *
+   * A 404 `TURN_NOT_FOUND` in the first {@link TURN_VISIBILITY_GRACE_MS} is
+   * treated as "the turn row has not materialized yet" and retried — the
+   * canonical call is `waitForTurn(id, sendTurn(...).turnId)`, and the turn
+   * projection is not guaranteed to have run by the time that returns. After
+   * the grace window the 404 is rethrown UNCHANGED, so a wrong turn id
+   * surfaces as `TURN_NOT_FOUND` within seconds instead of costing the full
+   * (10-minute) deadline.
+   *
+   * **Agent Recovery does not count against that grace.** After a 202
+   * `revival_in_progress`, the prompt is replayed server-side and its turn row
+   * only exists once the replay lands — minutes, not seconds. So on a 404 the
+   * wait asks `sessions.get`: while `pendingRevival` is non-null (or
+   * `lifecyclePhase` is `"reviving"`) the grace window is restarted rather
+   * than consumed, and polling continues until the replay materializes. Only
+   * the overall `timeoutMs` bounds that; a session NOT reviving keeps the
+   * plain 30s behavior.
    *
    * Throws `SESSION_TURN_WAIT_TIMEOUT` on deadline (default 10 min; managed
    * agent turns are long tasks, raise `timeoutMs` for longer runs).
@@ -10478,31 +11074,37 @@ var SessionsResource = class {
   async waitForTurn(sessionId, turnId, options = {}) {
     const intervalMs = options.intervalMs ?? 1e3;
     const timeoutMs = options.timeoutMs ?? 6e5;
-    const pageLimit = 200;
     const startedAt = Date.now();
-    let cursor = options.afterEventId;
-    let dispatchSeen = false;
+    const graceMs = Math.min(TURN_VISIBILITY_GRACE_MS, timeoutMs);
+    let graceDeadline = startedAt + graceMs;
     while (true) {
       if (options.signal?.aborted) throw options.signal.reason;
-      const events = await this.listEvents(sessionId, {
-        afterEventId: cursor,
-        limit: pageLimit,
-        signal: options.signal
-      });
-      for (const event of events) {
-        const payloadTurnId = typeof event.payload === "object" && event.payload !== null ? event.payload.turnId : void 0;
-        if (payloadTurnId === turnId) dispatchSeen = true;
-        if (!WORKER_PROTOCOL_TERMINAL_EVENT_TYPES.includes(event.eventType))
-          continue;
-        if (payloadTurnId === turnId) {
-          return { terminalEvent: event };
+      let turn;
+      try {
+        turn = await this.turns.get(sessionId, turnId, { signal: options.signal });
+      } catch (error) {
+        if (!isTurnNotFound(error)) throw error;
+        if (await isRevivalPending(this, sessionId, options.signal)) {
+          graceDeadline = Date.now() + graceMs;
+        } else if (Date.now() >= graceDeadline) {
+          throw error;
         }
-        if ((payloadTurnId === void 0 || payloadTurnId === null) && dispatchSeen) {
-          return { terminalEvent: event };
+        if (Date.now() - startedAt >= timeoutMs) {
+          throw new PilotPlatformApiError({
+            status: 0,
+            code: "SESSION_TURN_WAIT_TIMEOUT",
+            message: `Timed out waiting for turn ${turnId} of session ${sessionId} to appear; the session was still recovering.`
+          });
         }
+        await sleep(intervalMs, options.signal);
+        continue;
+      }
+      if (isTerminalTurnStatus(turn.status)) {
+        return {
+          terminalEvent: await fetchTerminalEvent(this, sessionId, turnId, options.signal),
+          turn
+        };
       }
-      const last = events[events.length - 1];
-      if (last) cursor = last.eventId;
       if (Date.now() - startedAt >= timeoutMs) {
         throw new PilotPlatformApiError({
           status: 0,
@@ -10510,7 +11112,6 @@ var SessionsResource = class {
           message: `Timed out waiting for turn ${turnId} of session ${sessionId} to terminate.`
         });
       }
-      if (events.length === pageLimit) continue;
       await sleep(intervalMs, options.signal);
     }
   }
@@ -10552,7 +11153,71 @@ async function* parseSseFrames(body, signal) {
     });
   }
 }
+var TURN_VISIBILITY_GRACE_MS = 3e4;
+function isTurnNotFound(error) {
+  return error instanceof PilotPlatformApiError && error.code === "TURN_NOT_FOUND";
+}
+var SessionRevivalStateSchema = import_zod76.z.object({
+  pendingRevival: import_zod76.z.object({ attemptId: import_zod76.z.string() }).nullish(),
+  session: import_zod76.z.object({ lifecyclePhase: import_zod76.z.string().nullish() }).loose().optional()
+});
+async function isRevivalPending(sessions, sessionId, signal) {
+  let snapshot;
+  try {
+    snapshot = await sessions.get(sessionId, { signal });
+  } catch (error) {
+    if (signal?.aborted) throw error;
+    return false;
+  }
+  const parsed = SessionRevivalStateSchema.safeParse(snapshot);
+  if (!parsed.success) return false;
+  return (parsed.data.pendingRevival ?? null) !== null || parsed.data.session?.lifecyclePhase === "reviving";
+}
+async function fetchTerminalEvent(sessions, sessionId, turnId, signal) {
+  let events;
+  try {
+    events = await sessions.listEvents(sessionId, {
+      turnId,
+      types: [...WORKER_PROTOCOL_TERMINAL_EVENT_TYPES],
+      limit: 10,
+      signal
+    });
+  } catch (error) {
+    if (!isTurnNotFound(error)) throw error;
+    return void 0;
+  }
+  const terminals = events.filter(
+    (event) => WORKER_PROTOCOL_TERMINAL_EVENT_TYPES.includes(event.eventType)
+  );
+  return terminals[terminals.length - 1];
+}
+function attachPageFields(events, fields) {
+  for (const [key, value] of Object.entries(fields)) {
+    if (value === void 0) continue;
+    Object.defineProperty(events, key, { value, enumerable: false, configurable: true });
+  }
+  return events;
+}
+async function resolveRuntimeBindingId(sessions, sessionId, signal) {
+  const snapshot = await sessions.get(sessionId, { signal });
+  const parsed = SessionRuntimeBindingEnvelopeSchema.safeParse(snapshot);
+  const runtimeBindingId = parsed.success ? parsed.data.runtimeBinding?.id ?? void 0 : void 0;
+  if (!runtimeBindingId) {
+    throw new PilotPlatformApiError({
+      status: 0,
+      code: "RUNTIME_BINDING_NOT_READY",
+      message: `Session ${sessionId} has no active runtime binding; there is no worker to abort.`
+    });
+  }
+  return runtimeBindingId;
+}
+function newTraceId() {
+  const cryptoImpl = globalThis.crypto;
+  if (typeof cryptoImpl?.randomUUID === "function") return cryptoImpl.randomUUID();
+  return `sdk-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 12)}`;
+}
 function sleep(ms, signal) {
+  if (signal?.aborted) return Promise.reject(signal.reason);
   if (ms <= 0) return Promise.resolve();
   return new Promise((resolve, reject) => {
     const timer = setTimeout(resolve, ms);
@@ -10568,11 +11233,11 @@ function sleep(ms, signal) {
 }
 
 // src/resources/workloads.ts
-var import_zod75 = require("zod");
-var CanaryPromoteResponseSchema = import_zod75.z.object({
+var import_zod77 = require("zod");
+var CanaryPromoteResponseSchema = import_zod77.z.object({
   slot: StageSlotViewSchema,
-  fromRevisionId: import_zod75.z.string().uuid(),
-  toRevisionId: import_zod75.z.string().uuid()
+  fromRevisionId: import_zod77.z.string().uuid(),
+  toRevisionId: import_zod77.z.string().uuid()
 }).strict();
 var WorkloadStageCanaryResource = class {
   constructor(client) {
@@ -11226,6 +11891,40 @@ function mergeSignals(...signals) {
   }
   return controller.signal;
 }
+
+// src/ui-messages.ts
+function toUIMessages(turns) {
+  const messages = [];
+  for (const turn of [...turns].sort(compareByDispatch)) {
+    const userMessage = {
+      id: turn.user.messageId,
+      role: "user",
+      parts: [{ type: "text", text: turn.user.text }]
+    };
+    if (turn.user.attachments.length > 0) {
+      userMessage.metadata = { attachments: turn.user.attachments };
+    }
+    messages.push(userMessage);
+    if (turn.assistant === null) continue;
+    const assistantMessage = {
+      id: turn.assistant.messageId,
+      role: "assistant",
+      parts: turn.assistant.parts
+    };
+    if (turn.assistant.state === "truncated") {
+      assistantMessage.metadata = { truncated: true };
+    }
+    messages.push(assistantMessage);
+  }
+  return messages;
+}
+function compareByDispatch(a, b) {
+  const aTime = Date.parse(a.dispatchedAt);
+  const bTime = Date.parse(b.dispatchedAt);
+  const byTime = Number.isNaN(aTime) || Number.isNaN(bTime) ? a.dispatchedAt.localeCompare(b.dispatchedAt) : aTime - bTime;
+  if (byTime !== 0) return byTime;
+  return a.turnId.localeCompare(b.turnId);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AGENTHUB_SDK_USER_AGENT,
@@ -11308,10 +12007,20 @@ function mergeSignals(...signals) {
   SessionFileResourceSchema,
   SessionMemorySubjectDeclarationSchema,
   SessionResourcesSchema,
+  SessionTurnsResource,
   SessionsResource,
   StageSchema,
   StageSlotViewSchema,
   StoredMemorySubjectPolicySchema,
+  TERMINAL_TURN_STATUSES,
+  TURN_LIST_DEFAULT_LIMIT,
+  TURN_LIST_MAX_LIMIT,
+  TurnAssistantPartSchema,
+  TurnKindSchema,
+  TurnListQuerySchema,
+  TurnListResponseDataSchema,
+  TurnSchema,
+  TurnStatusSchema,
   UpdateEnvironmentInputSchema,
   WorkbenchDTOSchema,
   WorkloadStageCanaryResource,
@@ -11321,8 +12030,11 @@ function mergeSignals(...signals) {
   WriteMemoriesRequestSchema,
   WriteMemoriesResultSchema,
   WriteMemoryItemSchema,
+  isTerminalTurnStatus,
   pilotPlatformErrorFromResponse,
   platformRevisionPublishToManifest,
-  platformWorkloadCreateToManifest
+  platformWorkloadCreateToManifest,
+  toUIMessages,
+  turnMessageIds
 });
 //# sourceMappingURL=index.cjs.map