@inf-monkeys-tech/monkeys 1.0.9 → 1.0.11

package/lib/esm/index.mjs

@@ -6687,13 +6687,243 @@ var OutputRecordSchema = z2.object({
   createdAt: IsoDateTimeSchema
 }).strict();
 
+// src/contracts/agent.ts
+import { z as z3 } from "zod";
+var AgentModeSchema = z3.enum(["chatbot", "agent"]);
+var AgentSessionCapabilitySchema = z3.enum([
+  "text",
+  "reasoning",
+  "plan",
+  "tasks",
+  "tools",
+  "mcp",
+  "shell",
+  "fileChange",
+  "skills",
+  "approval",
+  "artifacts",
+  "usage",
+  "resume",
+  "diff",
+  "workspaceFiles",
+  "terminal",
+  "testResults"
+]);
+var AgentSessionCapabilitiesSchema = z3.object({
+  text: z3.boolean().default(true),
+  reasoning: z3.boolean().default(false),
+  plan: z3.boolean().default(false),
+  tasks: z3.boolean().default(false),
+  tools: z3.boolean().default(false),
+  mcp: z3.boolean().default(false),
+  shell: z3.boolean().default(false),
+  fileChange: z3.boolean().default(false),
+  skills: z3.boolean().default(false),
+  approval: z3.boolean().default(false),
+  artifacts: z3.boolean().default(false),
+  usage: z3.boolean().default(false),
+  resume: z3.boolean().default(false),
+  diff: z3.boolean().default(false),
+  workspaceFiles: z3.boolean().default(false),
+  terminal: z3.boolean().default(false),
+  testResults: z3.boolean().default(false)
+}).strict();
+var AgentSessionSnapshotSchema = z3.object({
+  mode: AgentModeSchema,
+  modelId: z3.string().trim().min(1),
+  capabilities: AgentSessionCapabilitiesSchema
+}).strict();
+var AgentSessionEventHeaderSchema = z3.object({
+  contract: z3.literal("AgentSessionEvent"),
+  eventId: ContractIdentifierSchema,
+  sessionId: ContractIdentifierSchema,
+  sequence: z3.number().int().nonnegative(),
+  idempotencyKey: ContractIdentifierSchema,
+  occurredAt: IsoDateTimeSchema
+}).strict();
+var sessionEvent = (eventType, payload) => AgentSessionEventHeaderSchema.extend({
+  eventType: z3.literal(eventType),
+  payload: z3.object(payload).strict()
+}).strict();
+var AgentSessionEventSchema = z3.discriminatedUnion("eventType", [
+  sessionEvent("message", {
+    messageId: ContractIdentifierSchema,
+    role: z3.enum(["user", "assistant", "system"]),
+    operation: z3.enum(["append", "replace"]).default("append"),
+    parts: z3.array(JsonValueSchema),
+    status: z3.enum(["streaming", "completed", "failed"]).optional()
+  }),
+  sessionEvent("reasoning", {
+    reasoningId: ContractIdentifierSchema,
+    text: z3.string(),
+    status: z3.enum(["streaming", "completed"])
+  }),
+  sessionEvent("plan", {
+    planId: ContractIdentifierSchema,
+    title: z3.string().optional(),
+    status: z3.enum(["pending", "running", "completed", "failed"]),
+    steps: z3.array(
+      z3.object({
+        id: ContractIdentifierSchema,
+        title: z3.string(),
+        status: z3.enum(["pending", "running", "completed", "failed", "skipped"])
+      }).strict()
+    )
+  }),
+  sessionEvent("task", {
+    taskId: ContractIdentifierSchema,
+    title: z3.string(),
+    status: z3.enum(["pending", "running", "completed", "failed", "skipped"]),
+    detail: z3.string().optional()
+  }),
+  sessionEvent("tool", {
+    toolCallId: ContractIdentifierSchema,
+    toolName: z3.string().trim().min(1),
+    status: z3.enum(["pending", "running", "completed", "failed", "denied"]),
+    input: JsonValueSchema.optional(),
+    output: JsonValueSchema.optional(),
+    error: z3.string().optional(),
+    startedAt: IsoDateTimeSchema.optional(),
+    completedAt: IsoDateTimeSchema.optional()
+  }),
+  sessionEvent("approval", {
+    approvalId: ContractIdentifierSchema,
+    toolCallId: ContractIdentifierSchema.optional(),
+    status: z3.enum(["requested", "approved", "rejected", "expired"]),
+    title: z3.string(),
+    description: z3.string().optional(),
+    requestedAction: JsonValueSchema.optional()
+  }),
+  sessionEvent("status", {
+    status: z3.enum(["queued", "running", "waiting_approval", "stopping", "stopped", "completed", "failed"]),
+    detail: z3.string().optional()
+  }),
+  sessionEvent("artifact", {
+    artifactId: ContractIdentifierSchema,
+    name: z3.string().trim().min(1),
+    kind: z3.enum(["file", "image", "video", "audio", "web", "other"]),
+    status: z3.enum(["pending", "ready", "failed"]),
+    mimeType: z3.string().optional(),
+    url: z3.string().url().optional(),
+    size: z3.number().int().nonnegative().optional(),
+    sourceEventId: ContractIdentifierSchema.optional()
+  }),
+  sessionEvent("usage", {
+    inputTokens: z3.number().int().nonnegative().optional(),
+    outputTokens: z3.number().int().nonnegative().optional(),
+    totalTokens: z3.number().int().nonnegative().optional(),
+    contextTokens: z3.number().int().nonnegative().optional(),
+    contextWindow: z3.number().int().positive().optional()
+  }),
+  sessionEvent("resume", {
+    resumable: z3.boolean(),
+    state: JsonObjectSchema.optional(),
+    reason: z3.string().optional()
+  }),
+  sessionEvent("error", {
+    code: z3.string().trim().min(1),
+    message: z3.string(),
+    retryable: z3.boolean(),
+    sourceEventId: ContractIdentifierSchema.optional(),
+    details: JsonObjectSchema.optional()
+  }),
+  sessionEvent("diff", {
+    path: z3.string().trim().min(1),
+    status: z3.enum(["added", "modified", "deleted", "renamed"]),
+    patch: z3.string().optional()
+  }),
+  sessionEvent("workspace-file", {
+    path: z3.string().trim().min(1),
+    operation: z3.enum(["upsert", "delete"]),
+    mimeType: z3.string().optional(),
+    size: z3.number().int().nonnegative().optional()
+  }),
+  sessionEvent("terminal", {
+    terminalId: ContractIdentifierSchema,
+    stream: z3.enum(["stdin", "stdout", "stderr", "status"]),
+    chunk: z3.string(),
+    exitCode: z3.number().int().optional()
+  }),
+  sessionEvent("test-result", {
+    testId: ContractIdentifierSchema,
+    name: z3.string(),
+    status: z3.enum(["running", "passed", "failed", "skipped"]),
+    durationMs: z3.number().nonnegative().optional(),
+    output: z3.string().optional()
+  })
+]);
+var AgentSessionViewModelSchema = z3.object({
+  contract: z3.literal("AgentSessionViewModel"),
+  sessionId: ContractIdentifierSchema,
+  snapshot: AgentSessionSnapshotSchema,
+  status: z3.enum(["queued", "running", "waiting_approval", "stopping", "stopped", "completed", "failed"]),
+  events: z3.array(AgentSessionEventSchema),
+  lastSequence: z3.number().int().min(-1),
+  resumable: z3.boolean().default(false)
+}).strict().superRefine((value, context) => {
+  const eventIds = /* @__PURE__ */ new Set();
+  const idempotencyKeys = /* @__PURE__ */ new Set();
+  let previousSequence = -1;
+  value.events.forEach((event, index) => {
+    if (event.sessionId !== value.sessionId) {
+      context.addIssue({
+        code: "custom",
+        path: ["events", index, "sessionId"],
+        message: "Event sessionId must match the view model sessionId."
+      });
+    }
+    if (event.sequence <= previousSequence) {
+      context.addIssue({
+        code: "custom",
+        path: ["events", index, "sequence"],
+        message: "Events must be ordered by a strictly increasing sequence."
+      });
+    }
+    if (eventIds.has(event.eventId)) {
+      context.addIssue({
+        code: "custom",
+        path: ["events", index, "eventId"],
+        message: "Event IDs must be unique within a session view model."
+      });
+    }
+    if (idempotencyKeys.has(event.idempotencyKey)) {
+      context.addIssue({
+        code: "custom",
+        path: ["events", index, "idempotencyKey"],
+        message: "Idempotency keys must be unique within a session view model."
+      });
+    }
+    previousSequence = event.sequence;
+    eventIds.add(event.eventId);
+    idempotencyKeys.add(event.idempotencyKey);
+  });
+  const expectedLastSequence = value.events.length > 0 ? value.events[value.events.length - 1].sequence : -1;
+  if (value.lastSequence !== expectedLastSequence) {
+    context.addIssue({
+      code: "custom",
+      path: ["lastSequence"],
+      message: "lastSequence must match the final event sequence, or -1 when there are no events."
+    });
+  }
+});
+var AgentExecutionModeSchema = AgentModeSchema;
+function normalizeAgentMode(value) {
+  const normalized = String(value ?? "").trim().toLowerCase();
+  if (normalized === "agent" || normalized === "codex") return "agent";
+  if (normalized === "chatbot" || normalized === "vercel-ai" || normalized === "vercel" || normalized === "ai-sdk") {
+    return "chatbot";
+  }
+  return void 0;
+}
+var normalizeAgentExecutionMode = normalizeAgentMode;
+
 // src/contracts/capability.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
 // src/contracts/render.ts
-import { z as z3 } from "zod";
-var ProductContextSchema = z3.enum(["studio", "kernel", "compute"]);
-var RenderNodeStateSchema = z3.enum([
+import { z as z4 } from "zod";
+var ProductContextSchema = z4.enum(["studio", "kernel", "compute"]);
+var RenderNodeStateSchema = z4.enum([
   "idle",
   "loading",
   "empty",
@@ -6702,7 +6932,7 @@ var RenderNodeStateSchema = z3.enum([
   "disabled",
   "selected"
 ]);
-var RenderNodeKindSchema = z3.enum([
+var RenderNodeKindSchema = z4.enum([
   "shell",
   "page",
   "navigation",
@@ -6714,16 +6944,16 @@ var RenderNodeKindSchema = z3.enum([
   "overlay",
   "professional-provider"
 ]);
-var RenderSurfaceSchema = z3.object({
-  frameOwner: z3.enum(["host", "provider", "none"]),
+var RenderSurfaceSchema = z4.object({
+  frameOwner: z4.enum(["host", "provider", "none"]),
   tone: ContractIdentifierSchema.optional(),
-  density: z3.enum(["compact", "default", "comfortable"])
+  density: z4.enum(["compact", "default", "comfortable"])
 }).strict();
-var RenderScrollSchema = z3.object({
-  owner: z3.enum(["page", "surface", "provider"]),
-  axis: z3.enum(["x", "y", "both", "none"]),
+var RenderScrollSchema = z4.object({
+  owner: z4.enum(["page", "surface", "provider"]),
+  axis: z4.enum(["x", "y", "both", "none"]),
   restoreKey: ContractIdentifierSchema.optional(),
-  virtualizationBoundary: z3.boolean()
+  virtualizationBoundary: z4.boolean()
 }).strict().superRefine((scroll, context) => {
   if (scroll.owner === "provider" && scroll.restoreKey) {
     context.addIssue({
@@ -6740,11 +6970,11 @@ var RenderScrollSchema = z3.object({
     });
   }
 });
-var RenderActivationSchema = z3.object({
+var RenderActivationSchema = z4.object({
   activationId: ContractIdentifierSchema,
-  mode: z3.enum(["navigate", "select", "drawer", "modal", "fullscreen", "inline"]),
-  targetPath: z3.string().trim().regex(/^\/(?!\/)/, "Expected an application-relative path.").optional(),
-  history: z3.enum(["push", "replace"]).optional()
+  mode: z4.enum(["navigate", "select", "drawer", "modal", "fullscreen", "inline"]),
+  targetPath: z4.string().trim().regex(/^\/(?!\/)/, "Expected an application-relative path.").optional(),
+  history: z4.enum(["push", "replace"]).optional()
 }).strict().superRefine((activation, context) => {
   if (activation.mode === "navigate" && !activation.targetPath) {
     context.addIssue({ code: "custom", path: ["targetPath"], message: "Navigate activation requires an application-relative targetPath." });
@@ -6753,19 +6983,19 @@ var RenderActivationSchema = z3.object({
     context.addIssue({ code: "custom", path: ["targetPath"], message: "Only navigate activation may declare targetPath." });
   }
 });
-var RenderLifecycleSchema = z3.object({
-  mountPolicy: z3.enum(["always", "when-visible", "when-active"]),
-  queryPolicy: z3.enum(["always", "when-visible", "when-active", "manual"]),
-  retainOnDeactivate: z3.boolean(),
-  deepLink: z3.boolean(),
-  focusReturn: z3.boolean()
+var RenderLifecycleSchema = z4.object({
+  mountPolicy: z4.enum(["always", "when-visible", "when-active"]),
+  queryPolicy: z4.enum(["always", "when-visible", "when-active", "manual"]),
+  retainOnDeactivate: z4.boolean(),
+  deepLink: z4.boolean(),
+  focusReturn: z4.boolean()
 }).strict();
-var RenderLayoutSchema = z3.object({
-  mode: z3.enum(["contents", "block", "flex", "grid", "absolute"]),
-  direction: z3.enum(["row", "column"]).optional(),
-  columns: z3.number().int().positive().optional(),
-  align: z3.enum(["start", "center", "end", "stretch"]).optional(),
-  justify: z3.enum(["start", "center", "end", "between", "around"]).optional(),
+var RenderLayoutSchema = z4.object({
+  mode: z4.enum(["contents", "block", "flex", "grid", "absolute"]),
+  direction: z4.enum(["row", "column"]).optional(),
+  columns: z4.number().int().positive().optional(),
+  align: z4.enum(["start", "center", "end", "stretch"]).optional(),
+  justify: z4.enum(["start", "center", "end", "between", "around"]).optional(),
   gapTokenRef: EntityRefSchema.optional()
 }).strict().superRefine((layout, context) => {
   if (layout.direction && layout.mode !== "flex") {
@@ -6778,9 +7008,9 @@ var RenderLayoutSchema = z3.object({
     context.addIssue({ code: "custom", path: ["gapTokenRef", "kind"], message: "gapTokenRef must reference design-token." });
   }
 });
-var RenderResponsiveRuleSchema = z3.object({
-  minWidthPx: z3.number().nonnegative().optional(),
-  maxWidthPx: z3.number().positive().optional(),
+var RenderResponsiveRuleSchema = z4.object({
+  minWidthPx: z4.number().nonnegative().optional(),
+  maxWidthPx: z4.number().positive().optional(),
   layout: RenderLayoutSchema
 }).strict().superRefine((rule, context) => {
   if (rule.minWidthPx === void 0 && rule.maxWidthPx === void 0) {
@@ -6818,14 +7048,14 @@ var requirePinnedOwnedRef = (reference, expectedKind, path, context) => {
     });
   }
 };
-var RenderNodeSchema = z3.object({
-  contract: z3.literal("RenderNode"),
+var RenderNodeSchema = z4.object({
+  contract: z4.literal("RenderNode"),
   nodeId: ContractIdentifierSchema,
   kind: RenderNodeKindSchema,
   version: ContractVersionSchema,
   ownerRepo: ContractIdentifierSchema,
   parentNodeId: ContractIdentifierSchema.optional(),
-  children: z3.array(ContractIdentifierSchema),
+  children: z4.array(ContractIdentifierSchema),
   slot: ContractIdentifierSchema.optional(),
   pageRef: EntityRefSchema,
   semanticRef: EntityRefSchema.optional(),
@@ -6838,7 +7068,7 @@ var RenderNodeSchema = z3.object({
   activation: RenderActivationSchema,
   lifecycle: RenderLifecycleSchema,
   layout: RenderLayoutSchema,
-  responsive: z3.array(RenderResponsiveRuleSchema),
+  responsive: z4.array(RenderResponsiveRuleSchema),
   accessRef: EntityRefSchema.optional(),
   evidenceRef: EntityRefSchema.optional(),
   state: RenderNodeStateSchema,
@@ -6870,39 +7100,39 @@ var RenderNodeSchema = z3.object({
     });
   }
 });
-var RenderTreeSchema = z3.object({
-  contract: z3.literal("RenderTree"),
+var RenderTreeSchema = z4.object({
+  contract: z4.literal("RenderTree"),
   treeId: ContractIdentifierSchema,
   product: ProductContextSchema,
   rootNodeId: ContractIdentifierSchema,
-  nodes: z3.array(RenderNodeSchema).min(1)
+  nodes: z4.array(RenderNodeSchema).min(1)
 }).strict();
-var OverlayZIndexLaneSchema = z3.enum([
+var OverlayZIndexLaneSchema = z4.enum([
   "popover",
   "drawer",
   "modal",
   "fullscreen",
   "system"
 ]);
-var OverlayNodeSchema = z3.object({
-  contract: z3.literal("OverlayNode"),
+var OverlayNodeSchema = z4.object({
+  contract: z4.literal("OverlayNode"),
   overlayId: ContractIdentifierSchema,
   renderNode: RenderNodeSchema,
-  presentation: z3.enum(["drawer", "modal", "fullscreen"]),
+  presentation: z4.enum(["drawer", "modal", "fullscreen"]),
   zIndexLane: OverlayZIndexLaneSchema,
-  url: z3.object({
+  url: z4.object({
     parameter: ContractIdentifierSchema,
     value: ContractIdentifierSchema,
-    openMode: z3.enum(["push", "replace"]),
-    closeMode: z3.enum(["back", "replace"])
+    openMode: z4.enum(["push", "replace"]),
+    closeMode: z4.enum(["back", "replace"])
   }).strict(),
-  focus: z3.object({
-    initial: z3.enum(["first-interactive", "container", "explicit"]),
-    trap: z3.boolean()
+  focus: z4.object({
+    initial: z4.enum(["first-interactive", "container", "explicit"]),
+    trap: z4.boolean()
   }).strict(),
-  close: z3.object({
-    escape: z3.boolean(),
-    backdrop: z3.boolean()
+  close: z4.object({
+    escape: z4.boolean(),
+    backdrop: z4.boolean()
   }).strict()
 }).strict().superRefine((value, context) => {
   if (value.renderNode.kind !== "overlay") {
@@ -6941,8 +7171,8 @@ var OverlayNodeSchema = z3.object({
     });
   }
 });
-var ProductPathSchema = z3.string().trim().regex(/^\/(?!\/)/, "Expected an application-relative path.");
-var ApplicationHandoffEndpointSchema = z3.object({
+var ProductPathSchema = z4.string().trim().regex(/^\/(?!\/)/, "Expected an application-relative path.");
+var ApplicationHandoffEndpointSchema = z4.object({
   product: ProductContextSchema,
   pageId: ContractIdentifierSchema,
   viewId: ContractIdentifierSchema.optional(),
@@ -6951,8 +7181,8 @@ var ApplicationHandoffEndpointSchema = z3.object({
   activationId: ContractIdentifierSchema.optional(),
   path: ProductPathSchema
 }).strict();
-var ApplicationHandoffSchema = z3.object({
-  contract: z3.literal("ApplicationHandoff"),
+var ApplicationHandoffSchema = z4.object({
+  contract: z4.literal("ApplicationHandoff"),
   handoffId: ContractIdentifierSchema,
   source: ApplicationHandoffEndpointSchema,
   target: ApplicationHandoffEndpointSchema,
@@ -6968,8 +7198,8 @@ var ApplicationHandoffSchema = z3.object({
     });
   }
 });
-var ViewProviderDescriptorSchema = z3.object({
-  contract: z3.literal("ViewProviderDescriptor"),
+var ViewProviderDescriptorSchema = z4.object({
+  contract: z4.literal("ViewProviderDescriptor"),
   providerId: ContractIdentifierSchema,
   providerVersion: ContractIdentifierSchema,
   ownerRepo: ContractIdentifierSchema,
@@ -6977,22 +7207,22 @@ var ViewProviderDescriptorSchema = z3.object({
   rendererKey: ContractIdentifierSchema,
   renderModelSchemaRef: ContractIdentifierSchema,
   intentSchemaRef: ContractIdentifierSchema.optional(),
-  loading: z3.enum(["eager", "lazy", "viewport", "on-activation"]),
-  stateOwner: z3.enum(["host", "provider", "external"]),
-  supportedPageTypes: z3.array(ContractIdentifierSchema).min(1),
-  supportedSurfaces: z3.array(z3.enum(["page", "workspace", "view", "record", "action", "overlay", "agent"])).min(1),
-  frameOwner: z3.enum(["host", "provider", "none"]),
-  sideEffects: z3.array(z3.enum(["network", "storage", "navigation", "worker", "websocket"])),
+  loading: z4.enum(["eager", "lazy", "viewport", "on-activation"]),
+  stateOwner: z4.enum(["host", "provider", "external"]),
+  supportedPageTypes: z4.array(ContractIdentifierSchema).min(1),
+  supportedSurfaces: z4.array(z4.enum(["page", "workspace", "view", "record", "action", "overlay", "agent"])).min(1),
+  frameOwner: z4.enum(["host", "provider", "none"]),
+  sideEffects: z4.array(z4.enum(["network", "storage", "navigation", "worker", "websocket"])),
   sideEffectAdapterRef: EntityRefSchema.optional(),
-  lifecycle: z3.object({
-    preserveMount: z3.boolean(),
-    preserveScroll: z3.boolean(),
+  lifecycle: z4.object({
+    preserveMount: z4.boolean(),
+    preserveScroll: z4.boolean(),
     focusModel: ContractIdentifierSchema
   }).strict(),
-  performance: z3.object({
-    lazy: z3.boolean(),
-    virtualized: z3.boolean(),
-    budgetMs: z3.number().positive().optional()
+  performance: z4.object({
+    lazy: z4.boolean(),
+    virtualized: z4.boolean(),
+    budgetMs: z4.number().positive().optional()
   }).strict(),
   accessRef: EntityRefSchema.optional(),
   evidenceRef: EntityRefSchema.optional()
@@ -7024,54 +7254,54 @@ var ViewProviderDescriptorSchema = z3.object({
 });
 
 // src/contracts/capability.ts
-var ContractPortSchema = z4.object({
+var ContractPortSchema = z5.object({
   name: ContractIdentifierSchema,
   schemaRef: ContractIdentifierSchema,
-  required: z4.boolean().default(false),
-  multiple: z4.boolean().default(false),
-  description: z4.string().optional()
+  required: z5.boolean().default(false),
+  multiple: z5.boolean().default(false),
+  description: z5.string().optional()
 }).strict();
-var CapabilityProviderBindingSchema = z4.object({
+var CapabilityProviderBindingSchema = z5.object({
   providerRef: EntityRefSchema,
-  productContexts: z4.array(ProductContextSchema).default([]),
-  priority: z4.number().int().default(0)
+  productContexts: z5.array(ProductContextSchema).default([]),
+  priority: z5.number().int().default(0)
 }).strict();
-var CapabilityManifestSchema = z4.object({
-  contract: z4.literal("CapabilityManifest"),
+var CapabilityManifestSchema = z5.object({
+  contract: z5.literal("CapabilityManifest"),
   id: ContractIdentifierSchema,
   capabilityVersion: ContractIdentifierSchema,
   ownerRepo: ContractIdentifierSchema,
-  kind: z4.enum(["primitive", "composite", "view", "professional-provider", "tool", "workflow"]),
-  displayName: z4.string().trim().min(1),
-  description: z4.string().optional(),
-  ports: z4.object({
-    inputs: z4.array(ContractPortSchema).default([]),
-    outputs: z4.array(ContractPortSchema).default([])
+  kind: z5.enum(["primitive", "composite", "view", "professional-provider", "tool", "workflow"]),
+  displayName: z5.string().trim().min(1),
+  description: z5.string().optional(),
+  ports: z5.object({
+    inputs: z5.array(ContractPortSchema).default([]),
+    outputs: z5.array(ContractPortSchema).default([])
   }).strict(),
-  runtime: z4.object({
-    providerBindings: z4.array(CapabilityProviderBindingSchema).min(1),
-    loading: z4.enum(["eager", "lazy", "viewport", "on-activation"]),
+  runtime: z5.object({
+    providerBindings: z5.array(CapabilityProviderBindingSchema).min(1),
+    loading: z5.enum(["eager", "lazy", "viewport", "on-activation"]),
     fallbackCapabilityRef: EntityRefSchema.optional(),
-    stateOwner: z4.enum(["host", "provider", "external"]),
+    stateOwner: z5.enum(["host", "provider", "external"]),
     stateSchemaRef: ContractIdentifierSchema.optional(),
-    sideEffects: z4.array(z4.enum(["network", "storage", "navigation", "worker", "websocket"])).default([])
+    sideEffects: z5.array(z5.enum(["network", "storage", "navigation", "worker", "websocket"])).default([])
   }).strict(),
-  placement: z4.object({
-    surfaces: z4.array(ContractIdentifierSchema).min(1),
-    slots: z4.array(ContractIdentifierSchema).default([]),
-    variants: z4.array(ContractIdentifierSchema).default([]),
-    tokenRefs: z4.array(ContractIdentifierSchema).default([])
+  placement: z5.object({
+    surfaces: z5.array(ContractIdentifierSchema).min(1),
+    slots: z5.array(ContractIdentifierSchema).default([]),
+    variants: z5.array(ContractIdentifierSchema).default([]),
+    tokenRefs: z5.array(ContractIdentifierSchema).default([])
   }).strict(),
-  accessibility: z4.object({
+  accessibility: z5.object({
     keyboardModel: ContractIdentifierSchema,
     focusModel: ContractIdentifierSchema,
     labelContract: ContractIdentifierSchema
   }).strict(),
-  observability: z4.object({
+  observability: z5.object({
     eventNamespace: ContractIdentifierSchema,
-    metrics: z4.array(ContractIdentifierSchema).default([]),
-    evidenceRefs: z4.array(ContractIdentifierSchema).default([]),
-    performanceBudgetMs: z4.number().positive().optional()
+    metrics: z5.array(ContractIdentifierSchema).default([]),
+    evidenceRefs: z5.array(ContractIdentifierSchema).default([]),
+    performanceBudgetMs: z5.number().positive().optional()
   }).strict()
 }).strict().superRefine((manifest, context) => {
   const providerIds = /* @__PURE__ */ new Set();
@@ -7093,25 +7323,25 @@ var CapabilityManifestSchema = z4.object({
     }
   });
 });
-var CapabilitySourceTypeSchema = z4.enum([
+var CapabilitySourceTypeSchema = z5.enum([
   "tool-manifest",
   "plugin-manifest",
   "openapi",
   "workflow",
   "comfyui"
 ]);
-var CapabilityRegistrySourceSchema = z4.object({
+var CapabilityRegistrySourceSchema = z5.object({
   sourceType: CapabilitySourceTypeSchema,
   sourceId: ContractIdentifierSchema,
   ownerRepo: ContractIdentifierSchema
 }).strict();
-var CapabilityRegistryEntrySchema = z4.object({
+var CapabilityRegistryEntrySchema = z5.object({
   manifest: CapabilityManifestSchema,
-  sources: z4.array(CapabilityRegistrySourceSchema).min(1)
+  sources: z5.array(CapabilityRegistrySourceSchema).min(1)
 }).strict();
-var CapabilityRegistryDocumentSchema = z4.object({
-  contract: z4.literal("CapabilityRegistry"),
-  entries: z4.array(CapabilityRegistryEntrySchema)
+var CapabilityRegistryDocumentSchema = z5.object({
+  contract: z5.literal("CapabilityRegistry"),
+  entries: z5.array(CapabilityRegistryEntrySchema)
 }).strict().superRefine((registry, context) => {
   const ids = /* @__PURE__ */ new Set();
   registry.entries.forEach((entry, index) => {
@@ -7127,38 +7357,38 @@ var CapabilityRegistryDocumentSchema = z4.object({
 });
 
 // src/contracts/context.ts
-import { z as z5 } from "zod";
-var ActorRefSchema = z5.object({
-  kind: z5.enum(["human", "agent", "service", "tenant", "public"]),
+import { z as z6 } from "zod";
+var ActorRefSchema = z6.object({
+  kind: z6.enum(["human", "agent", "service", "tenant", "public"]),
   id: ContractIdentifierSchema.optional(),
   userId: ContractIdentifierSchema.optional(),
   agentId: ContractIdentifierSchema.optional(),
   serviceId: ContractIdentifierSchema.optional()
 }).strict();
-var AuthorityScopeSchema = z5.object({
+var AuthorityScopeSchema = z6.object({
   resource: ContractIdentifierSchema,
-  actions: z5.array(ContractIdentifierSchema).min(1),
-  constraints: z5.record(z5.string(), JsonValueSchema).optional()
+  actions: z6.array(ContractIdentifierSchema).min(1),
+  constraints: z6.record(z6.string(), JsonValueSchema).optional()
 }).strict();
-var RequestScopeSchema = z5.object({
-  contract: z5.literal("RequestScope"),
+var RequestScopeSchema = z6.object({
+  contract: z6.literal("RequestScope"),
   requestId: ContractIdentifierSchema,
   traceId: ContractIdentifierSchema.optional(),
   appId: ContractIdentifierSchema,
   tenantId: ContractIdentifierSchema.optional(),
   teamId: ContractIdentifierSchema.optional(),
   actor: ActorRefSchema,
-  session: z5.object({
+  session: z6.object({
     authType: ContractIdentifierSchema,
-    authenticated: z5.boolean(),
-    membershipVerified: z5.boolean()
+    authenticated: z6.boolean(),
+    membershipVerified: z6.boolean()
   }).strict(),
-  permissionCodes: z5.array(ContractIdentifierSchema).default([]),
-  authority: z5.array(AuthorityScopeSchema).default([]),
+  permissionCodes: z6.array(ContractIdentifierSchema).default([]),
+  authority: z6.array(AuthorityScopeSchema).default([]),
   issuedAt: IsoDateTimeSchema
 }).strict();
-var ExecutionLinkSchema = z5.object({
-  contract: z5.literal("ExecutionLink"),
+var ExecutionLinkSchema = z6.object({
+  contract: z6.literal("ExecutionLink"),
   requestId: ContractIdentifierSchema,
   traceId: ContractIdentifierSchema.optional(),
   correlationId: ContractIdentifierSchema.optional(),
@@ -7168,43 +7398,43 @@ var ExecutionLinkSchema = z5.object({
   taskRef: EntityRefSchema.optional(),
   parentRunRef: EntityRefSchema.optional()
 }).strict();
-var CompletionHeaderSchema = z5.object({
-  contract: z5.literal("CompletionHeader"),
+var CompletionHeaderSchema = z6.object({
+  contract: z6.literal("CompletionHeader"),
   eventId: ContractIdentifierSchema,
   runtimeEventId: ContractIdentifierSchema,
   idempotencyKey: ContractIdentifierSchema,
-  sequence: z5.number().int().nonnegative(),
+  sequence: z6.number().int().nonnegative(),
   execution: ExecutionLinkSchema,
-  producer: z5.object({
+  producer: z6.object({
     service: ContractIdentifierSchema,
     runtime: ContractIdentifierSchema,
     version: ContractIdentifierSchema
   }).strict(),
-  status: z5.enum(["SUCCEEDED", "FAILED", "CANCELLED", "TIMED_OUT"]),
+  status: z6.enum(["SUCCEEDED", "FAILED", "CANCELLED", "TIMED_OUT"]),
   occurredAt: IsoDateTimeSchema,
   payloadSchemaRef: ContractIdentifierSchema.optional()
 }).strict();
-var CompletionEventSchema = z5.object({
+var CompletionEventSchema = z6.object({
   header: CompletionHeaderSchema,
   payload: JsonValueSchema.optional()
 }).strict();
-var AgentRuntimeEventSchema = z5.object({
-  contract: z5.literal("AgentRuntimeEvent"),
+var AgentRuntimeEventSchema = z6.object({
+  contract: z6.literal("AgentRuntimeEvent"),
   runtimeEventId: ContractIdentifierSchema,
   streamId: ContractIdentifierSchema,
-  sequence: z5.number().int().nonnegative(),
+  sequence: z6.number().int().nonnegative(),
   requestId: ContractIdentifierSchema,
   teamId: ContractIdentifierSchema,
   threadId: ContractIdentifierSchema.optional(),
-  eventType: z5.enum(["messages:append", "messages:update", "thread:update", "tool-call:upsert"]),
+  eventType: z6.enum(["messages:append", "messages:update", "thread:update", "tool-call:upsert", "session:event"]),
   payload: JsonValueSchema,
   occurredAt: IsoDateTimeSchema
 }).strict();
 
 // src/contracts/continuity.ts
-import { z as z6 } from "zod";
-var DataContinuityEnvelopeSchema = z6.object({
-  contract: z6.literal("DataContinuityEnvelope"),
+import { z as z7 } from "zod";
+var DataContinuityEnvelopeSchema = z7.object({
+  contract: z7.literal("DataContinuityEnvelope"),
   tenantId: ContractIdentifierSchema,
   teamId: ContractIdentifierSchema,
   sourceRef: EntityRefSchema.optional(),
@@ -7219,104 +7449,104 @@ var DataContinuityEnvelopeSchema = z6.object({
   (value) => Boolean(value.sourceRef || value.bodyRef || value.runRef || value.outputRef || value.artifactRef),
   "At least one continuity ref is required."
 );
-var BodyRelationRecordSchema = z6.object({
-  contract: z6.literal("BodyRelationRecord"),
+var BodyRelationRecordSchema = z7.object({
+  contract: z7.literal("BodyRelationRecord"),
   relationId: ContractIdentifierSchema,
   relationKind: ContractIdentifierSchema,
   subjectRef: EntityRefSchema,
   objectRef: EntityRefSchema,
   ownerRepo: ContractIdentifierSchema,
-  authorityScope: z6.enum(["tenant", "team", "global"]),
+  authorityScope: z7.enum(["tenant", "team", "global"]),
   properties: JsonObjectSchema.default({}),
   createdAt: IsoDateTimeSchema,
   updatedAt: IsoDateTimeSchema
 }).strict();
-var ApplicationRunSchema = z6.object({
-  contract: z6.literal("ApplicationRun"),
+var ApplicationRunSchema = z7.object({
+  contract: z7.literal("ApplicationRun"),
   runId: ContractIdentifierSchema,
   definitionRef: EntityRefSchema,
   runtimeLedgerRef: EntityRefSchema,
   requestId: ContractIdentifierSchema,
   actorRef: EntityRefSchema,
-  status: z6.enum(["PENDING", "RUNNING", "COMPLETED", "FAILED", "CANCELLED", "EXPIRED"]),
-  inputRefs: z6.array(EntityRefSchema).default([]),
-  outputRefs: z6.array(EntityRefSchema).default([]),
+  status: z7.enum(["PENDING", "RUNNING", "COMPLETED", "FAILED", "CANCELLED", "EXPIRED"]),
+  inputRefs: z7.array(EntityRefSchema).default([]),
+  outputRefs: z7.array(EntityRefSchema).default([]),
   startedAt: IsoDateTimeSchema.optional(),
   completedAt: IsoDateTimeSchema.optional(),
   expiresAt: IsoDateTimeSchema.optional(),
   metadata: JsonObjectSchema.default({})
 }).strict();
-var ExpiringAccessGrantSchema = z6.object({
-  contract: z6.literal("ExpiringAccessGrant"),
+var ExpiringAccessGrantSchema = z7.object({
+  contract: z7.literal("ExpiringAccessGrant"),
   grantId: ContractIdentifierSchema,
   subjectRef: EntityRefSchema,
   resourceRef: EntityRefSchema,
-  permissions: z6.array(ContractIdentifierSchema).min(1),
+  permissions: z7.array(ContractIdentifierSchema).min(1),
   issuedAt: IsoDateTimeSchema,
   expiresAt: IsoDateTimeSchema,
   revokedAt: IsoDateTimeSchema.optional()
 }).strict().refine((value) => Date.parse(value.expiresAt) > Date.parse(value.issuedAt), "expiresAt must be after issuedAt");
 
 // src/contracts/data.ts
-import { z as z7 } from "zod";
-var SourceRecordRefSchema = z7.object({
+import { z as z8 } from "zod";
+var SourceRecordRefSchema = z8.object({
   sourceId: ContractIdentifierSchema,
   recordId: ContractIdentifierSchema,
-  recordVersion: z7.union([z7.number().int().nonnegative(), ContractIdentifierSchema]),
+  recordVersion: z8.union([z8.number().int().nonnegative(), ContractIdentifierSchema]),
   hash: Sha256Schema
 }).strict();
-var OntologyDefinitionSchema = z7.object({
-  contract: z7.literal("OntologyDefinition"),
+var OntologyDefinitionSchema = z8.object({
+  contract: z8.literal("OntologyDefinition"),
   ontologyId: ContractIdentifierSchema,
   dataSpaceId: ContractIdentifierSchema,
   ownerRepo: ContractIdentifierSchema,
   bodySchemaRef: ContractIdentifierSchema,
-  authority: z7.object({
+  authority: z8.object({
     service: ContractIdentifierSchema,
     storage: ContractIdentifierSchema,
-    scope: z7.enum(["tenant", "team", "user", "global"])
+    scope: z8.enum(["tenant", "team", "user", "global"])
   }).strict(),
-  relationKinds: z7.array(ContractIdentifierSchema).default([]),
-  metricKinds: z7.array(ContractIdentifierSchema).default([])
+  relationKinds: z8.array(ContractIdentifierSchema).default([]),
+  metricKinds: z8.array(ContractIdentifierSchema).default([])
 }).strict();
-var ProjectionSpecSchema = z7.object({
-  contract: z7.literal("ProjectionSpec"),
+var ProjectionSpecSchema = z8.object({
+  contract: z8.literal("ProjectionSpec"),
   projectionId: ContractIdentifierSchema,
-  ontologyIds: z7.array(ContractIdentifierSchema).min(1),
+  ontologyIds: z8.array(ContractIdentifierSchema).min(1),
   outputSchemaRef: ContractIdentifierSchema,
-  operator: z7.object({
-    kind: z7.enum(["query", "aggregate", "relationship", "search", "custom"]),
-    configuration: z7.record(z7.string(), JsonValueSchema).default({})
+  operator: z8.object({
+    kind: z8.enum(["query", "aggregate", "relationship", "search", "custom"]),
+    configuration: z8.record(z8.string(), JsonValueSchema).default({})
   }).strict(),
-  materialization: z7.enum(["on-demand", "event-driven", "scheduled"]),
-  invalidationEvents: z7.array(ContractIdentifierSchema).default([]),
-  rebuildable: z7.literal(true),
-  lineagePolicy: z7.object({
-    sourceRecords: z7.boolean(),
-    bodyVersions: z7.boolean(),
-    runRefs: z7.boolean(),
-    actorRefs: z7.boolean()
+  materialization: z8.enum(["on-demand", "event-driven", "scheduled"]),
+  invalidationEvents: z8.array(ContractIdentifierSchema).default([]),
+  rebuildable: z8.literal(true),
+  lineagePolicy: z8.object({
+    sourceRecords: z8.boolean(),
+    bodyVersions: z8.boolean(),
+    runRefs: z8.boolean(),
+    actorRefs: z8.boolean()
   }).strict()
 }).strict();
-var LineageRecordSchema = z7.object({
-  contract: z7.literal("LineageRecord"),
+var LineageRecordSchema = z8.object({
+  contract: z8.literal("LineageRecord"),
   lineageId: ContractIdentifierSchema,
   subjectRef: EntityRefSchema,
-  sourceRecords: z7.array(SourceRecordRefSchema).default([]),
-  bodyRefs: z7.array(EntityRefSchema).default([]),
-  runRefs: z7.array(EntityRefSchema).default([]),
-  outputRefs: z7.array(EntityRefSchema).default([]),
-  artifactRefs: z7.array(EntityRefSchema).default([]),
-  actorRefs: z7.array(EntityRefSchema).default([]),
-  evidenceRefs: z7.array(EntityRefSchema).default([]),
+  sourceRecords: z8.array(SourceRecordRefSchema).default([]),
+  bodyRefs: z8.array(EntityRefSchema).default([]),
+  runRefs: z8.array(EntityRefSchema).default([]),
+  outputRefs: z8.array(EntityRefSchema).default([]),
+  artifactRefs: z8.array(EntityRefSchema).default([]),
+  actorRefs: z8.array(EntityRefSchema).default([]),
+  evidenceRefs: z8.array(EntityRefSchema).default([]),
   recordedAt: IsoDateTimeSchema
 }).strict();
-var DomainEventSchema = z7.object({
-  contract: z7.literal("DomainEvent"),
+var DomainEventSchema = z8.object({
+  contract: z8.literal("DomainEvent"),
   eventId: ContractIdentifierSchema,
   eventType: ContractIdentifierSchema,
   aggregateRef: EntityRefSchema,
-  aggregateVersion: z7.number().int().nonnegative(),
+  aggregateVersion: z8.number().int().nonnegative(),
   requestId: ContractIdentifierSchema,
   actorRef: EntityRefSchema,
   payload: JsonValueSchema,
@@ -7324,8 +7554,8 @@ var DomainEventSchema = z7.object({
 }).strict();
 
 // src/contracts/page.ts
-import { z as z8 } from "zod";
-var PageTypeSchema = z8.enum([
+import { z as z9 } from "zod";
+var PageTypeSchema = z9.enum([
   "page",
   "workspace",
   "view",
@@ -7346,14 +7576,14 @@ var PageTypeSchema = z8.enum([
   "global-design-board",
   "iframe"
 ]);
-var PageVisibilitySchema = z8.object({
-  authenticated: z8.boolean().default(true),
-  permissionAllOf: z8.array(ContractIdentifierSchema).default([]),
-  permissionAnyOf: z8.array(ContractIdentifierSchema).default([]),
-  featureFlags: z8.array(ContractIdentifierSchema).default([]),
-  productContexts: z8.array(z8.enum(["studio", "kernel", "compute"])).min(1)
+var PageVisibilitySchema = z9.object({
+  authenticated: z9.boolean().default(true),
+  permissionAllOf: z9.array(ContractIdentifierSchema).default([]),
+  permissionAnyOf: z9.array(ContractIdentifierSchema).default([]),
+  featureFlags: z9.array(ContractIdentifierSchema).default([]),
+  productContexts: z9.array(z9.enum(["studio", "kernel", "compute"])).min(1)
 }).strict();
-var PageRoutePathSchema = z8.string().trim().regex(/^\/(?!\/)/, "Expected an application-relative route path.");
+var PageRoutePathSchema = z9.string().trim().regex(/^\/(?!\/)/, "Expected an application-relative route path.");
 var requireCapabilityReference = (reference, path, context) => {
   if (reference.kind !== "capability") {
     context.addIssue({
@@ -7377,50 +7607,50 @@ var requireCapabilityReference = (reference, path, context) => {
     });
   }
 };
-var PageDefinitionSchema = z8.object({
-  contract: z8.literal("PageDefinition"),
+var PageDefinitionSchema = z9.object({
+  contract: z9.literal("PageDefinition"),
   pageId: ContractIdentifierSchema,
   ownerRepo: ContractIdentifierSchema,
   title: LocalizedTextSchema,
   pageType: PageTypeSchema,
-  ownership: z8.object({
+  ownership: z9.object({
     teamId: ContractIdentifierSchema.optional(),
     creatorRef: EntityRefSchema.optional(),
     studioId: ContractIdentifierSchema.optional(),
-    builtIn: z8.boolean()
+    builtIn: z9.boolean()
   }).strict(),
-  record: z8.object({
-    createdTimestamp: z8.number().int().nonnegative().optional(),
-    updatedTimestamp: z8.number().int().nonnegative().optional(),
-    deleted: z8.boolean().default(false)
+  record: z9.object({
+    createdTimestamp: z9.number().int().nonnegative().optional(),
+    updatedTimestamp: z9.number().int().nonnegative().optional(),
+    deleted: z9.boolean().default(false)
   }).strict(),
-  surface: z8.enum(["page", "workspace", "view", "record", "action", "overlay", "agent"]),
+  surface: z9.enum(["page", "workspace", "view", "record", "action", "overlay", "agent"]),
   routeId: ContractIdentifierSchema,
   routePath: PageRoutePathSchema,
   rendererKey: ContractIdentifierSchema,
   capabilityRef: EntityRefSchema,
-  capabilityRefs: z8.array(EntityRefSchema).default([]),
+  capabilityRefs: z9.array(EntityRefSchema).default([]),
   workflowRef: EntityRefSchema.optional(),
-  binding: z8.object({
+  binding: z9.object({
     sourceRef: ContractIdentifierSchema.optional(),
     ontologyId: ContractIdentifierSchema.optional(),
     projectionRef: ContractIdentifierSchema.optional(),
     stateRef: ContractIdentifierSchema.optional()
   }).strict(),
-  access: z8.object({
-    actions: z8.array(z8.enum(["read", "write", "execute", "manage-permissions"])).default([])
+  access: z9.object({
+    actions: z9.array(z9.enum(["read", "write", "execute", "manage-permissions"])).default([])
   }).strict(),
-  rendererConfig: z8.object({
+  rendererConfig: z9.object({
     schemaRef: ContractIdentifierSchema,
     value: JsonObjectSchema
   }).strict(),
-  navigation: z8.object({
+  navigation: z9.object({
     label: LocalizedTextSchema,
     iconRef: ContractIdentifierSchema.optional(),
     parentPageId: ContractIdentifierSchema.optional(),
-    order: z8.number().int().optional(),
-    hidden: z8.boolean().default(false),
-    pinned: z8.boolean().default(false)
+    order: z9.number().int().optional(),
+    hidden: z9.boolean().default(false),
+    pinned: z9.boolean().default(false)
   }).strict(),
   visibility: PageVisibilitySchema
 }).strict().superRefine((page, context) => {
@@ -7441,8 +7671,8 @@ var PageDefinitionSchema = z8.object({
   });
   if (page.workflowRef && page.workflowRef.kind !== "workflow") context.addIssue({ code: "custom", path: ["workflowRef", "kind"], message: "workflowRef must reference a workflow." });
 });
-var PageRuntimeDescriptorSchema = z8.object({
-  contract: z8.literal("PageRuntimeDescriptor"),
+var PageRuntimeDescriptorSchema = z9.object({
+  contract: z9.literal("PageRuntimeDescriptor"),
   page: PageDefinitionSchema,
   nodeId: ContractIdentifierSchema,
   parentNodeId: ContractIdentifierSchema.optional(),
@@ -7450,54 +7680,54 @@ var PageRuntimeDescriptorSchema = z8.object({
   semanticRef: ContractIdentifierSchema.optional(),
   dataContextRef: ContractIdentifierSchema.optional(),
   providerRef: EntityRefSchema.optional(),
-  surface: z8.object({
+  surface: z9.object({
     frameOwner: ContractIdentifierSchema,
     tone: ContractIdentifierSchema.optional(),
-    density: z8.enum(["compact", "default", "comfortable"]).default("default")
+    density: z9.enum(["compact", "default", "comfortable"]).default("default")
   }).strict(),
-  scroll: z8.object({
-    owner: z8.enum(["page", "surface", "provider"]),
-    axis: z8.enum(["x", "y", "both", "none"]),
+  scroll: z9.object({
+    owner: z9.enum(["page", "surface", "provider"]),
+    axis: z9.enum(["x", "y", "both", "none"]),
     restoreKey: ContractIdentifierSchema.optional(),
-    virtualized: z8.boolean().default(false)
+    virtualized: z9.boolean().default(false)
   }).strict(),
-  activation: z8.enum(["navigate", "select", "drawer", "modal", "fullscreen"]),
-  lifecycle: z8.object({
-    mountPolicy: z8.enum(["always", "when-visible", "when-active"]),
-    queryPolicy: z8.enum(["always", "when-visible", "when-active", "manual"]),
-    deepLink: z8.boolean(),
-    focusReturn: z8.boolean()
+  activation: z9.enum(["navigate", "select", "drawer", "modal", "fullscreen"]),
+  lifecycle: z9.object({
+    mountPolicy: z9.enum(["always", "when-visible", "when-active"]),
+    queryPolicy: z9.enum(["always", "when-visible", "when-active", "manual"]),
+    deepLink: z9.boolean(),
+    focusReturn: z9.boolean()
   }).strict()
 }).strict();
-var PageRouteProjectionSchema = z8.object({
+var PageRouteProjectionSchema = z9.object({
   pageId: ContractIdentifierSchema,
   routeId: ContractIdentifierSchema,
   path: PageRoutePathSchema
 }).strict();
-var PageNavigationProjectionSchema = z8.object({
+var PageNavigationProjectionSchema = z9.object({
   pageId: ContractIdentifierSchema,
   routeId: ContractIdentifierSchema,
   path: PageRoutePathSchema,
   label: LocalizedTextSchema,
   iconRef: ContractIdentifierSchema.optional(),
   parentPageId: ContractIdentifierSchema.optional(),
-  order: z8.number().int().optional(),
-  pinned: z8.boolean()
+  order: z9.number().int().optional(),
+  pinned: z9.boolean()
 }).strict();
-var PageGuardProjectionSchema = z8.object({
+var PageGuardProjectionSchema = z9.object({
   pageId: ContractIdentifierSchema,
-  authenticated: z8.boolean(),
-  permissionAllOf: z8.array(ContractIdentifierSchema),
-  permissionAnyOf: z8.array(ContractIdentifierSchema),
-  featureFlags: z8.array(ContractIdentifierSchema),
-  actions: z8.array(z8.enum(["read", "write", "execute", "manage-permissions"]))
+  authenticated: z9.boolean(),
+  permissionAllOf: z9.array(ContractIdentifierSchema),
+  permissionAnyOf: z9.array(ContractIdentifierSchema),
+  featureFlags: z9.array(ContractIdentifierSchema),
+  actions: z9.array(z9.enum(["read", "write", "execute", "manage-permissions"]))
 }).strict();
-var PageRendererProjectionSchema = z8.object({
+var PageRendererProjectionSchema = z9.object({
   pageId: ContractIdentifierSchema,
-  surface: z8.enum(["page", "workspace", "view", "record", "action", "overlay", "agent"]),
+  surface: z9.enum(["page", "workspace", "view", "record", "action", "overlay", "agent"]),
   rendererKey: ContractIdentifierSchema,
   capabilityRef: EntityRefSchema,
-  capabilityRefs: z8.array(EntityRefSchema),
+  capabilityRefs: z9.array(EntityRefSchema),
   providerRef: EntityRefSchema,
   binding: PageDefinitionSchema.shape.binding,
   rendererConfig: PageDefinitionSchema.shape.rendererConfig,
@@ -7538,13 +7768,13 @@ var duplicateProjectionIdentity = (values, identity) => {
   }
   return void 0;
 };
-var PageRuntimeProjectionSchema = z8.object({
-  contract: z8.literal("PageRuntimeProjection"),
-  product: z8.enum(["studio", "kernel", "compute"]),
-  routes: z8.array(PageRouteProjectionSchema),
-  navigation: z8.array(PageNavigationProjectionSchema),
-  guards: z8.array(PageGuardProjectionSchema),
-  renderers: z8.array(PageRendererProjectionSchema)
+var PageRuntimeProjectionSchema = z9.object({
+  contract: z9.literal("PageRuntimeProjection"),
+  product: z9.enum(["studio", "kernel", "compute"]),
+  routes: z9.array(PageRouteProjectionSchema),
+  navigation: z9.array(PageNavigationProjectionSchema),
+  guards: z9.array(PageGuardProjectionSchema),
+  renderers: z9.array(PageRendererProjectionSchema)
 }).strict().superRefine((projection, context) => {
   const tables = [
     ["routes", projection.routes.map((value) => value.pageId)],
@@ -7600,39 +7830,39 @@ var PageRuntimeProjectionSchema = z8.object({
 });
 
 // src/contracts/semantic.ts
-import { z as z9 } from "zod";
-var ConceptRelationshipSchema = z9.object({
+import { z as z10 } from "zod";
+var ConceptRelationshipSchema = z10.object({
   kind: ContractIdentifierSchema,
   targetConceptId: ContractIdentifierSchema,
-  cardinality: z9.enum(["one", "optional", "many"])
+  cardinality: z10.enum(["one", "optional", "many"])
 }).strict();
-var ConceptDefinitionSchema = z9.object({
-  contract: z9.literal("ConceptDefinition"),
+var ConceptDefinitionSchema = z10.object({
+  contract: z10.literal("ConceptDefinition"),
   conceptId: ContractIdentifierSchema,
   ownerRepo: ContractIdentifierSchema,
-  displayName: z9.string().trim().min(1),
-  description: z9.string().optional(),
+  displayName: z10.string().trim().min(1),
+  description: z10.string().optional(),
   schemaRef: ContractIdentifierSchema,
   ontologyId: ContractIdentifierSchema.optional(),
-  capabilityIds: z9.array(ContractIdentifierSchema).default([]),
-  commandNames: z9.array(ContractIdentifierSchema).default([]),
-  relationships: z9.array(ConceptRelationshipSchema).default([])
+  capabilityIds: z10.array(ContractIdentifierSchema).default([]),
+  commandNames: z10.array(ContractIdentifierSchema).default([]),
+  relationships: z10.array(ConceptRelationshipSchema).default([])
 }).strict();
-var DomainCommandDefinitionSchema = z9.object({
-  contract: z9.literal("DomainCommandDefinition"),
+var DomainCommandDefinitionSchema = z10.object({
+  contract: z10.literal("DomainCommandDefinition"),
   commandName: ContractIdentifierSchema,
   ownerRepo: ContractIdentifierSchema,
-  displayName: z9.string().trim().min(1),
-  description: z9.string().optional(),
-  targetKinds: z9.array(ContractIdentifierSchema).min(1),
+  displayName: z10.string().trim().min(1),
+  description: z10.string().optional(),
+  targetKinds: z10.array(ContractIdentifierSchema).min(1),
   inputSchemaRef: ContractIdentifierSchema,
   outputSchemaRef: ContractIdentifierSchema.optional(),
-  requiredPermissionCodes: z9.array(ContractIdentifierSchema).default([]),
+  requiredPermissionCodes: z10.array(ContractIdentifierSchema).default([]),
   handlerRef: EntityRefSchema,
-  sideEffects: z9.array(z9.enum(["data-write", "execution", "navigation", "notification", "external-call"])).default([])
+  sideEffects: z10.array(z10.enum(["data-write", "execution", "navigation", "notification", "external-call"])).default([])
 }).strict();
-var DomainCommandSchema = z9.object({
-  contract: z9.literal("DomainCommand"),
+var DomainCommandSchema = z10.object({
+  contract: z10.literal("DomainCommand"),
   commandId: ContractIdentifierSchema,
   commandName: ContractIdentifierSchema,
   requestId: ContractIdentifierSchema,
@@ -7640,29 +7870,29 @@ var DomainCommandSchema = z9.object({
   idempotencyKey: ContractIdentifierSchema,
   targetRef: EntityRefSchema,
   actorRef: EntityRefSchema,
-  source: z9.object({
-    product: z9.enum(["studio", "kernel", "compute", "agent", "mcp", "service"]),
+  source: z10.object({
+    product: z10.enum(["studio", "kernel", "compute", "agent", "mcp", "service"]),
     pageId: ContractIdentifierSchema.optional(),
     capabilityId: ContractIdentifierSchema.optional()
   }).strict(),
   payload: JsonObjectSchema,
   issuedAt: IsoDateTimeSchema
 }).strict();
-var ProductDeclarationSchema = z9.object({
-  contract: z9.literal("ProductDeclaration"),
+var ProductDeclarationSchema = z10.object({
+  contract: z10.literal("ProductDeclaration"),
   declarationId: ContractIdentifierSchema,
   ownerRepo: ContractIdentifierSchema,
-  concepts: z9.array(ConceptDefinitionSchema).default([]),
-  ontologies: z9.array(OntologyDefinitionSchema).default([]),
-  projections: z9.array(ProjectionSpecSchema).default([]),
-  commands: z9.array(DomainCommandDefinitionSchema).default([]),
-  capabilities: z9.array(CapabilityManifestSchema).default([]),
-  pages: z9.array(PageDefinitionSchema).default([])
+  concepts: z10.array(ConceptDefinitionSchema).default([]),
+  ontologies: z10.array(OntologyDefinitionSchema).default([]),
+  projections: z10.array(ProjectionSpecSchema).default([]),
+  commands: z10.array(DomainCommandDefinitionSchema).default([]),
+  capabilities: z10.array(CapabilityManifestSchema).default([]),
+  pages: z10.array(PageDefinitionSchema).default([])
 }).strict();
-var DeclarationGraphEdgeSchema = z9.object({
+var DeclarationGraphEdgeSchema = z10.object({
   from: EntityRefSchema,
   to: EntityRefSchema,
-  relation: z9.enum([
+  relation: z10.enum([
     "uses-ontology",
     "uses-projection",
     "uses-capability",
@@ -7670,25 +7900,25 @@ var DeclarationGraphEdgeSchema = z9.object({
     "relates-to-concept"
   ])
 }).strict();
-var ChangeImpactSchema = z9.object({
+var ChangeImpactSchema = z10.object({
   changedRef: EntityRefSchema,
-  affectedRefs: z9.array(EntityRefSchema),
-  reasons: z9.array(ContractIdentifierSchema).min(1)
+  affectedRefs: z10.array(EntityRefSchema),
+  reasons: z10.array(ContractIdentifierSchema).min(1)
 }).strict();
-var ChangeImpactGraphSchema = z9.object({
-  contract: z9.literal("ChangeImpactGraph"),
+var ChangeImpactGraphSchema = z10.object({
+  contract: z10.literal("ChangeImpactGraph"),
   declarationId: ContractIdentifierSchema,
-  nodes: z9.array(EntityRefSchema),
-  edges: z9.array(DeclarationGraphEdgeSchema),
-  impacts: z9.array(ChangeImpactSchema),
+  nodes: z10.array(EntityRefSchema),
+  edges: z10.array(DeclarationGraphEdgeSchema),
+  impacts: z10.array(ChangeImpactSchema),
   generatedAt: IsoDateTimeSchema
 }).strict();
 
 // src/contracts/tenant.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 
 // src/contracts/theme.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 
 // src/theme-tokens/core.ts
 var import_ajv = __toESM(require_ajv());
@@ -9915,20 +10145,20 @@ function assertMonkeysThemeTokensComplete(input) {
 }
 
 // src/contracts/theme.ts
-var ThemeTokenTypeSchema = z10.enum(THEME_TOKEN_TYPES);
-var ThemeTokenSchema = z10.record(z10.string(), z10.unknown()).superRefine((input, context) => {
+var ThemeTokenTypeSchema = z11.enum(THEME_TOKEN_TYPES);
+var ThemeTokenSchema = z11.record(z11.string(), z11.unknown()).superRefine((input, context) => {
   const issues = validateThemeTokensDocumentStructure({ token: input });
   for (const issue of issues) {
     context.addIssue({ code: "custom", message: `${issue.path} ${issue.message}` });
   }
 });
-var ThemeTokenGroupSchema = z10.record(z10.string(), z10.unknown()).superRefine((input, context) => {
+var ThemeTokenGroupSchema = z11.record(z11.string(), z11.unknown()).superRefine((input, context) => {
   const issues = validateThemeTokensDocumentStructure(input);
   for (const issue of issues) {
     context.addIssue({ code: "custom", message: `${issue.path} ${issue.message}` });
   }
 });
-var ThemeTokensSchema = z10.record(z10.string(), z10.unknown()).superRefine((input, context) => {
+var ThemeTokensSchema = z11.record(z11.string(), z11.unknown()).superRefine((input, context) => {
   const issues = validateThemeTokensDocument(input);
   for (const issue of issues) {
     context.addIssue({ code: "custom", message: `${issue.path} ${issue.message}` });
@@ -9955,9 +10185,9 @@ var ResolvedThemeTokensSchema = ThemeTokensSchema.superRefine((input, context) =
 });
 
 // src/contracts/tenant.ts
-var DesignTokenFileSourceSchema = z11.object({
-  type: z11.literal("file"),
-  path: z11.string().trim().min(1).superRefine((source, context) => {
+var DesignTokenFileSourceSchema = z12.object({
+  type: z12.literal("file"),
+  path: z12.string().trim().min(1).superRefine((source, context) => {
     if (/^[a-z][a-z\d+.-]*:/i.test(source)) {
       context.addIssue({
         code: "custom",
@@ -9966,9 +10196,9 @@ var DesignTokenFileSourceSchema = z11.object({
     }
   })
 }).strict();
-var DesignTokenUrlSourceSchema = z11.object({
-  type: z11.literal("url"),
-  url: z11.string().trim().min(1).superRefine((source, context) => {
+var DesignTokenUrlSourceSchema = z12.object({
+  type: z12.literal("url"),
+  url: z12.string().trim().min(1).superRefine((source, context) => {
     if (!/^https?:\/\//i.test(source)) {
       context.addIssue({
         code: "custom",
@@ -9977,109 +10207,109 @@ var DesignTokenUrlSourceSchema = z11.object({
     }
   })
 }).strict();
-var DesignTokenInlineSourceSchema = z11.object({
-  type: z11.literal("inline"),
+var DesignTokenInlineSourceSchema = z12.object({
+  type: z12.literal("inline"),
   document: ThemeTokensSchema
 }).strict();
-var DesignTokenSourceSchema = z11.discriminatedUnion("type", [
+var DesignTokenSourceSchema = z12.discriminatedUnion("type", [
   DesignTokenFileSourceSchema,
   DesignTokenUrlSourceSchema,
   DesignTokenInlineSourceSchema
 ]);
-var TenantDesignTokensConfigSchema = z11.object({
+var TenantDesignTokensConfigSchema = z12.object({
   /** Ordered tenant overrides. The backend always applies the product default first. */
-  tokenSources: z11.array(DesignTokenSourceSchema)
+  tokenSources: z12.array(DesignTokenSourceSchema)
 }).strict();
-var TenantAuthBindingSchema = z11.object({
-  kind: z11.literal("auth-provider"),
+var TenantAuthBindingSchema = z12.object({
+  kind: z12.literal("auth-provider"),
   providerId: ContractIdentifierSchema,
   policyRef: ContractIdentifierSchema.optional()
 }).strict();
-var TenantDataBindingSchema = z11.discriminatedUnion("kind", [
-  z11.object({
-    kind: z11.literal("data-provider"),
+var TenantDataBindingSchema = z12.discriminatedUnion("kind", [
+  z12.object({
+    kind: z12.literal("data-provider"),
     providerId: ContractIdentifierSchema,
     domainRef: ContractIdentifierSchema.optional()
   }).strict(),
-  z11.object({
-    kind: z11.literal("projection"),
+  z12.object({
+    kind: z12.literal("projection"),
     projectionRef: ContractIdentifierSchema,
     domainRef: ContractIdentifierSchema.optional()
   }).strict()
 ]);
-var TenantAuthBindingsSchema = z11.record(
+var TenantAuthBindingsSchema = z12.record(
   ContractIdentifierSchema,
   TenantAuthBindingSchema
 );
-var TenantDataBindingsSchema = z11.record(
+var TenantDataBindingsSchema = z12.record(
   ContractIdentifierSchema,
   TenantDataBindingSchema
 );
-var AssetVariantsSchema = z11.object({
-  light: z11.string().optional(),
-  dark: z11.string().optional()
+var AssetVariantsSchema = z12.object({
+  light: z12.string().optional(),
+  dark: z12.string().optional()
 }).strict();
-var ThemeHeadbarSchema = z11.object({
-  theme: z11.enum(["card", "glassy", "ghost"]).optional(),
-  navPosition: z11.enum(["left", "center", "right"]).optional(),
-  actions: z11.union([z11.literal("*"), z11.array(ContractIdentifierSchema)]).optional(),
-  profile: z11.union([z11.literal("*"), z11.array(ContractIdentifierSchema)]).optional(),
-  showTeamQuota: z11.boolean().optional()
+var ThemeHeadbarSchema = z12.object({
+  theme: z12.enum(["card", "glassy", "ghost"]).optional(),
+  navPosition: z12.enum(["left", "center", "right"]).optional(),
+  actions: z12.union([z12.literal("*"), z12.array(ContractIdentifierSchema)]).optional(),
+  profile: z12.union([z12.literal("*"), z12.array(ContractIdentifierSchema)]).optional(),
+  showTeamQuota: z12.boolean().optional()
 }).strict();
-var TenantHeadbarModuleLeafSchema = z11.object({
+var TenantHeadbarModuleLeafSchema = z12.object({
   id: ContractIdentifierSchema,
-  extraInfo: z11.boolean().optional(),
-  displayName: z11.union([z11.string(), z11.record(LocaleIdentifierSchema, z11.string())]).optional(),
-  visible: z11.boolean().optional(),
-  disabled: z11.boolean().optional(),
-  icon: z11.string().optional(),
-  showQuickSwitcher: z11.boolean().optional(),
-  showSidebar: z11.boolean().optional()
+  extraInfo: z12.boolean().optional(),
+  displayName: z12.union([z12.string(), z12.record(LocaleIdentifierSchema, z12.string())]).optional(),
+  visible: z12.boolean().optional(),
+  disabled: z12.boolean().optional(),
+  icon: z12.string().optional(),
+  showQuickSwitcher: z12.boolean().optional(),
+  showSidebar: z12.boolean().optional()
 }).strict();
 var TenantHeadbarModuleItemSchema = TenantHeadbarModuleLeafSchema.extend({
-  children: z11.array(TenantHeadbarModuleLeafSchema).optional()
+  children: z12.array(TenantHeadbarModuleLeafSchema).optional()
 }).strict();
-var KernelHeadbarSchema = z11.object({
-  theme: z11.literal("card").optional(),
-  layoutMode: z11.enum(["boxed", "full-bleed"]).optional(),
-  heightPx: z11.number().positive().optional(),
-  navPosition: z11.enum(["left", "center", "right"]).optional(),
-  brandTitle: z11.string().optional(),
-  menuRadius: z11.enum(["default", "none", "sm", "md", "lg", "xl", "full"]).optional()
+var KernelHeadbarSchema = z12.object({
+  theme: z12.literal("card").optional(),
+  layoutMode: z12.enum(["boxed", "full-bleed"]).optional(),
+  heightPx: z12.number().positive().optional(),
+  navPosition: z12.enum(["left", "center", "right"]).optional(),
+  brandTitle: z12.string().optional(),
+  menuRadius: z12.enum(["default", "none", "sm", "md", "lg", "xl", "full"]).optional()
 }).strict();
-var CustomIconSchema = z11.object({
-  color: z11.string().optional(),
-  url: z11.string().optional(),
-  type: z11.enum(["svg", "image"]).optional(),
-  hintTextColor: z11.string().optional()
+var CustomIconSchema = z12.object({
+  color: z12.string().optional(),
+  url: z12.string().optional(),
+  type: z12.enum(["svg", "image"]).optional(),
+  hintTextColor: z12.string().optional()
 }).strict();
-var WorkbenchCustomerToolSchema = z11.object({
+var WorkbenchCustomerToolSchema = z12.object({
   id: ContractIdentifierSchema,
-  label: z11.union([z11.string(), z11.record(LocaleIdentifierSchema, z11.string())]).optional(),
-  fixed: z11.boolean().optional()
+  label: z12.union([z12.string(), z12.record(LocaleIdentifierSchema, z12.string())]).optional(),
+  fixed: z12.boolean().optional()
 }).strict();
-var WorkbenchStudioOverrideSchema = z11.object({
-  studioName: z11.string().trim().min(1),
-  dropdownToolsDefault: z11.array(ContractIdentifierSchema).optional(),
-  existingToolsDefault: z11.array(ContractIdentifierSchema).optional(),
-  historyColumnsDefault: z11.number().int().min(1).max(6).optional()
+var WorkbenchStudioOverrideSchema = z12.object({
+  studioName: z12.string().trim().min(1),
+  dropdownToolsDefault: z12.array(ContractIdentifierSchema).optional(),
+  existingToolsDefault: z12.array(ContractIdentifierSchema).optional(),
+  historyColumnsDefault: z12.number().int().min(1).max(6).optional()
 }).strict();
-var TenantWorkbenchPageContextSchema = z11.object({
+var TenantWorkbenchPageContextSchema = z12.object({
   workflow: JsonObjectSchema.optional(),
   agent: JsonObjectSchema.optional(),
   agentId: ContractIdentifierSchema.optional(),
   designProject: JsonObjectSchema.optional(),
   designMetadataId: ContractIdentifierSchema.optional(),
-  iframeUrl: z11.string().trim().min(1).optional(),
-  info: z11.object({
+  iframeUrl: z12.string().trim().min(1).optional(),
+  info: z12.object({
     displayName: LocalizedTextSchema.optional(),
     description: LocalizedTextSchema.optional(),
-    iconUrl: z11.string().trim().min(1).optional()
+    iconUrl: z12.string().trim().min(1).optional()
   }).strict().optional(),
-  isBuiltinPinned: z11.boolean().optional(),
-  isBuiltinReadonly: z11.boolean().optional()
+  isBuiltinPinned: z12.boolean().optional(),
+  isBuiltinReadonly: z12.boolean().optional()
 }).strict();
-var TenantWorkbenchPageEnvelopeSchema = z11.object({
+var TenantWorkbenchPageEnvelopeSchema = z12.object({
   definition: PageDefinitionSchema,
   context: TenantWorkbenchPageContextSchema
 }).strict().superRefine(({ definition }, context) => {
@@ -10112,56 +10342,56 @@ var TenantWorkbenchPageEnvelopeSchema = z11.object({
     });
   }
 });
-var TenantWorkbenchPageGroupSchema = z11.object({
+var TenantWorkbenchPageGroupSchema = z12.object({
   id: ContractIdentifierSchema,
-  pageIds: z11.array(ContractIdentifierSchema),
+  pageIds: z12.array(ContractIdentifierSchema),
   displayName: LocalizedTextSchema,
-  isBuiltIn: z11.boolean(),
-  iconUrl: z11.string().optional(),
-  sortIndex: z11.number().int().nullable().optional(),
+  isBuiltIn: z12.boolean(),
+  iconUrl: z12.string().optional(),
+  sortIndex: z12.number().int().nullable().optional(),
   presetRelationId: ContractIdentifierSchema.optional(),
   relationKey: ContractIdentifierSchema.nullable().optional(),
   studioId: ContractIdentifierSchema.optional()
 }).strict();
-var TenantWorkbenchConfigSchema = z11.object({
-  pages: z11.array(TenantWorkbenchPageEnvelopeSchema),
-  pageGroups: z11.array(TenantWorkbenchPageGroupSchema),
-  catalog: z11.object({ enabled: z11.boolean().optional(), defaultEntry: z11.boolean().optional() }).strict().optional(),
-  quickSwitcherMaxItems: z11.number().int().nonnegative().optional(),
-  defaultOrder: z11.object({
-    groups: z11.array(ContractIdentifierSchema),
-    pages: z11.record(ContractIdentifierSchema, z11.array(ContractIdentifierSchema))
+var TenantWorkbenchConfigSchema = z12.object({
+  pages: z12.array(TenantWorkbenchPageEnvelopeSchema),
+  pageGroups: z12.array(TenantWorkbenchPageGroupSchema),
+  catalog: z12.object({ enabled: z12.boolean().optional(), defaultEntry: z12.boolean().optional() }).strict().optional(),
+  quickSwitcherMaxItems: z12.number().int().nonnegative().optional(),
+  defaultOrder: z12.object({
+    groups: z12.array(ContractIdentifierSchema),
+    pages: z12.record(ContractIdentifierSchema, z12.array(ContractIdentifierSchema))
   }).strict().optional(),
-  customers: z11.object({
-    dropdownToolsDefault: z11.array(ContractIdentifierSchema).optional(),
-    layoutManagerTools: z11.array(WorkbenchCustomerToolSchema).optional(),
-    studioTabsMode: z11.enum(["dropdown", "tabs"]).optional(),
-    historyWatermark: z11.object({
-      svgUrl: z11.string().optional(),
-      coverage: z11.array(z11.enum(["list", "detail", "download"])).optional(),
-      maxLongEdgeRatio: z11.number().positive().optional(),
-      sizing: z11.object({
+  customers: z12.object({
+    dropdownToolsDefault: z12.array(ContractIdentifierSchema).optional(),
+    layoutManagerTools: z12.array(WorkbenchCustomerToolSchema).optional(),
+    studioTabsMode: z12.enum(["dropdown", "tabs"]).optional(),
+    historyWatermark: z12.object({
+      svgUrl: z12.string().optional(),
+      coverage: z12.array(z12.enum(["list", "detail", "download"])).optional(),
+      maxLongEdgeRatio: z12.number().positive().optional(),
+      sizing: z12.object({
         mode: ContractIdentifierSchema,
-        heightRatio: z11.number().positive().optional(),
-        minHeightPx: z11.number().nonnegative().optional(),
-        maxHeightPx: z11.number().nonnegative().optional()
+        heightRatio: z12.number().positive().optional(),
+        minHeightPx: z12.number().nonnegative().optional(),
+        maxHeightPx: z12.number().nonnegative().optional()
       }).strict().optional(),
-      enhance: z11.object({
-        enabled: z11.boolean().optional(),
-        backgroundLumaThreshold: z11.number().min(0).max(1).optional(),
-        stroke: z11.object({
-          color: z11.string().optional(),
-          opacity: z11.number().min(0).max(1).optional(),
-          widthRatio: z11.number().nonnegative().optional(),
-          blurRatio: z11.number().nonnegative().optional(),
-          steps: z11.number().int().positive().optional()
+      enhance: z12.object({
+        enabled: z12.boolean().optional(),
+        backgroundLumaThreshold: z12.number().min(0).max(1).optional(),
+        stroke: z12.object({
+          color: z12.string().optional(),
+          opacity: z12.number().min(0).max(1).optional(),
+          widthRatio: z12.number().nonnegative().optional(),
+          blurRatio: z12.number().nonnegative().optional(),
+          steps: z12.number().int().positive().optional()
         }).strict().optional()
       }).strict().optional()
     }).strict().optional(),
-    layoutManagerEnabled: z11.boolean().optional(),
-    existingToolsDefault: z11.array(ContractIdentifierSchema).optional(),
-    historyColumnsDefault: z11.number().int().min(1).max(6).optional(),
-    studioOverrides: z11.array(WorkbenchStudioOverrideSchema).optional()
+    layoutManagerEnabled: z12.boolean().optional(),
+    existingToolsDefault: z12.array(ContractIdentifierSchema).optional(),
+    historyColumnsDefault: z12.number().int().min(1).max(6).optional(),
+    studioOverrides: z12.array(WorkbenchStudioOverrideSchema).optional()
   }).strict().optional()
 }).strict().superRefine(({ pages, pageGroups }, context) => {
   const pageIds = pages.map(({ definition }) => definition.pageId);
@@ -10185,31 +10415,31 @@ var TenantWorkbenchConfigSchema = z11.object({
     });
   });
 });
-var LoginPageSchema = z11.object({
-  background: z11.object({ imageUrl: z11.string().optional(), gradient: z11.string().optional() }).strict().optional(),
-  logo: z11.object({
-    url: z11.string().optional(),
-    lightUrl: z11.string().optional(),
-    darkUrl: z11.string().optional(),
-    position: z11.enum(["top", "middle", "bottom"]).optional(),
-    scale: z11.number().positive().optional()
+var LoginPageSchema = z12.object({
+  background: z12.object({ imageUrl: z12.string().optional(), gradient: z12.string().optional() }).strict().optional(),
+  logo: z12.object({
+    url: z12.string().optional(),
+    lightUrl: z12.string().optional(),
+    darkUrl: z12.string().optional(),
+    position: z12.enum(["top", "middle", "bottom"]).optional(),
+    scale: z12.number().positive().optional()
   }).strict().optional(),
-  customCss: z11.string().optional()
+  customCss: z12.string().optional()
 }).strict();
-var LandingPageDefaultConfigSchema = z11.object({
-  mode: z11.literal("default")
+var LandingPageDefaultConfigSchema = z12.object({
+  mode: z12.literal("default")
 }).strict();
-var LandingPageMarkdownConfigSchema = z11.object({
-  mode: z11.literal("markdown"),
-  content: z11.string()
+var LandingPageMarkdownConfigSchema = z12.object({
+  mode: z12.literal("markdown"),
+  content: z12.string()
 }).strict();
-var LandingPageHtmlConfigSchema = z11.object({
-  mode: z11.literal("html"),
-  content: z11.string()
+var LandingPageHtmlConfigSchema = z12.object({
+  mode: z12.literal("html"),
+  content: z12.string()
 }).strict();
-var LandingPageIframeConfigSchema = z11.object({
-  mode: z11.literal("iframe"),
-  url: z11.string().refine((value) => {
+var LandingPageIframeConfigSchema = z12.object({
+  mode: z12.literal("iframe"),
+  url: z12.string().refine((value) => {
     if (/^\/(?!\/)/.test(value)) {
       return !value.includes("\\");
     }
@@ -10221,420 +10451,420 @@ var LandingPageIframeConfigSchema = z11.object({
     }
   }, "Landing page iframe URL must use a root-relative path or HTTP(S) without embedded credentials.")
 }).strict();
-var TenantLandingPageConfigSchema = z11.discriminatedUnion("mode", [
+var TenantLandingPageConfigSchema = z12.discriminatedUnion("mode", [
   LandingPageDefaultConfigSchema,
   LandingPageMarkdownConfigSchema,
   LandingPageHtmlConfigSchema,
   LandingPageIframeConfigSchema
 ]);
-var TenantApplicationConfigSchema = z11.object({
-  theme: z11.object({
-    id: z11.string().optional(),
-    name: z11.string().optional(),
-    title: z11.string().optional(),
+var TenantApplicationConfigSchema = z12.object({
+  theme: z12.object({
+    id: z12.string().optional(),
+    name: z12.string().optional(),
+    title: z12.string().optional(),
     favicon: AssetVariantsSchema.optional(),
     logo: AssetVariantsSchema.optional(),
-    pwaIcon: z11.string().optional(),
-    form: z11.object({ variant: z11.enum(["bento", "ghost"]) }).strict().optional(),
-    toast: z11.object({
-      position: z11.enum(["top-right", "top-left", "bottom-right", "bottom-left", "top-center", "bottom-center"])
+    pwaIcon: z12.string().optional(),
+    form: z12.object({ variant: z12.enum(["bento", "ghost"]) }).strict().optional(),
+    toast: z12.object({
+      position: z12.enum(["top-right", "top-left", "bottom-right", "bottom-left", "top-center", "bottom-center"])
     }).strict().optional(),
-    icons: z11.object({ error: CustomIconSchema.optional(), empty: CustomIconSchema.optional() }).strict().optional(),
-    views: z11.object({
-      form: z11.object({
-        toast: z11.object({ afterCreate: z11.boolean(), afterDelete: z11.boolean() }).strict(),
-        progress: z11.enum(["estimate", "infinite"]),
-        onlyResult: z11.boolean(),
-        tabular: z11.object({ theme: z11.enum(["default", "tentiary", "primary"]) }).strict()
+    icons: z12.object({ error: CustomIconSchema.optional(), empty: CustomIconSchema.optional() }).strict().optional(),
+    views: z12.object({
+      form: z12.object({
+        toast: z12.object({ afterCreate: z12.boolean(), afterDelete: z12.boolean() }).strict(),
+        progress: z12.enum(["estimate", "infinite"]),
+        onlyResult: z12.boolean(),
+        tabular: z12.object({ theme: z12.enum(["default", "tentiary", "primary"]) }).strict()
       }).strict()
     }).strict().optional(),
     loginPage: LoginPageSchema.optional(),
-    extraLanguageURL: z11.record(z11.string(), z11.string()).optional(),
-    hideSpaceHeader: z11.boolean().optional(),
-    showSidebarTeamSelector: z11.boolean().optional(),
-    showWorkbenchSidebar: z11.boolean().optional(),
-    workbenchViewTheme: z11.enum(["default", "bsd-blue"]).optional(),
-    defaults: z11.object({
-      showFormInImageDetail: z11.boolean().optional(),
-      darkMode: z11.enum(["light", "dark", "auto"]).optional(),
-      language: z11.enum(["en-US", "zh-CN", "ja-JP"]).optional(),
-      showDarkModeToggle: z11.boolean().optional(),
-      showLanguageToggle: z11.boolean().optional()
+    extraLanguageURL: z12.record(z12.string(), z12.string()).optional(),
+    hideSpaceHeader: z12.boolean().optional(),
+    showSidebarTeamSelector: z12.boolean().optional(),
+    showWorkbenchSidebar: z12.boolean().optional(),
+    workbenchViewTheme: z12.enum(["default", "bsd-blue"]).optional(),
+    defaults: z12.object({
+      showFormInImageDetail: z12.boolean().optional(),
+      darkMode: z12.enum(["light", "dark", "auto"]).optional(),
+      language: z12.enum(["en-US", "zh-CN", "ja-JP"]).optional(),
+      showDarkModeToggle: z12.boolean().optional(),
+      showLanguageToggle: z12.boolean().optional()
     }).strict().optional(),
-    modules: z11.object({
-      monkeysSpaceSidebar: z11.union([z11.literal("*"), z11.array(ContractIdentifierSchema)]).optional(),
-      monkeysSpaceHeadbar: z11.union([
-        z11.literal("*"),
-        z11.array(TenantHeadbarModuleItemSchema)
+    modules: z12.object({
+      monkeysSpaceSidebar: z12.union([z12.literal("*"), z12.array(ContractIdentifierSchema)]).optional(),
+      monkeysSpaceHeadbar: z12.union([
+        z12.literal("*"),
+        z12.array(TenantHeadbarModuleItemSchema)
       ]).optional(),
-      settingsSidebar: z11.union([z11.literal("*"), z11.array(ContractIdentifierSchema)]).optional()
+      settingsSidebar: z12.union([z12.literal("*"), z12.array(ContractIdentifierSchema)]).optional()
     }).strict().optional(),
     headbar: ThemeHeadbarSchema.optional(),
-    kernelLayout: z11.object({
-      navigationMode: z11.enum(["sidebar", "topbar"]).optional(),
-      allowNavigationModeSwitch: z11.boolean().optional(),
+    kernelLayout: z12.object({
+      navigationMode: z12.enum(["sidebar", "topbar"]).optional(),
+      allowNavigationModeSwitch: z12.boolean().optional(),
       headbar: KernelHeadbarSchema.optional()
     }).strict().optional(),
-    paginationPosition: z11.enum(["left", "right"]).optional(),
-    ugcViewIconOnlyMode: z11.boolean().optional(),
-    workflowPreviewExecutionGrid: z11.object({
-      selectionModeDisplayType: z11.enum(["operation-button", "dropdown-menu"]).optional(),
-      clickBehavior: z11.enum(["preview", "select", "fill-form", "none"]).optional(),
-      showErrorFilter: z11.boolean().optional(),
-      displayType: z11.enum(["grid", "masonry"]).optional(),
-      showDetailButton: z11.boolean().optional()
+    paginationPosition: z12.enum(["left", "right"]).optional(),
+    ugcViewIconOnlyMode: z12.boolean().optional(),
+    workflowPreviewExecutionGrid: z12.object({
+      selectionModeDisplayType: z12.enum(["operation-button", "dropdown-menu"]).optional(),
+      clickBehavior: z12.enum(["preview", "select", "fill-form", "none"]).optional(),
+      showErrorFilter: z12.boolean().optional(),
+      displayType: z12.enum(["grid", "masonry"]).optional(),
+      showDetailButton: z12.boolean().optional()
     }).strict().optional(),
-    workbenchSidebarDefaultOpen: z11.boolean().optional(),
-    workbenchSidebarMoreAction: z11.boolean().optional(),
-    workbenchSidebarApart: z11.boolean().optional(),
-    workbenchSidebarToggleGroupDetail: z11.boolean().optional(),
-    workbenchSidebarViewType: z11.boolean().optional(),
-    workbenchSidebarFormViewEmbed: z11.boolean().optional(),
-    workbenchSidebarModernMode: z11.boolean().optional(),
-    ugc: z11.object({ onItemClick: z11.boolean(), subtitle: z11.boolean().optional() }).strict().optional(),
-    uniImagePreview: z11.boolean().optional(),
-    imagePreviewStyle: z11.union([z11.literal(false), z11.enum(["simple", "normal", "uni"])]).optional(),
-    teamAsUser: z11.boolean().optional(),
-    themeMode: z11.enum(["shadow", "border"]).optional(),
-    density: z11.enum(["compact", "default", "comfortable"]).optional(),
-    pageZoom: z11.number().positive().optional(),
-    miniMode: z11.object({ showPreviewViewExecutionResultGrid: z11.boolean() }).strict().optional(),
-    workflow: z11.object({ allowConcurrentRuns: z11.boolean() }).strict().optional(),
-    historyResult: z11.object({ display: z11.boolean() }).strict().optional(),
-    uploader: z11.object({
-      orientation: z11.enum(["vertical", "horizontal"]),
-      pasteButton: z11.boolean(),
-      statusText: z11.boolean()
+    workbenchSidebarDefaultOpen: z12.boolean().optional(),
+    workbenchSidebarMoreAction: z12.boolean().optional(),
+    workbenchSidebarApart: z12.boolean().optional(),
+    workbenchSidebarToggleGroupDetail: z12.boolean().optional(),
+    workbenchSidebarViewType: z12.boolean().optional(),
+    workbenchSidebarFormViewEmbed: z12.boolean().optional(),
+    workbenchSidebarModernMode: z12.boolean().optional(),
+    ugc: z12.object({ onItemClick: z12.boolean(), subtitle: z12.boolean().optional() }).strict().optional(),
+    uniImagePreview: z12.boolean().optional(),
+    imagePreviewStyle: z12.union([z12.literal(false), z12.enum(["simple", "normal", "uni"])]).optional(),
+    teamAsUser: z12.boolean().optional(),
+    themeMode: z12.enum(["shadow", "border"]).optional(),
+    density: z12.enum(["compact", "default", "comfortable"]).optional(),
+    pageZoom: z12.number().positive().optional(),
+    miniMode: z12.object({ showPreviewViewExecutionResultGrid: z12.boolean() }).strict().optional(),
+    workflow: z12.object({ allowConcurrentRuns: z12.boolean() }).strict().optional(),
+    historyResult: z12.object({ display: z12.boolean() }).strict().optional(),
+    uploader: z12.object({
+      orientation: z12.enum(["vertical", "horizontal"]),
+      pasteButton: z12.boolean(),
+      statusText: z12.boolean()
     }).strict().optional(),
-    designProjects: z11.object({
-      oneOnOne: z11.boolean(),
-      newTabOpenBoard: z11.boolean(),
-      defaultShowGrid: z11.boolean().optional(),
-      createDefaultFrame: z11.boolean(),
-      showPageMenu: z11.boolean(),
-      showMainMenu: z11.boolean(),
-      showStylePanel: z11.boolean(),
-      showToolbar: z11.boolean(),
-      toolbarPosition: z11.enum(["bottom", "left"]).optional(),
-      showContextMenu: z11.boolean(),
-      showActionsMenu: z11.boolean(),
-      showPageAndLayerSidebar: z11.boolean().optional(),
-      showBoardOperationSidebar: z11.boolean().optional(),
-      showMiniToolsToolbar: z11.boolean().optional(),
-      showRightSidebar: z11.boolean().optional(),
-      showRealtimeDrawing: z11.boolean().optional(),
-      showWorkflow: z11.boolean().optional(),
-      showVersionManager: z11.boolean().optional(),
-      showAgent: z11.boolean().optional(),
-      AgentTools: z11.array(ContractIdentifierSchema).optional()
+    designProjects: z12.object({
+      oneOnOne: z12.boolean(),
+      newTabOpenBoard: z12.boolean(),
+      defaultShowGrid: z12.boolean().optional(),
+      createDefaultFrame: z12.boolean(),
+      showPageMenu: z12.boolean(),
+      showMainMenu: z12.boolean(),
+      showStylePanel: z12.boolean(),
+      showToolbar: z12.boolean(),
+      toolbarPosition: z12.enum(["bottom", "left"]).optional(),
+      showContextMenu: z12.boolean(),
+      showActionsMenu: z12.boolean(),
+      showPageAndLayerSidebar: z12.boolean().optional(),
+      showBoardOperationSidebar: z12.boolean().optional(),
+      showMiniToolsToolbar: z12.boolean().optional(),
+      showRightSidebar: z12.boolean().optional(),
+      showRealtimeDrawing: z12.boolean().optional(),
+      showWorkflow: z12.boolean().optional(),
+      showVersionManager: z12.boolean().optional(),
+      showAgent: z12.boolean().optional(),
+      AgentTools: z12.array(ContractIdentifierSchema).optional()
     }).strict().optional(),
     workbench: TenantWorkbenchConfigSchema.optional(),
-    visionProWorkflows: z11.array(ContractIdentifierSchema).optional(),
-    initTeam: z11.boolean().optional(),
-    imageThumbnail: z11.boolean().optional(),
-    pages: z11.object({
-      allowPageKeys: z11.union([z11.literal("*"), z11.array(ContractIdentifierSchema)]),
+    visionProWorkflows: z12.array(ContractIdentifierSchema).optional(),
+    initTeam: z12.boolean().optional(),
+    imageThumbnail: z12.boolean().optional(),
+    pages: z12.object({
+      allowPageKeys: z12.union([z12.literal("*"), z12.array(ContractIdentifierSchema)]),
       defaultPageKey: ContractIdentifierSchema.optional()
     }).strict().optional(),
-    agent: z11.object({
+    agent: z12.object({
       logo: AssetVariantsSchema.optional(),
-      brandDisplayMode: z11.enum(["auto", "logo-only", "logo-name", "name-only"]).optional(),
-      density: z11.enum(["compact", "default", "comfortable"]).optional()
+      brandDisplayMode: z12.enum(["auto", "logo-only", "logo-name", "name-only"]).optional(),
+      density: z12.enum(["compact", "default", "comfortable"]).optional()
     }).strict().optional()
   }).strict(),
   landingPage: TenantLandingPageConfigSchema.optional(),
-  auth: z11.object({
-    enabled: z11.array(ContractIdentifierSchema).default([]),
-    oidc: z11.object({ buttonText: z11.string().optional(), autoSignin: z11.boolean().optional() }).strict().optional(),
-    password: z11.object({ disableAutoRegister: z11.boolean().optional() }).strict().optional(),
-    hideAuthToast: z11.boolean().optional(),
-    autoReload: z11.boolean().optional(),
-    defaultOtherTeam: z11.boolean().optional()
+  auth: z12.object({
+    enabled: z12.array(ContractIdentifierSchema).default([]),
+    oidc: z12.object({ buttonText: z12.string().optional(), autoSignin: z12.boolean().optional() }).strict().optional(),
+    password: z12.object({ disableAutoRegister: z12.boolean().optional() }).strict().optional(),
+    hideAuthToast: z12.boolean().optional(),
+    autoReload: z12.boolean().optional(),
+    defaultOtherTeam: z12.boolean().optional()
   }).strict(),
-  endpoints: z11.record(ContractIdentifierSchema, z11.string()),
-  module: z11.union([z11.literal("*"), z11.array(ContractIdentifierSchema)]),
-  behavior: z11.object({
-    clearWorkflowFormStorageAfterUpdate: z11.boolean().optional(),
-    autoApproveOAuth: z11.boolean().optional(),
-    rememberWorkflowModelSelection: z11.boolean().optional()
+  endpoints: z12.record(ContractIdentifierSchema, z12.string()),
+  module: z12.union([z12.literal("*"), z12.array(ContractIdentifierSchema)]),
+  behavior: z12.object({
+    clearWorkflowFormStorageAfterUpdate: z12.boolean().optional(),
+    autoApproveOAuth: z12.boolean().optional(),
+    rememberWorkflowModelSelection: z12.boolean().optional()
   }).strict(),
-  dataManagement: z11.object({
-    favoriteBucketId: z11.string().optional(),
-    pairedBucketId: z11.string().optional(),
-    galleryBucketId: z11.string().optional(),
-    dataBrowserDefaultBucketId: z11.string().optional(),
-    workflowResultBucketId: z11.string().optional(),
-    homeAdvertisement: z11.object({
+  dataManagement: z12.object({
+    favoriteBucketId: z12.string().optional(),
+    pairedBucketId: z12.string().optional(),
+    galleryBucketId: z12.string().optional(),
+    dataBrowserDefaultBucketId: z12.string().optional(),
+    workflowResultBucketId: z12.string().optional(),
+    homeAdvertisement: z12.object({
       bucketId: ContractIdentifierSchema,
       viewId: ContractIdentifierSchema.optional(),
-      viewType: z11.enum(["filter", "container", "share_link"]).optional(),
+      viewType: z12.enum(["filter", "container", "share_link"]).optional(),
       teamId: ContractIdentifierSchema.optional(),
-      teamOnly: z11.boolean().optional(),
-      pageSize: z11.number().int().positive().optional(),
-      sortBy: z11.enum(["pin_order", "asset_id", "updated_timestamp", "created_timestamp"]).optional(),
-      sortOrder: z11.enum(["asc", "desc"]).optional(),
-      fieldMap: z11.record(z11.string(), z11.string()).optional(),
-      columnIds: z11.record(z11.string(), z11.string()).optional()
+      teamOnly: z12.boolean().optional(),
+      pageSize: z12.number().int().positive().optional(),
+      sortBy: z12.enum(["pin_order", "asset_id", "updated_timestamp", "created_timestamp"]).optional(),
+      sortOrder: z12.enum(["asc", "desc"]).optional(),
+      fieldMap: z12.record(z12.string(), z12.string()).optional(),
+      columnIds: z12.record(z12.string(), z12.string()).optional()
     }).strict().optional(),
-    homeTrendAssistant: z11.object({
+    homeTrendAssistant: z12.object({
       bucketId: ContractIdentifierSchema.optional(),
       viewId: ContractIdentifierSchema.optional(),
       viewInstanceId: ContractIdentifierSchema.optional(),
-      viewName: z11.string().optional(),
+      viewName: z12.string().optional(),
       teamId: ContractIdentifierSchema.optional(),
       designOptionsWorkflowId: ContractIdentifierSchema.optional(),
-      tep: z11.object({ baseUrl: z11.string().optional(), timeoutMs: z11.number().int().positive().optional() }).strict().optional(),
-      runtime: z11.object({ appId: ContractIdentifierSchema, tepBaseUrlConfigured: z11.boolean(), tepAuthorizationConfigured: z11.boolean(), tepCookieConfigured: z11.boolean() }).strict().optional()
+      tep: z12.object({ baseUrl: z12.string().optional(), timeoutMs: z12.number().int().positive().optional() }).strict().optional(),
+      runtime: z12.object({ appId: ContractIdentifierSchema, tepBaseUrlConfigured: z12.boolean(), tepAuthorizationConfigured: z12.boolean(), tepCookieConfigured: z12.boolean() }).strict().optional()
     }).strict().optional(),
-    sharing: z11.object({
-      silentViewLinks: z11.object({ enabled: z11.boolean().optional(), placement: z11.object({ mode: z11.enum(["sourceBucket", "bucket"]).optional(), bucketId: ContractIdentifierSchema.optional(), parentId: ContractIdentifierSchema.optional(), navId: ContractIdentifierSchema.optional() }).strict().optional() }).strict().optional(),
-      shareAccess: z11.object({ publicLinksEnabled: z11.boolean().optional(), passwordGateEnabled: z11.boolean().optional(), passwordAccessTtlSeconds: z11.number().int().positive().optional(), defaultViewTreeDelivery: z11.enum(["manual", "auto"]).optional() }).strict().optional(),
-      shareDialog: z11.object({
-        audience: z11.object({ enabled: z11.boolean().optional(), allowed: z11.array(z11.enum(["user", "team", "public"])).optional(), default: z11.enum(["user", "team", "public"]).optional() }).strict().optional(),
-        accessLevel: z11.object({ enabled: z11.boolean().optional(), allowed: z11.array(z11.enum(["read", "write"])).optional(), default: z11.enum(["read", "write"]).optional() }).strict().optional(),
-        viewTreeDelivery: z11.object({ enabled: z11.boolean().optional(), allowed: z11.array(z11.enum(["manual", "auto"])).optional(), default: z11.enum(["manual", "auto"]).optional() }).strict().optional()
+    sharing: z12.object({
+      silentViewLinks: z12.object({ enabled: z12.boolean().optional(), placement: z12.object({ mode: z12.enum(["sourceBucket", "bucket"]).optional(), bucketId: ContractIdentifierSchema.optional(), parentId: ContractIdentifierSchema.optional(), navId: ContractIdentifierSchema.optional() }).strict().optional() }).strict().optional(),
+      shareAccess: z12.object({ publicLinksEnabled: z12.boolean().optional(), passwordGateEnabled: z12.boolean().optional(), passwordAccessTtlSeconds: z12.number().int().positive().optional(), defaultViewTreeDelivery: z12.enum(["manual", "auto"]).optional() }).strict().optional(),
+      shareDialog: z12.object({
+        audience: z12.object({ enabled: z12.boolean().optional(), allowed: z12.array(z12.enum(["user", "team", "public"])).optional(), default: z12.enum(["user", "team", "public"]).optional() }).strict().optional(),
+        accessLevel: z12.object({ enabled: z12.boolean().optional(), allowed: z12.array(z12.enum(["read", "write"])).optional(), default: z12.enum(["read", "write"]).optional() }).strict().optional(),
+        viewTreeDelivery: z12.object({ enabled: z12.boolean().optional(), allowed: z12.array(z12.enum(["manual", "auto"])).optional(), default: z12.enum(["manual", "auto"]).optional() }).strict().optional()
       }).strict().optional()
     }).strict().optional()
   }).strict().optional(),
-  compute: z11.object({
-    integrations: z11.object({
-      harbor: z11.object({ endpoint: z11.string().optional(), projectScopes: z11.array(z11.string()).optional(), authMode: z11.string().optional(), principal: z11.string().optional(), autoSync: z11.boolean().optional(), proxyUrl: z11.string().optional() }).strict().optional(),
-      gitlab: z11.object({ baseUrl: z11.string().optional(), groupScopes: z11.array(z11.string()).optional(), tokenMode: z11.string().optional(), deployProjectPath: z11.string().optional(), deploymentReportsEnabled: z11.boolean().optional(), proxyUrl: z11.string().optional() }).strict().optional(),
-      kubernetes: z11.object({ accessMode: z11.string().optional(), clusterAlias: z11.string().optional(), agentProjectPath: z11.string().optional(), agentName: z11.string().optional(), namespaceScopes: z11.array(z11.string()).optional(), rolloutObserverEnabled: z11.boolean().optional(), proxyUrl: z11.string().optional() }).strict().optional()
+  compute: z12.object({
+    integrations: z12.object({
+      harbor: z12.object({ endpoint: z12.string().optional(), projectScopes: z12.array(z12.string()).optional(), authMode: z12.string().optional(), principal: z12.string().optional(), autoSync: z12.boolean().optional(), proxyUrl: z12.string().optional() }).strict().optional(),
+      gitlab: z12.object({ baseUrl: z12.string().optional(), groupScopes: z12.array(z12.string()).optional(), tokenMode: z12.string().optional(), deployProjectPath: z12.string().optional(), deploymentReportsEnabled: z12.boolean().optional(), proxyUrl: z12.string().optional() }).strict().optional(),
+      kubernetes: z12.object({ accessMode: z12.string().optional(), clusterAlias: z12.string().optional(), agentProjectPath: z12.string().optional(), agentName: z12.string().optional(), namespaceScopes: z12.array(z12.string()).optional(), rolloutObserverEnabled: z12.boolean().optional(), proxyUrl: z12.string().optional() }).strict().optional()
     }).strict().optional()
   }).strict().optional(),
-  data: z11.object({}).strict().optional(),
-  storage: z11.object({
-    presignMode: z11.enum(["frontend", "backend", "both"]).optional(),
-    presign: z11.object({
-      expiresInSeconds: z11.number().int().positive(),
-      buckets: z11.array(
-        z11.object({
+  data: z12.object({}).strict().optional(),
+  storage: z12.object({
+    presignMode: z12.enum(["frontend", "backend", "both"]).optional(),
+    presign: z12.object({
+      expiresInSeconds: z12.number().int().positive(),
+      buckets: z12.array(
+        z12.object({
           id: ContractIdentifierSchema,
           provider: ContractIdentifierSchema,
           preferredUrlPatternId: ContractIdentifierSchema,
-          urlPatterns: z11.array(
-            z11.object({
+          urlPatterns: z12.array(
+            z12.object({
               id: ContractIdentifierSchema,
-              type: z11.enum(["bucket-hostname", "provider-hostname"]),
-              hostname: z11.string().trim().min(1),
-              preferred: z11.boolean().optional(),
-              bucketSegment: z11.string().optional()
+              type: z12.enum(["bucket-hostname", "provider-hostname"]),
+              hostname: z12.string().trim().min(1),
+              preferred: z12.boolean().optional(),
+              bucketSegment: z12.string().optional()
             }).strict()
           )
         }).strict()
       )
     }).strict().optional()
   }).strict().optional(),
-  monkeyData: z11.object({ baseUrl: z11.string().optional() }).strict().optional()
+  monkeyData: z12.object({ baseUrl: z12.string().optional() }).strict().optional()
 }).strict();
-var TenantProductConfigSchema = z11.object({
-  contract: z11.literal("TenantProductConfig"),
+var TenantProductConfigSchema = z12.object({
+  contract: z12.literal("TenantProductConfig"),
   tenantId: ContractIdentifierSchema,
   appId: ContractIdentifierSchema,
   environment: ContractIdentifierSchema,
   designTokens: TenantDesignTokensConfigSchema,
-  moduleRefs: z11.array(ContractIdentifierSchema).default([]),
-  pageRefs: z11.array(ContractIdentifierSchema).default([]),
-  featureFlags: z11.record(z11.string(), z11.boolean()).default({}),
+  moduleRefs: z12.array(ContractIdentifierSchema).default([]),
+  pageRefs: z12.array(ContractIdentifierSchema).default([]),
+  featureFlags: z12.record(z12.string(), z12.boolean()).default({}),
   authBinding: TenantAuthBindingsSchema,
   dataBinding: TenantDataBindingsSchema,
-  sourceMap: z11.record(z11.string(), ContractIdentifierSchema),
-  warnings: z11.array(z11.string()).default([]),
+  sourceMap: z12.record(z12.string(), ContractIdentifierSchema),
+  warnings: z12.array(z12.string()).default([]),
   applicationConfig: TenantApplicationConfigSchema
 }).strict();
-var TenantRuntimeConfigSchema = z11.object({
-  contract: z11.literal("TenantRuntimeConfig"),
+var TenantRuntimeConfigSchema = z12.object({
+  contract: z12.literal("TenantRuntimeConfig"),
   tenantId: ContractIdentifierSchema,
   appId: ContractIdentifierSchema,
   environment: ContractIdentifierSchema,
   designTokens: ResolvedThemeTokensSchema,
-  moduleRefs: z11.array(ContractIdentifierSchema).default([]),
-  pageRefs: z11.array(ContractIdentifierSchema).default([]),
-  featureFlags: z11.record(z11.string(), z11.boolean()).default({}),
+  moduleRefs: z12.array(ContractIdentifierSchema).default([]),
+  pageRefs: z12.array(ContractIdentifierSchema).default([]),
+  featureFlags: z12.record(z12.string(), z12.boolean()).default({}),
   authBinding: TenantAuthBindingsSchema,
   dataBinding: TenantDataBindingsSchema,
-  sourceMap: z11.record(z11.string(), ContractIdentifierSchema),
-  warnings: z11.array(z11.string()).default([]),
+  sourceMap: z12.record(z12.string(), ContractIdentifierSchema),
+  warnings: z12.array(z12.string()).default([]),
   applicationConfig: TenantApplicationConfigSchema
 }).strict();
 
 // src/contracts/trend.ts
-import { z as z12 } from "zod";
-var RadarDecisionMetricsSchema = z12.object({
-  currentSales: z12.number().finite(),
-  forecastSales: z12.number().finite(),
-  searchHeat: z12.number().finite(),
-  socialHeat: z12.number().finite(),
-  confidence: z12.number().min(0).max(1)
+import { z as z13 } from "zod";
+var RadarDecisionMetricsSchema = z13.object({
+  currentSales: z13.number().finite(),
+  forecastSales: z13.number().finite(),
+  searchHeat: z13.number().finite(),
+  socialHeat: z13.number().finite(),
+  confidence: z13.number().min(0).max(1)
 }).strict();
-var TrendSourceSchema = z12.object({
+var TrendSourceSchema = z13.object({
   sourceId: ContractIdentifierSchema,
   provider: ContractIdentifierSchema,
-  channel: z12.enum(["trend", "ecommerce", "social", "search", "internal"]),
+  channel: z13.enum(["trend", "ecommerce", "social", "search", "internal"]),
   collectedAt: IsoDateTimeSchema,
-  sourceUrl: z12.string().url().optional(),
-  evidenceRefs: z12.array(EntityRefSchema).default([])
+  sourceUrl: z13.string().url().optional(),
+  evidenceRefs: z13.array(EntityRefSchema).default([])
 }).strict();
-var TrendIngestRunSchema = z12.object({
-  contract: z12.literal("TrendIngestRun"),
+var TrendIngestRunSchema = z13.object({
+  contract: z13.literal("TrendIngestRun"),
   ingestRunId: ContractIdentifierSchema,
   sourceId: ContractIdentifierSchema,
   requestId: ContractIdentifierSchema,
   idempotencyKey: ContractIdentifierSchema,
-  status: z12.enum(["RUNNING", "SUCCEEDED", "FAILED", "PARTIAL"]),
-  recordCount: z12.number().int().nonnegative(),
-  errorCount: z12.number().int().nonnegative(),
+  status: z13.enum(["RUNNING", "SUCCEEDED", "FAILED", "PARTIAL"]),
+  recordCount: z13.number().int().nonnegative(),
+  errorCount: z13.number().int().nonnegative(),
   startedAt: IsoDateTimeSchema,
   completedAt: IsoDateTimeSchema.optional()
 }).strict();
-var TrendSourceRecordSchema = z12.object({
-  contract: z12.literal("TrendSourceRecord"),
+var TrendSourceRecordSchema = z13.object({
+  contract: z13.literal("TrendSourceRecord"),
   sourceRecordId: ContractIdentifierSchema,
   source: TrendSourceSchema,
   ingestRunRef: EntityRefSchema,
-  recordVersion: z12.number().int().positive(),
+  recordVersion: z13.number().int().positive(),
   contentHash: Sha256Schema,
   payload: JsonValueSchema,
   idempotencyKey: ContractIdentifierSchema,
   collectedAt: IsoDateTimeSchema
 }).strict();
-var HotwordBodySchema = z12.object({
-  contract: z12.literal("HotwordBody"),
+var HotwordBodySchema = z13.object({
+  contract: z13.literal("HotwordBody"),
   hotwordId: ContractIdentifierSchema,
-  label: z12.string().trim().min(1),
-  normalizedLabel: z12.string().trim().min(1),
-  categories: z12.array(ContractIdentifierSchema).default([]),
-  sourceRefs: z12.array(TrendSourceSchema).min(1),
-  relationRefs: z12.array(EntityRefSchema).default([]),
+  label: z13.string().trim().min(1),
+  normalizedLabel: z13.string().trim().min(1),
+  categories: z13.array(ContractIdentifierSchema).default([]),
+  sourceRefs: z13.array(TrendSourceSchema).min(1),
+  relationRefs: z13.array(EntityRefSchema).default([]),
   createdAt: IsoDateTimeSchema,
   updatedAt: IsoDateTimeSchema
 }).strict();
 var CommerceBodyFieldsSchema = {
-  displayName: z12.string().trim().min(1),
-  normalizedName: z12.string().trim().min(1),
-  categories: z12.array(ContractIdentifierSchema).default([]),
-  sourceRefs: z12.array(EntityRefSchema).min(1),
-  relationRefs: z12.array(EntityRefSchema).default([]),
+  displayName: z13.string().trim().min(1),
+  normalizedName: z13.string().trim().min(1),
+  categories: z13.array(ContractIdentifierSchema).default([]),
+  sourceRefs: z13.array(EntityRefSchema).min(1),
+  relationRefs: z13.array(EntityRefSchema).default([]),
   createdAt: IsoDateTimeSchema,
   updatedAt: IsoDateTimeSchema
 };
-var BrandBodySchema = z12.object({
-  contract: z12.literal("BrandBody"),
+var BrandBodySchema = z13.object({
+  contract: z13.literal("BrandBody"),
   brandId: ContractIdentifierSchema,
   ...CommerceBodyFieldsSchema
 }).strict();
-var ProductBodySchema = z12.object({
-  contract: z12.literal("ProductBody"),
+var ProductBodySchema = z13.object({
+  contract: z13.literal("ProductBody"),
   productId: ContractIdentifierSchema,
   brandRef: EntityRefSchema.optional(),
   ...CommerceBodyFieldsSchema
 }).strict();
-var TrendMetricSnapshotSchema = z12.object({
-  contract: z12.literal("TrendMetricSnapshot"),
+var TrendMetricSnapshotSchema = z13.object({
+  contract: z13.literal("TrendMetricSnapshot"),
   snapshotId: ContractIdentifierSchema,
   subjectRef: EntityRefSchema,
   observedAt: IsoDateTimeSchema,
-  metrics: z12.record(z12.string(), z12.number().finite()),
-  confidence: z12.number().min(0).max(1),
-  evidenceRefs: z12.array(EntityRefSchema).min(1)
+  metrics: z13.record(z13.string(), z13.number().finite()),
+  confidence: z13.number().min(0).max(1),
+  evidenceRefs: z13.array(EntityRefSchema).min(1)
 }).strict();
-var RadarScoreModelBodySchema = z12.object({
-  contract: z12.literal("RadarScoreModelBody"),
+var RadarScoreModelBodySchema = z13.object({
+  contract: z13.literal("RadarScoreModelBody"),
   modelId: ContractIdentifierSchema,
-  version: z12.number().int().positive(),
+  version: z13.number().int().positive(),
   weights: RadarDecisionMetricsSchema,
-  thresholds: z12.record(z12.string(), z12.number().finite()).default({}),
-  explanationRules: z12.record(z12.string(), z12.string().trim().min(1)).default({}),
+  thresholds: z13.record(z13.string(), z13.number().finite()).default({}),
+  explanationRules: z13.record(z13.string(), z13.string().trim().min(1)).default({}),
   createdAt: IsoDateTimeSchema
 }).strict();
-var RadarScoreProjectionSchema = z12.object({
-  contract: z12.literal("RadarScoreProjection"),
+var RadarScoreProjectionSchema = z13.object({
+  contract: z13.literal("RadarScoreProjection"),
   projectionId: ContractIdentifierSchema,
   subjectRef: EntityRefSchema,
   modelRef: EntityRefSchema,
-  totalScore: z12.number().finite(),
+  totalScore: z13.number().finite(),
   dimensions: RadarDecisionMetricsSchema,
-  evidenceRefs: z12.array(EntityRefSchema).min(1),
+  evidenceRefs: z13.array(EntityRefSchema).min(1),
   freshnessAt: IsoDateTimeSchema
 }).strict();
-var RadarPanoramaNodeSchema = z12.object({
+var RadarPanoramaNodeSchema = z13.object({
   ref: EntityRefSchema,
-  label: z12.string().trim().min(1),
-  categories: z12.array(ContractIdentifierSchema).default([]),
-  score: z12.number().finite().optional(),
+  label: z13.string().trim().min(1),
+  categories: z13.array(ContractIdentifierSchema).default([]),
+  score: z13.number().finite().optional(),
   freshnessAt: IsoDateTimeSchema.optional()
 }).strict();
-var RadarPanoramaEdgeSchema = z12.object({
+var RadarPanoramaEdgeSchema = z13.object({
   sourceRef: EntityRefSchema,
   targetRef: EntityRefSchema,
   relation: ContractIdentifierSchema,
-  evidenceRefs: z12.array(EntityRefSchema).default([])
+  evidenceRefs: z13.array(EntityRefSchema).default([])
 }).strict();
-var RadarPanoramaSchema = z12.object({
-  contract: z12.literal("RadarPanorama"),
-  nodes: z12.array(RadarPanoramaNodeSchema),
-  edges: z12.array(RadarPanoramaEdgeSchema),
+var RadarPanoramaSchema = z13.object({
+  contract: z13.literal("RadarPanorama"),
+  nodes: z13.array(RadarPanoramaNodeSchema),
+  edges: z13.array(RadarPanoramaEdgeSchema),
   generatedAt: IsoDateTimeSchema
 }).strict();
-var BrandGeneticsProfileSchema = z12.object({
-  contract: z12.literal("BrandGeneticsProfile"),
+var BrandGeneticsProfileSchema = z13.object({
+  contract: z13.literal("BrandGeneticsProfile"),
   brandRef: EntityRefSchema,
-  categories: z12.array(ContractIdentifierSchema).default([]),
-  signature: z12.record(ContractIdentifierSchema, z12.number().finite()),
-  relatedRefs: z12.array(EntityRefSchema).default([]),
-  evidenceRefs: z12.array(EntityRefSchema).default([]),
+  categories: z13.array(ContractIdentifierSchema).default([]),
+  signature: z13.record(ContractIdentifierSchema, z13.number().finite()),
+  relatedRefs: z13.array(EntityRefSchema).default([]),
+  evidenceRefs: z13.array(EntityRefSchema).default([]),
   computedAt: IsoDateTimeSchema
 }).strict();
-var RadarOpportunityMatrixPointSchema = z12.object({
+var RadarOpportunityMatrixPointSchema = z13.object({
   subjectRef: EntityRefSchema,
-  label: z12.string().trim().min(1),
-  x: z12.number().finite(),
-  y: z12.number().finite(),
-  score: z12.number().finite(),
-  evidenceRefs: z12.array(EntityRefSchema).default([])
+  label: z13.string().trim().min(1),
+  x: z13.number().finite(),
+  y: z13.number().finite(),
+  score: z13.number().finite(),
+  evidenceRefs: z13.array(EntityRefSchema).default([])
 }).strict();
-var RadarOpportunityMatrixSchema = z12.object({
-  contract: z12.literal("RadarOpportunityMatrix"),
-  xMetric: z12.enum(["currentSales", "forecastSales", "searchHeat", "socialHeat", "confidence"]),
-  yMetric: z12.enum(["currentSales", "forecastSales", "searchHeat", "socialHeat", "confidence"]),
-  points: z12.array(RadarOpportunityMatrixPointSchema),
+var RadarOpportunityMatrixSchema = z13.object({
+  contract: z13.literal("RadarOpportunityMatrix"),
+  xMetric: z13.enum(["currentSales", "forecastSales", "searchHeat", "socialHeat", "confidence"]),
+  yMetric: z13.enum(["currentSales", "forecastSales", "searchHeat", "socialHeat", "confidence"]),
+  points: z13.array(RadarOpportunityMatrixPointSchema),
   computedAt: IsoDateTimeSchema
 }).strict();
-var RadarQueryBodySchema = z12.object({
-  contract: z12.literal("RadarQueryBody"),
+var RadarQueryBodySchema = z13.object({
+  contract: z13.literal("RadarQueryBody"),
   queryId: ContractIdentifierSchema,
-  filters: z12.record(z12.string(), JsonValueSchema).default({}),
-  sort: z12.object({
+  filters: z13.record(z13.string(), JsonValueSchema).default({}),
+  sort: z13.object({
     field: ContractIdentifierSchema,
-    direction: z12.enum(["asc", "desc"])
+    direction: z13.enum(["asc", "desc"])
   }).strict(),
-  pageSize: z12.number().int().min(1).max(200),
+  pageSize: z13.number().int().min(1).max(200),
   updatedAt: IsoDateTimeSchema
 }).strict();
-var SavedRadarQuerySchema = z12.object({
-  contract: z12.literal("SavedRadarQuery"),
+var SavedRadarQuerySchema = z13.object({
+  contract: z13.literal("SavedRadarQuery"),
   savedQueryId: ContractIdentifierSchema,
   teamId: ContractIdentifierSchema,
   ownerRef: EntityRefSchema,
-  name: z12.string().trim().min(1),
+  name: z13.string().trim().min(1),
   queryRef: EntityRefSchema,
-  expectedVersion: z12.number().int().nonnegative(),
+  expectedVersion: z13.number().int().nonnegative(),
   updatedAt: IsoDateTimeSchema
 }).strict();
-var RadarSelectionSchema = z12.object({
-  contract: z12.literal("RadarSelection"),
+var RadarSelectionSchema = z13.object({
+  contract: z13.literal("RadarSelection"),
   selectionId: ContractIdentifierSchema,
   teamId: ContractIdentifierSchema,
   ownerRef: EntityRefSchema,
-  subjectRefs: z12.array(EntityRefSchema),
-  status: z12.enum(["stashed", "selected", "rejected", "archived"]),
-  note: z12.string().optional(),
-  expectedVersion: z12.number().int().nonnegative(),
+  subjectRefs: z13.array(EntityRefSchema),
+  status: z13.enum(["stashed", "selected", "rejected", "archived"]),
+  note: z13.string().optional(),
+  expectedVersion: z13.number().int().nonnegative(),
   updatedAt: IsoDateTimeSchema
 }).strict();
-var RadarAnalysisRunSchema = z12.object({
-  contract: z12.literal("RadarAnalysisRun"),
+var RadarAnalysisRunSchema = z13.object({
+  contract: z13.literal("RadarAnalysisRun"),
   runId: ContractIdentifierSchema,
   teamId: ContractIdentifierSchema,
   selectionRef: EntityRefSchema,
@@ -10643,66 +10873,66 @@ var RadarAnalysisRunSchema = z12.object({
   designProjectRef: EntityRefSchema.optional(),
   replayedFromRef: EntityRefSchema.optional(),
   workflowDefinitionTeamId: ContractIdentifierSchema.optional(),
-  workflowInput: z12.record(z12.string(), JsonValueSchema).default({}),
-  createDesignProject: z12.boolean().default(true),
-  designProjectName: z12.string().trim().min(1).max(200).optional(),
+  workflowInput: z13.record(z13.string(), JsonValueSchema).default({}),
+  createDesignProject: z13.boolean().default(true),
+  designProjectName: z13.string().trim().min(1).max(200).optional(),
   modelRef: EntityRefSchema,
   requestId: ContractIdentifierSchema,
   idempotencyKey: ContractIdentifierSchema,
-  status: z12.enum(["QUEUED", "RUNNING", "SUCCEEDED", "FAILED", "CANCELLED", "PARTIAL"]),
-  outputRefs: z12.array(EntityRefSchema).default([]),
-  error: z12.object({
+  status: z13.enum(["QUEUED", "RUNNING", "SUCCEEDED", "FAILED", "CANCELLED", "PARTIAL"]),
+  outputRefs: z13.array(EntityRefSchema).default([]),
+  error: z13.object({
     code: ContractIdentifierSchema,
-    message: z12.string().trim().min(1),
-    retryable: z12.boolean()
+    message: z13.string().trim().min(1),
+    retryable: z13.boolean()
   }).strict().optional(),
   startedAt: IsoDateTimeSchema.optional(),
   completedAt: IsoDateTimeSchema.optional(),
   createdAt: IsoDateTimeSchema
 }).strict();
-var RadarAnalysisAssetSchema = z12.object({
+var RadarAnalysisAssetSchema = z13.object({
   artifactRef: EntityRefSchema,
   kind: ContractIdentifierSchema,
-  mimeType: z12.string().trim().min(1).optional(),
-  url: z12.string().url(),
-  metadata: z12.record(z12.string(), JsonValueSchema).default({}),
+  mimeType: z13.string().trim().min(1).optional(),
+  url: z13.string().url(),
+  metadata: z13.record(z13.string(), JsonValueSchema).default({}),
   createdAt: IsoDateTimeSchema
 }).strict();
-var RadarAnalysisDetailSchema = z12.object({
-  contract: z12.literal("RadarAnalysisDetail"),
+var RadarAnalysisDetailSchema = z13.object({
+  contract: z13.literal("RadarAnalysisDetail"),
   run: RadarAnalysisRunSchema,
-  runVersion: z12.number().int().positive(),
+  runVersion: z13.number().int().positive(),
   selection: RadarSelectionSchema,
-  outputs: z12.array(OutputRecordSchema),
-  assets: z12.array(RadarAnalysisAssetSchema),
-  lineage: z12.array(LineageRecordSchema)
+  outputs: z13.array(OutputRecordSchema),
+  assets: z13.array(RadarAnalysisAssetSchema),
+  lineage: z13.array(LineageRecordSchema)
 }).strict();
-var RadarActionRecordSchema = z12.object({
-  contract: z12.literal("RadarActionRecord"),
+var RadarActionRecordSchema = z13.object({
+  contract: z13.literal("RadarActionRecord"),
   actionId: ContractIdentifierSchema,
   teamId: ContractIdentifierSchema,
   actorRef: EntityRefSchema,
-  action: z12.enum(["stash", "select", "reject", "archive", "launch", "retry", "replay", "rollback"]),
+  action: z13.enum(["stash", "select", "reject", "archive", "launch", "retry", "replay", "rollback"]),
   targetRef: EntityRefSchema,
   requestId: ContractIdentifierSchema,
   idempotencyKey: ContractIdentifierSchema,
-  expectedVersion: z12.number().int().nonnegative(),
+  expectedVersion: z13.number().int().nonnegative(),
   occurredAt: IsoDateTimeSchema
 }).strict();
-var RadarWritebackRecordSchema = z12.object({
-  contract: z12.literal("RadarWritebackRecord"),
+var RadarWritebackRecordSchema = z13.object({
+  contract: z13.literal("RadarWritebackRecord"),
   writebackId: ContractIdentifierSchema,
   actionRef: EntityRefSchema,
   targetRef: EntityRefSchema,
-  status: z12.enum(["PENDING", "APPLIED", "FAILED"]),
-  resultingVersion: z12.number().int().nonnegative().optional(),
-  error: z12.string().trim().min(1).optional(),
+  status: z13.enum(["PENDING", "APPLIED", "FAILED"]),
+  resultingVersion: z13.number().int().nonnegative().optional(),
+  error: z13.string().trim().min(1).optional(),
   recordedAt: IsoDateTimeSchema
 }).strict();
 
 // src/contracts/workflow-definition.ts
-import { z as z13 } from "zod";
-var ConductorTaskTypeSchema = z13.enum([
+import { z as z14 } from "zod";
+var ConductorTaskTypeSchema = z14.enum([
   "SIMPLE",
   "DYNAMIC",
   "FORK_JOIN",
@@ -10751,46 +10981,46 @@ var requiredTaskFields = {
   WAIT: ["inputParameters"],
   TERMINATE: ["inputParameters"]
 };
-var ConductorTaskDefinitionSchema = z13.lazy(
-  () => z13.object({
+var ConductorTaskDefinitionSchema = z14.lazy(
+  () => z14.object({
     name: ContractIdentifierSchema,
     taskReferenceName: ContractIdentifierSchema,
     type: ConductorTaskTypeSchema,
-    inputParameters: z13.record(z13.string(), JsonValueSchema).optional(),
-    startDelay: z13.number().int().nonnegative().optional(),
-    optional: z13.boolean().optional(),
-    asyncComplete: z13.boolean().optional(),
-    rateLimited: z13.boolean().optional(),
-    retryCount: z13.number().int().nonnegative().optional(),
-    taskDefinition: z13.record(z13.string(), JsonValueSchema).optional(),
-    loopCondition: z13.string().optional(),
-    loopOver: z13.array(ConductorTaskDefinitionSchema).optional(),
-    sink: z13.string().optional(),
-    forkTasks: z13.array(z13.array(ConductorTaskDefinitionSchema)).optional(),
-    joinOn: z13.array(ContractIdentifierSchema).optional(),
-    defaultExclusiveJoinTask: z13.array(ContractIdentifierSchema).optional(),
-    dynamicForkTasksParam: z13.string().optional(),
-    dynamicForkTasksInputParamName: z13.string().optional(),
-    subWorkflowParam: z13.object({
-      $ref: z13.string().optional(),
+    inputParameters: z14.record(z14.string(), JsonValueSchema).optional(),
+    startDelay: z14.number().int().nonnegative().optional(),
+    optional: z14.boolean().optional(),
+    asyncComplete: z14.boolean().optional(),
+    rateLimited: z14.boolean().optional(),
+    retryCount: z14.number().int().nonnegative().optional(),
+    taskDefinition: z14.record(z14.string(), JsonValueSchema).optional(),
+    loopCondition: z14.string().optional(),
+    loopOver: z14.array(ConductorTaskDefinitionSchema).optional(),
+    sink: z14.string().optional(),
+    forkTasks: z14.array(z14.array(ConductorTaskDefinitionSchema)).optional(),
+    joinOn: z14.array(ContractIdentifierSchema).optional(),
+    defaultExclusiveJoinTask: z14.array(ContractIdentifierSchema).optional(),
+    dynamicForkTasksParam: z14.string().optional(),
+    dynamicForkTasksInputParamName: z14.string().optional(),
+    subWorkflowParam: z14.object({
+      $ref: z14.string().optional(),
       name: ContractIdentifierSchema,
-      version: z13.number().int().positive().optional(),
-      taskToDomain: z13.record(z13.string(), z13.string()).optional(),
-      workflowDefinition: z13.record(z13.string(), JsonValueSchema).optional()
+      version: z14.number().int().positive().optional(),
+      taskToDomain: z14.record(z14.string(), z14.string()).optional(),
+      workflowDefinition: z14.record(z14.string(), JsonValueSchema).optional()
     }).strict().optional(),
-    decisionCases: z13.record(z13.string(), z13.array(ConductorTaskDefinitionSchema)).optional(),
-    defaultCase: z13.array(ConductorTaskDefinitionSchema).optional(),
-    evaluatorType: z13.enum(["value-param", "javascript", "graaljs"]).optional(),
-    expression: z13.string().optional(),
+    decisionCases: z14.record(z14.string(), z14.array(ConductorTaskDefinitionSchema)).optional(),
+    defaultCase: z14.array(ConductorTaskDefinitionSchema).optional(),
+    evaluatorType: z14.enum(["value-param", "javascript", "graaljs"]).optional(),
+    expression: z14.string().optional(),
     __alias: JsonValueSchema.optional(),
-    callbackFromWorker: z13.boolean().optional(),
+    callbackFromWorker: z14.boolean().optional(),
     caseExpression: JsonValueSchema.optional(),
-    caseValueParam: z13.string().optional(),
-    dependencies: z13.array(JsonValueSchema).optional(),
-    description: z13.string().optional(),
-    dynamicTaskNameParam: z13.string().optional(),
-    joinMode: z13.string().optional(),
-    permissive: z13.boolean().optional(),
+    caseValueParam: z14.string().optional(),
+    dependencies: z14.array(JsonValueSchema).optional(),
+    description: z14.string().optional(),
+    dynamicTaskNameParam: z14.string().optional(),
+    joinMode: z14.string().optional(),
+    permissive: z14.boolean().optional(),
     joinTaskRef: ContractIdentifierSchema.optional(),
     forkTaskRef: ContractIdentifierSchema.optional()
   }).strict().superRefine((task, context) => {
@@ -10804,29 +11034,29 @@ var ConductorTaskDefinitionSchema = z13.lazy(
     }
   })
 );
-var ConductorWorkflowDefinitionSchema = z13.object({
-  ownerApp: z13.string().optional(),
-  createTime: z13.number().int().nonnegative().optional(),
-  updateTime: z13.number().int().nonnegative().optional(),
-  createdBy: z13.string().optional(),
-  updatedBy: z13.string().optional(),
+var ConductorWorkflowDefinitionSchema = z14.object({
+  ownerApp: z14.string().optional(),
+  createTime: z14.number().int().nonnegative().optional(),
+  updateTime: z14.number().int().nonnegative().optional(),
+  createdBy: z14.string().optional(),
+  updatedBy: z14.string().optional(),
   name: ContractIdentifierSchema,
-  description: z13.string().optional(),
-  version: z13.number().int().positive(),
-  tasks: z13.array(ConductorTaskDefinitionSchema),
-  inputParameters: z13.array(ContractIdentifierSchema),
-  outputParameters: z13.record(z13.string(), JsonValueSchema).optional(),
+  description: z14.string().optional(),
+  version: z14.number().int().positive(),
+  tasks: z14.array(ConductorTaskDefinitionSchema),
+  inputParameters: z14.array(ContractIdentifierSchema),
+  outputParameters: z14.record(z14.string(), JsonValueSchema).optional(),
   failureWorkflow: ContractIdentifierSchema.optional(),
-  schemaVersion: z13.number().int().positive().optional(),
-  restartable: z13.boolean().optional(),
-  workflowStatusListenerEnabled: z13.boolean().optional(),
-  ownerEmail: z13.string().email().optional(),
-  timeoutPolicy: z13.enum(["TIME_OUT_WF", "ALERT_ONLY"]).optional(),
-  timeoutSeconds: z13.number().int().nonnegative(),
-  variables: z13.record(z13.string(), JsonValueSchema).optional(),
-  inputTemplate: z13.record(z13.string(), JsonValueSchema).optional()
+  schemaVersion: z14.number().int().positive().optional(),
+  restartable: z14.boolean().optional(),
+  workflowStatusListenerEnabled: z14.boolean().optional(),
+  ownerEmail: z14.string().email().optional(),
+  timeoutPolicy: z14.enum(["TIME_OUT_WF", "ALERT_ONLY"]).optional(),
+  timeoutSeconds: z14.number().int().nonnegative(),
+  variables: z14.record(z14.string(), JsonValueSchema).optional(),
+  inputTemplate: z14.record(z14.string(), JsonValueSchema).optional()
 }).strict();
-var WorkflowParameterTypeSchema = z13.enum([
+var WorkflowParameterTypeSchema = z14.enum([
   "string",
   "file",
   "number",
@@ -10836,213 +11066,213 @@ var WorkflowParameterTypeSchema = z13.enum([
   "notice",
   "canvas-assist"
 ]);
-var WorkflowConditionalStateSchema = z13.object({
-  conditions: z13.array(
-    z13.object({
-      field: z13.string(),
-      operator: z13.enum(["is", "isNot", "isGreaterThan", "isLessThan", "isGreaterThanOrEqual", "isLessThanOrEqual", "in", "notIn"]),
+var WorkflowConditionalStateSchema = z14.object({
+  conditions: z14.array(
+    z14.object({
+      field: z14.string(),
+      operator: z14.enum(["is", "isNot", "isGreaterThan", "isLessThan", "isGreaterThanOrEqual", "isLessThanOrEqual", "in", "notIn"]),
       value: JsonValueSchema
     }).strict()
   ),
-  logic: z13.enum(["AND", "OR"]).optional()
+  logic: z14.enum(["AND", "OR"]).optional()
 }).strict();
-var ImageSelectMappingAppearanceSchema = z13.object({
-  columns: z13.number().int().min(1).max(4).optional(),
-  cardSize: z13.enum(["sm", "md", "lg"]).optional(),
-  imageAspectRatio: z13.enum(["square", "4:5", "3:4", "16:9"]).optional(),
-  gap: z13.enum(["sm", "md", "lg"]).optional(),
-  radius: z13.enum(["sm", "md", "lg", "xl"]).optional(),
-  borderStyle: z13.enum(["none", "soft", "strong"]).optional(),
-  borderWidth: z13.union([z13.literal(0), z13.literal(1), z13.literal(2)]).optional(),
-  enableScroll: z13.boolean().optional(),
-  maxHeight: z13.number().int().min(160).max(1200).optional(),
-  enableCollapse: z13.boolean().optional(),
-  visibleRows: z13.number().int().min(1).max(6).optional(),
-  hideLabel: z13.boolean().optional(),
-  hideDescription: z13.boolean().optional(),
-  hideValue: z13.boolean().optional()
+var ImageSelectMappingAppearanceSchema = z14.object({
+  columns: z14.number().int().min(1).max(4).optional(),
+  cardSize: z14.enum(["sm", "md", "lg"]).optional(),
+  imageAspectRatio: z14.enum(["square", "4:5", "3:4", "16:9"]).optional(),
+  gap: z14.enum(["sm", "md", "lg"]).optional(),
+  radius: z14.enum(["sm", "md", "lg", "xl"]).optional(),
+  borderStyle: z14.enum(["none", "soft", "strong"]).optional(),
+  borderWidth: z14.union([z14.literal(0), z14.literal(1), z14.literal(2)]).optional(),
+  enableScroll: z14.boolean().optional(),
+  maxHeight: z14.number().int().min(160).max(1200).optional(),
+  enableCollapse: z14.boolean().optional(),
+  visibleRows: z14.number().int().min(1).max(6).optional(),
+  hideLabel: z14.boolean().optional(),
+  hideDescription: z14.boolean().optional(),
+  hideValue: z14.boolean().optional()
 }).strict();
-var ComfyWorkflowPortBindingSchema = z13.object({
-  node: z13.union([z13.string(), z13.number()]),
-  key: z13.string().optional()
+var ComfyWorkflowPortBindingSchema = z14.object({
+  node: z14.union([z14.string(), z14.number()]),
+  key: z14.string().optional()
 }).strict();
-var WorkflowParameterTypeOptionsSchema = z13.object({
-  editor: z13.enum(["code", "codeNodeEditor", "htmlEditor", "sqlEditor", "json"]).optional(),
-  editorLanguage: z13.enum(["javaScript", "json", "python", "sql"]).optional(),
-  maxValue: z13.number().optional(),
-  minValue: z13.number().optional(),
-  max: z13.number().optional(),
-  min: z13.number().optional(),
-  multipleValues: z13.boolean().optional(),
-  numberPrecision: z13.number().nonnegative().optional(),
-  password: z13.boolean().optional(),
-  rows: z13.number().int().positive().optional(),
-  assetType: z13.string().optional(),
-  accept: z13.string().optional(),
-  maxSize: z13.number().positive().optional(),
-  fileType: z13.string().optional(),
-  aiMultiShotMainImageField: z13.string().optional(),
-  aiMultiShotWorkflowAppId: z13.string().optional(),
-  aiMultiShotWorkflowId: z13.string().optional(),
-  allowCustomInput: z13.boolean().optional(),
-  allowUploadVideo: z13.boolean().optional(),
-  aspectRatioField: z13.string().optional(),
-  assemblyValueType: z13.string().optional(),
-  autoAnalyzeDesignImage: z13.boolean().optional(),
-  autoDetectAspectRatio: z13.boolean().optional(),
-  autoIncrementId: z13.boolean().optional(),
+var WorkflowParameterTypeOptionsSchema = z14.object({
+  editor: z14.enum(["code", "codeNodeEditor", "htmlEditor", "sqlEditor", "json"]).optional(),
+  editorLanguage: z14.enum(["javaScript", "json", "python", "sql"]).optional(),
+  maxValue: z14.number().optional(),
+  minValue: z14.number().optional(),
+  max: z14.number().optional(),
+  min: z14.number().optional(),
+  multipleValues: z14.boolean().optional(),
+  numberPrecision: z14.number().nonnegative().optional(),
+  password: z14.boolean().optional(),
+  rows: z14.number().int().positive().optional(),
+  assetType: z14.string().optional(),
+  accept: z14.string().optional(),
+  maxSize: z14.number().positive().optional(),
+  fileType: z14.string().optional(),
+  aiMultiShotMainImageField: z14.string().optional(),
+  aiMultiShotWorkflowAppId: z14.string().optional(),
+  aiMultiShotWorkflowId: z14.string().optional(),
+  allowCustomInput: z14.boolean().optional(),
+  allowUploadVideo: z14.boolean().optional(),
+  aspectRatioField: z14.string().optional(),
+  assemblyValueType: z14.string().optional(),
+  autoAnalyzeDesignImage: z14.boolean().optional(),
+  autoDetectAspectRatio: z14.boolean().optional(),
+  autoIncrementId: z14.boolean().optional(),
   comfyOptions: ComfyWorkflowPortBindingSchema.optional(),
-  comfyuiModelServerId: z13.string().optional(),
-  comfyuiModelTypeName: z13.string().optional(),
+  comfyuiModelServerId: z14.string().optional(),
+  comfyuiModelTypeName: z14.string().optional(),
   defaultCustomInput: JsonValueSchema.optional(),
-  descriptionAlert: z13.boolean().optional(),
-  disabled: z13.union([z13.boolean(), WorkflowConditionalStateSchema]).optional(),
-  editable: z13.union([z13.boolean(), WorkflowConditionalStateSchema]).optional(),
-  enableAiMultiShot: z13.boolean().optional(),
-  enableBooleanSwitchMode: z13.boolean().optional(),
-  enableClear: z13.boolean().optional(),
-  enableExpand: z13.boolean().optional(),
-  enableImageMask: z13.boolean().optional(),
-  enableImageOverlay: z13.boolean().optional(),
-  enablePopupEditor: z13.boolean().optional(),
-  enablePromptFontSize: z13.boolean().optional(),
-  enableReset: z13.boolean().optional(),
-  enableSelectItemIcon: z13.boolean().optional(),
-  enableSelectList: z13.boolean().optional(),
-  enableSelectSearch: z13.boolean().optional(),
-  enableSliderEnterMode: z13.boolean().optional(),
-  enableVoice: z13.boolean().optional(),
-  expandButtonText: z13.string().optional(),
-  foldUp: z13.boolean().optional(),
-  hidden: z13.boolean().optional(),
-  hideRequiredDot: z13.boolean().optional(),
-  inlineTitleWithSelect: z13.boolean().optional(),
-  knowledgeGraphButtonText: z13.string().optional(),
-  identifyAttributeCount: z13.union([z13.number().nonnegative(), z13.string().min(1), z13.object({ min: z13.number().nonnegative().optional(), max: z13.number().nonnegative().optional() }).strict()]).optional(),
-  identifyAttributes: z13.array(JsonValueSchema).optional(),
-  identifyMaxVariants: z13.number().int().nonnegative().optional(),
-  identifySourceField: z13.string().optional(),
-  imageOverlayBaseField: z13.string().optional(),
-  imageOverlayOverlayField: z13.string().optional(),
+  descriptionAlert: z14.boolean().optional(),
+  disabled: z14.union([z14.boolean(), WorkflowConditionalStateSchema]).optional(),
+  editable: z14.union([z14.boolean(), WorkflowConditionalStateSchema]).optional(),
+  enableAiMultiShot: z14.boolean().optional(),
+  enableBooleanSwitchMode: z14.boolean().optional(),
+  enableClear: z14.boolean().optional(),
+  enableExpand: z14.boolean().optional(),
+  enableImageMask: z14.boolean().optional(),
+  enableImageOverlay: z14.boolean().optional(),
+  enablePopupEditor: z14.boolean().optional(),
+  enablePromptFontSize: z14.boolean().optional(),
+  enableReset: z14.boolean().optional(),
+  enableSelectItemIcon: z14.boolean().optional(),
+  enableSelectList: z14.boolean().optional(),
+  enableSelectSearch: z14.boolean().optional(),
+  enableSliderEnterMode: z14.boolean().optional(),
+  enableVoice: z14.boolean().optional(),
+  expandButtonText: z14.string().optional(),
+  foldUp: z14.boolean().optional(),
+  hidden: z14.boolean().optional(),
+  hideRequiredDot: z14.boolean().optional(),
+  inlineTitleWithSelect: z14.boolean().optional(),
+  knowledgeGraphButtonText: z14.string().optional(),
+  identifyAttributeCount: z14.union([z14.number().nonnegative(), z14.string().min(1), z14.object({ min: z14.number().nonnegative().optional(), max: z14.number().nonnegative().optional() }).strict()]).optional(),
+  identifyAttributes: z14.array(JsonValueSchema).optional(),
+  identifyMaxVariants: z14.number().int().nonnegative().optional(),
+  identifySourceField: z14.string().optional(),
+  imageOverlayBaseField: z14.string().optional(),
+  imageOverlayOverlayField: z14.string().optional(),
   imageSelectMappingAppearance: ImageSelectMappingAppearanceSchema.optional(),
-  imageSelectMappingColumns: z13.number().int().min(1).max(4).optional(),
-  imageSelectMappingEnableCustomUpload: z13.boolean().optional(),
-  imageSelectMappingHideLabel: z13.boolean().optional(),
-  imageSelectMappingHideLink: z13.boolean().optional(),
-  imageSelectMappingHideMeta: z13.boolean().optional(),
-  imageSelectMappingInlineUseLargeUploadBox: z13.boolean().optional(),
-  imageSelectMappingPromptField: z13.string().optional(),
-  imageSelectMappingTabOrder: z13.enum(["template-first", "upload-first"]).optional(),
-  imageSelectMappingTabWidthMode: z13.enum(["content", "fill"]).optional(),
+  imageSelectMappingColumns: z14.number().int().min(1).max(4).optional(),
+  imageSelectMappingEnableCustomUpload: z14.boolean().optional(),
+  imageSelectMappingHideLabel: z14.boolean().optional(),
+  imageSelectMappingHideLink: z14.boolean().optional(),
+  imageSelectMappingHideMeta: z14.boolean().optional(),
+  imageSelectMappingInlineUseLargeUploadBox: z14.boolean().optional(),
+  imageSelectMappingPromptField: z14.string().optional(),
+  imageSelectMappingTabOrder: z14.enum(["template-first", "upload-first"]).optional(),
+  imageSelectMappingTabWidthMode: z14.enum(["content", "fill"]).optional(),
   imageSelectMappingTemplatePrompt: LocalizedTextSchema.optional(),
   imageSelectMappingTemplateTabTitle: LocalizedTextSchema.optional(),
-  imageSelectMappingUploadMode: z13.enum(["tabs", "inline"]).optional(),
+  imageSelectMappingUploadMode: z14.enum(["tabs", "inline"]).optional(),
   imageSelectMappingUploadPrompt: LocalizedTextSchema.optional(),
   imageSelectMappingUploadTabTitle: LocalizedTextSchema.optional(),
-  endpoints: z13.array(JsonValueSchema).optional(),
-  examples: z13.array(JsonValueSchema).optional(),
+  endpoints: z14.array(JsonValueSchema).optional(),
+  examples: z14.array(JsonValueSchema).optional(),
   extraData: JsonValueSchema.optional(),
   layer: JsonValueSchema.optional(),
   map: JsonValueSchema.optional(),
-  multiline: z13.boolean().optional(),
-  options: z13.array(JsonValueSchema).optional(),
-  originalFiles: z13.array(JsonValueSchema).optional(),
+  multiline: z14.boolean().optional(),
+  options: z14.array(JsonValueSchema).optional(),
+  originalFiles: z14.array(JsonValueSchema).optional(),
   placeholder: LocalizedTextSchema.optional(),
-  preserveSelectListOrder: z13.boolean().optional(),
+  preserveSelectListOrder: z14.boolean().optional(),
   promptDictionary: JsonValueSchema.optional(),
-  promptFontSize: z13.number().optional(),
+  promptFontSize: z14.number().optional(),
   promptModeToggle: JsonValueSchema.optional(),
-  requireActiveSelectFilter: z13.boolean().optional(),
-  restoreDefaultOnEmptyEnter: z13.boolean().optional(),
-  search: z13.boolean().optional(),
-  selectButtonEnableCollapse: z13.boolean().optional(),
-  selectButtonVisibleRows: z13.number().int().positive().optional(),
-  selectList: z13.array(JsonValueSchema).optional(),
-  selectListDisplayMode: z13.string().optional(),
-  selectPromptField: z13.string().optional(),
-  showAddLocalFileButton: z13.boolean().optional(),
-  singleColumn: z13.boolean().optional(),
-  singleFrameForMultiple: z13.boolean().optional(),
-  textSingleLine: z13.boolean().optional(),
-  textareaMiniHeight: z13.number().nonnegative().optional(),
+  requireActiveSelectFilter: z14.boolean().optional(),
+  restoreDefaultOnEmptyEnter: z14.boolean().optional(),
+  search: z14.boolean().optional(),
+  selectButtonEnableCollapse: z14.boolean().optional(),
+  selectButtonVisibleRows: z14.number().int().positive().optional(),
+  selectList: z14.array(JsonValueSchema).optional(),
+  selectListDisplayMode: z14.string().optional(),
+  selectPromptField: z14.string().optional(),
+  showAddLocalFileButton: z14.boolean().optional(),
+  singleColumn: z14.boolean().optional(),
+  singleFrameForMultiple: z14.boolean().optional(),
+  textSingleLine: z14.boolean().optional(),
+  textareaMiniHeight: z14.number().nonnegative().optional(),
   tips: LocalizedTextSchema.optional(),
   visibility: JsonValueSchema.optional(),
-  voiceButtonText: z13.string().optional(),
-  designAnalysisFields: z13.array(JsonValueSchema).optional(),
-  designAnalysisFillStrategy: z13.string().optional(),
-  designAnalysisMaxFields: z13.number().int().nonnegative().optional(),
-  designAnalysisType: z13.string().optional(),
-  designAnalysisFieldPrefix: z13.string().optional()
+  voiceButtonText: z14.string().optional(),
+  designAnalysisFields: z14.array(JsonValueSchema).optional(),
+  designAnalysisFillStrategy: z14.string().optional(),
+  designAnalysisMaxFields: z14.number().int().nonnegative().optional(),
+  designAnalysisType: z14.string().optional(),
+  designAnalysisFieldPrefix: z14.string().optional()
 }).strict();
-var WorkflowParameterSchema = z13.lazy(
-  () => z13.object({
+var WorkflowParameterSchema = z14.lazy(
+  () => z14.object({
     displayName: LocalizedTextSchema,
     name: ContractIdentifierSchema,
     type: WorkflowParameterTypeSchema,
     typeOptions: WorkflowParameterTypeOptionsSchema.optional(),
     default: JsonValueSchema.optional(),
     description: LocalizedTextSchema.optional(),
-    hint: z13.string().optional(),
-    displayOptions: z13.object({
-      hide: z13.record(z13.string(), z13.array(JsonValueSchema)).optional(),
-      show: z13.record(z13.string(), z13.array(JsonValueSchema)).optional()
+    hint: z14.string().optional(),
+    displayOptions: z14.object({
+      hide: z14.record(z14.string(), z14.array(JsonValueSchema)).optional(),
+      show: z14.record(z14.string(), z14.array(JsonValueSchema)).optional()
     }).strict().optional(),
-    options: z13.array(z13.union([
-      z13.object({ name: LocalizedTextSchema, value: z13.union([z13.string(), z13.number(), z13.boolean()]), action: z13.string().optional(), description: LocalizedTextSchema.optional() }).strict(),
+    options: z14.array(z14.union([
+      z14.object({ name: LocalizedTextSchema, value: z14.union([z14.string(), z14.number(), z14.boolean()]), action: z14.string().optional(), description: LocalizedTextSchema.optional() }).strict(),
       WorkflowParameterSchema,
-      z13.object({ displayName: z13.string(), name: ContractIdentifierSchema, values: z13.array(WorkflowParameterSchema) }).strict()
+      z14.object({ displayName: z14.string(), name: ContractIdentifierSchema, values: z14.array(WorkflowParameterSchema) }).strict()
     ])).optional(),
     placeholder: LocalizedTextSchema.optional(),
-    isNodeSetting: z13.boolean().optional(),
-    noDataExpression: z13.boolean().optional(),
-    required: z13.boolean().optional(),
-    example: z13.string().optional(),
-    extractValue: z13.object({ type: z13.literal("regex"), regex: z13.string() }).strict().optional(),
-    properties: z13.array(WorkflowParameterSchema).optional(),
-    assetType: z13.string().optional(),
-    flag: z13.boolean().optional(),
-    enableExpand: z13.boolean().optional(),
-    enableVoice: z13.boolean().optional(),
-    expandButtonText: z13.string().optional(),
-    knowledgeGraphButtonText: z13.string().optional(),
-    selectListDisplayMode: z13.string().optional(),
-    voiceButtonText: z13.string().optional()
+    isNodeSetting: z14.boolean().optional(),
+    noDataExpression: z14.boolean().optional(),
+    required: z14.boolean().optional(),
+    example: z14.string().optional(),
+    extractValue: z14.object({ type: z14.literal("regex"), regex: z14.string() }).strict().optional(),
+    properties: z14.array(WorkflowParameterSchema).optional(),
+    assetType: z14.string().optional(),
+    flag: z14.boolean().optional(),
+    enableExpand: z14.boolean().optional(),
+    enableVoice: z14.boolean().optional(),
+    expandButtonText: z14.string().optional(),
+    knowledgeGraphButtonText: z14.string().optional(),
+    selectListDisplayMode: z14.string().optional(),
+    voiceButtonText: z14.string().optional()
   }).strict()
 );
-var WorkflowOutputBindingSchema = z13.object({ key: ContractIdentifierSchema, value: z13.string() }).strict();
-var WorkflowNodeSchema = z13.object({
+var WorkflowOutputBindingSchema = z14.object({ key: ContractIdentifierSchema, value: z14.string() }).strict();
+var WorkflowNodeSchema = z14.object({
   id: ContractIdentifierSchema,
   referenceName: ContractIdentifierSchema,
   capabilityRef: ContractIdentifierSchema,
   capabilityVersion: ContractIdentifierSchema.optional(),
-  inputBindings: z13.record(z13.string(), JsonValueSchema).default({}),
-  configuration: z13.object({ executor: z13.literal("conductor"), task: ConductorTaskDefinitionSchema }).strict()
+  inputBindings: z14.record(z14.string(), JsonValueSchema).default({}),
+  configuration: z14.object({ executor: z14.literal("conductor"), task: ConductorTaskDefinitionSchema }).strict()
 }).strict().superRefine((node, context) => {
   if (node.configuration.task.taskReferenceName !== node.referenceName) context.addIssue({ code: "custom", path: ["configuration", "task", "taskReferenceName"], message: "Conductor task reference must match node referenceName." });
   if (node.configuration.task.name !== node.capabilityRef) context.addIssue({ code: "custom", path: ["configuration", "task", "name"], message: "Conductor task name must match node capabilityRef." });
   if (JSON.stringify(node.configuration.task.inputParameters ?? {}) !== JSON.stringify(node.inputBindings)) context.addIssue({ code: "custom", path: ["configuration", "task", "inputParameters"], message: "Conductor task inputs must match node inputBindings." });
 });
-var WorkflowEdgeSchema = z13.object({
+var WorkflowEdgeSchema = z14.object({
   from: ContractIdentifierSchema,
   to: ContractIdentifierSchema,
   outputPort: ContractIdentifierSchema.optional(),
   inputPort: ContractIdentifierSchema.optional(),
-  condition: z13.string().optional()
+  condition: z14.string().optional()
 }).strict();
-var WorkflowTriggerSchema = z13.object({
+var WorkflowTriggerSchema = z14.object({
   id: ContractIdentifierSchema,
-  type: z13.enum(["manual", "schedule", "webhook", "event", "api"]),
-  enabled: z13.boolean(),
-  schedule: z13.object({ cron: z13.string().trim().min(1) }).strict().optional(),
-  webhook: z13.object({
-    path: z13.string().trim().min(1).optional(),
-    method: z13.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"]),
-    auth: z13.enum(["NONE", "BASIC", "CUSTOM_HEADER"]),
-    basicAuth: z13.object({ username: z13.string(), password: z13.string() }).strict().optional(),
-    headerAuth: z13.object({ name: z13.string().trim().min(1), value: z13.string() }).strict().optional(),
-    responseUntil: z13.enum(["WORKFLOW_STARTED", "WORKFLOW_COMPLETED_OR_FINISHED"])
+  type: z14.enum(["manual", "schedule", "webhook", "event", "api"]),
+  enabled: z14.boolean(),
+  schedule: z14.object({ cron: z14.string().trim().min(1) }).strict().optional(),
+  webhook: z14.object({
+    path: z14.string().trim().min(1).optional(),
+    method: z14.enum(["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"]),
+    auth: z14.enum(["NONE", "BASIC", "CUSTOM_HEADER"]),
+    basicAuth: z14.object({ username: z14.string(), password: z14.string() }).strict().optional(),
+    headerAuth: z14.object({ name: z14.string().trim().min(1), value: z14.string() }).strict().optional(),
+    responseUntil: z14.enum(["WORKFLOW_STARTED", "WORKFLOW_COMPLETED_OR_FINISHED"])
   }).strict().optional(),
-  event: z13.object({
+  event: z14.object({
     eventType: ContractIdentifierSchema,
     configuration: JsonValueSchema.optional()
   }).strict().optional()
@@ -11051,63 +11281,63 @@ var WorkflowTriggerSchema = z13.object({
   if (trigger.type === "webhook" && !trigger.webhook) context.addIssue({ code: "custom", path: ["webhook"], message: "Webhook trigger requires webhook configuration." });
   if (trigger.type === "event" && !trigger.event) context.addIssue({ code: "custom", path: ["event"], message: "Event trigger requires event configuration." });
 });
-var WorkflowValidationIssueSchema = z13.object({
+var WorkflowValidationIssueSchema = z14.object({
   taskReferenceName: ContractIdentifierSchema,
-  issueType: z13.enum(["ERROR", "WARNING"]),
-  detailReason: z13.object({ type: ContractIdentifierSchema, name: ContractIdentifierSchema, detailInformation: JsonValueSchema.optional() }).strict(),
-  humanMessage: z13.object({ en: z13.string(), zh: z13.string() }).strict()
+  issueType: z14.enum(["ERROR", "WARNING"]),
+  detailReason: z14.object({ type: ContractIdentifierSchema, name: ContractIdentifierSchema, detailInformation: JsonValueSchema.optional() }).strict(),
+  humanMessage: z14.object({ en: z14.string(), zh: z14.string() }).strict()
 }).strict();
-var WorkflowDefinitionSchema = z13.object({
-  contract: z13.literal("WorkflowDefinition"),
+var WorkflowDefinitionSchema = z14.object({
+  contract: z14.literal("WorkflowDefinition"),
   metadata: ContractMetadataSchema.omit({ name: true, description: true, labels: true }).extend({
     name: LocalizedTextSchema,
     description: LocalizedTextSchema.optional(),
-    role: z13.enum(["workflow", "template"]),
+    role: z14.enum(["workflow", "template"]),
     teamId: ContractIdentifierSchema,
     creatorRef: EntityRefSchema,
-    tags: z13.array(ContractIdentifierSchema).default([])
+    tags: z14.array(ContractIdentifierSchema).default([])
   }).strict(),
-  revision: z13.object({
-    kind: z13.enum(["release", "backup"]),
-    recordVersion: z13.number().int().positive(),
-    sourceVersion: z13.number().int().positive().optional()
+  revision: z14.object({
+    kind: z14.enum(["release", "backup"]),
+    recordVersion: z14.number().int().positive(),
+    sourceVersion: z14.number().int().positive().optional()
   }).strict().superRefine((revision, context) => {
     if (revision.kind === "backup" && revision.sourceVersion === void 0) context.addIssue({ code: "custom", path: ["sourceVersion"], message: "Backup revisions require a sourceVersion." });
   }),
-  presentation: z13.object({ iconUrl: z13.string().optional(), thumbnail: z13.string().optional() }).strict(),
-  ports: z13.object({ inputs: z13.array(ContractPortSchema).default([]), outputs: z13.array(ContractPortSchema).default([]) }).strict(),
-  parameters: z13.object({ variables: z13.array(WorkflowParameterSchema).default([]), outputs: z13.array(WorkflowOutputBindingSchema).default([]) }).strict(),
-  graph: z13.object({ nodes: z13.array(WorkflowNodeSchema), edges: z13.array(WorkflowEdgeSchema).default([]) }).strict(),
-  execution: z13.object({
-    timeoutMs: z13.number().int().positive().optional(),
-    retries: z13.number().int().nonnegative().default(0),
-    concurrencyLimit: z13.number().int().positive().optional(),
-    idempotency: z13.enum(["required", "supported", "none"]),
-    rateLimit: z13.object({ enabled: z13.boolean(), max: z13.number().int().nonnegative(), windowMs: z13.number().int().nonnegative() }).strict().superRefine((rateLimit, context) => {
+  presentation: z14.object({ iconUrl: z14.string().optional(), thumbnail: z14.string().optional() }).strict(),
+  ports: z14.object({ inputs: z14.array(ContractPortSchema).default([]), outputs: z14.array(ContractPortSchema).default([]) }).strict(),
+  parameters: z14.object({ variables: z14.array(WorkflowParameterSchema).default([]), outputs: z14.array(WorkflowOutputBindingSchema).default([]) }).strict(),
+  graph: z14.object({ nodes: z14.array(WorkflowNodeSchema), edges: z14.array(WorkflowEdgeSchema).default([]) }).strict(),
+  execution: z14.object({
+    timeoutMs: z14.number().int().positive().optional(),
+    retries: z14.number().int().nonnegative().default(0),
+    concurrencyLimit: z14.number().int().positive().optional(),
+    idempotency: z14.enum(["required", "supported", "none"]),
+    rateLimit: z14.object({ enabled: z14.boolean(), max: z14.number().int().nonnegative(), windowMs: z14.number().int().nonnegative() }).strict().superRefine((rateLimit, context) => {
       if (rateLimit.enabled && (rateLimit.max === 0 || rateLimit.windowMs === 0)) context.addIssue({ code: "custom", message: "Enabled rate limit requires positive max and windowMs." });
     }).optional(),
-    conductor: z13.object({
-      ownerApp: z13.string().optional(),
-      createTime: z13.number().int().nonnegative().optional(),
-      updateTime: z13.number().int().nonnegative().optional(),
-      createdBy: z13.string().optional(),
-      updatedBy: z13.string().optional(),
+    conductor: z14.object({
+      ownerApp: z14.string().optional(),
+      createTime: z14.number().int().nonnegative().optional(),
+      updateTime: z14.number().int().nonnegative().optional(),
+      createdBy: z14.string().optional(),
+      updatedBy: z14.string().optional(),
       failureWorkflow: ContractIdentifierSchema.optional(),
-      schemaVersion: z13.number().int().positive().optional(),
-      restartable: z13.boolean().optional(),
-      workflowStatusListenerEnabled: z13.boolean().optional(),
-      ownerEmail: z13.string().email().optional(),
-      timeoutPolicy: z13.enum(["TIME_OUT_WF", "ALERT_ONLY"]).optional(),
-      variables: z13.record(z13.string(), JsonValueSchema).optional(),
-      inputTemplate: z13.record(z13.string(), JsonValueSchema).optional()
+      schemaVersion: z14.number().int().positive().optional(),
+      restartable: z14.boolean().optional(),
+      workflowStatusListenerEnabled: z14.boolean().optional(),
+      ownerEmail: z14.string().email().optional(),
+      timeoutPolicy: z14.enum(["TIME_OUT_WF", "ALERT_ONLY"]).optional(),
+      variables: z14.record(z14.string(), JsonValueSchema).optional(),
+      inputTemplate: z14.record(z14.string(), JsonValueSchema).optional()
     }).strict()
   }).strict(),
-  triggers: z13.array(WorkflowTriggerSchema).default([]),
-  views: z13.array(z13.object({ pageRef: ContractIdentifierSchema, placement: ContractIdentifierSchema.optional() }).strict()).default([]),
-  dataContracts: z13.object({ reads: z13.array(ContractIdentifierSchema).default([]), writes: z13.array(ContractIdentifierSchema).default([]), emits: z13.array(ContractIdentifierSchema).default([]) }).strict(),
-  governance: z13.object({ activated: z13.boolean(), validated: z13.boolean(), validationIssues: z13.array(WorkflowValidationIssueSchema).default([]), hidden: z13.boolean().optional() }).strict(),
-  interfaces: z13.object({
-    openai: z13.object({ enabled: z13.boolean(), modelName: z13.string().trim().min(1).optional() }).strict(),
+  triggers: z14.array(WorkflowTriggerSchema).default([]),
+  views: z14.array(z14.object({ pageRef: ContractIdentifierSchema, placement: ContractIdentifierSchema.optional() }).strict()).default([]),
+  dataContracts: z14.object({ reads: z14.array(ContractIdentifierSchema).default([]), writes: z14.array(ContractIdentifierSchema).default([]), emits: z14.array(ContractIdentifierSchema).default([]) }).strict(),
+  governance: z14.object({ activated: z14.boolean(), validated: z14.boolean(), validationIssues: z14.array(WorkflowValidationIssueSchema).default([]), hidden: z14.boolean().optional() }).strict(),
+  interfaces: z14.object({
+    openai: z14.object({ enabled: z14.boolean(), modelName: z14.string().trim().min(1).optional() }).strict(),
     shortcutRef: EntityRefSchema.optional(),
     preferredAppId: ContractIdentifierSchema.optional()
   }).strict().superRefine((interfaces, context) => {
@@ -11127,6 +11357,8 @@ var WorkflowDefinitionSchema = z13.object({
 
 // src/schemas/index.ts
 var canonicalContractSchemas = {
+  "agent-session-event": AgentSessionEventSchema,
+  "agent-session-view-model": AgentSessionViewModelSchema,
   "agent-runtime-event": AgentRuntimeEventSchema,
   "application-run": ApplicationRunSchema,
   "application-handoff": ApplicationHandoffSchema,
@@ -12320,7 +12552,14 @@ var compileWorkflowPersistenceProjection = (input) => {
 export {
   APPLICATION_HANDOFF_QUERY_PARAMETER,
   ActorRefSchema,
+  AgentExecutionModeSchema,
+  AgentModeSchema,
   AgentRuntimeEventSchema,
+  AgentSessionCapabilitiesSchema,
+  AgentSessionCapabilitySchema,
+  AgentSessionEventSchema,
+  AgentSessionSnapshotSchema,
+  AgentSessionViewModelSchema,
   ApplicationHandoffEndpointSchema,
   ApplicationHandoffSchema,
   ApplicationRunSchema,
@@ -12479,6 +12718,8 @@ export {
   createWorkflowCapabilityManifest,
   extractOpenApiCapabilityManifests,
   mergeThemeTokenDocuments,
+  normalizeAgentExecutionMode,
+  normalizeAgentMode,
   parseApplicationHandoff,
   publishOpenApiToolCapabilityManifests,
   readApplicationHandoffFromUrl,