@inf-monkeys-tech/monkeys 1.0.14 → 1.0.16

package/lib/esm/runtime/index.mjs

@@ -7593,69 +7593,512 @@ var compileCapabilityRegistry = (sources) => {
   });
 };
 
+// src/contracts/agent.ts
+import { z as z5 } from "zod";
+var AgentModeSchema = z5.enum(["chatbot", "agent"]);
+var AgentConfigurationCapabilitySchema = z5.enum([
+  "models",
+  "skills",
+  "tools",
+  "mcp",
+  "reasoning"
+]);
+var AgentModeCapabilitiesSchema = z5.object({
+  models: z5.boolean(),
+  skills: z5.boolean(),
+  tools: z5.boolean(),
+  mcp: z5.boolean(),
+  reasoning: z5.boolean()
+}).strict();
+var AgentResourceModeSupportSchema = z5.object({
+  modes: z5.array(AgentModeSchema).min(1)
+}).strict();
+var AGENT_MODE_CAPABILITIES = Object.freeze({
+  chatbot: AgentModeCapabilitiesSchema.parse({
+    models: true,
+    skills: true,
+    tools: true,
+    mcp: true,
+    reasoning: false
+  }),
+  agent: AgentModeCapabilitiesSchema.parse({
+    models: true,
+    skills: true,
+    tools: true,
+    mcp: true,
+    reasoning: true
+  })
+});
+var AgentSessionCapabilitySchema = z5.enum([
+  "text",
+  "reasoning",
+  "plan",
+  "tasks",
+  "tools",
+  "mcp",
+  "shell",
+  "fileChange",
+  "skills",
+  "approval",
+  "artifacts",
+  "usage",
+  "resume",
+  "diff",
+  "workspaceFiles",
+  "terminal",
+  "testResults"
+]);
+var AgentSessionCapabilitiesSchema = z5.object({
+  text: z5.boolean().default(true),
+  reasoning: z5.boolean().default(false),
+  plan: z5.boolean().default(false),
+  tasks: z5.boolean().default(false),
+  tools: z5.boolean().default(false),
+  mcp: z5.boolean().default(false),
+  shell: z5.boolean().default(false),
+  fileChange: z5.boolean().default(false),
+  skills: z5.boolean().default(false),
+  approval: z5.boolean().default(false),
+  artifacts: z5.boolean().default(false),
+  usage: z5.boolean().default(false),
+  resume: z5.boolean().default(false),
+  diff: z5.boolean().default(false),
+  workspaceFiles: z5.boolean().default(false),
+  terminal: z5.boolean().default(false),
+  testResults: z5.boolean().default(false)
+}).strict();
+var AGENT_SESSION_RUNTIME_CAPABILITIES = Object.freeze({
+  chatbot: AgentSessionCapabilitiesSchema.parse({ text: true, tools: true, mcp: true, skills: true, approval: true, usage: true }),
+  agent: AgentSessionCapabilitiesSchema.parse({ text: true, tools: true, mcp: true, shell: true, fileChange: true, skills: true, approval: true, artifacts: true, usage: true, resume: true })
+});
+var AGENT_SESSION_CAPABILITY_EVIDENCE = Object.freeze({
+  text: { eventTypes: ["message"], commandTypes: [] },
+  reasoning: { eventTypes: ["reasoning"], commandTypes: [] },
+  plan: { eventTypes: ["plan"], commandTypes: [] },
+  tasks: { eventTypes: ["task"], commandTypes: [] },
+  tools: { eventTypes: ["tool"], commandTypes: [] },
+  mcp: { eventTypes: ["tool"], commandTypes: [] },
+  shell: { eventTypes: ["tool", "terminal"], commandTypes: [] },
+  fileChange: { eventTypes: ["tool", "diff", "workspace-file"], commandTypes: [] },
+  skills: { eventTypes: ["tool"], commandTypes: [] },
+  approval: { eventTypes: ["approval"], commandTypes: ["approval"] },
+  artifacts: { eventTypes: ["artifact"], commandTypes: [] },
+  usage: { eventTypes: ["usage"], commandTypes: [] },
+  resume: { eventTypes: ["resume"], commandTypes: ["resume"] },
+  diff: { eventTypes: ["diff"], commandTypes: [] },
+  workspaceFiles: { eventTypes: ["workspace-file"], commandTypes: [] },
+  terminal: { eventTypes: ["terminal"], commandTypes: [] },
+  testResults: { eventTypes: ["test-result"], commandTypes: [] }
+});
+var AgentSessionSnapshotSchema = z5.object({
+  mode: AgentModeSchema,
+  modelId: z5.string().trim().min(1),
+  capabilities: AgentSessionCapabilitiesSchema
+}).strict();
+var AgentSessionStatusSchema = z5.enum([
+  "queued",
+  "running",
+  "waiting_approval",
+  "stopping",
+  "stopped",
+  "completed",
+  "failed"
+]);
+var AgentSessionCommandTypeSchema = z5.enum(["stop", "resume", "retry", "approval"]);
+var AgentSessionCommandHeaderSchema = z5.object({
+  contract: z5.literal("AgentSessionCommand"),
+  commandId: ContractIdentifierSchema,
+  sessionId: ContractIdentifierSchema,
+  idempotencyKey: ContractIdentifierSchema,
+  expectedSequence: z5.number().int().min(-1),
+  issuedAt: IsoDateTimeSchema
+}).strict();
+var sessionCommand = (commandType, payload) => AgentSessionCommandHeaderSchema.extend({
+  commandType: z5.literal(commandType),
+  payload: z5.object(payload).strict()
+}).strict();
+var AgentSessionCommandSchema = z5.discriminatedUnion("commandType", [
+  sessionCommand("stop", {
+    reason: z5.string().trim().min(1).optional()
+  }),
+  sessionCommand("resume", {
+    resumeEventId: ContractIdentifierSchema.optional()
+  }),
+  sessionCommand("retry", {
+    sourceEventId: ContractIdentifierSchema
+  }),
+  sessionCommand("approval", {
+    approvalId: ContractIdentifierSchema,
+    decision: z5.enum(["approved", "rejected"]),
+    reason: z5.string().trim().min(1).optional()
+  })
+]);
+var AgentSessionCommandErrorCodeSchema = z5.enum([
+  "SESSION_NOT_FOUND",
+  "COMMAND_NOT_SUPPORTED",
+  "CAPABILITY_UNAVAILABLE",
+  "SEQUENCE_CONFLICT",
+  "INVALID_SESSION_STATE",
+  "TARGET_EVENT_NOT_FOUND",
+  "TARGET_EVENT_NOT_RETRYABLE",
+  "APPROVAL_NOT_FOUND",
+  "APPROVAL_ALREADY_RESOLVED",
+  "COMMAND_EXECUTION_FAILED"
+]);
+var AgentSessionCommandResultSchema = z5.object({
+  contract: z5.literal("AgentSessionCommandResult"),
+  commandId: ContractIdentifierSchema,
+  sessionId: ContractIdentifierSchema,
+  idempotencyKey: ContractIdentifierSchema,
+  outcome: z5.enum(["accepted", "duplicate", "rejected", "failed"]),
+  sessionStatus: AgentSessionStatusSchema,
+  acceptedSequence: z5.number().int().nonnegative().optional(),
+  resultEventIds: z5.array(ContractIdentifierSchema).default([]),
+  error: z5.object({
+    code: AgentSessionCommandErrorCodeSchema,
+    message: z5.string(),
+    retryable: z5.boolean()
+  }).strict().optional(),
+  occurredAt: IsoDateTimeSchema
+}).strict().superRefine((value, context) => {
+  const requiresError = value.outcome === "rejected" || value.outcome === "failed";
+  if (requiresError !== Boolean(value.error)) {
+    context.addIssue({
+      code: "custom",
+      path: ["error"],
+      message: requiresError ? "Rejected and failed command results require an error." : "Accepted and duplicate command results must not contain an error."
+    });
+  }
+});
+var AgentSessionEventHeaderSchema = z5.object({
+  contract: z5.literal("AgentSessionEvent"),
+  eventId: ContractIdentifierSchema,
+  sessionId: ContractIdentifierSchema,
+  sequence: z5.number().int().nonnegative(),
+  idempotencyKey: ContractIdentifierSchema,
+  occurredAt: IsoDateTimeSchema
+}).strict();
+var sessionEvent = (eventType, payload) => AgentSessionEventHeaderSchema.extend({
+  eventType: z5.literal(eventType),
+  payload: z5.object(payload).strict()
+}).strict();
+var AgentSessionEventSchema = z5.discriminatedUnion("eventType", [
+  sessionEvent("message", {
+    messageId: ContractIdentifierSchema,
+    role: z5.enum(["user", "assistant", "system"]),
+    operation: z5.enum(["append", "replace"]).default("append"),
+    parts: z5.array(JsonValueSchema),
+    status: z5.enum(["streaming", "completed", "failed"]).optional()
+  }),
+  sessionEvent("reasoning", {
+    reasoningId: ContractIdentifierSchema,
+    text: z5.string(),
+    status: z5.enum(["streaming", "completed"])
+  }),
+  sessionEvent("plan", {
+    planId: ContractIdentifierSchema,
+    title: z5.string().optional(),
+    status: z5.enum(["pending", "running", "completed", "failed"]),
+    steps: z5.array(
+      z5.object({
+        id: ContractIdentifierSchema,
+        title: z5.string(),
+        status: z5.enum(["pending", "running", "completed", "failed", "skipped"])
+      }).strict()
+    )
+  }),
+  sessionEvent("task", {
+    taskId: ContractIdentifierSchema,
+    title: z5.string(),
+    status: z5.enum(["pending", "running", "completed", "failed", "skipped"]),
+    detail: z5.string().optional()
+  }),
+  sessionEvent("tool", {
+    toolCallId: ContractIdentifierSchema,
+    toolName: z5.string().trim().min(1),
+    status: z5.enum(["pending", "running", "completed", "failed", "denied"]),
+    input: JsonValueSchema.optional(),
+    output: JsonValueSchema.optional(),
+    error: z5.string().optional(),
+    startedAt: IsoDateTimeSchema.optional(),
+    completedAt: IsoDateTimeSchema.optional()
+  }),
+  sessionEvent("approval", {
+    approvalId: ContractIdentifierSchema,
+    toolCallId: ContractIdentifierSchema.optional(),
+    status: z5.enum(["requested", "approved", "rejected", "expired"]),
+    title: z5.string(),
+    description: z5.string().optional(),
+    requestedAction: JsonValueSchema.optional()
+  }),
+  sessionEvent("status", {
+    status: AgentSessionStatusSchema,
+    detail: z5.string().optional()
+  }),
+  sessionEvent("artifact", {
+    artifactId: ContractIdentifierSchema,
+    name: z5.string().trim().min(1),
+    kind: z5.enum(["file", "image", "video", "audio", "web", "other"]),
+    status: z5.enum(["pending", "ready", "failed"]),
+    mimeType: z5.string().optional(),
+    url: z5.string().url().optional(),
+    size: z5.number().int().nonnegative().optional(),
+    sourceEventId: ContractIdentifierSchema.optional()
+  }),
+  sessionEvent("usage", {
+    inputTokens: z5.number().int().nonnegative().optional(),
+    outputTokens: z5.number().int().nonnegative().optional(),
+    totalTokens: z5.number().int().nonnegative().optional(),
+    contextTokens: z5.number().int().nonnegative().optional(),
+    contextWindow: z5.number().int().positive().optional()
+  }),
+  sessionEvent("resume", {
+    resumable: z5.boolean(),
+    state: JsonObjectSchema.optional(),
+    reason: z5.string().optional()
+  }),
+  sessionEvent("error", {
+    code: z5.string().trim().min(1),
+    message: z5.string(),
+    retryable: z5.boolean(),
+    sourceEventId: ContractIdentifierSchema.optional(),
+    details: JsonObjectSchema.optional()
+  }),
+  sessionEvent("diff", {
+    path: z5.string().trim().min(1),
+    status: z5.enum(["added", "modified", "deleted", "renamed"]),
+    patch: z5.string().optional()
+  }),
+  sessionEvent("workspace-file", {
+    path: z5.string().trim().min(1),
+    operation: z5.enum(["upsert", "delete"]),
+    mimeType: z5.string().optional(),
+    size: z5.number().int().nonnegative().optional()
+  }),
+  sessionEvent("terminal", {
+    terminalId: ContractIdentifierSchema,
+    stream: z5.enum(["stdin", "stdout", "stderr", "status"]),
+    chunk: z5.string(),
+    exitCode: z5.number().int().optional()
+  }),
+  sessionEvent("test-result", {
+    testId: ContractIdentifierSchema,
+    name: z5.string(),
+    status: z5.enum(["running", "passed", "failed", "skipped"]),
+    durationMs: z5.number().nonnegative().optional(),
+    output: z5.string().optional()
+  })
+]);
+var AgentSessionViewModelSchema = z5.object({
+  contract: z5.literal("AgentSessionViewModel"),
+  sessionId: ContractIdentifierSchema,
+  snapshot: AgentSessionSnapshotSchema,
+  status: AgentSessionStatusSchema,
+  events: z5.array(AgentSessionEventSchema),
+  lastSequence: z5.number().int().min(-1),
+  resumable: z5.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."
+    });
+  }
+});
+
+// src/runtime/agent-session-projector.ts
+function createAgentSessionEventProjection(sessionId) {
+  return {
+    sessionId,
+    events: [],
+    lastSequence: -1,
+    status: "queued",
+    resumable: false
+  };
+}
+function projectAgentSessionEvents(current, candidates) {
+  const parsed = candidates.map(
+    (candidate) => AgentSessionEventSchema.parse(candidate)
+  );
+  if (parsed.some((event) => event.sessionId !== current.sessionId)) {
+    throw new TypeError(
+      "Agent session event sessionId does not match the projection sessionId."
+    );
+  }
+  const eventIds = new Set(current.events.map((event) => event.eventId));
+  const idempotencyKeys = new Set(
+    current.events.map((event) => event.idempotencyKey)
+  );
+  const eventsBySequence = new Map(
+    current.events.map((event) => [event.sequence, event])
+  );
+  const acceptedCandidates = [];
+  for (const event of parsed.sort(
+    (left, right) => left.sequence - right.sequence
+  )) {
+    if (eventIds.has(event.eventId) || idempotencyKeys.has(event.idempotencyKey))
+      continue;
+    const existing = eventsBySequence.get(event.sequence);
+    if (existing) {
+      throw new TypeError(
+        `Conflicting Agent session events share sequence ${event.sequence}.`
+      );
+    }
+    eventsBySequence.set(event.sequence, event);
+    eventIds.add(event.eventId);
+    idempotencyKeys.add(event.idempotencyKey);
+    acceptedCandidates.push(event);
+  }
+  for (const event of acceptedCandidates)
+    eventsBySequence.delete(event.sequence);
+  let expectedSequence = current.lastSequence + 1;
+  let gap;
+  for (const event of acceptedCandidates) {
+    if (event.sequence < expectedSequence) {
+      throw new TypeError(
+        `Agent session event sequence ${event.sequence} is behind the recovery cursor.`
+      );
+    }
+    if (event.sequence > expectedSequence) {
+      gap = { expectedSequence, receivedSequence: event.sequence };
+      break;
+    }
+    eventsBySequence.set(event.sequence, event);
+    eventIds.add(event.eventId);
+    idempotencyKeys.add(event.idempotencyKey);
+    expectedSequence += 1;
+  }
+  const events = [...eventsBySequence.values()].sort(
+    (left, right) => left.sequence - right.sequence
+  );
+  let status = "queued";
+  let resumable = false;
+  for (const event of events) {
+    if (event.eventType === "status") status = event.payload.status;
+    if (event.eventType === "resume") resumable = event.payload.resumable;
+  }
+  return {
+    sessionId: current.sessionId,
+    events,
+    lastSequence: events.length > 0 ? events[events.length - 1].sequence : -1,
+    status,
+    resumable,
+    ...gap ? { gap } : {}
+  };
+}
+function toAgentSessionViewModel(projection, snapshot) {
+  return AgentSessionViewModelSchema.parse({
+    contract: "AgentSessionViewModel",
+    sessionId: projection.sessionId,
+    snapshot,
+    status: projection.status,
+    events: projection.events,
+    lastSequence: projection.lastSequence,
+    resumable: projection.resumable
+  });
+}
+
 // src/contracts/semantic.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 
 // src/contracts/data.ts
-import { z as z5 } from "zod";
-var SourceRecordRefSchema = z5.object({
+import { z as z6 } from "zod";
+var SourceRecordRefSchema = z6.object({
   sourceId: ContractIdentifierSchema,
   recordId: ContractIdentifierSchema,
-  recordVersion: z5.union([z5.number().int().nonnegative(), ContractIdentifierSchema]),
+  recordVersion: z6.union([z6.number().int().nonnegative(), ContractIdentifierSchema]),
   hash: Sha256Schema
 }).strict();
-var OntologyDefinitionSchema = z5.object({
-  contract: z5.literal("OntologyDefinition"),
+var OntologyDefinitionSchema = z6.object({
+  contract: z6.literal("OntologyDefinition"),
   ontologyId: ContractIdentifierSchema,
   dataSpaceId: ContractIdentifierSchema,
   ownerRepo: ContractIdentifierSchema,
   bodySchemaRef: ContractIdentifierSchema,
-  authority: z5.object({
+  authority: z6.object({
     service: ContractIdentifierSchema,
     storage: ContractIdentifierSchema,
-    scope: z5.enum(["tenant", "team", "user", "global"])
+    scope: z6.enum(["tenant", "team", "user", "global"])
   }).strict(),
-  relationKinds: z5.array(ContractIdentifierSchema).default([]),
-  metricKinds: z5.array(ContractIdentifierSchema).default([])
+  relationKinds: z6.array(ContractIdentifierSchema).default([]),
+  metricKinds: z6.array(ContractIdentifierSchema).default([])
 }).strict();
-var ProjectionSpecSchema = z5.object({
-  contract: z5.literal("ProjectionSpec"),
+var ProjectionSpecSchema = z6.object({
+  contract: z6.literal("ProjectionSpec"),
   projectionId: ContractIdentifierSchema,
-  ontologyIds: z5.array(ContractIdentifierSchema).min(1),
+  ontologyIds: z6.array(ContractIdentifierSchema).min(1),
   outputSchemaRef: ContractIdentifierSchema,
-  operator: z5.object({
-    kind: z5.enum(["query", "aggregate", "relationship", "search", "custom"]),
-    configuration: z5.record(z5.string(), JsonValueSchema).default({})
+  operator: z6.object({
+    kind: z6.enum(["query", "aggregate", "relationship", "search", "custom"]),
+    configuration: z6.record(z6.string(), JsonValueSchema).default({})
   }).strict(),
-  materialization: z5.enum(["on-demand", "event-driven", "scheduled"]),
-  invalidationEvents: z5.array(ContractIdentifierSchema).default([]),
-  rebuildable: z5.literal(true),
-  lineagePolicy: z5.object({
-    sourceRecords: z5.boolean(),
-    bodyVersions: z5.boolean(),
-    runRefs: z5.boolean(),
-    actorRefs: z5.boolean()
+  materialization: z6.enum(["on-demand", "event-driven", "scheduled"]),
+  invalidationEvents: z6.array(ContractIdentifierSchema).default([]),
+  rebuildable: z6.literal(true),
+  lineagePolicy: z6.object({
+    sourceRecords: z6.boolean(),
+    bodyVersions: z6.boolean(),
+    runRefs: z6.boolean(),
+    actorRefs: z6.boolean()
   }).strict()
 }).strict();
-var LineageRecordSchema = z5.object({
-  contract: z5.literal("LineageRecord"),
+var LineageRecordSchema = z6.object({
+  contract: z6.literal("LineageRecord"),
   lineageId: ContractIdentifierSchema,
   subjectRef: EntityRefSchema,
-  sourceRecords: z5.array(SourceRecordRefSchema).default([]),
-  bodyRefs: z5.array(EntityRefSchema).default([]),
-  runRefs: z5.array(EntityRefSchema).default([]),
-  outputRefs: z5.array(EntityRefSchema).default([]),
-  artifactRefs: z5.array(EntityRefSchema).default([]),
-  actorRefs: z5.array(EntityRefSchema).default([]),
-  evidenceRefs: z5.array(EntityRefSchema).default([]),
+  sourceRecords: z6.array(SourceRecordRefSchema).default([]),
+  bodyRefs: z6.array(EntityRefSchema).default([]),
+  runRefs: z6.array(EntityRefSchema).default([]),
+  outputRefs: z6.array(EntityRefSchema).default([]),
+  artifactRefs: z6.array(EntityRefSchema).default([]),
+  actorRefs: z6.array(EntityRefSchema).default([]),
+  evidenceRefs: z6.array(EntityRefSchema).default([]),
   recordedAt: IsoDateTimeSchema
 }).strict();
-var DomainEventSchema = z5.object({
-  contract: z5.literal("DomainEvent"),
+var DomainEventSchema = z6.object({
+  contract: z6.literal("DomainEvent"),
   eventId: ContractIdentifierSchema,
   eventType: ContractIdentifierSchema,
   aggregateRef: EntityRefSchema,
-  aggregateVersion: z5.number().int().nonnegative(),
+  aggregateVersion: z6.number().int().nonnegative(),
   requestId: ContractIdentifierSchema,
   actorRef: EntityRefSchema,
   payload: JsonValueSchema,
@@ -7663,8 +8106,8 @@ var DomainEventSchema = z5.object({
 }).strict();
 
 // src/contracts/page.ts
-import { z as z6 } from "zod";
-var PageTypeSchema = z6.enum([
+import { z as z7 } from "zod";
+var PageTypeSchema = z7.enum([
   "page",
   "workspace",
   "view",
@@ -7685,14 +8128,14 @@ var PageTypeSchema = z6.enum([
   "global-design-board",
   "iframe"
 ]);
-var PageVisibilitySchema = z6.object({
-  authenticated: z6.boolean().default(true),
-  permissionAllOf: z6.array(ContractIdentifierSchema).default([]),
-  permissionAnyOf: z6.array(ContractIdentifierSchema).default([]),
-  featureFlags: z6.array(ContractIdentifierSchema).default([]),
-  productContexts: z6.array(z6.enum(["studio", "kernel", "compute"])).min(1)
+var PageVisibilitySchema = z7.object({
+  authenticated: z7.boolean().default(true),
+  permissionAllOf: z7.array(ContractIdentifierSchema).default([]),
+  permissionAnyOf: z7.array(ContractIdentifierSchema).default([]),
+  featureFlags: z7.array(ContractIdentifierSchema).default([]),
+  productContexts: z7.array(z7.enum(["studio", "kernel", "compute"])).min(1)
 }).strict();
-var PageRoutePathSchema = z6.string().trim().regex(/^\/(?!\/)/, "Expected an application-relative route path.");
+var PageRoutePathSchema = z7.string().trim().regex(/^\/(?!\/)/, "Expected an application-relative route path.");
 var requireCapabilityReference = (reference, path, context) => {
   if (reference.kind !== "capability") {
     context.addIssue({
@@ -7716,50 +8159,50 @@ var requireCapabilityReference = (reference, path, context) => {
     });
   }
 };
-var PageDefinitionSchema = z6.object({
-  contract: z6.literal("PageDefinition"),
+var PageDefinitionSchema = z7.object({
+  contract: z7.literal("PageDefinition"),
   pageId: ContractIdentifierSchema,
   ownerRepo: ContractIdentifierSchema,
   title: LocalizedTextSchema,
   pageType: PageTypeSchema,
-  ownership: z6.object({
+  ownership: z7.object({
     teamId: ContractIdentifierSchema.optional(),
     creatorRef: EntityRefSchema.optional(),
     studioId: ContractIdentifierSchema.optional(),
-    builtIn: z6.boolean()
+    builtIn: z7.boolean()
   }).strict(),
-  record: z6.object({
-    createdTimestamp: z6.number().int().nonnegative().optional(),
-    updatedTimestamp: z6.number().int().nonnegative().optional(),
-    deleted: z6.boolean().default(false)
+  record: z7.object({
+    createdTimestamp: z7.number().int().nonnegative().optional(),
+    updatedTimestamp: z7.number().int().nonnegative().optional(),
+    deleted: z7.boolean().default(false)
   }).strict(),
-  surface: z6.enum(["page", "workspace", "view", "record", "action", "overlay", "agent"]),
+  surface: z7.enum(["page", "workspace", "view", "record", "action", "overlay", "agent"]),
   routeId: ContractIdentifierSchema,
   routePath: PageRoutePathSchema,
   rendererKey: ContractIdentifierSchema,
   capabilityRef: EntityRefSchema,
-  capabilityRefs: z6.array(EntityRefSchema).default([]),
+  capabilityRefs: z7.array(EntityRefSchema).default([]),
   workflowRef: EntityRefSchema.optional(),
-  binding: z6.object({
+  binding: z7.object({
     sourceRef: ContractIdentifierSchema.optional(),
     ontologyId: ContractIdentifierSchema.optional(),
     projectionRef: ContractIdentifierSchema.optional(),
     stateRef: ContractIdentifierSchema.optional()
   }).strict(),
-  access: z6.object({
-    actions: z6.array(z6.enum(["read", "write", "execute", "manage-permissions"])).default([])
+  access: z7.object({
+    actions: z7.array(z7.enum(["read", "write", "execute", "manage-permissions"])).default([])
   }).strict(),
-  rendererConfig: z6.object({
+  rendererConfig: z7.object({
     schemaRef: ContractIdentifierSchema,
     value: JsonObjectSchema
   }).strict(),
-  navigation: z6.object({
+  navigation: z7.object({
     label: LocalizedTextSchema,
     iconRef: ContractIdentifierSchema.optional(),
     parentPageId: ContractIdentifierSchema.optional(),
-    order: z6.number().int().optional(),
-    hidden: z6.boolean().default(false),
-    pinned: z6.boolean().default(false)
+    order: z7.number().int().optional(),
+    hidden: z7.boolean().default(false),
+    pinned: z7.boolean().default(false)
   }).strict(),
   visibility: PageVisibilitySchema
 }).strict().superRefine((page, context) => {
@@ -7780,8 +8223,8 @@ var PageDefinitionSchema = z6.object({
   });
   if (page.workflowRef && page.workflowRef.kind !== "workflow") context.addIssue({ code: "custom", path: ["workflowRef", "kind"], message: "workflowRef must reference a workflow." });
 });
-var PageRuntimeDescriptorSchema = z6.object({
-  contract: z6.literal("PageRuntimeDescriptor"),
+var PageRuntimeDescriptorSchema = z7.object({
+  contract: z7.literal("PageRuntimeDescriptor"),
   page: PageDefinitionSchema,
   nodeId: ContractIdentifierSchema,
   parentNodeId: ContractIdentifierSchema.optional(),
@@ -7789,54 +8232,54 @@ var PageRuntimeDescriptorSchema = z6.object({
   semanticRef: ContractIdentifierSchema.optional(),
   dataContextRef: ContractIdentifierSchema.optional(),
   providerRef: EntityRefSchema.optional(),
-  surface: z6.object({
+  surface: z7.object({
     frameOwner: ContractIdentifierSchema,
     tone: ContractIdentifierSchema.optional(),
-    density: z6.enum(["compact", "default", "comfortable"]).default("default")
+    density: z7.enum(["compact", "default", "comfortable"]).default("default")
   }).strict(),
-  scroll: z6.object({
-    owner: z6.enum(["page", "surface", "provider"]),
-    axis: z6.enum(["x", "y", "both", "none"]),
+  scroll: z7.object({
+    owner: z7.enum(["page", "surface", "provider"]),
+    axis: z7.enum(["x", "y", "both", "none"]),
     restoreKey: ContractIdentifierSchema.optional(),
-    virtualized: z6.boolean().default(false)
+    virtualized: z7.boolean().default(false)
   }).strict(),
-  activation: z6.enum(["navigate", "select", "drawer", "modal", "fullscreen"]),
-  lifecycle: z6.object({
-    mountPolicy: z6.enum(["always", "when-visible", "when-active"]),
-    queryPolicy: z6.enum(["always", "when-visible", "when-active", "manual"]),
-    deepLink: z6.boolean(),
-    focusReturn: z6.boolean()
+  activation: z7.enum(["navigate", "select", "drawer", "modal", "fullscreen"]),
+  lifecycle: z7.object({
+    mountPolicy: z7.enum(["always", "when-visible", "when-active"]),
+    queryPolicy: z7.enum(["always", "when-visible", "when-active", "manual"]),
+    deepLink: z7.boolean(),
+    focusReturn: z7.boolean()
   }).strict()
 }).strict();
-var PageRouteProjectionSchema = z6.object({
+var PageRouteProjectionSchema = z7.object({
   pageId: ContractIdentifierSchema,
   routeId: ContractIdentifierSchema,
   path: PageRoutePathSchema
 }).strict();
-var PageNavigationProjectionSchema = z6.object({
+var PageNavigationProjectionSchema = z7.object({
   pageId: ContractIdentifierSchema,
   routeId: ContractIdentifierSchema,
   path: PageRoutePathSchema,
   label: LocalizedTextSchema,
   iconRef: ContractIdentifierSchema.optional(),
   parentPageId: ContractIdentifierSchema.optional(),
-  order: z6.number().int().optional(),
-  pinned: z6.boolean()
+  order: z7.number().int().optional(),
+  pinned: z7.boolean()
 }).strict();
-var PageGuardProjectionSchema = z6.object({
+var PageGuardProjectionSchema = z7.object({
   pageId: ContractIdentifierSchema,
-  authenticated: z6.boolean(),
-  permissionAllOf: z6.array(ContractIdentifierSchema),
-  permissionAnyOf: z6.array(ContractIdentifierSchema),
-  featureFlags: z6.array(ContractIdentifierSchema),
-  actions: z6.array(z6.enum(["read", "write", "execute", "manage-permissions"]))
+  authenticated: z7.boolean(),
+  permissionAllOf: z7.array(ContractIdentifierSchema),
+  permissionAnyOf: z7.array(ContractIdentifierSchema),
+  featureFlags: z7.array(ContractIdentifierSchema),
+  actions: z7.array(z7.enum(["read", "write", "execute", "manage-permissions"]))
 }).strict();
-var PageRendererProjectionSchema = z6.object({
+var PageRendererProjectionSchema = z7.object({
   pageId: ContractIdentifierSchema,
-  surface: z6.enum(["page", "workspace", "view", "record", "action", "overlay", "agent"]),
+  surface: z7.enum(["page", "workspace", "view", "record", "action", "overlay", "agent"]),
   rendererKey: ContractIdentifierSchema,
   capabilityRef: EntityRefSchema,
-  capabilityRefs: z6.array(EntityRefSchema),
+  capabilityRefs: z7.array(EntityRefSchema),
   providerRef: EntityRefSchema,
   binding: PageDefinitionSchema.shape.binding,
   rendererConfig: PageDefinitionSchema.shape.rendererConfig,
@@ -7877,13 +8320,13 @@ var duplicateProjectionIdentity = (values, identity) => {
   }
   return void 0;
 };
-var PageRuntimeProjectionSchema = z6.object({
-  contract: z6.literal("PageRuntimeProjection"),
-  product: z6.enum(["studio", "kernel", "compute"]),
-  routes: z6.array(PageRouteProjectionSchema),
-  navigation: z6.array(PageNavigationProjectionSchema),
-  guards: z6.array(PageGuardProjectionSchema),
-  renderers: z6.array(PageRendererProjectionSchema)
+var PageRuntimeProjectionSchema = z7.object({
+  contract: z7.literal("PageRuntimeProjection"),
+  product: z7.enum(["studio", "kernel", "compute"]),
+  routes: z7.array(PageRouteProjectionSchema),
+  navigation: z7.array(PageNavigationProjectionSchema),
+  guards: z7.array(PageGuardProjectionSchema),
+  renderers: z7.array(PageRendererProjectionSchema)
 }).strict().superRefine((projection, context) => {
   const tables = [
     ["routes", projection.routes.map((value) => value.pageId)],
@@ -7939,38 +8382,38 @@ var PageRuntimeProjectionSchema = z6.object({
 });
 
 // src/contracts/semantic.ts
-var ConceptRelationshipSchema = z7.object({
+var ConceptRelationshipSchema = z8.object({
   kind: ContractIdentifierSchema,
   targetConceptId: ContractIdentifierSchema,
-  cardinality: z7.enum(["one", "optional", "many"])
+  cardinality: z8.enum(["one", "optional", "many"])
 }).strict();
-var ConceptDefinitionSchema = z7.object({
-  contract: z7.literal("ConceptDefinition"),
+var ConceptDefinitionSchema = z8.object({
+  contract: z8.literal("ConceptDefinition"),
   conceptId: ContractIdentifierSchema,
   ownerRepo: ContractIdentifierSchema,
-  displayName: z7.string().trim().min(1),
-  description: z7.string().optional(),
+  displayName: z8.string().trim().min(1),
+  description: z8.string().optional(),
   schemaRef: ContractIdentifierSchema,
   ontologyId: ContractIdentifierSchema.optional(),
-  capabilityIds: z7.array(ContractIdentifierSchema).default([]),
-  commandNames: z7.array(ContractIdentifierSchema).default([]),
-  relationships: z7.array(ConceptRelationshipSchema).default([])
+  capabilityIds: z8.array(ContractIdentifierSchema).default([]),
+  commandNames: z8.array(ContractIdentifierSchema).default([]),
+  relationships: z8.array(ConceptRelationshipSchema).default([])
 }).strict();
-var DomainCommandDefinitionSchema = z7.object({
-  contract: z7.literal("DomainCommandDefinition"),
+var DomainCommandDefinitionSchema = z8.object({
+  contract: z8.literal("DomainCommandDefinition"),
   commandName: ContractIdentifierSchema,
   ownerRepo: ContractIdentifierSchema,
-  displayName: z7.string().trim().min(1),
-  description: z7.string().optional(),
-  targetKinds: z7.array(ContractIdentifierSchema).min(1),
+  displayName: z8.string().trim().min(1),
+  description: z8.string().optional(),
+  targetKinds: z8.array(ContractIdentifierSchema).min(1),
   inputSchemaRef: ContractIdentifierSchema,
   outputSchemaRef: ContractIdentifierSchema.optional(),
-  requiredPermissionCodes: z7.array(ContractIdentifierSchema).default([]),
+  requiredPermissionCodes: z8.array(ContractIdentifierSchema).default([]),
   handlerRef: EntityRefSchema,
-  sideEffects: z7.array(z7.enum(["data-write", "execution", "navigation", "notification", "external-call"])).default([])
+  sideEffects: z8.array(z8.enum(["data-write", "execution", "navigation", "notification", "external-call"])).default([])
 }).strict();
-var DomainCommandSchema = z7.object({
-  contract: z7.literal("DomainCommand"),
+var DomainCommandSchema = z8.object({
+  contract: z8.literal("DomainCommand"),
   commandId: ContractIdentifierSchema,
   commandName: ContractIdentifierSchema,
   requestId: ContractIdentifierSchema,
@@ -7978,29 +8421,29 @@ var DomainCommandSchema = z7.object({
   idempotencyKey: ContractIdentifierSchema,
   targetRef: EntityRefSchema,
   actorRef: EntityRefSchema,
-  source: z7.object({
-    product: z7.enum(["studio", "kernel", "compute", "agent", "mcp", "service"]),
+  source: z8.object({
+    product: z8.enum(["studio", "kernel", "compute", "agent", "mcp", "service"]),
     pageId: ContractIdentifierSchema.optional(),
     capabilityId: ContractIdentifierSchema.optional()
   }).strict(),
   payload: JsonObjectSchema,
   issuedAt: IsoDateTimeSchema
 }).strict();
-var ProductDeclarationSchema = z7.object({
-  contract: z7.literal("ProductDeclaration"),
+var ProductDeclarationSchema = z8.object({
+  contract: z8.literal("ProductDeclaration"),
   declarationId: ContractIdentifierSchema,
   ownerRepo: ContractIdentifierSchema,
-  concepts: z7.array(ConceptDefinitionSchema).default([]),
-  ontologies: z7.array(OntologyDefinitionSchema).default([]),
-  projections: z7.array(ProjectionSpecSchema).default([]),
-  commands: z7.array(DomainCommandDefinitionSchema).default([]),
-  capabilities: z7.array(CapabilityManifestSchema).default([]),
-  pages: z7.array(PageDefinitionSchema).default([])
+  concepts: z8.array(ConceptDefinitionSchema).default([]),
+  ontologies: z8.array(OntologyDefinitionSchema).default([]),
+  projections: z8.array(ProjectionSpecSchema).default([]),
+  commands: z8.array(DomainCommandDefinitionSchema).default([]),
+  capabilities: z8.array(CapabilityManifestSchema).default([]),
+  pages: z8.array(PageDefinitionSchema).default([])
 }).strict();
-var DeclarationGraphEdgeSchema = z7.object({
+var DeclarationGraphEdgeSchema = z8.object({
   from: EntityRefSchema,
   to: EntityRefSchema,
-  relation: z7.enum([
+  relation: z8.enum([
     "uses-ontology",
     "uses-projection",
     "uses-capability",
@@ -8008,17 +8451,17 @@ var DeclarationGraphEdgeSchema = z7.object({
     "relates-to-concept"
   ])
 }).strict();
-var ChangeImpactSchema = z7.object({
+var ChangeImpactSchema = z8.object({
   changedRef: EntityRefSchema,
-  affectedRefs: z7.array(EntityRefSchema),
-  reasons: z7.array(ContractIdentifierSchema).min(1)
+  affectedRefs: z8.array(EntityRefSchema),
+  reasons: z8.array(ContractIdentifierSchema).min(1)
 }).strict();
-var ChangeImpactGraphSchema = z7.object({
-  contract: z7.literal("ChangeImpactGraph"),
+var ChangeImpactGraphSchema = z8.object({
+  contract: z8.literal("ChangeImpactGraph"),
   declarationId: ContractIdentifierSchema,
-  nodes: z7.array(EntityRefSchema),
-  edges: z7.array(DeclarationGraphEdgeSchema),
-  impacts: z7.array(ChangeImpactSchema),
+  nodes: z8.array(EntityRefSchema),
+  edges: z8.array(DeclarationGraphEdgeSchema),
+  impacts: z8.array(ChangeImpactSchema),
   generatedAt: IsoDateTimeSchema
 }).strict();
 
@@ -8762,10 +9205,10 @@ var compileRenderTree = (input) => {
 };
 
 // src/contracts/tenant.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 
 // src/contracts/theme.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // src/theme-tokens/core.ts
 var import_ajv = __toESM(require_ajv());
@@ -10992,20 +11435,20 @@ function assertMonkeysThemeTokensComplete(input) {
 }
 
 // src/contracts/theme.ts
-var ThemeTokenTypeSchema = z8.enum(THEME_TOKEN_TYPES);
-var ThemeTokenSchema = z8.record(z8.string(), z8.unknown()).superRefine((input, context) => {
+var ThemeTokenTypeSchema = z9.enum(THEME_TOKEN_TYPES);
+var ThemeTokenSchema = z9.record(z9.string(), z9.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 = z8.record(z8.string(), z8.unknown()).superRefine((input, context) => {
+var ThemeTokenGroupSchema = z9.record(z9.string(), z9.unknown()).superRefine((input, context) => {
   const issues = validateThemeTokensDocumentStructure(input);
   for (const issue of issues) {
     context.addIssue({ code: "custom", message: `${issue.path} ${issue.message}` });
   }
 });
-var ThemeTokensSchema = z8.record(z8.string(), z8.unknown()).superRefine((input, context) => {
+var ThemeTokensSchema = z9.record(z9.string(), z9.unknown()).superRefine((input, context) => {
   const issues = validateThemeTokensDocument(input);
   for (const issue of issues) {
     context.addIssue({ code: "custom", message: `${issue.path} ${issue.message}` });
@@ -11032,9 +11475,9 @@ var ResolvedThemeTokensSchema = ThemeTokensSchema.superRefine((input, context) =
 });
 
 // src/contracts/tenant.ts
-var DesignTokenFileSourceSchema = z9.object({
-  type: z9.literal("file"),
-  path: z9.string().trim().min(1).superRefine((source, context) => {
+var DesignTokenFileSourceSchema = z10.object({
+  type: z10.literal("file"),
+  path: z10.string().trim().min(1).superRefine((source, context) => {
     if (/^[a-z][a-z\d+.-]*:/i.test(source)) {
       context.addIssue({
         code: "custom",
@@ -11043,9 +11486,9 @@ var DesignTokenFileSourceSchema = z9.object({
     }
   })
 }).strict();
-var DesignTokenUrlSourceSchema = z9.object({
-  type: z9.literal("url"),
-  url: z9.string().trim().min(1).superRefine((source, context) => {
+var DesignTokenUrlSourceSchema = z10.object({
+  type: z10.literal("url"),
+  url: z10.string().trim().min(1).superRefine((source, context) => {
     if (!/^https?:\/\//i.test(source)) {
       context.addIssue({
         code: "custom",
@@ -11054,109 +11497,109 @@ var DesignTokenUrlSourceSchema = z9.object({
     }
   })
 }).strict();
-var DesignTokenInlineSourceSchema = z9.object({
-  type: z9.literal("inline"),
+var DesignTokenInlineSourceSchema = z10.object({
+  type: z10.literal("inline"),
   document: ThemeTokensSchema
 }).strict();
-var DesignTokenSourceSchema = z9.discriminatedUnion("type", [
+var DesignTokenSourceSchema = z10.discriminatedUnion("type", [
   DesignTokenFileSourceSchema,
   DesignTokenUrlSourceSchema,
   DesignTokenInlineSourceSchema
 ]);
-var TenantDesignTokensConfigSchema = z9.object({
+var TenantDesignTokensConfigSchema = z10.object({
   /** Ordered tenant overrides. The backend always applies the product default first. */
-  tokenSources: z9.array(DesignTokenSourceSchema)
+  tokenSources: z10.array(DesignTokenSourceSchema)
 }).strict();
-var TenantAuthBindingSchema = z9.object({
-  kind: z9.literal("auth-provider"),
+var TenantAuthBindingSchema = z10.object({
+  kind: z10.literal("auth-provider"),
   providerId: ContractIdentifierSchema,
   policyRef: ContractIdentifierSchema.optional()
 }).strict();
-var TenantDataBindingSchema = z9.discriminatedUnion("kind", [
-  z9.object({
-    kind: z9.literal("data-provider"),
+var TenantDataBindingSchema = z10.discriminatedUnion("kind", [
+  z10.object({
+    kind: z10.literal("data-provider"),
     providerId: ContractIdentifierSchema,
     domainRef: ContractIdentifierSchema.optional()
   }).strict(),
-  z9.object({
-    kind: z9.literal("projection"),
+  z10.object({
+    kind: z10.literal("projection"),
     projectionRef: ContractIdentifierSchema,
     domainRef: ContractIdentifierSchema.optional()
   }).strict()
 ]);
-var TenantAuthBindingsSchema = z9.record(
+var TenantAuthBindingsSchema = z10.record(
   ContractIdentifierSchema,
   TenantAuthBindingSchema
 );
-var TenantDataBindingsSchema = z9.record(
+var TenantDataBindingsSchema = z10.record(
   ContractIdentifierSchema,
   TenantDataBindingSchema
 );
-var AssetVariantsSchema = z9.object({
-  light: z9.string().optional(),
-  dark: z9.string().optional()
+var AssetVariantsSchema = z10.object({
+  light: z10.string().optional(),
+  dark: z10.string().optional()
 }).strict();
-var ThemeHeadbarSchema = z9.object({
-  theme: z9.enum(["card", "glassy", "ghost"]).optional(),
-  navPosition: z9.enum(["left", "center", "right"]).optional(),
-  actions: z9.union([z9.literal("*"), z9.array(ContractIdentifierSchema)]).optional(),
-  profile: z9.union([z9.literal("*"), z9.array(ContractIdentifierSchema)]).optional(),
-  showTeamQuota: z9.boolean().optional()
+var ThemeHeadbarSchema = z10.object({
+  theme: z10.enum(["card", "glassy", "ghost"]).optional(),
+  navPosition: z10.enum(["left", "center", "right"]).optional(),
+  actions: z10.union([z10.literal("*"), z10.array(ContractIdentifierSchema)]).optional(),
+  profile: z10.union([z10.literal("*"), z10.array(ContractIdentifierSchema)]).optional(),
+  showTeamQuota: z10.boolean().optional()
 }).strict();
-var TenantHeadbarModuleLeafSchema = z9.object({
+var TenantHeadbarModuleLeafSchema = z10.object({
   id: ContractIdentifierSchema,
-  extraInfo: z9.boolean().optional(),
-  displayName: z9.union([z9.string(), z9.record(LocaleIdentifierSchema, z9.string())]).optional(),
-  visible: z9.boolean().optional(),
-  disabled: z9.boolean().optional(),
-  icon: z9.string().optional(),
-  showQuickSwitcher: z9.boolean().optional(),
-  showSidebar: z9.boolean().optional()
+  extraInfo: z10.boolean().optional(),
+  displayName: z10.union([z10.string(), z10.record(LocaleIdentifierSchema, z10.string())]).optional(),
+  visible: z10.boolean().optional(),
+  disabled: z10.boolean().optional(),
+  icon: z10.string().optional(),
+  showQuickSwitcher: z10.boolean().optional(),
+  showSidebar: z10.boolean().optional()
 }).strict();
 var TenantHeadbarModuleItemSchema = TenantHeadbarModuleLeafSchema.extend({
-  children: z9.array(TenantHeadbarModuleLeafSchema).optional()
+  children: z10.array(TenantHeadbarModuleLeafSchema).optional()
 }).strict();
-var KernelHeadbarSchema = z9.object({
-  theme: z9.literal("card").optional(),
-  layoutMode: z9.enum(["boxed", "full-bleed"]).optional(),
-  heightPx: z9.number().positive().optional(),
-  navPosition: z9.enum(["left", "center", "right"]).optional(),
-  brandTitle: z9.string().optional(),
-  menuRadius: z9.enum(["default", "none", "sm", "md", "lg", "xl", "full"]).optional()
+var KernelHeadbarSchema = z10.object({
+  theme: z10.literal("card").optional(),
+  layoutMode: z10.enum(["boxed", "full-bleed"]).optional(),
+  heightPx: z10.number().positive().optional(),
+  navPosition: z10.enum(["left", "center", "right"]).optional(),
+  brandTitle: z10.string().optional(),
+  menuRadius: z10.enum(["default", "none", "sm", "md", "lg", "xl", "full"]).optional()
 }).strict();
-var CustomIconSchema = z9.object({
-  color: z9.string().optional(),
-  url: z9.string().optional(),
-  type: z9.enum(["svg", "image"]).optional(),
-  hintTextColor: z9.string().optional()
+var CustomIconSchema = z10.object({
+  color: z10.string().optional(),
+  url: z10.string().optional(),
+  type: z10.enum(["svg", "image"]).optional(),
+  hintTextColor: z10.string().optional()
 }).strict();
-var WorkbenchCustomerToolSchema = z9.object({
+var WorkbenchCustomerToolSchema = z10.object({
   id: ContractIdentifierSchema,
-  label: z9.union([z9.string(), z9.record(LocaleIdentifierSchema, z9.string())]).optional(),
-  fixed: z9.boolean().optional()
+  label: z10.union([z10.string(), z10.record(LocaleIdentifierSchema, z10.string())]).optional(),
+  fixed: z10.boolean().optional()
 }).strict();
-var WorkbenchStudioOverrideSchema = z9.object({
-  studioName: z9.string().trim().min(1),
-  dropdownToolsDefault: z9.array(ContractIdentifierSchema).optional(),
-  existingToolsDefault: z9.array(ContractIdentifierSchema).optional(),
-  historyColumnsDefault: z9.number().int().min(1).max(6).optional()
+var WorkbenchStudioOverrideSchema = z10.object({
+  studioName: z10.string().trim().min(1),
+  dropdownToolsDefault: z10.array(ContractIdentifierSchema).optional(),
+  existingToolsDefault: z10.array(ContractIdentifierSchema).optional(),
+  historyColumnsDefault: z10.number().int().min(1).max(6).optional()
 }).strict();
-var TenantWorkbenchPageContextSchema = z9.object({
+var TenantWorkbenchPageContextSchema = z10.object({
   workflow: JsonObjectSchema.optional(),
   agent: JsonObjectSchema.optional(),
   agentId: ContractIdentifierSchema.optional(),
   designProject: JsonObjectSchema.optional(),
   designMetadataId: ContractIdentifierSchema.optional(),
-  iframeUrl: z9.string().trim().min(1).optional(),
-  info: z9.object({
+  iframeUrl: z10.string().trim().min(1).optional(),
+  info: z10.object({
     displayName: LocalizedTextSchema.optional(),
     description: LocalizedTextSchema.optional(),
-    iconUrl: z9.string().trim().min(1).optional()
+    iconUrl: z10.string().trim().min(1).optional()
   }).strict().optional(),
-  isBuiltinPinned: z9.boolean().optional(),
-  isBuiltinReadonly: z9.boolean().optional()
+  isBuiltinPinned: z10.boolean().optional(),
+  isBuiltinReadonly: z10.boolean().optional()
 }).strict();
-var TenantWorkbenchPageEnvelopeSchema = z9.object({
+var TenantWorkbenchPageEnvelopeSchema = z10.object({
   definition: PageDefinitionSchema,
   context: TenantWorkbenchPageContextSchema
 }).strict().superRefine(({ definition }, context) => {
@@ -11189,56 +11632,56 @@ var TenantWorkbenchPageEnvelopeSchema = z9.object({
     });
   }
 });
-var TenantWorkbenchPageGroupSchema = z9.object({
+var TenantWorkbenchPageGroupSchema = z10.object({
   id: ContractIdentifierSchema,
-  pageIds: z9.array(ContractIdentifierSchema),
+  pageIds: z10.array(ContractIdentifierSchema),
   displayName: LocalizedTextSchema,
-  isBuiltIn: z9.boolean(),
-  iconUrl: z9.string().optional(),
-  sortIndex: z9.number().int().nullable().optional(),
+  isBuiltIn: z10.boolean(),
+  iconUrl: z10.string().optional(),
+  sortIndex: z10.number().int().nullable().optional(),
   presetRelationId: ContractIdentifierSchema.optional(),
   relationKey: ContractIdentifierSchema.nullable().optional(),
   studioId: ContractIdentifierSchema.optional()
 }).strict();
-var TenantWorkbenchConfigSchema = z9.object({
-  pages: z9.array(TenantWorkbenchPageEnvelopeSchema),
-  pageGroups: z9.array(TenantWorkbenchPageGroupSchema),
-  catalog: z9.object({ enabled: z9.boolean().optional(), defaultEntry: z9.boolean().optional() }).strict().optional(),
-  quickSwitcherMaxItems: z9.number().int().nonnegative().optional(),
-  defaultOrder: z9.object({
-    groups: z9.array(ContractIdentifierSchema),
-    pages: z9.record(ContractIdentifierSchema, z9.array(ContractIdentifierSchema))
+var TenantWorkbenchConfigSchema = z10.object({
+  pages: z10.array(TenantWorkbenchPageEnvelopeSchema),
+  pageGroups: z10.array(TenantWorkbenchPageGroupSchema),
+  catalog: z10.object({ enabled: z10.boolean().optional(), defaultEntry: z10.boolean().optional() }).strict().optional(),
+  quickSwitcherMaxItems: z10.number().int().nonnegative().optional(),
+  defaultOrder: z10.object({
+    groups: z10.array(ContractIdentifierSchema),
+    pages: z10.record(ContractIdentifierSchema, z10.array(ContractIdentifierSchema))
   }).strict().optional(),
-  customers: z9.object({
-    dropdownToolsDefault: z9.array(ContractIdentifierSchema).optional(),
-    layoutManagerTools: z9.array(WorkbenchCustomerToolSchema).optional(),
-    studioTabsMode: z9.enum(["dropdown", "tabs"]).optional(),
-    historyWatermark: z9.object({
-      svgUrl: z9.string().optional(),
-      coverage: z9.array(z9.enum(["list", "detail", "download"])).optional(),
-      maxLongEdgeRatio: z9.number().positive().optional(),
-      sizing: z9.object({
+  customers: z10.object({
+    dropdownToolsDefault: z10.array(ContractIdentifierSchema).optional(),
+    layoutManagerTools: z10.array(WorkbenchCustomerToolSchema).optional(),
+    studioTabsMode: z10.enum(["dropdown", "tabs"]).optional(),
+    historyWatermark: z10.object({
+      svgUrl: z10.string().optional(),
+      coverage: z10.array(z10.enum(["list", "detail", "download"])).optional(),
+      maxLongEdgeRatio: z10.number().positive().optional(),
+      sizing: z10.object({
         mode: ContractIdentifierSchema,
-        heightRatio: z9.number().positive().optional(),
-        minHeightPx: z9.number().nonnegative().optional(),
-        maxHeightPx: z9.number().nonnegative().optional()
+        heightRatio: z10.number().positive().optional(),
+        minHeightPx: z10.number().nonnegative().optional(),
+        maxHeightPx: z10.number().nonnegative().optional()
       }).strict().optional(),
-      enhance: z9.object({
-        enabled: z9.boolean().optional(),
-        backgroundLumaThreshold: z9.number().min(0).max(1).optional(),
-        stroke: z9.object({
-          color: z9.string().optional(),
-          opacity: z9.number().min(0).max(1).optional(),
-          widthRatio: z9.number().nonnegative().optional(),
-          blurRatio: z9.number().nonnegative().optional(),
-          steps: z9.number().int().positive().optional()
+      enhance: z10.object({
+        enabled: z10.boolean().optional(),
+        backgroundLumaThreshold: z10.number().min(0).max(1).optional(),
+        stroke: z10.object({
+          color: z10.string().optional(),
+          opacity: z10.number().min(0).max(1).optional(),
+          widthRatio: z10.number().nonnegative().optional(),
+          blurRatio: z10.number().nonnegative().optional(),
+          steps: z10.number().int().positive().optional()
         }).strict().optional()
       }).strict().optional()
     }).strict().optional(),
-    layoutManagerEnabled: z9.boolean().optional(),
-    existingToolsDefault: z9.array(ContractIdentifierSchema).optional(),
-    historyColumnsDefault: z9.number().int().min(1).max(6).optional(),
-    studioOverrides: z9.array(WorkbenchStudioOverrideSchema).optional()
+    layoutManagerEnabled: z10.boolean().optional(),
+    existingToolsDefault: z10.array(ContractIdentifierSchema).optional(),
+    historyColumnsDefault: z10.number().int().min(1).max(6).optional(),
+    studioOverrides: z10.array(WorkbenchStudioOverrideSchema).optional()
   }).strict().optional()
 }).strict().superRefine(({ pages, pageGroups }, context) => {
   const pageIds = pages.map(({ definition }) => definition.pageId);
@@ -11262,31 +11705,31 @@ var TenantWorkbenchConfigSchema = z9.object({
     });
   });
 });
-var LoginPageSchema = z9.object({
-  background: z9.object({ imageUrl: z9.string().optional(), gradient: z9.string().optional() }).strict().optional(),
-  logo: z9.object({
-    url: z9.string().optional(),
-    lightUrl: z9.string().optional(),
-    darkUrl: z9.string().optional(),
-    position: z9.enum(["top", "middle", "bottom"]).optional(),
-    scale: z9.number().positive().optional()
+var LoginPageSchema = z10.object({
+  background: z10.object({ imageUrl: z10.string().optional(), gradient: z10.string().optional() }).strict().optional(),
+  logo: z10.object({
+    url: z10.string().optional(),
+    lightUrl: z10.string().optional(),
+    darkUrl: z10.string().optional(),
+    position: z10.enum(["top", "middle", "bottom"]).optional(),
+    scale: z10.number().positive().optional()
   }).strict().optional(),
-  customCss: z9.string().optional()
+  customCss: z10.string().optional()
 }).strict();
-var LandingPageDefaultConfigSchema = z9.object({
-  mode: z9.literal("default")
+var LandingPageDefaultConfigSchema = z10.object({
+  mode: z10.literal("default")
 }).strict();
-var LandingPageMarkdownConfigSchema = z9.object({
-  mode: z9.literal("markdown"),
-  content: z9.string()
+var LandingPageMarkdownConfigSchema = z10.object({
+  mode: z10.literal("markdown"),
+  content: z10.string()
 }).strict();
-var LandingPageHtmlConfigSchema = z9.object({
-  mode: z9.literal("html"),
-  content: z9.string()
+var LandingPageHtmlConfigSchema = z10.object({
+  mode: z10.literal("html"),
+  content: z10.string()
 }).strict();
-var LandingPageIframeConfigSchema = z9.object({
-  mode: z9.literal("iframe"),
-  url: z9.string().refine((value) => {
+var LandingPageIframeConfigSchema = z10.object({
+  mode: z10.literal("iframe"),
+  url: z10.string().refine((value) => {
     if (/^\/(?!\/)/.test(value)) {
       return !value.includes("\\");
     }
@@ -11298,241 +11741,241 @@ var LandingPageIframeConfigSchema = z9.object({
     }
   }, "Landing page iframe URL must use a root-relative path or HTTP(S) without embedded credentials.")
 }).strict();
-var TenantLandingPageConfigSchema = z9.discriminatedUnion("mode", [
+var TenantLandingPageConfigSchema = z10.discriminatedUnion("mode", [
   LandingPageDefaultConfigSchema,
   LandingPageMarkdownConfigSchema,
   LandingPageHtmlConfigSchema,
   LandingPageIframeConfigSchema
 ]);
-var TenantApplicationConfigSchema = z9.object({
-  theme: z9.object({
-    id: z9.string().optional(),
-    name: z9.string().optional(),
-    title: z9.string().optional(),
+var TenantApplicationConfigSchema = z10.object({
+  theme: z10.object({
+    id: z10.string().optional(),
+    name: z10.string().optional(),
+    title: z10.string().optional(),
     favicon: AssetVariantsSchema.optional(),
     logo: AssetVariantsSchema.optional(),
-    pwaIcon: z9.string().optional(),
-    form: z9.object({ variant: z9.enum(["bento", "ghost"]) }).strict().optional(),
-    toast: z9.object({
-      position: z9.enum(["top-right", "top-left", "bottom-right", "bottom-left", "top-center", "bottom-center"])
+    pwaIcon: z10.string().optional(),
+    form: z10.object({ variant: z10.enum(["bento", "ghost"]) }).strict().optional(),
+    toast: z10.object({
+      position: z10.enum(["top-right", "top-left", "bottom-right", "bottom-left", "top-center", "bottom-center"])
     }).strict().optional(),
-    icons: z9.object({ error: CustomIconSchema.optional(), empty: CustomIconSchema.optional() }).strict().optional(),
-    views: z9.object({
-      form: z9.object({
-        toast: z9.object({ afterCreate: z9.boolean(), afterDelete: z9.boolean() }).strict(),
-        progress: z9.enum(["estimate", "infinite"]),
-        onlyResult: z9.boolean(),
-        tabular: z9.object({ theme: z9.enum(["default", "tentiary", "primary"]) }).strict()
+    icons: z10.object({ error: CustomIconSchema.optional(), empty: CustomIconSchema.optional() }).strict().optional(),
+    views: z10.object({
+      form: z10.object({
+        toast: z10.object({ afterCreate: z10.boolean(), afterDelete: z10.boolean() }).strict(),
+        progress: z10.enum(["estimate", "infinite"]),
+        onlyResult: z10.boolean(),
+        tabular: z10.object({ theme: z10.enum(["default", "tentiary", "primary"]) }).strict()
       }).strict()
     }).strict().optional(),
     loginPage: LoginPageSchema.optional(),
-    extraLanguageURL: z9.record(z9.string(), z9.string()).optional(),
-    hideSpaceHeader: z9.boolean().optional(),
-    showSidebarTeamSelector: z9.boolean().optional(),
-    showWorkbenchSidebar: z9.boolean().optional(),
-    workbenchViewTheme: z9.enum(["default", "bsd-blue"]).optional(),
-    defaults: z9.object({
-      showFormInImageDetail: z9.boolean().optional(),
-      darkMode: z9.enum(["light", "dark", "auto"]).optional(),
-      language: z9.enum(["en-US", "zh-CN", "ja-JP"]).optional(),
-      showDarkModeToggle: z9.boolean().optional(),
-      showLanguageToggle: z9.boolean().optional()
+    extraLanguageURL: z10.record(z10.string(), z10.string()).optional(),
+    hideSpaceHeader: z10.boolean().optional(),
+    showSidebarTeamSelector: z10.boolean().optional(),
+    showWorkbenchSidebar: z10.boolean().optional(),
+    workbenchViewTheme: z10.enum(["default", "bsd-blue"]).optional(),
+    defaults: z10.object({
+      showFormInImageDetail: z10.boolean().optional(),
+      darkMode: z10.enum(["light", "dark", "auto"]).optional(),
+      language: z10.enum(["en-US", "zh-CN", "ja-JP"]).optional(),
+      showDarkModeToggle: z10.boolean().optional(),
+      showLanguageToggle: z10.boolean().optional()
     }).strict().optional(),
-    modules: z9.object({
-      monkeysSpaceSidebar: z9.union([z9.literal("*"), z9.array(ContractIdentifierSchema)]).optional(),
-      monkeysSpaceHeadbar: z9.union([
-        z9.literal("*"),
-        z9.array(TenantHeadbarModuleItemSchema)
+    modules: z10.object({
+      monkeysSpaceSidebar: z10.union([z10.literal("*"), z10.array(ContractIdentifierSchema)]).optional(),
+      monkeysSpaceHeadbar: z10.union([
+        z10.literal("*"),
+        z10.array(TenantHeadbarModuleItemSchema)
       ]).optional(),
-      settingsSidebar: z9.union([z9.literal("*"), z9.array(ContractIdentifierSchema)]).optional()
+      settingsSidebar: z10.union([z10.literal("*"), z10.array(ContractIdentifierSchema)]).optional()
     }).strict().optional(),
     headbar: ThemeHeadbarSchema.optional(),
-    kernelLayout: z9.object({
-      navigationMode: z9.enum(["sidebar", "topbar"]).optional(),
-      allowNavigationModeSwitch: z9.boolean().optional(),
+    kernelLayout: z10.object({
+      navigationMode: z10.enum(["sidebar", "topbar"]).optional(),
+      allowNavigationModeSwitch: z10.boolean().optional(),
       headbar: KernelHeadbarSchema.optional()
     }).strict().optional(),
-    paginationPosition: z9.enum(["left", "right"]).optional(),
-    ugcViewIconOnlyMode: z9.boolean().optional(),
-    workflowPreviewExecutionGrid: z9.object({
-      selectionModeDisplayType: z9.enum(["operation-button", "dropdown-menu"]).optional(),
-      clickBehavior: z9.enum(["preview", "select", "fill-form", "none"]).optional(),
-      showErrorFilter: z9.boolean().optional(),
-      displayType: z9.enum(["grid", "masonry"]).optional(),
-      showDetailButton: z9.boolean().optional()
+    paginationPosition: z10.enum(["left", "right"]).optional(),
+    ugcViewIconOnlyMode: z10.boolean().optional(),
+    workflowPreviewExecutionGrid: z10.object({
+      selectionModeDisplayType: z10.enum(["operation-button", "dropdown-menu"]).optional(),
+      clickBehavior: z10.enum(["preview", "select", "fill-form", "none"]).optional(),
+      showErrorFilter: z10.boolean().optional(),
+      displayType: z10.enum(["grid", "masonry"]).optional(),
+      showDetailButton: z10.boolean().optional()
     }).strict().optional(),
-    workbenchSidebarDefaultOpen: z9.boolean().optional(),
-    workbenchSidebarMoreAction: z9.boolean().optional(),
-    workbenchSidebarApart: z9.boolean().optional(),
-    workbenchSidebarToggleGroupDetail: z9.boolean().optional(),
-    workbenchSidebarViewType: z9.boolean().optional(),
-    workbenchSidebarFormViewEmbed: z9.boolean().optional(),
-    workbenchSidebarModernMode: z9.boolean().optional(),
-    ugc: z9.object({ onItemClick: z9.boolean(), subtitle: z9.boolean().optional() }).strict().optional(),
-    uniImagePreview: z9.boolean().optional(),
-    imagePreviewStyle: z9.union([z9.literal(false), z9.enum(["simple", "normal", "uni"])]).optional(),
-    teamAsUser: z9.boolean().optional(),
-    themeMode: z9.enum(["shadow", "border"]).optional(),
-    density: z9.enum(["compact", "default", "comfortable"]).optional(),
-    pageZoom: z9.number().positive().optional(),
-    miniMode: z9.object({ showPreviewViewExecutionResultGrid: z9.boolean() }).strict().optional(),
-    workflow: z9.object({ allowConcurrentRuns: z9.boolean() }).strict().optional(),
-    historyResult: z9.object({ display: z9.boolean() }).strict().optional(),
-    uploader: z9.object({
-      orientation: z9.enum(["vertical", "horizontal"]),
-      pasteButton: z9.boolean(),
-      statusText: z9.boolean()
+    workbenchSidebarDefaultOpen: z10.boolean().optional(),
+    workbenchSidebarMoreAction: z10.boolean().optional(),
+    workbenchSidebarApart: z10.boolean().optional(),
+    workbenchSidebarToggleGroupDetail: z10.boolean().optional(),
+    workbenchSidebarViewType: z10.boolean().optional(),
+    workbenchSidebarFormViewEmbed: z10.boolean().optional(),
+    workbenchSidebarModernMode: z10.boolean().optional(),
+    ugc: z10.object({ onItemClick: z10.boolean(), subtitle: z10.boolean().optional() }).strict().optional(),
+    uniImagePreview: z10.boolean().optional(),
+    imagePreviewStyle: z10.union([z10.literal(false), z10.enum(["simple", "normal", "uni"])]).optional(),
+    teamAsUser: z10.boolean().optional(),
+    themeMode: z10.enum(["shadow", "border"]).optional(),
+    density: z10.enum(["compact", "default", "comfortable"]).optional(),
+    pageZoom: z10.number().positive().optional(),
+    miniMode: z10.object({ showPreviewViewExecutionResultGrid: z10.boolean() }).strict().optional(),
+    workflow: z10.object({ allowConcurrentRuns: z10.boolean() }).strict().optional(),
+    historyResult: z10.object({ display: z10.boolean() }).strict().optional(),
+    uploader: z10.object({
+      orientation: z10.enum(["vertical", "horizontal"]),
+      pasteButton: z10.boolean(),
+      statusText: z10.boolean()
     }).strict().optional(),
-    designProjects: z9.object({
-      oneOnOne: z9.boolean(),
-      newTabOpenBoard: z9.boolean(),
-      defaultShowGrid: z9.boolean().optional(),
-      createDefaultFrame: z9.boolean(),
-      showPageMenu: z9.boolean(),
-      showMainMenu: z9.boolean(),
-      showStylePanel: z9.boolean(),
-      showToolbar: z9.boolean(),
-      toolbarPosition: z9.enum(["bottom", "left"]).optional(),
-      showContextMenu: z9.boolean(),
-      showActionsMenu: z9.boolean(),
-      showPageAndLayerSidebar: z9.boolean().optional(),
-      showBoardOperationSidebar: z9.boolean().optional(),
-      showMiniToolsToolbar: z9.boolean().optional(),
-      showRightSidebar: z9.boolean().optional(),
-      showRealtimeDrawing: z9.boolean().optional(),
-      showWorkflow: z9.boolean().optional(),
-      showVersionManager: z9.boolean().optional(),
-      showAgent: z9.boolean().optional(),
-      AgentTools: z9.array(ContractIdentifierSchema).optional()
+    designProjects: z10.object({
+      oneOnOne: z10.boolean(),
+      newTabOpenBoard: z10.boolean(),
+      defaultShowGrid: z10.boolean().optional(),
+      createDefaultFrame: z10.boolean(),
+      showPageMenu: z10.boolean(),
+      showMainMenu: z10.boolean(),
+      showStylePanel: z10.boolean(),
+      showToolbar: z10.boolean(),
+      toolbarPosition: z10.enum(["bottom", "left"]).optional(),
+      showContextMenu: z10.boolean(),
+      showActionsMenu: z10.boolean(),
+      showPageAndLayerSidebar: z10.boolean().optional(),
+      showBoardOperationSidebar: z10.boolean().optional(),
+      showMiniToolsToolbar: z10.boolean().optional(),
+      showRightSidebar: z10.boolean().optional(),
+      showRealtimeDrawing: z10.boolean().optional(),
+      showWorkflow: z10.boolean().optional(),
+      showVersionManager: z10.boolean().optional(),
+      showAgent: z10.boolean().optional(),
+      AgentTools: z10.array(ContractIdentifierSchema).optional()
     }).strict().optional(),
     workbench: TenantWorkbenchConfigSchema.optional(),
-    visionProWorkflows: z9.array(ContractIdentifierSchema).optional(),
-    initTeam: z9.boolean().optional(),
-    imageThumbnail: z9.boolean().optional(),
-    pages: z9.object({
-      allowPageKeys: z9.union([z9.literal("*"), z9.array(ContractIdentifierSchema)]),
+    visionProWorkflows: z10.array(ContractIdentifierSchema).optional(),
+    initTeam: z10.boolean().optional(),
+    imageThumbnail: z10.boolean().optional(),
+    pages: z10.object({
+      allowPageKeys: z10.union([z10.literal("*"), z10.array(ContractIdentifierSchema)]),
       defaultPageKey: ContractIdentifierSchema.optional()
     }).strict().optional(),
-    agent: z9.object({
+    agent: z10.object({
       logo: AssetVariantsSchema.optional(),
-      brandDisplayMode: z9.enum(["auto", "logo-only", "logo-name", "name-only"]).optional(),
-      density: z9.enum(["compact", "default", "comfortable"]).optional()
+      brandDisplayMode: z10.enum(["auto", "logo-only", "logo-name", "name-only"]).optional(),
+      density: z10.enum(["compact", "default", "comfortable"]).optional()
     }).strict().optional()
   }).strict(),
   landingPage: TenantLandingPageConfigSchema.optional(),
-  auth: z9.object({
-    enabled: z9.array(ContractIdentifierSchema).default([]),
-    oidc: z9.object({ buttonText: z9.string().optional(), autoSignin: z9.boolean().optional() }).strict().optional(),
-    password: z9.object({ disableAutoRegister: z9.boolean().optional() }).strict().optional(),
-    hideAuthToast: z9.boolean().optional(),
-    autoReload: z9.boolean().optional(),
-    defaultOtherTeam: z9.boolean().optional()
+  auth: z10.object({
+    enabled: z10.array(ContractIdentifierSchema).default([]),
+    oidc: z10.object({ buttonText: z10.string().optional(), autoSignin: z10.boolean().optional() }).strict().optional(),
+    password: z10.object({ disableAutoRegister: z10.boolean().optional() }).strict().optional(),
+    hideAuthToast: z10.boolean().optional(),
+    autoReload: z10.boolean().optional(),
+    defaultOtherTeam: z10.boolean().optional()
   }).strict(),
-  endpoints: z9.record(ContractIdentifierSchema, z9.string()),
-  module: z9.union([z9.literal("*"), z9.array(ContractIdentifierSchema)]),
-  behavior: z9.object({
-    clearWorkflowFormStorageAfterUpdate: z9.boolean().optional(),
-    autoApproveOAuth: z9.boolean().optional(),
-    rememberWorkflowModelSelection: z9.boolean().optional()
+  endpoints: z10.record(ContractIdentifierSchema, z10.string()),
+  module: z10.union([z10.literal("*"), z10.array(ContractIdentifierSchema)]),
+  behavior: z10.object({
+    clearWorkflowFormStorageAfterUpdate: z10.boolean().optional(),
+    autoApproveOAuth: z10.boolean().optional(),
+    rememberWorkflowModelSelection: z10.boolean().optional()
   }).strict(),
-  dataManagement: z9.object({
-    favoriteOntologyId: z9.string().optional(),
-    pairedOntologyId: z9.string().optional(),
-    galleryOntologyId: z9.string().optional(),
-    dataBrowserDefaultOntologyId: z9.string().optional(),
-    workflowResultOntologyId: z9.string().optional(),
-    homeAdvertisement: z9.object({
+  dataManagement: z10.object({
+    favoriteOntologyId: z10.string().optional(),
+    pairedOntologyId: z10.string().optional(),
+    galleryOntologyId: z10.string().optional(),
+    dataBrowserDefaultOntologyId: z10.string().optional(),
+    workflowResultOntologyId: z10.string().optional(),
+    homeAdvertisement: z10.object({
       ontologyId: ContractIdentifierSchema,
       viewId: ContractIdentifierSchema.optional(),
-      viewType: z9.enum(["filter", "container", "share_link"]).optional(),
+      viewType: z10.enum(["filter", "container", "share_link"]).optional(),
       teamId: ContractIdentifierSchema.optional(),
-      teamOnly: z9.boolean().optional(),
-      pageSize: z9.number().int().positive().optional(),
-      sortBy: z9.enum(["pin_order", "asset_id", "updated_timestamp", "created_timestamp"]).optional(),
-      sortOrder: z9.enum(["asc", "desc"]).optional(),
-      fieldMap: z9.record(z9.string(), z9.string()).optional(),
-      columnIds: z9.record(z9.string(), z9.string()).optional()
+      teamOnly: z10.boolean().optional(),
+      pageSize: z10.number().int().positive().optional(),
+      sortBy: z10.enum(["pin_order", "asset_id", "updated_timestamp", "created_timestamp"]).optional(),
+      sortOrder: z10.enum(["asc", "desc"]).optional(),
+      fieldMap: z10.record(z10.string(), z10.string()).optional(),
+      columnIds: z10.record(z10.string(), z10.string()).optional()
     }).strict().optional(),
-    homeTrendAssistant: z9.object({
+    homeTrendAssistant: z10.object({
       ontologyId: ContractIdentifierSchema.optional(),
       viewId: ContractIdentifierSchema.optional(),
       viewInstanceId: ContractIdentifierSchema.optional(),
-      viewName: z9.string().optional(),
+      viewName: z10.string().optional(),
       teamId: ContractIdentifierSchema.optional(),
       designOptionsWorkflowId: ContractIdentifierSchema.optional(),
-      tep: z9.object({ baseUrl: z9.string().optional(), timeoutMs: z9.number().int().positive().optional() }).strict().optional(),
-      runtime: z9.object({ appId: ContractIdentifierSchema, tepBaseUrlConfigured: z9.boolean(), tepAuthorizationConfigured: z9.boolean(), tepCookieConfigured: z9.boolean() }).strict().optional()
+      tep: z10.object({ baseUrl: z10.string().optional(), timeoutMs: z10.number().int().positive().optional() }).strict().optional(),
+      runtime: z10.object({ appId: ContractIdentifierSchema, tepBaseUrlConfigured: z10.boolean(), tepAuthorizationConfigured: z10.boolean(), tepCookieConfigured: z10.boolean() }).strict().optional()
     }).strict().optional(),
-    sharing: z9.object({
-      silentViewLinks: z9.object({ enabled: z9.boolean().optional(), placement: z9.object({ mode: z9.enum(["sourceOntology", "ontology"]).optional(), ontologyId: ContractIdentifierSchema.optional(), parentId: ContractIdentifierSchema.optional(), navId: ContractIdentifierSchema.optional() }).strict().optional() }).strict().optional(),
-      shareAccess: z9.object({ publicLinksEnabled: z9.boolean().optional(), passwordGateEnabled: z9.boolean().optional(), passwordAccessTtlSeconds: z9.number().int().positive().optional(), defaultViewTreeDelivery: z9.enum(["manual", "auto"]).optional() }).strict().optional(),
-      shareDialog: z9.object({
-        audience: z9.object({ enabled: z9.boolean().optional(), allowed: z9.array(z9.enum(["user", "team", "public"])).optional(), default: z9.enum(["user", "team", "public"]).optional() }).strict().optional(),
-        accessLevel: z9.object({ enabled: z9.boolean().optional(), allowed: z9.array(z9.enum(["read", "write"])).optional(), default: z9.enum(["read", "write"]).optional() }).strict().optional(),
-        viewTreeDelivery: z9.object({ enabled: z9.boolean().optional(), allowed: z9.array(z9.enum(["manual", "auto"])).optional(), default: z9.enum(["manual", "auto"]).optional() }).strict().optional()
+    sharing: z10.object({
+      silentViewLinks: z10.object({ enabled: z10.boolean().optional(), placement: z10.object({ mode: z10.enum(["sourceOntology", "ontology"]).optional(), ontologyId: ContractIdentifierSchema.optional(), parentId: ContractIdentifierSchema.optional(), navId: ContractIdentifierSchema.optional() }).strict().optional() }).strict().optional(),
+      shareAccess: z10.object({ publicLinksEnabled: z10.boolean().optional(), passwordGateEnabled: z10.boolean().optional(), passwordAccessTtlSeconds: z10.number().int().positive().optional(), defaultViewTreeDelivery: z10.enum(["manual", "auto"]).optional() }).strict().optional(),
+      shareDialog: z10.object({
+        audience: z10.object({ enabled: z10.boolean().optional(), allowed: z10.array(z10.enum(["user", "team", "public"])).optional(), default: z10.enum(["user", "team", "public"]).optional() }).strict().optional(),
+        accessLevel: z10.object({ enabled: z10.boolean().optional(), allowed: z10.array(z10.enum(["read", "write"])).optional(), default: z10.enum(["read", "write"]).optional() }).strict().optional(),
+        viewTreeDelivery: z10.object({ enabled: z10.boolean().optional(), allowed: z10.array(z10.enum(["manual", "auto"])).optional(), default: z10.enum(["manual", "auto"]).optional() }).strict().optional()
       }).strict().optional()
     }).strict().optional()
   }).strict().optional(),
-  compute: z9.object({
-    integrations: z9.object({
-      harbor: z9.object({ endpoint: z9.string().optional(), projectScopes: z9.array(z9.string()).optional(), authMode: z9.string().optional(), principal: z9.string().optional(), autoSync: z9.boolean().optional(), proxyUrl: z9.string().optional() }).strict().optional(),
-      gitlab: z9.object({ baseUrl: z9.string().optional(), groupScopes: z9.array(z9.string()).optional(), tokenMode: z9.string().optional(), deployProjectPath: z9.string().optional(), deploymentReportsEnabled: z9.boolean().optional(), proxyUrl: z9.string().optional() }).strict().optional(),
-      kubernetes: z9.object({ accessMode: z9.string().optional(), clusterAlias: z9.string().optional(), agentProjectPath: z9.string().optional(), agentName: z9.string().optional(), namespaceScopes: z9.array(z9.string()).optional(), rolloutObserverEnabled: z9.boolean().optional(), proxyUrl: z9.string().optional() }).strict().optional()
+  compute: z10.object({
+    integrations: z10.object({
+      harbor: z10.object({ endpoint: z10.string().optional(), projectScopes: z10.array(z10.string()).optional(), authMode: z10.string().optional(), principal: z10.string().optional(), autoSync: z10.boolean().optional(), proxyUrl: z10.string().optional() }).strict().optional(),
+      gitlab: z10.object({ baseUrl: z10.string().optional(), groupScopes: z10.array(z10.string()).optional(), tokenMode: z10.string().optional(), deployProjectPath: z10.string().optional(), deploymentReportsEnabled: z10.boolean().optional(), proxyUrl: z10.string().optional() }).strict().optional(),
+      kubernetes: z10.object({ accessMode: z10.string().optional(), clusterAlias: z10.string().optional(), agentProjectPath: z10.string().optional(), agentName: z10.string().optional(), namespaceScopes: z10.array(z10.string()).optional(), rolloutObserverEnabled: z10.boolean().optional(), proxyUrl: z10.string().optional() }).strict().optional()
     }).strict().optional()
   }).strict().optional(),
-  data: z9.object({}).strict().optional(),
-  storage: z9.object({
-    presignMode: z9.enum(["frontend", "backend", "both"]).optional(),
-    presign: z9.object({
-      expiresInSeconds: z9.number().int().positive(),
-      buckets: z9.array(
-        z9.object({
+  data: z10.object({}).strict().optional(),
+  storage: z10.object({
+    presignMode: z10.enum(["frontend", "backend", "both"]).optional(),
+    presign: z10.object({
+      expiresInSeconds: z10.number().int().positive(),
+      buckets: z10.array(
+        z10.object({
           id: ContractIdentifierSchema,
           provider: ContractIdentifierSchema,
           preferredUrlPatternId: ContractIdentifierSchema,
-          urlPatterns: z9.array(
-            z9.object({
+          urlPatterns: z10.array(
+            z10.object({
               id: ContractIdentifierSchema,
-              type: z9.enum(["bucket-hostname", "provider-hostname"]),
-              hostname: z9.string().trim().min(1),
-              preferred: z9.boolean().optional(),
-              bucketSegment: z9.string().optional()
+              type: z10.enum(["bucket-hostname", "provider-hostname"]),
+              hostname: z10.string().trim().min(1),
+              preferred: z10.boolean().optional(),
+              bucketSegment: z10.string().optional()
             }).strict()
           )
         }).strict()
       )
     }).strict().optional()
   }).strict().optional(),
-  monkeyData: z9.object({ baseUrl: z9.string().optional() }).strict().optional()
+  monkeyData: z10.object({ baseUrl: z10.string().optional() }).strict().optional()
 }).strict();
-var TenantProductConfigSchema = z9.object({
-  contract: z9.literal("TenantProductConfig"),
+var TenantProductConfigSchema = z10.object({
+  contract: z10.literal("TenantProductConfig"),
   tenantId: ContractIdentifierSchema,
   appId: ContractIdentifierSchema,
   environment: ContractIdentifierSchema,
   designTokens: TenantDesignTokensConfigSchema,
-  moduleRefs: z9.array(ContractIdentifierSchema).default([]),
-  pageRefs: z9.array(ContractIdentifierSchema).default([]),
-  featureFlags: z9.record(z9.string(), z9.boolean()).default({}),
+  moduleRefs: z10.array(ContractIdentifierSchema).default([]),
+  pageRefs: z10.array(ContractIdentifierSchema).default([]),
+  featureFlags: z10.record(z10.string(), z10.boolean()).default({}),
   authBinding: TenantAuthBindingsSchema,
   dataBinding: TenantDataBindingsSchema,
-  sourceMap: z9.record(z9.string(), ContractIdentifierSchema),
-  warnings: z9.array(z9.string()).default([]),
+  sourceMap: z10.record(z10.string(), ContractIdentifierSchema),
+  warnings: z10.array(z10.string()).default([]),
   applicationConfig: TenantApplicationConfigSchema
 }).strict();
-var TenantRuntimeConfigSchema = z9.object({
-  contract: z9.literal("TenantRuntimeConfig"),
+var TenantRuntimeConfigSchema = z10.object({
+  contract: z10.literal("TenantRuntimeConfig"),
   tenantId: ContractIdentifierSchema,
   appId: ContractIdentifierSchema,
   environment: ContractIdentifierSchema,
   designTokens: ResolvedThemeTokensSchema,
-  moduleRefs: z9.array(ContractIdentifierSchema).default([]),
-  pageRefs: z9.array(ContractIdentifierSchema).default([]),
-  featureFlags: z9.record(z9.string(), z9.boolean()).default({}),
+  moduleRefs: z10.array(ContractIdentifierSchema).default([]),
+  pageRefs: z10.array(ContractIdentifierSchema).default([]),
+  featureFlags: z10.record(z10.string(), z10.boolean()).default({}),
   authBinding: TenantAuthBindingsSchema,
   dataBinding: TenantDataBindingsSchema,
-  sourceMap: z9.record(z9.string(), ContractIdentifierSchema),
-  warnings: z9.array(z9.string()).default([]),
+  sourceMap: z10.record(z10.string(), ContractIdentifierSchema),
+  warnings: z10.array(z10.string()).default([]),
   applicationConfig: TenantApplicationConfigSchema
 }).strict();
 
@@ -11827,6 +12270,7 @@ export {
   compileViewProviderRegistry,
   compileWorkflowDefinitionFromConductor,
   compileWorkflowPersistenceProjection,
+  createAgentSessionEventProjection,
   createCapabilityRegistrySource,
   createOpenApiCapabilityRegistrySource,
   createToolCapabilityManifest,
@@ -11834,10 +12278,12 @@ export {
   extractOpenApiCapabilityManifests,
   mergeThemeTokenDocuments,
   parseApplicationHandoff,
+  projectAgentSessionEvents,
   publishOpenApiToolCapabilityManifests,
   readApplicationHandoffFromUrl,
   resolveThemeTokens,
   serializeApplicationHandoff,
+  toAgentSessionViewModel,
   validateDomainCommand,
   validateThemeTokensDocument,
   validateThemeTokensDocumentStructure