skedyul 1.7.26 → 1.7.28

package/dist/cli/index.js

@@ -1855,8 +1855,9 @@ var file = {
   /**
    * Upload file content and create a File record.
    *
-   * Files are scoped to the app installation and stored privately.
+   * Files are stored privately under workplaces/{subdomain}/files/{timestamp}-{name}.
    * Use file.getUrl() to generate a temporary download URL when needed.
+   * The optional `path` argument is accepted for compatibility but ignored for the S3 key.
    *
    * @example
    * ```ts
@@ -1867,14 +1868,6 @@ var file = {
    *   name: 'document.pdf',
    *   mimeType: 'application/pdf',
    * })
-   *
-   * // Upload with a path prefix for organization
-   * const { id } = await file.upload({
-   *   content: imageBuffer,
-   *   name: 'photo.jpg',
-   *   mimeType: 'image/jpeg',
-   *   path: 'attachments',
-   * })
    * ```
    */
   async upload(params) {
@@ -2290,6 +2283,586 @@ Example: skedyul dev invoke ${toolName} --workplace ${linkedWorkplaces[0]}`);
 var fs6 = __toESM(require("fs"));
 var path6 = __toESM(require("path"));
 init_utils();
+
+// src/cli/api/context.ts
+function cliApi(ctx) {
+  return {
+    serverUrl: ctx.serverUrl,
+    token: ctx.token
+  };
+}
+async function getWorkplaceToken(ctx, workplaceSubdomain) {
+  return callCliApi(cliApi(ctx), "/workplace-token", {
+    workplaceSubdomain
+  });
+}
+
+// src/cli/api/crm.ts
+async function listModels(ctx, workplace) {
+  const workplaceToken = await getWorkplaceToken(ctx, workplace);
+  const result = await callCliApi(
+    cliApi(ctx),
+    "/crm-models",
+    void 0,
+    { method: "GET", query: { workplaceId: workplaceToken.workplaceId } }
+  );
+  if (!result.success) {
+    throw new Error(result.error || "Failed to list models");
+  }
+  return result.models;
+}
+async function pullSchema(ctx, workplace) {
+  const workplaceToken = await getWorkplaceToken(ctx, workplace);
+  const result = await callCliApi(
+    cliApi(ctx),
+    "/crm-schema",
+    void 0,
+    { method: "GET", query: { workplaceId: workplaceToken.workplaceId } }
+  );
+  if (!result.success) {
+    throw new Error(result.error || "Failed to pull schema");
+  }
+  return { schema: result.schema, workplaceName: result.workplaceName };
+}
+async function postSchema(ctx, workplace, schema, options) {
+  const workplaceToken = await getWorkplaceToken(ctx, workplace);
+  return callCliApi(cliApi(ctx), "/crm-schema", {
+    workplace,
+    workplaceId: workplaceToken.workplaceId,
+    schema,
+    dryRun: options.dryRun ?? false,
+    autoApprove: options.autoApprove ?? false,
+    schemaName: schema.name,
+    schemaVersion: schema.version
+  });
+}
+async function diffSchema(ctx, workplace, schema) {
+  return postSchema(ctx, workplace, schema, { dryRun: true });
+}
+async function approveMigration(ctx, migrationId) {
+  await callCliApi(cliApi(ctx), "/approve-migration", { migrationId });
+}
+async function pushSchema(ctx, workplace, schema, options = {}) {
+  const result = await postSchema(ctx, workplace, schema, {
+    dryRun: options.dryRun ?? false,
+    autoApprove: options.autoApprove ?? false
+  });
+  if (!options.dryRun && options.autoApprove && result.requiresApproval && result.migrationId) {
+    await approveMigration(ctx, result.migrationId);
+    return {
+      ...result,
+      requiresApproval: false
+    };
+  }
+  return result;
+}
+
+// src/cli/api/workflows.ts
+var import_yaml = require("yaml");
+
+// src/workflows/types.ts
+var import_v44 = require("zod/v4");
+
+// src/events/types.ts
+var import_v42 = require("zod/v4");
+var ThreadEventTypeSchema = import_v42.z.enum([
+  // Message events
+  "thread.message.received",
+  "thread.message.sent",
+  "thread.attachment.received",
+  // Participant events
+  "thread.participant.joined",
+  "thread.participant.left",
+  "thread.participant.mentioned",
+  // Context events
+  "thread.context.changed",
+  "thread.status.changed",
+  // Agent/Workflow events
+  "thread.agent.delegated",
+  "thread.agent.completed",
+  "thread.workflow.triggered",
+  "thread.workflow.completed",
+  // Scheduled events
+  "thread.follow_up.due",
+  "thread.reminder.due",
+  // Signal events
+  "thread.signal.created"
+]);
+var CustomEventTypeSchema = import_v42.z.string().regex(/^custom\.[a-z][a-z0-9_]*(\.[a-z][a-z0-9_]*)*$/, {
+  message: "Custom event type must match pattern: custom.{namespace}.{event}"
+});
+var EventTypeSchema = import_v42.z.union([ThreadEventTypeSchema, CustomEventTypeSchema]);
+var ParticipantKindSchema = import_v42.z.enum(["CONTACT", "MEMBER", "AGENT", "WORKFLOW"]);
+var BaseEventPayloadSchema = import_v42.z.object({
+  threadId: import_v42.z.string(),
+  workplaceId: import_v42.z.string(),
+  timestamp: import_v42.z.string().datetime().optional()
+});
+var MessageEventPayloadSchema = BaseEventPayloadSchema.extend({
+  message: import_v42.z.object({
+    id: import_v42.z.string(),
+    content: import_v42.z.string(),
+    senderId: import_v42.z.string().optional()
+  }),
+  participant: import_v42.z.object({
+    id: import_v42.z.string(),
+    kind: ParticipantKindSchema,
+    displayName: import_v42.z.string().optional()
+  }).optional(),
+  isFirstMessage: import_v42.z.boolean().optional(),
+  messageCount: import_v42.z.number().optional()
+});
+var ParticipantEventPayloadSchema = BaseEventPayloadSchema.extend({
+  participant: import_v42.z.object({
+    id: import_v42.z.string(),
+    kind: ParticipantKindSchema,
+    displayName: import_v42.z.string().optional(),
+    contactId: import_v42.z.string().optional(),
+    memberId: import_v42.z.string().optional(),
+    agentId: import_v42.z.string().optional(),
+    workflowId: import_v42.z.string().optional()
+  })
+});
+var ContextChangedPayloadSchema = BaseEventPayloadSchema.extend({
+  context: import_v42.z.object({
+    handle: import_v42.z.string(),
+    model: import_v42.z.string(),
+    instanceId: import_v42.z.string()
+  }),
+  change: import_v42.z.object({
+    field: import_v42.z.string().optional(),
+    oldValue: import_v42.z.unknown().optional(),
+    newValue: import_v42.z.unknown().optional()
+  }).optional()
+});
+var StatusChangedPayloadSchema = BaseEventPayloadSchema.extend({
+  oldStatus: import_v42.z.string(),
+  newStatus: import_v42.z.string()
+});
+var ScheduledEventPayloadSchema = BaseEventPayloadSchema.extend({
+  scheduledEventId: import_v42.z.string(),
+  reason: import_v42.z.string().optional(),
+  context: import_v42.z.record(import_v42.z.string(), import_v42.z.unknown()).optional()
+});
+var AgentWorkflowEventPayloadSchema = BaseEventPayloadSchema.extend({
+  agentId: import_v42.z.string().optional(),
+  workflowId: import_v42.z.string().optional(),
+  workflowRunId: import_v42.z.string().optional(),
+  outputs: import_v42.z.record(import_v42.z.string(), import_v42.z.unknown()).optional(),
+  error: import_v42.z.string().optional()
+});
+var CustomEventPayloadSchema = BaseEventPayloadSchema.extend({
+  data: import_v42.z.record(import_v42.z.string(), import_v42.z.unknown()).optional()
+});
+var ThreadEventPayloadSchema = import_v42.z.union([
+  MessageEventPayloadSchema,
+  ParticipantEventPayloadSchema,
+  ContextChangedPayloadSchema,
+  StatusChangedPayloadSchema,
+  ScheduledEventPayloadSchema,
+  AgentWorkflowEventPayloadSchema,
+  CustomEventPayloadSchema
+]);
+var ThreadEventSchema = import_v42.z.object({
+  id: import_v42.z.string(),
+  threadId: import_v42.z.string(),
+  type: EventTypeSchema,
+  payload: ThreadEventPayloadSchema,
+  emittedBy: import_v42.z.string().optional(),
+  createdAt: import_v42.z.string().datetime()
+});
+var CreateThreadEventInputSchema = import_v42.z.object({
+  threadId: import_v42.z.string(),
+  type: EventTypeSchema,
+  payload: import_v42.z.record(import_v42.z.string(), import_v42.z.unknown()),
+  emittedBy: import_v42.z.string().optional()
+});
+var EventSubscriptionSchema = import_v42.z.object({
+  subscribes: import_v42.z.array(EventTypeSchema),
+  condition: import_v42.z.string().optional(),
+  cancels: import_v42.z.array(EventTypeSchema).optional(),
+  cancelCondition: import_v42.z.string().optional()
+});
+var EventWaitSchema = import_v42.z.object({
+  event: EventTypeSchema,
+  timeout: import_v42.z.string().optional(),
+  onTimeout: import_v42.z.string().optional()
+});
+var EventsConfigSchema = import_v42.z.object({
+  subscribes: import_v42.z.array(EventTypeSchema).optional(),
+  condition: import_v42.z.string().optional(),
+  emits: import_v42.z.array(EventTypeSchema).optional(),
+  waits: import_v42.z.array(EventWaitSchema).optional(),
+  cancels: import_v42.z.array(EventTypeSchema).optional(),
+  cancelCondition: import_v42.z.string().optional()
+});
+
+// src/triggers/types.ts
+var import_v43 = require("zod/v4");
+var CRMDataSchema = import_v43.z.object({
+  model: import_v43.z.string(),
+  instanceId: import_v43.z.string(),
+  data: import_v43.z.record(import_v43.z.string(), import_v43.z.unknown())
+});
+var SenderContextSchema = import_v43.z.object({
+  kind: ParticipantKindSchema,
+  displayName: import_v43.z.string().optional(),
+  crm: CRMDataSchema.optional()
+});
+var ThreadContextItemSchema = import_v43.z.object({
+  handle: import_v43.z.string(),
+  model: import_v43.z.string(),
+  instanceId: import_v43.z.string(),
+  data: import_v43.z.record(import_v43.z.string(), import_v43.z.unknown()).optional()
+});
+var ParticipantContextSchema = import_v43.z.object({
+  id: import_v43.z.string(),
+  kind: ParticipantKindSchema,
+  displayName: import_v43.z.string().optional(),
+  contactId: import_v43.z.string().optional(),
+  memberId: import_v43.z.string().optional(),
+  agentId: import_v43.z.string().optional(),
+  workflowId: import_v43.z.string().optional()
+});
+var TriggerContextSchema = import_v43.z.object({
+  // The event that triggered this
+  event: import_v43.z.object({
+    type: EventTypeSchema,
+    payload: import_v43.z.record(import_v43.z.string(), import_v43.z.unknown()),
+    participant: ParticipantContextSchema.optional()
+  }),
+  // Thread information
+  thread: import_v43.z.object({
+    id: import_v43.z.string(),
+    title: import_v43.z.string().optional(),
+    status: import_v43.z.string().optional(),
+    sender: SenderContextSchema.optional(),
+    context: import_v43.z.record(import_v43.z.string(), CRMDataSchema).optional(),
+    participants: import_v43.z.array(ParticipantContextSchema).optional()
+  }),
+  // Workplace info
+  workplace: import_v43.z.object({
+    id: import_v43.z.string(),
+    name: import_v43.z.string().optional(),
+    settings: import_v43.z.record(import_v43.z.string(), import_v43.z.unknown()).optional()
+  })
+});
+var InputMappingSchema = import_v43.z.record(import_v43.z.string(), import_v43.z.string());
+var EventConditionsSchema = import_v43.z.record(import_v43.z.string(), import_v43.z.string());
+var TriggerConfigSchema = import_v43.z.object({
+  id: import_v43.z.string(),
+  workflowId: import_v43.z.string(),
+  workflowVersionId: import_v43.z.string().optional(),
+  workplaceId: import_v43.z.string(),
+  handle: import_v43.z.string(),
+  // Input mappings: how to resolve workflow inputs from thread context
+  inputMappings: InputMappingSchema.optional(),
+  // Event conditions: additional workplace-specific conditions
+  eventConditions: EventConditionsSchema.optional(),
+  // Workplace-specific config overrides
+  config: import_v43.z.record(import_v43.z.string(), import_v43.z.unknown()).optional(),
+  // Trigger type and status
+  type: import_v43.z.string().optional(),
+  isEnabled: import_v43.z.boolean().optional()
+});
+var ResolvedTriggerSchema = import_v43.z.object({
+  trigger: TriggerConfigSchema,
+  workflow: import_v43.z.object({
+    id: import_v43.z.string(),
+    handle: import_v43.z.string(),
+    name: import_v43.z.string().optional(),
+    inputs: import_v43.z.record(import_v43.z.string(), import_v43.z.unknown()).optional(),
+    events: import_v43.z.object({
+      subscribes: import_v43.z.array(EventTypeSchema).optional(),
+      condition: import_v43.z.string().optional()
+    }).optional()
+  }),
+  inputs: import_v43.z.record(import_v43.z.string(), import_v43.z.unknown()),
+  context: TriggerContextSchema
+});
+var WorkflowInputDefinitionSchema = import_v43.z.object({
+  type: import_v43.z.string(),
+  required: import_v43.z.boolean().optional(),
+  description: import_v43.z.string().optional(),
+  default: import_v43.z.unknown().optional()
+});
+var WorkflowInputSchemaSchema = import_v43.z.record(import_v43.z.string(), WorkflowInputDefinitionSchema);
+
+// src/workflows/types.ts
+var WorkflowInputSchema = import_v44.z.object({
+  type: import_v44.z.string(),
+  required: import_v44.z.boolean().optional().default(false),
+  description: import_v44.z.string().optional(),
+  default: import_v44.z.unknown().optional()
+});
+var WorkflowStepInputSchema = import_v44.z.union([import_v44.z.string(), import_v44.z.number(), import_v44.z.boolean(), import_v44.z.record(import_v44.z.string(), import_v44.z.unknown())]);
+var WorkflowStepSchema = import_v44.z.object({
+  // Service and command
+  service: import_v44.z.string(),
+  cmd: import_v44.z.string(),
+  // Dependencies
+  needs: import_v44.z.array(import_v44.z.string()).optional(),
+  // Inputs (Liquid templates supported)
+  inputs: import_v44.z.record(import_v44.z.string(), WorkflowStepInputSchema).optional(),
+  // Conditional execution
+  condition: import_v44.z.string().optional(),
+  // Retry configuration
+  retry: import_v44.z.object({
+    attempts: import_v44.z.number().optional(),
+    backoff: import_v44.z.enum(["linear", "exponential"]).optional()
+  }).optional(),
+  // Timeout
+  timeout: import_v44.z.string().optional()
+});
+var WorkflowRuntimeSchema = import_v44.z.object({
+  durable: import_v44.z.boolean().optional().default(true),
+  timeout: import_v44.z.string().optional(),
+  retry: import_v44.z.object({
+    attempts: import_v44.z.number().optional(),
+    backoff: import_v44.z.enum(["linear", "exponential"]).optional()
+  }).optional()
+});
+var WorkflowYAMLSchema = import_v44.z.object({
+  // Schema version
+  $schema: import_v44.z.string().optional(),
+  // Identity
+  handle: import_v44.z.string(),
+  name: import_v44.z.string(),
+  version: import_v44.z.string().optional(),
+  description: import_v44.z.string().optional(),
+  // Inputs this workflow needs (portable, declared in YAML)
+  inputs: import_v44.z.record(import_v44.z.string(), WorkflowInputSchema).optional(),
+  // Event subscriptions and conditions
+  events: EventsConfigSchema.optional(),
+  // Deterministic steps
+  steps: import_v44.z.record(import_v44.z.string(), WorkflowStepSchema),
+  // Runtime configuration
+  runtime: WorkflowRuntimeSchema.optional()
+});
+var WorkflowMetadataSchema = import_v44.z.object({
+  handle: import_v44.z.string(),
+  name: import_v44.z.string(),
+  version: import_v44.z.string().optional(),
+  description: import_v44.z.string().optional(),
+  inputs: import_v44.z.record(import_v44.z.string(), WorkflowInputDefinitionSchema).optional(),
+  events: EventsConfigSchema.optional()
+});
+var WorkflowExecutionStatusSchema = import_v44.z.enum([
+  "PENDING",
+  "RUNNING",
+  "COMPLETED",
+  "FAILED",
+  "CANCELLED",
+  "WAITING"
+]);
+var WorkflowExecutionResultSchema = import_v44.z.object({
+  status: WorkflowExecutionStatusSchema,
+  outputs: import_v44.z.record(import_v44.z.string(), import_v44.z.unknown()).optional(),
+  error: import_v44.z.string().optional(),
+  startedAt: import_v44.z.string().datetime().optional(),
+  completedAt: import_v44.z.string().datetime().optional(),
+  cancelledAt: import_v44.z.string().datetime().optional(),
+  cancelReason: import_v44.z.string().optional()
+});
+function validateWorkflowYAML(workflow) {
+  const result = WorkflowYAMLSchema.safeParse(workflow);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return { success: false, error: result.error };
+}
+
+// src/cli/api/workflows.ts
+function hasPlatformWorkflowSteps(rawWorkflow) {
+  if (!rawWorkflow || typeof rawWorkflow !== "object") {
+    return false;
+  }
+  const steps = rawWorkflow.steps;
+  if (!steps || typeof steps !== "object") {
+    return false;
+  }
+  return Object.values(steps).some(
+    (step) => step && typeof step === "object" && typeof step.type === "string"
+  );
+}
+function validateWorkflowContent(yamlContent) {
+  let rawWorkflow;
+  try {
+    rawWorkflow = (0, import_yaml.parse)(yamlContent);
+  } catch (err) {
+    throw new Error(`Failed to parse YAML: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  const validation = validateWorkflowYAML(rawWorkflow);
+  if (!validation.success) {
+    if (!hasPlatformWorkflowSteps(rawWorkflow)) {
+      const errorMessages = validation.error.issues.map((e) => `  - ${String(e.path.join(".")) || "(root)"}: ${e.message}`).join("\n");
+      throw new Error(`Workflow validation failed:
+${errorMessages}`);
+    }
+  }
+  return { content: yamlContent };
+}
+async function listWorkflows(ctx, workplace) {
+  const workplaceToken = await getWorkplaceToken(ctx, workplace);
+  const result = await callCliApi(cliApi(ctx), "/workflows", void 0, {
+    method: "GET",
+    query: { workplaceId: workplaceToken.workplaceId }
+  });
+  if (!result.success) {
+    throw new Error(result.error || "Failed to list workflows");
+  }
+  return result.workflows;
+}
+async function getWorkflow(ctx, workplace, handle) {
+  const workplaceToken = await getWorkplaceToken(ctx, workplace);
+  const result = await callCliApi(cliApi(ctx), "/workflows", void 0, {
+    method: "GET",
+    query: { workplaceId: workplaceToken.workplaceId, handle }
+  });
+  if (!result.success) {
+    throw new Error(result.error || "Failed to get workflow");
+  }
+  return result.workflow;
+}
+async function listWorkflowVersions(ctx, workplace, handle) {
+  const workplaceToken = await getWorkplaceToken(ctx, workplace);
+  const result = await callCliApi(cliApi(ctx), "/workflows", void 0, {
+    method: "GET",
+    query: {
+      workplaceId: workplaceToken.workplaceId,
+      handle,
+      action: "versions"
+    }
+  });
+  if (!result.success) {
+    throw new Error(result.error || "Failed to list versions");
+  }
+  return result.workflow.versions ?? [];
+}
+async function validateWorkflow(ctx, workplace, yamlContent) {
+  validateWorkflowContent(yamlContent);
+  const workplaceToken = await getWorkplaceToken(ctx, workplace);
+  return callCliApi(cliApi(ctx), "/workflows", {
+    action: "validate",
+    workplaceId: workplaceToken.workplaceId,
+    yamlContent
+  });
+}
+async function deployWorkflow(ctx, workplace, yamlContent, options = {}) {
+  validateWorkflowContent(yamlContent);
+  const workplaceToken = await getWorkplaceToken(ctx, workplace);
+  return callCliApi(cliApi(ctx), "/workflows", {
+    action: "deploy",
+    workplaceId: workplaceToken.workplaceId,
+    yamlContent,
+    publish: options.publish ?? true,
+    versionLabel: options.versionLabel
+  });
+}
+async function publishWorkflow(ctx, workplace, handle, version) {
+  const workplaceToken = await getWorkplaceToken(ctx, workplace);
+  return callCliApi(cliApi(ctx), "/workflows", {
+    action: "publish",
+    workplaceId: workplaceToken.workplaceId,
+    handle,
+    version
+  });
+}
+async function pullWorkflow(ctx, workplace, handle, version) {
+  const workplaceToken = await getWorkplaceToken(ctx, workplace);
+  return callCliApi(cliApi(ctx), "/workflows", void 0, {
+    method: "GET",
+    query: {
+      workplaceId: workplaceToken.workplaceId,
+      handle,
+      action: "pull",
+      version: version !== void 0 ? String(version) : void 0
+    }
+  });
+}
+async function getWorkflowSchema(ctx, workplace, handle, version) {
+  const workplaceToken = await getWorkplaceToken(ctx, workplace);
+  return callCliApi(cliApi(ctx), "/workflow-schema", void 0, {
+    method: "GET",
+    query: {
+      workplaceId: workplaceToken.workplaceId,
+      handle,
+      version: version !== void 0 ? String(version) : void 0
+    }
+  });
+}
+async function runWorkflow(ctx, workplace, handle, options = {}) {
+  const workplaceToken = await getWorkplaceToken(ctx, workplace);
+  return callCliApi(cliApi(ctx), "/workflows/run", {
+    workplaceId: workplaceToken.workplaceId,
+    handle,
+    version: options.version,
+    inputs: options.inputs ?? {}
+  });
+}
+async function getWorkflowRun(ctx, workplace, workflowRunId) {
+  const workplaceToken = await getWorkplaceToken(ctx, workplace);
+  return callCliApi(cliApi(ctx), "/workflows/run", void 0, {
+    method: "GET",
+    query: {
+      workplaceId: workplaceToken.workplaceId,
+      workflowRunId
+    }
+  });
+}
+
+// src/cli/api/apps.ts
+async function linkApp(ctx, input) {
+  return callCliApi(cliApi(ctx), "/link", {
+    appHandle: input.appHandle,
+    workplaceSubdomain: input.workplaceSubdomain
+  });
+}
+async function registerEndpoint(ctx, input) {
+  return callCliApi(cliApi(ctx), "/register-endpoint", {
+    appVersionId: input.appVersionId,
+    invokeEndpoint: input.invokeEndpoint,
+    config: input.config
+  });
+}
+async function unregisterEndpoint(ctx, input) {
+  return callCliApi(cliApi(ctx), "/unregister-endpoint", {
+    appVersionId: input.appVersionId
+  });
+}
+async function heartbeat(ctx, input) {
+  return callCliApi(cliApi(ctx), "/heartbeat", {
+    appVersionId: input.appVersionId,
+    config: input.config
+  });
+}
+async function installApp(ctx, input) {
+  return callCliApi(cliApi(ctx), "/install", {
+    appVersionId: input.appVersionId,
+    env: input.env
+  });
+}
+async function uninstallApp(ctx, input) {
+  return callCliApi(cliApi(ctx), "/uninstall", {
+    appInstallationId: input.appInstallationId,
+    deleteFields: input.deleteFields
+  });
+}
+async function getInstallation(ctx, input) {
+  return callCliApi(cliApi(ctx), "/installation", {
+    appVersionId: input.appVersionId
+  });
+}
+async function invokeTool(ctx, input) {
+  return callCliApi(cliApi(ctx), "/invoke-tool", {
+    appInstallationId: input.appInstallationId,
+    toolName: input.toolName,
+    args: input.args ?? {},
+    timeout: input.timeout
+  });
+}
+
+// src/cli/commands/invoke-remote.ts
 function getMimeType2(filePath) {
   const ext = path6.extname(filePath).toLowerCase();
   const mimeTypes = {
@@ -2407,42 +2980,7 @@ async function processUploadTemplates2(args2, serverUrl, token, appInstallationI
       result[key] = value;
     }
   }
-  return result;
-}
-async function callInvokeApi(serverUrl, token, body) {
-  const url = `${serverUrl}/api/cli/invoke-tool`;
-  const response = await fetch(url, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "Authorization": `Bearer ${token}`
-    },
-    body: JSON.stringify(body)
-  });
-  const text = await response.text();
-  let json;
-  try {
-    json = JSON.parse(text);
-  } catch {
-    if (text.startsWith("<!DOCTYPE") || text.startsWith("<html")) {
-      throw new Error(
-        `Server returned HTML instead of JSON (status ${response.status}). This usually means the API endpoint doesn't exist or there's a server error.`
-      );
-    }
-    throw new Error(`Invalid response from server: ${text.substring(0, 200)}`);
-  }
-  if (!response.ok) {
-    const errorResponse = json;
-    let errorMessage = errorResponse.error ?? `API error: ${response.status}`;
-    if (errorResponse.availableTools && errorResponse.availableTools.length > 0) {
-      errorMessage += `
-
-Available tools:
-${errorResponse.availableTools.map((t) => `  - ${t}`).join("\n")}`;
-    }
-    throw new Error(errorMessage);
-  }
-  return json;
+  return result;
 }
 function printHelp2() {
   console.log(`
@@ -2556,9 +3094,8 @@ async function invokeRemoteCommand(args2) {
       credentials.token,
       appInstallationId
     );
-    const response = await callInvokeApi(
-      serverUrl,
-      credentials.token,
+    const response = await invokeTool(
+      { serverUrl, token: credentials.token },
       {
         appInstallationId,
         toolName,
@@ -2579,7 +3116,7 @@ async function invokeRemoteCommand(args2) {
 }
 
 // src/cli/commands/tools.ts
-var z3 = __toESM(require("zod"));
+var z6 = __toESM(require("zod"));
 init_utils();
 function printHelp3() {
   console.log(`
@@ -2613,7 +3150,7 @@ Examples:
   skedyul tools sync --workplace gym-demo --model prospect
 `);
 }
-async function getWorkplaceToken(workplaceSubdomain, serverUrl, cliToken) {
+async function getWorkplaceToken2(workplaceSubdomain, serverUrl, cliToken) {
   return callCliApi(
     { serverUrl, token: cliToken },
     "/workplace-token",
@@ -2631,12 +3168,12 @@ function ensureAuth() {
 }
 function getZodSchema2(schema) {
   if (!schema) return void 0;
-  if (schema instanceof z3.ZodType) {
+  if (schema instanceof z6.ZodType) {
     return schema;
   }
   if (typeof schema === "object" && schema !== null && "zod" in schema) {
     const schemaWithZod = schema;
-    if (schemaWithZod.zod instanceof z3.ZodType) {
+    if (schemaWithZod.zod instanceof z6.ZodType) {
       return schemaWithZod.zod;
     }
   }
@@ -2645,7 +3182,7 @@ function getZodSchema2(schema) {
 function toJsonSchema(schema) {
   if (!schema) return void 0;
   try {
-    return z3.toJSONSchema(schema, {
+    return z6.toJSONSchema(schema, {
       unrepresentable: "any"
     });
   } catch {
@@ -2715,7 +3252,7 @@ async function handleSync(args2) {
   const { token, serverUrl } = ensureAuth();
   let workplaceToken;
   try {
-    workplaceToken = await getWorkplaceToken(workplace, serverUrl, token);
+    workplaceToken = await getWorkplaceToken2(workplace, serverUrl, token);
   } catch (error) {
     if (jsonOutput) {
       console.log(JSON.stringify({ error: `Failed to get workplace token: ${error instanceof Error ? error.message : String(error)}` }));
@@ -2803,7 +3340,7 @@ init_utils();
 
 // src/server/index.ts
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
-var z5 = __toESM(require("zod"));
+var z8 = __toESM(require("zod"));
 
 // src/core/service.ts
 var CoreApiService = class {
@@ -2870,7 +3407,7 @@ function registerSequencerConfig(config) {
 }
 
 // src/server/utils/schema.ts
-var z4 = __toESM(require("zod"));
+var z7 = __toESM(require("zod"));
 function normalizeBilling(billing) {
   if (!billing || typeof billing !== "object") {
     return { credits: 0 };
@@ -2883,7 +3420,7 @@ function normalizeBilling(billing) {
 function toJsonSchema2(schema) {
   if (!schema) return void 0;
   try {
-    return z4.toJSONSchema(schema, {
+    return z7.toJSONSchema(schema, {
       unrepresentable: "any"
       // Handle z.date(), z.bigint() etc gracefully
     });
@@ -2894,12 +3431,12 @@ function toJsonSchema2(schema) {
 }
 function isToolSchemaWithJson(schema) {
   return Boolean(
-    schema && typeof schema === "object" && "zod" in schema && schema.zod instanceof z4.ZodType
+    schema && typeof schema === "object" && "zod" in schema && schema.zod instanceof z7.ZodType
   );
 }
 function getZodSchema3(schema) {
   if (!schema) return void 0;
-  if (schema instanceof z4.ZodType) {
+  if (schema instanceof z7.ZodType) {
     return schema;
   }
   if (isToolSchemaWithJson(schema)) {
@@ -5265,12 +5802,12 @@ function createSkedyulServer(config) {
     const toolDisplayName = tool.label || toolName;
     const inputZodSchema = getZodSchema3(tool.inputSchema);
     const outputZodSchema = getZodSchema3(tool.outputSchema);
-    const wrappedInputSchema = z5.object({
-      inputs: inputZodSchema ?? z5.record(z5.string(), z5.unknown()).optional(),
-      context: z5.record(z5.string(), z5.unknown()).optional(),
-      env: z5.record(z5.string(), z5.string()).optional(),
-      invocation: z5.record(z5.string(), z5.unknown()).optional(),
-      estimate: z5.boolean().optional()
+    const wrappedInputSchema = z8.object({
+      inputs: inputZodSchema ?? z8.record(z8.string(), z8.unknown()).optional(),
+      context: z8.record(z8.string(), z8.unknown()).optional(),
+      env: z8.record(z8.string(), z8.string()).optional(),
+      invocation: z8.record(z8.string(), z8.unknown()).optional(),
+      estimate: z8.boolean().optional()
     }).passthrough();
     mcpServer.registerTool(
       toolName,
@@ -5706,7 +6243,7 @@ async function isNgrokAvailable() {
 
 // src/cli/commands/serve.ts
 var readline2 = __toESM(require("readline"));
-var z6 = __toESM(require("zod"));
+var z9 = __toESM(require("zod"));
 var net = __toESM(require("net"));
 var SERVE_STATE_FILE = ".skedyul/serve.json";
 function writeServeState(port, workplace) {
@@ -5809,9 +6346,8 @@ async function shouldRunInstallWorkflow(linkConfig, credentials) {
     }
   }
   try {
-    const result = await callCliApi(
+    const result = await getInstallation(
       { serverUrl: linkConfig.serverUrl, token: credentials.token },
-      "/installation",
       { appVersionId: linkConfig.appVersionId }
     );
     return result.status !== "INSTALLED";
@@ -5923,9 +6459,9 @@ Endpoints:
 }
 function safeInputSchemaToJson(schema) {
   if (!schema) return void 0;
-  if (schema instanceof z6.ZodType) {
+  if (schema instanceof z9.ZodType) {
     try {
-      return z6.toJSONSchema(schema, { unrepresentable: "any" });
+      return z9.toJSONSchema(schema, { unrepresentable: "any" });
     } catch {
       return void 0;
     }
@@ -6025,9 +6561,8 @@ async function serveCommand(args2) {
       console.log(`  App: ${appConfig.handle}`);
       const serverUrl = getServerUrl();
       try {
-        const response = await callCliApi(
+        const response = await linkApp(
           { serverUrl, token: credentials.token },
-          "/link",
           {
             appHandle: appConfig.handle,
             workplaceSubdomain
@@ -6197,28 +6732,16 @@ Starting ngrok tunnel...`);
     console.log(`
 Registering endpoint with Skedyul...`);
     try {
-      const registerUrl = `${linkConfig.serverUrl}/api/cli/register-endpoint`;
-      const registerBody = {
-        appVersionId: linkConfig.appVersionId,
-        invokeEndpoint,
-        config: executableConfig
-      };
-      const registerResponse = await fetch(registerUrl, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "Authorization": `Bearer ${credentials.token}`
-        },
-        body: JSON.stringify(registerBody)
-      });
-      if (!registerResponse.ok) {
-        const responseText = await registerResponse.text();
-        console.error(`Failed to register endpoint (HTTP ${registerResponse.status}):`);
-        console.error(`  Response: ${responseText.substring(0, 500)}`);
-      } else {
-        console.log(`  \u2713 Registered as invokeEndpoint for ${linkConfig.appVersionHandle}`);
-        console.log(`  \u2713 Synced ${toolCount} tools to Skedyul`);
-      }
+      await registerEndpoint(
+        { serverUrl: linkConfig.serverUrl, token: credentials.token },
+        {
+          appVersionId: linkConfig.appVersionId,
+          invokeEndpoint,
+          config: executableConfig
+        }
+      );
+      console.log(`  \u2713 Registered as invokeEndpoint for ${linkConfig.appVersionHandle}`);
+      console.log(`  \u2713 Synced ${toolCount} tools to Skedyul`);
     } catch (error) {
       console.error(`Failed to register endpoint: ${error instanceof Error ? error.message : String(error)}`);
     }
@@ -6233,9 +6756,8 @@ Running installation workflow...`);
           "install"
         );
         const installEnv = filterEnvForInstallWorkflow(installEnvFromDb, installConfig);
-        await callCliApi(
+        await installApp(
           { serverUrl: linkConfig.serverUrl, token: credentials.token },
-          "/install",
           {
             appVersionId: linkConfig.appVersionId,
             env: installEnv
@@ -6257,9 +6779,8 @@ Running installation workflow...`);
           void 0,
           webhookRegistry
         );
-        await callCliApi(
+        await heartbeat(
           { serverUrl: linkConfig.serverUrl, token: credentials.token },
-          "/heartbeat",
           {
             appVersionId: linkConfig.appVersionId,
             config: freshConfig
@@ -6292,9 +6813,8 @@ ${"\u2501".repeat(60)}`);
         clearInterval(heartbeatInterval);
       }
       try {
-        await callCliApi(
+        await unregisterEndpoint(
           { serverUrl: linkConfig.serverUrl, token: credentials.token },
-          "/unregister-endpoint",
           { appVersionId: linkConfig.appVersionId }
         );
         console.log("  \u2713 Endpoint unregistered (installation preserved)");
@@ -6318,9 +6838,8 @@ To restart: skedyul dev serve --workplace ${workplaceSubdomain}`);
         clearInterval(heartbeatInterval);
       }
       try {
-        await callCliApi(
+        await unregisterEndpoint(
           { serverUrl: linkConfig.serverUrl, token: credentials.token },
-          "/unregister-endpoint",
           { appVersionId: linkConfig.appVersionId }
         );
         console.log("  \u2713 Endpoint unregistered");
@@ -6328,13 +6847,11 @@ To restart: skedyul dev serve --workplace ${workplaceSubdomain}`);
       }
       try {
         console.log("  Running uninstall workflow...");
-        await callCliApi(
+        await uninstallApp(
           { serverUrl: linkConfig.serverUrl, token: credentials.token },
-          "/uninstall",
           {
             appInstallationId: linkConfig.appInstallationId,
             deleteFields: false
-            // Preserve custom fields for re-install
           }
         );
         console.log("  \u2713 Uninstall workflow started");
@@ -6404,8 +6921,8 @@ var path11 = __toESM(require("path"));
 var os2 = __toESM(require("os"));
 
 // src/schemas/crm-schema.ts
-var import_v42 = require("zod/v4");
-var CRMFieldTypeSchema = import_v42.z.enum([
+var import_v45 = require("zod/v4");
+var CRMFieldTypeSchema = import_v45.z.enum([
   "string",
   "long_string",
   "number",
@@ -6417,132 +6934,148 @@ var CRMFieldTypeSchema = import_v42.z.enum([
   "image",
   "object"
 ]);
-var CRMFieldRequirementSchema = import_v42.z.enum([
+var CRMFieldRequirementSchema = import_v45.z.enum([
   "optional",
   "on_create",
   "required"
 ]);
-var CRMFieldOptionSchema = import_v42.z.object({
-  label: import_v42.z.string(),
-  value: import_v42.z.string(),
-  color: import_v42.z.string().optional()
+var CRMFieldOptionSchema = import_v45.z.object({
+  label: import_v45.z.string(),
+  value: import_v45.z.string(),
+  color: import_v45.z.string().optional()
 });
-var CRMFieldDefinitionObjectSchema = import_v42.z.object({
-  options: import_v42.z.array(CRMFieldOptionSchema).optional(),
-  limitChoices: import_v42.z.number().optional(),
-  minLength: import_v42.z.number().optional(),
-  maxLength: import_v42.z.number().optional(),
-  min: import_v42.z.number().optional(),
-  max: import_v42.z.number().optional(),
-  pattern: import_v42.z.string().optional()
+var CRMFieldDefinitionObjectSchema = import_v45.z.object({
+  options: import_v45.z.array(CRMFieldOptionSchema).optional(),
+  limitChoices: import_v45.z.number().optional(),
+  minLength: import_v45.z.number().optional(),
+  maxLength: import_v45.z.number().optional(),
+  min: import_v45.z.number().optional(),
+  max: import_v45.z.number().optional(),
+  pattern: import_v45.z.string().optional()
 });
-var CRMFieldDefinitionSchema = import_v42.z.union([
-  import_v42.z.string(),
+var CRMFieldDefinitionSchema = import_v45.z.union([
+  import_v45.z.string(),
   CRMFieldDefinitionObjectSchema
 ]);
-var CRMFieldAppearanceSchemaZ = import_v42.z.object({
-  leftIcon: import_v42.z.string().optional(),
-  rightIcon: import_v42.z.string().optional(),
-  placeholder: import_v42.z.string().optional(),
-  helpText: import_v42.z.string().optional()
+var CRMFieldAppearanceSchemaZ = import_v45.z.object({
+  leftIcon: import_v45.z.string().optional(),
+  rightIcon: import_v45.z.string().optional(),
+  placeholder: import_v45.z.string().optional(),
+  helpText: import_v45.z.string().optional()
+});
+var CRMFieldAiMetaSchemaZ = import_v45.z.object({
+  description: import_v45.z.string().optional(),
+  mutability: import_v45.z.enum(["always", "restricted", "create_only", "immutable"]).optional()
 });
-var CRMFieldSchemaZ = import_v42.z.object({
-  handle: import_v42.z.string().regex(/^[a-z][a-z0-9_]*$/, "Handle must be lowercase alphanumeric with underscores, starting with a letter"),
-  label: import_v42.z.string().min(1, "Label is required"),
+var CRMFieldSchemaZ = import_v45.z.object({
+  handle: import_v45.z.string().regex(/^[a-z][a-z0-9_]*$/, "Handle must be lowercase alphanumeric with underscores, starting with a letter"),
+  label: import_v45.z.string().min(1, "Label is required"),
   type: CRMFieldTypeSchema,
   /** Field description - explains what the field is for (metadata, not UI) */
-  description: import_v42.z.string().optional(),
+  description: import_v45.z.string().optional(),
   /** Field appearance - UI presentation settings */
   appearance: CRMFieldAppearanceSchemaZ.optional(),
   requirement: CRMFieldRequirementSchema.optional(),
-  unique: import_v42.z.boolean().optional(),
-  list: import_v42.z.boolean().optional(),
-  default: import_v42.z.unknown().optional(),
+  unique: import_v45.z.boolean().optional(),
+  list: import_v45.z.boolean().optional(),
+  default: import_v45.z.unknown().optional(),
   definition: CRMFieldDefinitionSchema.optional(),
+  /** AI metadata - description and mutability hints for agents */
+  aiMeta: CRMFieldAiMetaSchemaZ.optional(),
   /**
    * Workplace-scoped field section handle (visualization helper).
    * Find-or-create on apply; display name is derived from the handle on create.
    */
-  section: import_v42.z.string().regex(/^[a-z][a-z0-9_-]*$/, "Section handle must be lowercase alphanumeric with underscores/hyphens, starting with a letter").optional()
+  section: import_v45.z.string().regex(/^[a-z][a-z0-9_-]*$/, "Section handle must be lowercase alphanumeric with underscores/hyphens, starting with a letter").optional()
 });
-var CRMModelSchemaZ = import_v42.z.object({
-  handle: import_v42.z.string().regex(/^[a-z][a-z0-9_]*$/, "Handle must be lowercase alphanumeric with underscores, starting with a letter"),
-  name: import_v42.z.string().min(1, "Name is required"),
-  namePlural: import_v42.z.string().optional(),
-  labelTemplate: import_v42.z.string().optional(),
-  description: import_v42.z.string().optional(),
-  icon: import_v42.z.string().optional(),
-  fields: import_v42.z.array(CRMFieldSchemaZ)
+var CRMModelSchemaZ = import_v45.z.object({
+  handle: import_v45.z.string().regex(/^[a-z][a-z0-9_]*$/, "Handle must be lowercase alphanumeric with underscores, starting with a letter"),
+  name: import_v45.z.string().min(1, "Name is required"),
+  namePlural: import_v45.z.string().optional(),
+  labelTemplate: import_v45.z.string().optional(),
+  description: import_v45.z.string().optional(),
+  icon: import_v45.z.string().optional(),
+  fields: import_v45.z.array(CRMFieldSchemaZ)
 });
-var CRMCardinalitySchema = import_v42.z.enum(["one_to_one", "one_to_many"]);
-var CRMOnDeleteSchema = import_v42.z.enum(["none", "cascade", "restrict"]);
-var CRMRelationshipLinkSchema = import_v42.z.object({
-  model: import_v42.z.string(),
-  field: import_v42.z.string(),
-  label: import_v42.z.string()
+var CRMCardinalitySchema = import_v45.z.enum([
+  "one_to_one",
+  "one_to_many",
+  "many_to_one",
+  "many_to_many"
+]);
+var CRMOnDeleteSchema = import_v45.z.enum([
+  "none",
+  "cascade",
+  "restrict",
+  "set_null"
+]);
+var CRMRelationshipLinkSchema = import_v45.z.object({
+  model: import_v45.z.string(),
+  field: import_v45.z.string(),
+  label: import_v45.z.string()
 });
-var CRMRelationshipSchemaZ = import_v42.z.object({
+var CRMRelationshipSchemaZ = import_v45.z.object({
   source: CRMRelationshipLinkSchema,
   target: CRMRelationshipLinkSchema,
   cardinality: CRMCardinalitySchema,
   onDelete: CRMOnDeleteSchema.optional()
 });
-var CRMBlockTypeSchema = import_v42.z.enum([
+var CRMBlockTypeSchema = import_v45.z.enum([
   "spreadsheet",
   "form",
   "card",
   "metric",
   "kanban"
 ]);
-var CRMBlockSchemaZ = import_v42.z.object({
+var CRMBlockSchemaZ = import_v45.z.object({
   type: CRMBlockTypeSchema,
-  title: import_v42.z.string().optional(),
-  config: import_v42.z.unknown().optional(),
-  default: import_v42.z.boolean().optional()
+  title: import_v45.z.string().optional(),
+  config: import_v45.z.unknown().optional(),
+  default: import_v45.z.boolean().optional()
 });
-var CRMPageTypeSchema = import_v42.z.enum(["list", "instance"]);
-var CRMPageSchemaZ = import_v42.z.object({
-  path: import_v42.z.string(),
+var CRMPageTypeSchema = import_v45.z.enum(["list", "instance"]);
+var CRMPageSchemaZ = import_v45.z.object({
+  path: import_v45.z.string(),
   type: CRMPageTypeSchema,
-  title: import_v42.z.string(),
-  icon: import_v42.z.string().optional(),
-  modelHandle: import_v42.z.string(),
-  parentPath: import_v42.z.string().optional(),
-  isDefault: import_v42.z.boolean().optional(),
-  visibility: import_v42.z.enum(["team", "private"]).optional(),
-  baseQuery: import_v42.z.unknown().optional(),
-  blocks: import_v42.z.array(CRMBlockSchemaZ).optional()
+  title: import_v45.z.string(),
+  icon: import_v45.z.string().optional(),
+  modelHandle: import_v45.z.string(),
+  parentPath: import_v45.z.string().optional(),
+  isDefault: import_v45.z.boolean().optional(),
+  visibility: import_v45.z.enum(["team", "private"]).optional(),
+  baseQuery: import_v45.z.unknown().optional(),
+  blocks: import_v45.z.array(CRMBlockSchemaZ).optional()
 });
-var CRMNavigationNodeBaseSchemaZ = import_v42.z.object({
-  label: import_v42.z.string(),
-  icon: import_v42.z.string().optional(),
-  path: import_v42.z.string().optional(),
-  kind: import_v42.z.enum(["section", "group"]).optional(),
-  sortIndex: import_v42.z.number().optional()
+var CRMNavigationNodeBaseSchemaZ = import_v45.z.object({
+  label: import_v45.z.string(),
+  icon: import_v45.z.string().optional(),
+  path: import_v45.z.string().optional(),
+  kind: import_v45.z.enum(["section", "group"]).optional(),
+  sortIndex: import_v45.z.number().optional()
 });
-var CRMNavigationItemSchemaZ = import_v42.z.lazy(
+var CRMNavigationItemSchemaZ = import_v45.z.lazy(
   () => CRMNavigationNodeBaseSchemaZ.extend({
-    children: import_v42.z.array(CRMNavigationItemSchemaZ).optional()
+    children: import_v45.z.array(CRMNavigationItemSchemaZ).optional()
   })
 );
-var CRMNavigationSchemaZ = import_v42.z.object({
-  sidebar: import_v42.z.array(CRMNavigationItemSchemaZ).optional()
+var CRMNavigationSchemaZ = import_v45.z.object({
+  sidebar: import_v45.z.array(CRMNavigationItemSchemaZ).optional()
 });
-var CRMSchemaZ = import_v42.z.object({
+var CRMSchemaZ = import_v45.z.object({
   /** Schema format version for future compatibility */
-  $schema: import_v42.z.literal("https://skedyul.com/schemas/crm/v1").optional(),
+  $schema: import_v45.z.literal("https://skedyul.com/schemas/crm/v1").optional(),
   /** Schema name for identification */
-  name: import_v42.z.string().min(1, "Name is required"),
+  name: import_v45.z.string().min(1, "Name is required"),
   /** Optional description */
-  description: import_v42.z.string().optional(),
+  description: import_v45.z.string().optional(),
   /** Schema version (semver) */
-  version: import_v42.z.string().optional(),
+  version: import_v45.z.string().optional(),
   /** Model definitions */
-  models: import_v42.z.array(CRMModelSchemaZ),
+  models: import_v45.z.array(CRMModelSchemaZ),
   /** Relationship definitions */
-  relationships: import_v42.z.array(CRMRelationshipSchemaZ).optional(),
+  relationships: import_v45.z.array(CRMRelationshipSchemaZ).optional(),
   /** Page definitions */
-  pages: import_v42.z.array(CRMPageSchemaZ).optional(),
+  pages: import_v45.z.array(CRMPageSchemaZ).optional(),
   /** Navigation definitions */
   navigation: CRMNavigationSchemaZ.optional()
 });
@@ -6642,149 +7175,6 @@ async function saveSchema(schema, outputPath, options = {}) {
   const content = isTypeScript ? serializeSchemaToTypeScript(schema) : serializeSchemaToJson(schema, options);
   fs11.writeFileSync(absolutePath, content, "utf-8");
 }
-var FIELD_TYPE_MAP = {
-  string: "STRING",
-  long_string: "LONG_STRING",
-  number: "NUMBER",
-  boolean: "BOOLEAN",
-  date: "DATE",
-  datetime: "DATE_TIME",
-  time: "TIME",
-  file: "FILE",
-  image: "IMAGE",
-  object: "OBJECT"
-};
-var FIELD_REQUIREMENT_MAP = {
-  optional: "OPTIONAL",
-  on_create: "ON_CREATE",
-  required: "REQUIRED"
-};
-var CARDINALITY_MAP = {
-  one_to_one: "ONE_TO_ONE",
-  one_to_many: "ONE_TO_MANY"
-};
-var ON_DELETE_MAP = {
-  none: "NONE",
-  cascade: "CASCADE",
-  restrict: "RESTRICT"
-};
-var PAGE_TYPE_MAP = {
-  list: "LIST",
-  instance: "INSTANCE"
-};
-var BLOCK_TYPE_MAP = {
-  spreadsheet: "SPREADSHEET",
-  form: "FORM",
-  card: "CARD",
-  metric: "METRIC",
-  kanban: "KANBAN"
-};
-function transformToBackendSchema(schema) {
-  const fieldDefinitions = [];
-  const models = schema.models.map((model) => {
-    const fields = model.fields.map((field) => {
-      let appearance;
-      if (field.appearance) {
-        appearance = {};
-        if (field.appearance.leftIcon) appearance.leftIcon = field.appearance.leftIcon;
-        if (field.appearance.rightIcon) appearance.rightIcon = field.appearance.rightIcon;
-        if (field.appearance.placeholder) appearance.placeholder = field.appearance.placeholder;
-        if (field.appearance.helpText) appearance.helpText = field.appearance.helpText;
-        if (Object.keys(appearance).length === 0) appearance = void 0;
-      }
-      const backendField = {
-        handle: field.handle,
-        label: field.label,
-        type: FIELD_TYPE_MAP[field.type] || field.type.toUpperCase(),
-        description: field.description || void 0,
-        appearance,
-        isList: field.list,
-        isUnique: field.unique,
-        requirement: field.requirement ? FIELD_REQUIREMENT_MAP[field.requirement] : void 0
-      };
-      if (field.default !== void 0) {
-        backendField.defaultValue = {
-          value: Array.isArray(field.default) ? field.default : [field.default]
-        };
-      }
-      if (field.definition) {
-        if (typeof field.definition === "string") {
-          backendField.definition = field.definition;
-        } else if (field.definition.options && field.definition.options.length > 0) {
-          const definitionHandle = `${model.handle}_${field.handle}`;
-          backendField.definition = {
-            type: FIELD_TYPE_MAP[field.type] || field.type.toUpperCase(),
-            options: field.definition.options.map((opt) => ({
-              value: opt.value,
-              label: opt.label,
-              color: opt.color || null
-            })),
-            limitChoices: field.definition.limitChoices
-          };
-          fieldDefinitions.push({
-            handle: definitionHandle,
-            type: FIELD_TYPE_MAP[field.type] || field.type.toUpperCase(),
-            options: field.definition.options.map((opt) => ({
-              value: opt.value,
-              label: opt.label,
-              color: opt.color || null
-            }))
-          });
-        }
-      }
-      return backendField;
-    });
-    return {
-      handle: model.handle,
-      name: model.name,
-      namePlural: model.namePlural,
-      labelTemplate: model.labelTemplate || `{{ ${model.fields[0]?.handle || "id"} }}`,
-      description: model.description,
-      icon: model.icon,
-      fields
-    };
-  });
-  const relationships = (schema.relationships || []).map(
-    (rel) => ({
-      source: rel.source,
-      target: rel.target,
-      cardinality: CARDINALITY_MAP[rel.cardinality] || rel.cardinality.toUpperCase(),
-      onDelete: rel.onDelete ? ON_DELETE_MAP[rel.onDelete] : void 0
-    })
-  );
-  const pages = (schema.pages || []).map((page) => ({
-    path: page.path,
-    type: PAGE_TYPE_MAP[page.type] || page.type.toUpperCase(),
-    title: page.title,
-    icon: page.icon,
-    modelHandle: page.modelHandle,
-    parentPath: page.parentPath,
-    baseQuery: page.baseQuery,
-    blocks: page.blocks?.map((block) => ({
-      type: BLOCK_TYPE_MAP[block.type] || block.type.toUpperCase(),
-      title: block.title,
-      config: block.config,
-      default: block.default
-    }))
-  }));
-  const navigation = schema.navigation ? {
-    sidebar: schema.navigation.sidebar?.map((item) => ({
-      label: item.label,
-      icon: item.icon,
-      path: item.path,
-      kind: item.kind,
-      sortIndex: item.sortIndex,
-      children: item.children
-    }))
-  } : void 0;
-  return {
-    models,
-    relationships,
-    fieldDefinitions,
-    pages,
-    navigation
-  };
-}
 
 // src/config/resolver.ts
 var fs12 = __toESM(require("fs"));
@@ -8459,9 +8849,8 @@ To re-link, first run 'skedyul dev unlink --workplace ${workplaceSubdomain}'`);
   console.log(`
 Linking to ${workplaceSubdomain}...`);
   try {
-    const response = await callCliApi(
+    const response = await linkApp(
       { serverUrl, token: credentials.token },
-      "/link",
       {
         appHandle: config.handle,
         workplaceSubdomain
@@ -8827,7 +9216,7 @@ Examples:
   skedyul instances upsert-many panel_result --workplace crux --file ./data.json --match-field vetnostics_id
 `);
 }
-async function getWorkplaceToken2(workplaceSubdomain, serverUrl, cliToken) {
+async function getWorkplaceToken3(workplaceSubdomain, serverUrl, cliToken) {
   return callCliApi(
     { serverUrl, token: cliToken },
     "/workplace-token",
@@ -8858,7 +9247,7 @@ async function instancesCommand(args2) {
   const serverUrl = getServerUrl();
   let workplaceToken;
   try {
-    workplaceToken = await getWorkplaceToken2(
+    workplaceToken = await getWorkplaceToken3(
       workplaceSubdomain,
       serverUrl,
       credentials.token
@@ -9527,13 +9916,6 @@ Examples:
   skedyul crm push --schema ./gym.schema.ts --workplace gym-demo --yes
 `);
 }
-async function getWorkplaceToken3(workplaceSubdomain, serverUrl, cliToken) {
-  return callCliApi(
-    { serverUrl, token: cliToken },
-    "/workplace-token",
-    { workplaceSubdomain }
-  );
-}
 function ensureAuth2() {
   const credentials = getCredentials();
   if (!credentials?.token) {
@@ -9599,46 +9981,14 @@ async function handlePush(args2) {
     }
     process.exit(1);
   }
-  const { token, serverUrl } = ensureAuth2();
-  let workplaceToken;
-  try {
-    workplaceToken = await getWorkplaceToken3(workplace, serverUrl, token);
-  } catch (error) {
-    if (jsonOutput) {
-      console.log(JSON.stringify({ error: `Failed to get workplace token: ${error instanceof Error ? error.message : String(error)}` }));
-    } else {
-      console.error(`Error: Failed to get workplace token: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    process.exit(1);
-  }
-  const backendSchema = transformToBackendSchema(schema);
+  const ctx = ensureAuth2();
   if (!jsonOutput && !dryRun) {
     console.log("");
     console.log(`\u{1F4E6} Pushing schema "${schema.name}" to ${workplace}`);
     console.log("");
   }
   try {
-    const response = await fetch(`${serverUrl}/api/cli/crm-schema`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${token}`
-      },
-      body: JSON.stringify({
-        workplace,
-        workplaceId: workplaceToken.workplaceId,
-        schema: backendSchema,
-        dryRun,
-        autoApprove,
-        schemaName: schema.name,
-        schemaVersion: schema.version
-      })
-    });
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => ({}));
-      throw new Error(errorData.error || `Request failed: ${response.statusText}`);
-    }
-    const result = await response.json();
+    const result = dryRun ? await diffSchema(ctx, workplace, schema) : await pushSchema(ctx, workplace, schema, { autoApprove: false });
     if (jsonOutput) {
       console.log(JSON.stringify(result, null, 2));
       return;
@@ -9666,17 +10016,10 @@ async function handlePush(args2) {
           console.log("\u274C Operation cancelled");
           process.exit(1);
         }
-        const approvalResponse = await fetch(`${serverUrl}/api/cli/crm-schema/approve`, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${token}`
-          },
-          body: JSON.stringify({ migrationId: result.migrationId })
-        });
-        if (!approvalResponse.ok) {
-          throw new Error("Failed to approve migration");
+        if (!result.migrationId) {
+          throw new Error("Migration requires approval but no migrationId was returned");
         }
+        await approveMigration(ctx, result.migrationId);
         console.log("");
         console.log("\u2705 Migration approved and applied");
       } else {
@@ -9712,34 +10055,9 @@ async function handlePull(args2) {
     console.error("Usage: skedyul crm pull --workplace gym-demo --output ./current.schema.json");
     process.exit(1);
   }
-  const { token, serverUrl } = ensureAuth2();
-  let workplaceToken;
-  try {
-    workplaceToken = await getWorkplaceToken3(workplace, serverUrl, token);
-  } catch (error) {
-    if (jsonOutput) {
-      console.log(JSON.stringify({ error: `Failed to get workplace token: ${error instanceof Error ? error.message : String(error)}` }));
-    } else {
-      console.error(`Error: Failed to get workplace token: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    process.exit(1);
-  }
+  const ctx = ensureAuth2();
   try {
-    const response = await fetch(`${serverUrl}/api/cli/crm-schema?workplaceId=${workplaceToken.workplaceId}`, {
-      method: "GET",
-      headers: {
-        Authorization: `Bearer ${token}`
-      }
-    });
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => ({}));
-      throw new Error(errorData.error || `Request failed: ${response.statusText}`);
-    }
-    const result = await response.json();
-    if (!result.success) {
-      throw new Error(result.error || "Failed to pull schema");
-    }
-    const schema = result.schema;
+    const { schema } = await pullSchema(ctx, workplace);
     if (outputPath) {
       const isTypeScript = outputPath.endsWith(".ts") || format === "ts";
       await saveSchema(schema, outputPath);
@@ -9785,46 +10103,22 @@ async function handleModels(args2) {
     console.error("Usage: skedyul crm models --workplace gym-demo");
     process.exit(1);
   }
-  const { token, serverUrl } = ensureAuth2();
-  let workplaceToken;
-  try {
-    workplaceToken = await getWorkplaceToken3(workplace, serverUrl, token);
-  } catch (error) {
-    if (jsonOutput) {
-      console.log(JSON.stringify({ error: `Failed to get workplace token: ${error instanceof Error ? error.message : String(error)}` }));
-    } else {
-      console.error(`Error: Failed to get workplace token: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    process.exit(1);
-  }
+  const ctx = ensureAuth2();
   try {
-    const response = await fetch(`${serverUrl}/api/cli/crm-models?workplaceId=${workplaceToken.workplaceId}`, {
-      method: "GET",
-      headers: {
-        Authorization: `Bearer ${token}`
-      }
-    });
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => ({}));
-      throw new Error(errorData.error || `Request failed: ${response.statusText}`);
-    }
-    const result = await response.json();
-    if (!result.success) {
-      throw new Error(result.error || "Failed to list models");
-    }
+    const models = await listModels(ctx, workplace);
     if (jsonOutput) {
-      console.log(JSON.stringify(result.models, null, 2));
+      console.log(JSON.stringify(models, null, 2));
       return;
     }
     console.log("");
     console.log(`\u{1F4E6} Models in ${workplace}`);
     console.log("");
-    if (result.models.length === 0) {
+    if (models.length === 0) {
       console.log("  No models found.");
     } else {
       console.log("  Handle                Label                   Fields  Instances");
       console.log("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
-      for (const model of result.models) {
+      for (const model of models) {
         const handle = model.handle.padEnd(20);
         const label = model.name.padEnd(22);
         const fields = String(model.fieldCount).padStart(6);
@@ -9872,163 +10166,163 @@ async function crmCommand(args2) {
 // src/cli/commands/agents.ts
 var fs22 = __toESM(require("fs"));
 var path22 = __toESM(require("path"));
-var import_yaml = require("yaml");
+var import_yaml2 = require("yaml");
 init_utils();
 
 // src/schemas/agent-schema.ts
-var import_v43 = require("zod/v4");
-var ToolReferenceInputZ = import_v43.z.union([
-  import_v43.z.string(),
-  import_v43.z.object({
-    tool: import_v43.z.string(),
-    handle: import_v43.z.string().optional(),
-    name: import_v43.z.string().optional(),
-    description: import_v43.z.string().optional(),
+var import_v46 = require("zod/v4");
+var ToolReferenceInputZ = import_v46.z.union([
+  import_v46.z.string(),
+  import_v46.z.object({
+    tool: import_v46.z.string(),
+    handle: import_v46.z.string().optional(),
+    name: import_v46.z.string().optional(),
+    description: import_v46.z.string().optional(),
     /** Execution mode: ALLOW_ALL (default) or REQUIRE_APPROVAL */
-    executionMode: import_v43.z.enum(["ALLOW_ALL", "REQUIRE_APPROVAL"]).optional(),
+    executionMode: import_v46.z.enum(["ALLOW_ALL", "REQUIRE_APPROVAL"]).optional(),
     /** Approval timeout in ms (default: 86400000 = 1 day) */
-    approvalTimeoutMs: import_v43.z.number().optional()
+    approvalTimeoutMs: import_v46.z.number().optional()
   })
 ]);
-var ToolBindingZ = import_v43.z.union([
-  import_v43.z.object({
-    kind: import_v43.z.literal("SYSTEM"),
-    name: import_v43.z.string(),
-    handle: import_v43.z.string().optional(),
-    displayName: import_v43.z.string().optional(),
-    description: import_v43.z.string().optional(),
+var ToolBindingZ = import_v46.z.union([
+  import_v46.z.object({
+    kind: import_v46.z.literal("SYSTEM"),
+    name: import_v46.z.string(),
+    handle: import_v46.z.string().optional(),
+    displayName: import_v46.z.string().optional(),
+    description: import_v46.z.string().optional(),
     /** Execution mode: ALLOW_ALL (default) or REQUIRE_APPROVAL */
-    executionMode: import_v43.z.enum(["ALLOW_ALL", "REQUIRE_APPROVAL"]).optional(),
+    executionMode: import_v46.z.enum(["ALLOW_ALL", "REQUIRE_APPROVAL"]).optional(),
     /** Approval timeout in ms (default: 86400000 = 1 day) */
-    approvalTimeoutMs: import_v43.z.number().optional()
+    approvalTimeoutMs: import_v46.z.number().optional()
   }),
-  import_v43.z.object({
-    kind: import_v43.z.literal("AGENT"),
-    name: import_v43.z.string(),
-    handle: import_v43.z.string().optional(),
-    displayName: import_v43.z.string().optional(),
-    description: import_v43.z.string().optional(),
+  import_v46.z.object({
+    kind: import_v46.z.literal("AGENT"),
+    name: import_v46.z.string(),
+    handle: import_v46.z.string().optional(),
+    displayName: import_v46.z.string().optional(),
+    description: import_v46.z.string().optional(),
     /** Execution mode: ALLOW_ALL (default) or REQUIRE_APPROVAL */
-    executionMode: import_v43.z.enum(["ALLOW_ALL", "REQUIRE_APPROVAL"]).optional(),
+    executionMode: import_v46.z.enum(["ALLOW_ALL", "REQUIRE_APPROVAL"]).optional(),
     /** Approval timeout in ms (default: 86400000 = 1 day) */
-    approvalTimeoutMs: import_v43.z.number().optional()
+    approvalTimeoutMs: import_v46.z.number().optional()
   }),
-  import_v43.z.object({
-    kind: import_v43.z.literal("MCP"),
-    server: import_v43.z.string(),
-    tool: import_v43.z.string(),
-    handle: import_v43.z.string().optional(),
-    displayName: import_v43.z.string().optional(),
-    description: import_v43.z.string().optional(),
+  import_v46.z.object({
+    kind: import_v46.z.literal("MCP"),
+    server: import_v46.z.string(),
+    tool: import_v46.z.string(),
+    handle: import_v46.z.string().optional(),
+    displayName: import_v46.z.string().optional(),
+    description: import_v46.z.string().optional(),
     /** Execution mode: ALLOW_ALL (default) or REQUIRE_APPROVAL */
-    executionMode: import_v43.z.enum(["ALLOW_ALL", "REQUIRE_APPROVAL"]).optional(),
+    executionMode: import_v46.z.enum(["ALLOW_ALL", "REQUIRE_APPROVAL"]).optional(),
     /** Approval timeout in ms (default: 86400000 = 1 day) */
-    approvalTimeoutMs: import_v43.z.number().optional()
+    approvalTimeoutMs: import_v46.z.number().optional()
   })
 ]);
-var StageBaseZ = import_v43.z.object({
+var StageBaseZ = import_v46.z.object({
   /** Unique identifier for the stage */
-  id: import_v43.z.string(),
+  id: import_v46.z.string(),
   /** Stage IDs that must complete before this stage runs */
-  needs: import_v43.z.array(import_v43.z.string()).optional(),
+  needs: import_v46.z.array(import_v46.z.string()).optional(),
   /** Liquid condition - stage is skipped if this evaluates to false */
-  if: import_v43.z.string().optional()
+  if: import_v46.z.string().optional()
 });
 var ToolStageZ = StageBaseZ.extend({
-  type: import_v43.z.literal("tool"),
+  type: import_v46.z.literal("tool"),
   /** Tool identifier (e.g., 'system:crm:prospect:get', 'app:hubspot:create_contact') */
-  resource: import_v43.z.string(),
+  resource: import_v46.z.string(),
   /** Input mappings - Liquid templates */
-  inputs: import_v43.z.record(import_v43.z.string(), import_v43.z.string()).optional(),
+  inputs: import_v46.z.record(import_v46.z.string(), import_v46.z.string()).optional(),
   /** Output mappings - Liquid templates referencing {{ result.xxx }} */
-  outputs: import_v43.z.record(import_v43.z.string(), import_v43.z.string()).optional()
+  outputs: import_v46.z.record(import_v46.z.string(), import_v46.z.string()).optional()
 });
-var StageAgentDefinitionZ = import_v43.z.object({
+var StageAgentDefinitionZ = import_v46.z.object({
   /** Unique identifier for the agent (lowercase, alphanumeric with dashes/underscores) */
-  handle: import_v43.z.string().regex(/^[a-z][a-z0-9_-]*$/, "Handle must be lowercase alphanumeric with dashes/underscores, starting with a letter"),
+  handle: import_v46.z.string().regex(/^[a-z][a-z0-9_-]*$/, "Handle must be lowercase alphanumeric with dashes/underscores, starting with a letter"),
   /** Display name for the agent */
-  name: import_v43.z.string().min(1, "Name is required"),
+  name: import_v46.z.string().min(1, "Name is required"),
   /** Description of what the agent does */
-  description: import_v43.z.string().optional(),
+  description: import_v46.z.string().optional(),
   /** System prompt that defines the agent behavior and tool selection logic */
-  system: import_v43.z.string(),
+  system: import_v46.z.string(),
   /** Optional persona name for response generation (e.g., "Brett") */
-  personaName: import_v43.z.string().optional(),
+  personaName: import_v46.z.string().optional(),
   /** Optional persona prompt for two-phase response generation (tone, style, format rules) */
-  persona: import_v43.z.string().optional(),
+  persona: import_v46.z.string().optional(),
   /** LLM model ID (e.g., "openai/gpt-4o-mini"). Defaults to gpt-4o-mini */
-  llmModelId: import_v43.z.string().optional(),
+  llmModelId: import_v46.z.string().optional(),
   /** Array of tool references to bind to this agent */
-  tools: import_v43.z.array(import_v43.z.union([ToolReferenceInputZ, ToolBindingZ])).optional(),
+  tools: import_v46.z.array(import_v46.z.union([ToolReferenceInputZ, ToolBindingZ])).optional(),
   /** JSON Schema for structured data output */
-  outputSchema: import_v43.z.record(import_v43.z.string(), import_v43.z.unknown()).optional()
+  outputSchema: import_v46.z.record(import_v46.z.string(), import_v46.z.unknown()).optional()
 });
 var AgentStageBaseZ = StageBaseZ.extend({
-  type: import_v43.z.literal("agent"),
+  type: import_v46.z.literal("agent"),
   /** Inline agent definition via props (preferred - contains full agent config) */
   props: StageAgentDefinitionZ.optional(),
   /** External agent reference by handle (for referencing DB agents) */
-  resource: import_v43.z.string().optional(),
+  resource: import_v46.z.string().optional(),
   /** Prompt template - Liquid template for the user message */
-  prompt: import_v43.z.string().optional(),
+  prompt: import_v46.z.string().optional(),
   /** Input mappings - Liquid templates injected into agent context */
-  inputs: import_v43.z.record(import_v43.z.string(), import_v43.z.string()).optional(),
+  inputs: import_v46.z.record(import_v46.z.string(), import_v46.z.string()).optional(),
   /** Output mappings - Liquid templates referencing {{ result.xxx }} */
-  outputs: import_v43.z.record(import_v43.z.string(), import_v43.z.string()).optional()
+  outputs: import_v46.z.record(import_v46.z.string(), import_v46.z.string()).optional()
 });
 var AgentStageZ = AgentStageBaseZ.refine(
   (data) => data.props || data.resource,
   { message: "Either 'props' (inline definition) or 'resource' (external reference) must be provided" }
 );
 var TransformStageZ = StageBaseZ.extend({
-  type: import_v43.z.literal("transform"),
+  type: import_v46.z.literal("transform"),
   /** Output mappings - Liquid templates that compute values */
-  outputs: import_v43.z.record(import_v43.z.string(), import_v43.z.string())
+  outputs: import_v46.z.record(import_v46.z.string(), import_v46.z.string())
 });
 var OutputStageZ = StageBaseZ.extend({
-  type: import_v43.z.literal("output"),
+  type: import_v46.z.literal("output"),
   /** Output mappings - Liquid templates for the final response */
-  outputs: import_v43.z.record(import_v43.z.string(), import_v43.z.string())
+  outputs: import_v46.z.record(import_v46.z.string(), import_v46.z.string())
 });
-var StageZ = import_v43.z.discriminatedUnion("type", [
+var StageZ = import_v46.z.discriminatedUnion("type", [
   ToolStageZ,
   AgentStageBaseZ,
   TransformStageZ,
   OutputStageZ
 ]);
-var LegacyActivityStageZ = import_v43.z.object({
-  id: import_v43.z.string(),
-  type: import_v43.z.literal("activity"),
-  activity: import_v43.z.string(),
-  inputs: import_v43.z.record(import_v43.z.string(), import_v43.z.string()).optional(),
-  outputs: import_v43.z.record(import_v43.z.string(), import_v43.z.string()).optional()
+var LegacyActivityStageZ = import_v46.z.object({
+  id: import_v46.z.string(),
+  type: import_v46.z.literal("activity"),
+  activity: import_v46.z.string(),
+  inputs: import_v46.z.record(import_v46.z.string(), import_v46.z.string()).optional(),
+  outputs: import_v46.z.record(import_v46.z.string(), import_v46.z.string()).optional()
 });
-var LegacyAgentStageZ = import_v43.z.object({
-  id: import_v43.z.string(),
-  type: import_v43.z.literal("agent"),
-  agent: import_v43.z.string(),
-  prompt: import_v43.z.string().optional(),
-  inputs: import_v43.z.record(import_v43.z.string(), import_v43.z.string()).optional(),
-  outputs: import_v43.z.record(import_v43.z.string(), import_v43.z.string()).optional()
+var LegacyAgentStageZ = import_v46.z.object({
+  id: import_v46.z.string(),
+  type: import_v46.z.literal("agent"),
+  agent: import_v46.z.string(),
+  prompt: import_v46.z.string().optional(),
+  inputs: import_v46.z.record(import_v46.z.string(), import_v46.z.string()).optional(),
+  outputs: import_v46.z.record(import_v46.z.string(), import_v46.z.string()).optional()
 });
-var LegacyConditionalStageZ = import_v43.z.object({
-  id: import_v43.z.string(),
-  type: import_v43.z.literal("conditional"),
-  condition: import_v43.z.string(),
-  then: import_v43.z.string(),
-  else: import_v43.z.string().optional()
+var LegacyConditionalStageZ = import_v46.z.object({
+  id: import_v46.z.string(),
+  type: import_v46.z.literal("conditional"),
+  condition: import_v46.z.string(),
+  then: import_v46.z.string(),
+  else: import_v46.z.string().optional()
 });
-var LegacyTransformStageZ = import_v43.z.object({
-  id: import_v43.z.string(),
-  type: import_v43.z.literal("transform"),
-  set: import_v43.z.record(import_v43.z.string(), import_v43.z.string())
+var LegacyTransformStageZ = import_v46.z.object({
+  id: import_v46.z.string(),
+  type: import_v46.z.literal("transform"),
+  set: import_v46.z.record(import_v46.z.string(), import_v46.z.string())
 });
-var LegacyOutputStageZ = import_v43.z.object({
-  id: import_v43.z.string(),
-  type: import_v43.z.literal("output"),
-  value: import_v43.z.record(import_v43.z.string(), import_v43.z.string())
+var LegacyOutputStageZ = import_v46.z.object({
+  id: import_v46.z.string(),
+  type: import_v46.z.literal("output"),
+  value: import_v46.z.record(import_v46.z.string(), import_v46.z.string())
 });
-var StageWithLegacyZ = import_v43.z.union([
+var StageWithLegacyZ = import_v46.z.union([
   StageZ,
   LegacyActivityStageZ,
   LegacyAgentStageZ,
@@ -10036,87 +10330,87 @@ var StageWithLegacyZ = import_v43.z.union([
   LegacyTransformStageZ,
   LegacyOutputStageZ
 ]);
-var InlineAgentDefinitionZ = import_v43.z.object({
+var InlineAgentDefinitionZ = import_v46.z.object({
   /** Unique identifier for the agent (lowercase, alphanumeric with dashes/underscores) */
-  handle: import_v43.z.string().regex(/^[a-z][a-z0-9_-]*$/, "Handle must be lowercase alphanumeric with dashes/underscores, starting with a letter"),
+  handle: import_v46.z.string().regex(/^[a-z][a-z0-9_-]*$/, "Handle must be lowercase alphanumeric with dashes/underscores, starting with a letter"),
   /** Display name for the agent */
-  name: import_v43.z.string().min(1, "Name is required"),
+  name: import_v46.z.string().min(1, "Name is required"),
   /** Description of what the agent does */
-  description: import_v43.z.string(),
+  description: import_v46.z.string(),
   /** System prompt that defines the agent behavior and tool selection logic */
-  system: import_v43.z.string(),
+  system: import_v46.z.string(),
   /** Optional persona name for response generation (e.g., "Brett") */
-  personaName: import_v43.z.string().optional(),
+  personaName: import_v46.z.string().optional(),
   /** Optional persona prompt for two-phase response generation (tone, style, format rules) */
-  persona: import_v43.z.string().optional(),
+  persona: import_v46.z.string().optional(),
   /** LLM model ID (e.g., "openai/gpt-4o-mini"). Defaults to gpt-4o-mini */
-  llmModelId: import_v43.z.string().optional(),
+  llmModelId: import_v46.z.string().optional(),
   /** Array of tool references to bind to this agent */
-  tools: import_v43.z.array(import_v43.z.union([ToolReferenceInputZ, ToolBindingZ])).optional(),
+  tools: import_v46.z.array(import_v46.z.union([ToolReferenceInputZ, ToolBindingZ])).optional(),
   /** 
    * JSON Schema for structured data output. When provided, the agent returns structured
    * data in the `data` field matching this schema. When not provided, agent defaults to
    * plain text output in the `content` field.
    */
-  outputSchema: import_v43.z.record(import_v43.z.string(), import_v43.z.unknown()).optional()
+  outputSchema: import_v46.z.record(import_v46.z.string(), import_v46.z.unknown()).optional()
 });
-var AgentInputOptionZ = import_v43.z.object({
+var AgentInputOptionZ = import_v46.z.object({
   /** Value to store when selected */
-  value: import_v43.z.string(),
+  value: import_v46.z.string(),
   /** Display label for the option */
-  label: import_v43.z.string()
+  label: import_v46.z.string()
 });
-var AgentInputFieldZ = import_v43.z.object({
+var AgentInputFieldZ = import_v46.z.object({
   /** Unique key for this input (used in Thread.inputs) */
-  key: import_v43.z.string(),
+  key: import_v46.z.string(),
   /** Display label for the input field */
-  label: import_v43.z.string().optional(),
+  label: import_v46.z.string().optional(),
   /** Help text/description for the input */
-  description: import_v43.z.string().optional(),
+  description: import_v46.z.string().optional(),
   /** Whether this input is required */
-  required: import_v43.z.boolean().optional(),
+  required: import_v46.z.boolean().optional(),
   /** Input type for rendering appropriate control */
-  type: import_v43.z.enum(["text", "number", "select", "textarea"]).optional(),
+  type: import_v46.z.enum(["text", "number", "select", "textarea"]).optional(),
   /** Options for select-type inputs */
-  options: import_v43.z.array(AgentInputOptionZ).optional(),
+  options: import_v46.z.array(AgentInputOptionZ).optional(),
   /** Placeholder text for the input */
-  placeholder: import_v43.z.string().optional()
+  placeholder: import_v46.z.string().optional()
 });
-var PersonaVoiceFormatZ = import_v43.z.object({
+var PersonaVoiceFormatZ = import_v46.z.object({
   /** Maximum character count for messages */
-  maxChars: import_v43.z.number().optional(),
+  maxChars: import_v46.z.number().optional(),
   /** Whether to avoid emojis */
-  noEmojis: import_v43.z.boolean().optional(),
+  noEmojis: import_v46.z.boolean().optional(),
   /** Whether to avoid hyphens */
-  noHyphens: import_v43.z.boolean().optional(),
+  noHyphens: import_v46.z.boolean().optional(),
   /** Whether to avoid bullet points */
-  noBulletPoints: import_v43.z.boolean().optional(),
+  noBulletPoints: import_v46.z.boolean().optional(),
   /** Maximum questions per message */
-  maxQuestionsPerMessage: import_v43.z.number().optional(),
+  maxQuestionsPerMessage: import_v46.z.number().optional(),
   /** Whether to avoid sign-offs like "Cheers" or "Thanks" */
-  noSignOffs: import_v43.z.boolean().optional()
+  noSignOffs: import_v46.z.boolean().optional()
 });
-var PersonaVoiceZ = import_v43.z.object({
+var PersonaVoiceZ = import_v46.z.object({
   /** Style guidelines as a single string (voice, tone, personality) */
-  style: import_v43.z.string(),
+  style: import_v46.z.string(),
   /** Formatting constraints */
   format: PersonaVoiceFormatZ.optional()
 });
-var PersonaZ = import_v43.z.object({
+var PersonaZ = import_v46.z.object({
   /** Display name for the persona (e.g., "Brett") */
-  name: import_v43.z.string(),
+  name: import_v46.z.string(),
   /** Voice configuration with style and format rules */
   voice: PersonaVoiceZ
 });
-var RespondBlockZ = import_v43.z.object({
+var RespondBlockZ = import_v46.z.object({
   /** Optional Liquid condition - if false, no message is sent */
-  if: import_v43.z.string().optional(),
+  if: import_v46.z.string().optional(),
   /** Direct message content (no persona transformation) - mutually exclusive with instructions */
-  content: import_v43.z.string().optional(),
+  content: import_v46.z.string().optional(),
   /** Instructions for persona to write message (Liquid template) - mutually exclusive with content */
-  instructions: import_v43.z.string().optional(),
+  instructions: import_v46.z.string().optional(),
   /** If true, message requires human approval before sending */
-  requiresApproval: import_v43.z.boolean().optional()
+  requiresApproval: import_v46.z.boolean().optional()
 }).refine(
   (data) => {
     const hasContent = !!data.content;
@@ -10125,51 +10419,51 @@ var RespondBlockZ = import_v43.z.object({
   },
   { message: "respond must have either content or instructions, but not both" }
 );
-var AgentBaseZ = import_v43.z.object({
+var AgentBaseZ = import_v46.z.object({
   /** Schema format version for future compatibility */
-  $schema: import_v43.z.literal("https://skedyul.com/schemas/agent/v1").optional(),
+  $schema: import_v46.z.literal("https://skedyul.com/schemas/agent/v1").optional(),
   /** Unique identifier for the agent (lowercase, alphanumeric with dashes/underscores) */
-  handle: import_v43.z.string().regex(/^[a-z][a-z0-9_-]*$/, "Handle must be lowercase alphanumeric with dashes/underscores, starting with a letter"),
+  handle: import_v46.z.string().regex(/^[a-z][a-z0-9_-]*$/, "Handle must be lowercase alphanumeric with dashes/underscores, starting with a letter"),
   /** Display name for the agent */
-  name: import_v43.z.string().min(1, "Name is required"),
+  name: import_v46.z.string().min(1, "Name is required"),
   /** Description of what the agent does */
-  description: import_v43.z.string(),
+  description: import_v46.z.string(),
   /** Whether the agent is enabled (default: true) */
-  isEnabled: import_v43.z.boolean().optional()
+  isEnabled: import_v46.z.boolean().optional()
 });
 var SingleStageAgentZ = AgentBaseZ.extend({
   /** System prompt that defines the agent behavior and tool selection logic */
-  system: import_v43.z.string(),
+  system: import_v46.z.string(),
   /** Optional persona name for response generation (e.g., "Brett") */
-  personaName: import_v43.z.string().optional(),
+  personaName: import_v46.z.string().optional(),
   /** Optional persona prompt for two-phase response generation (tone, style, format rules) */
-  persona: import_v43.z.string().optional(),
+  persona: import_v46.z.string().optional(),
   /** LLM model ID (e.g., "openai/gpt-4o-mini"). Defaults to gpt-4o-mini */
-  llmModelId: import_v43.z.string().optional(),
+  llmModelId: import_v46.z.string().optional(),
   /** Array of tool references to bind to this agent */
-  tools: import_v43.z.array(import_v43.z.union([ToolReferenceInputZ, ToolBindingZ])).optional(),
+  tools: import_v46.z.array(import_v46.z.union([ToolReferenceInputZ, ToolBindingZ])).optional(),
   /** Input fields to collect from user before agent runs (stored in Thread.inputs) */
-  inputs: import_v43.z.array(AgentInputFieldZ).optional()
+  inputs: import_v46.z.array(AgentInputFieldZ).optional()
 });
 var MultiStageAgentZ = AgentBaseZ.extend({
   /** @deprecated Use inline agent definitions in stages instead. Kept for backward compatibility. */
-  agents: import_v43.z.array(InlineAgentDefinitionZ).optional(),
+  agents: import_v46.z.array(InlineAgentDefinitionZ).optional(),
   /** Stages define the execution flow - each stage runs an agent, tool, or transform */
-  stages: import_v43.z.array(StageWithLegacyZ).min(1, "Multi-stage agents must have at least one stage"),
+  stages: import_v46.z.array(StageWithLegacyZ).min(1, "Multi-stage agents must have at least one stage"),
   /** Input schema for the agent (validated at runtime) */
-  inputs: import_v43.z.record(import_v43.z.string(), import_v43.z.object({
-    type: import_v43.z.enum(["string", "number", "boolean", "object", "array"]),
-    required: import_v43.z.boolean().optional(),
-    description: import_v43.z.string().optional()
+  inputs: import_v46.z.record(import_v46.z.string(), import_v46.z.object({
+    type: import_v46.z.enum(["string", "number", "boolean", "object", "array"]),
+    required: import_v46.z.boolean().optional(),
+    description: import_v46.z.string().optional()
   })).optional(),
   /** Error handling strategy */
-  onError: import_v43.z.enum(["fail", "skip", "retry"]).optional(),
+  onError: import_v46.z.enum(["fail", "skip", "retry"]).optional(),
   /** Persona configuration for voice and formatting */
   persona: PersonaZ.optional(),
   /** Respond block for explicit message output */
   respond: RespondBlockZ.optional()
 });
-var AgentSchemaZ = import_v43.z.union([SingleStageAgentZ, MultiStageAgentZ]);
+var AgentSchemaZ = import_v46.z.union([SingleStageAgentZ, MultiStageAgentZ]);
 function isMultiStageAgent(agent) {
   return "stages" in agent && Array.isArray(agent.stages);
 }
@@ -10186,265 +10480,131 @@ function validateAgentSchema(data) {
 }
 
 // src/schemas/agent-schema-v3.ts
-var import_v47 = require("zod/v4");
-
-// src/events/types.ts
-var import_v44 = require("zod/v4");
-var ThreadEventTypeSchema = import_v44.z.enum([
-  // Message events
-  "thread.message.received",
-  "thread.message.sent",
-  "thread.attachment.received",
-  // Participant events
-  "thread.participant.joined",
-  "thread.participant.left",
-  "thread.participant.mentioned",
-  // Context events
-  "thread.context.changed",
-  "thread.status.changed",
-  // Agent/Workflow events
-  "thread.agent.delegated",
-  "thread.agent.completed",
-  "thread.workflow.triggered",
-  "thread.workflow.completed",
-  // Scheduled events
-  "thread.follow_up.due",
-  "thread.reminder.due",
-  // Signal events
-  "thread.signal.created"
-]);
-var CustomEventTypeSchema = import_v44.z.string().regex(/^custom\.[a-z][a-z0-9_]*(\.[a-z][a-z0-9_]*)*$/, {
-  message: "Custom event type must match pattern: custom.{namespace}.{event}"
-});
-var EventTypeSchema = import_v44.z.union([ThreadEventTypeSchema, CustomEventTypeSchema]);
-var ParticipantKindSchema = import_v44.z.enum(["CONTACT", "MEMBER", "AGENT", "WORKFLOW"]);
-var BaseEventPayloadSchema = import_v44.z.object({
-  threadId: import_v44.z.string(),
-  workplaceId: import_v44.z.string(),
-  timestamp: import_v44.z.string().datetime().optional()
-});
-var MessageEventPayloadSchema = BaseEventPayloadSchema.extend({
-  message: import_v44.z.object({
-    id: import_v44.z.string(),
-    content: import_v44.z.string(),
-    senderId: import_v44.z.string().optional()
-  }),
-  participant: import_v44.z.object({
-    id: import_v44.z.string(),
-    kind: ParticipantKindSchema,
-    displayName: import_v44.z.string().optional()
-  }).optional(),
-  isFirstMessage: import_v44.z.boolean().optional(),
-  messageCount: import_v44.z.number().optional()
-});
-var ParticipantEventPayloadSchema = BaseEventPayloadSchema.extend({
-  participant: import_v44.z.object({
-    id: import_v44.z.string(),
-    kind: ParticipantKindSchema,
-    displayName: import_v44.z.string().optional(),
-    contactId: import_v44.z.string().optional(),
-    memberId: import_v44.z.string().optional(),
-    agentId: import_v44.z.string().optional(),
-    workflowId: import_v44.z.string().optional()
-  })
-});
-var ContextChangedPayloadSchema = BaseEventPayloadSchema.extend({
-  context: import_v44.z.object({
-    handle: import_v44.z.string(),
-    model: import_v44.z.string(),
-    instanceId: import_v44.z.string()
-  }),
-  change: import_v44.z.object({
-    field: import_v44.z.string().optional(),
-    oldValue: import_v44.z.unknown().optional(),
-    newValue: import_v44.z.unknown().optional()
-  }).optional()
-});
-var StatusChangedPayloadSchema = BaseEventPayloadSchema.extend({
-  oldStatus: import_v44.z.string(),
-  newStatus: import_v44.z.string()
-});
-var ScheduledEventPayloadSchema = BaseEventPayloadSchema.extend({
-  scheduledEventId: import_v44.z.string(),
-  reason: import_v44.z.string().optional(),
-  context: import_v44.z.record(import_v44.z.string(), import_v44.z.unknown()).optional()
-});
-var AgentWorkflowEventPayloadSchema = BaseEventPayloadSchema.extend({
-  agentId: import_v44.z.string().optional(),
-  workflowId: import_v44.z.string().optional(),
-  workflowRunId: import_v44.z.string().optional(),
-  outputs: import_v44.z.record(import_v44.z.string(), import_v44.z.unknown()).optional(),
-  error: import_v44.z.string().optional()
-});
-var CustomEventPayloadSchema = BaseEventPayloadSchema.extend({
-  data: import_v44.z.record(import_v44.z.string(), import_v44.z.unknown()).optional()
-});
-var ThreadEventPayloadSchema = import_v44.z.union([
-  MessageEventPayloadSchema,
-  ParticipantEventPayloadSchema,
-  ContextChangedPayloadSchema,
-  StatusChangedPayloadSchema,
-  ScheduledEventPayloadSchema,
-  AgentWorkflowEventPayloadSchema,
-  CustomEventPayloadSchema
-]);
-var ThreadEventSchema = import_v44.z.object({
-  id: import_v44.z.string(),
-  threadId: import_v44.z.string(),
-  type: EventTypeSchema,
-  payload: ThreadEventPayloadSchema,
-  emittedBy: import_v44.z.string().optional(),
-  createdAt: import_v44.z.string().datetime()
-});
-var CreateThreadEventInputSchema = import_v44.z.object({
-  threadId: import_v44.z.string(),
-  type: EventTypeSchema,
-  payload: import_v44.z.record(import_v44.z.string(), import_v44.z.unknown()),
-  emittedBy: import_v44.z.string().optional()
-});
-var EventSubscriptionSchema = import_v44.z.object({
-  subscribes: import_v44.z.array(EventTypeSchema),
-  condition: import_v44.z.string().optional(),
-  cancels: import_v44.z.array(EventTypeSchema).optional(),
-  cancelCondition: import_v44.z.string().optional()
-});
-var EventWaitSchema = import_v44.z.object({
-  event: EventTypeSchema,
-  timeout: import_v44.z.string().optional(),
-  onTimeout: import_v44.z.string().optional()
-});
-var EventsConfigSchema = import_v44.z.object({
-  subscribes: import_v44.z.array(EventTypeSchema).optional(),
-  condition: import_v44.z.string().optional(),
-  emits: import_v44.z.array(EventTypeSchema).optional(),
-  waits: import_v44.z.array(EventWaitSchema).optional(),
-  cancels: import_v44.z.array(EventTypeSchema).optional(),
-  cancelCondition: import_v44.z.string().optional()
-});
+var import_v49 = require("zod/v4");
 
 // src/skills/types.ts
-var import_v45 = require("zod/v4");
+var import_v47 = require("zod/v4");
 var SKILL_SCHEMA_VERSION_V2 = "https://skedyul.com/schemas/skill/v2";
-var SkillSourceSchema = import_v45.z.enum(["BUILTIN", "S3", "APP", "EXTERNAL"]);
-var SkillToolRequirementSchema = import_v45.z.object({
-  requires: import_v45.z.array(import_v45.z.string()).optional(),
-  provides: import_v45.z.array(import_v45.z.string()).optional()
+var SkillSourceSchema = import_v47.z.enum(["BUILTIN", "S3", "APP", "EXTERNAL"]);
+var SkillToolRequirementSchema = import_v47.z.object({
+  requires: import_v47.z.array(import_v47.z.string()).optional(),
+  provides: import_v47.z.array(import_v47.z.string()).optional()
 });
-var SkillToolSandboxSchema = import_v45.z.object({
-  mock: import_v45.z.unknown().optional()
+var SkillToolSandboxSchema = import_v47.z.object({
+  mock: import_v47.z.unknown().optional()
 });
-var ToolConstraintsSchema = import_v45.z.object({
-  maxCallsPerRun: import_v45.z.number().optional(),
-  idempotent: import_v45.z.boolean().optional(),
-  restricted: import_v45.z.boolean().optional(),
-  tags: import_v45.z.array(import_v45.z.string()).optional()
+var ToolConstraintsSchema = import_v47.z.object({
+  maxCallsPerRun: import_v47.z.number().optional(),
+  idempotent: import_v47.z.boolean().optional(),
+  restricted: import_v47.z.boolean().optional(),
+  tags: import_v47.z.array(import_v47.z.string()).optional()
 });
-var SkillToolDefinitionSchema = import_v45.z.object({
-  tool: import_v45.z.string(),
-  description: import_v45.z.string().optional(),
-  overrides: import_v45.z.record(import_v45.z.string(), import_v45.z.unknown()).optional(),
+var SkillToolDefinitionSchema = import_v47.z.object({
+  tool: import_v47.z.string(),
+  description: import_v47.z.string().optional(),
+  overrides: import_v47.z.record(import_v47.z.string(), import_v47.z.unknown()).optional(),
   sandbox: SkillToolSandboxSchema.optional(),
-  requiresApproval: import_v45.z.boolean().optional(),
+  requiresApproval: import_v47.z.boolean().optional(),
   constraints: ToolConstraintsSchema.optional()
 });
-var SkillToolsSchema = import_v45.z.union([
+var SkillToolsSchema = import_v47.z.union([
   SkillToolRequirementSchema,
-  import_v45.z.array(SkillToolDefinitionSchema)
+  import_v47.z.array(SkillToolDefinitionSchema)
 ]);
-var SkillExampleSchema = import_v45.z.object({
-  context: import_v45.z.string().optional(),
-  input: import_v45.z.string(),
-  reasoning: import_v45.z.string().optional(),
-  output: import_v45.z.string(),
-  tool_call: import_v45.z.string().optional()
+var SkillExampleSchema = import_v47.z.object({
+  context: import_v47.z.string().optional(),
+  input: import_v47.z.string(),
+  reasoning: import_v47.z.string().optional(),
+  output: import_v47.z.string(),
+  tool_call: import_v47.z.string().optional()
 });
-var CRMModelFieldRequirementsSchema = import_v45.z.object({
-  required: import_v45.z.array(import_v45.z.string()).optional(),
-  recommended: import_v45.z.array(import_v45.z.string()).optional()
+var CRMModelFieldRequirementsSchema = import_v47.z.object({
+  required: import_v47.z.array(import_v47.z.string()).optional(),
+  recommended: import_v47.z.array(import_v47.z.string()).optional()
 });
-var CRMContextSchema = import_v45.z.object({
-  models: import_v45.z.record(import_v45.z.string(), CRMModelFieldRequirementsSchema)
+var CRMContextSchema = import_v47.z.object({
+  models: import_v47.z.record(import_v47.z.string(), CRMModelFieldRequirementsSchema)
 });
-var SkillYAMLSchema = import_v45.z.object({
+var SkillYAMLSchema = import_v47.z.object({
   // Schema version
-  $schema: import_v45.z.string().optional(),
+  $schema: import_v47.z.string().optional(),
   // Identity
-  handle: import_v45.z.string(),
-  name: import_v45.z.string(),
-  version: import_v45.z.string().optional(),
-  description: import_v45.z.string().optional(),
+  handle: import_v47.z.string(),
+  name: import_v47.z.string(),
+  version: import_v47.z.string().optional(),
+  description: import_v47.z.string().optional(),
   // Instructions injected into agent system prompt
-  instructions: import_v45.z.string(),
+  instructions: import_v47.z.string(),
   // Tool configuration - supports both v1 and v2 formats
   tools: SkillToolsSchema.optional(),
   // CRM context - specifies which models/fields to include in schema
   crmContext: CRMContextSchema.optional(),
   // Few-shot examples
-  examples: import_v45.z.array(SkillExampleSchema).optional()
+  examples: import_v47.z.array(SkillExampleSchema).optional()
 });
-var SkillYAMLV2Schema = import_v45.z.object({
-  $schema: import_v45.z.literal(SKILL_SCHEMA_VERSION_V2).optional(),
-  handle: import_v45.z.string(),
-  name: import_v45.z.string(),
-  version: import_v45.z.string().optional(),
-  description: import_v45.z.string().optional(),
-  instructions: import_v45.z.string(),
-  tools: import_v45.z.array(SkillToolDefinitionSchema).optional(),
+var SkillYAMLV2Schema = import_v47.z.object({
+  $schema: import_v47.z.literal(SKILL_SCHEMA_VERSION_V2).optional(),
+  handle: import_v47.z.string(),
+  name: import_v47.z.string(),
+  version: import_v47.z.string().optional(),
+  description: import_v47.z.string().optional(),
+  instructions: import_v47.z.string(),
+  tools: import_v47.z.array(SkillToolDefinitionSchema).optional(),
   crmContext: CRMContextSchema.optional(),
-  examples: import_v45.z.array(SkillExampleSchema).optional()
+  examples: import_v47.z.array(SkillExampleSchema).optional()
 });
-var SkillVersionWeightSchema = import_v45.z.object({
-  version: import_v45.z.number(),
-  weight: import_v45.z.number()
+var SkillVersionWeightSchema = import_v47.z.object({
+  version: import_v47.z.number(),
+  weight: import_v47.z.number()
 });
-var SkillRefSchema = import_v45.z.union([
-  import_v45.z.string(),
+var SkillRefSchema = import_v47.z.union([
+  import_v47.z.string(),
   // Just handle - uses latest published version
-  import_v45.z.object({
-    skill: import_v45.z.string(),
-    description: import_v45.z.string().optional(),
+  import_v47.z.object({
+    skill: import_v47.z.string(),
+    description: import_v47.z.string().optional(),
     // For AI SDK Agent Skills discovery
     /** Auto-inject this skill's instructions and tools on every agent turn */
-    alwaysLoad: import_v45.z.boolean().optional(),
+    alwaysLoad: import_v47.z.boolean().optional(),
     // Version selection (pick one):
-    version: import_v45.z.number().optional(),
+    version: import_v47.z.number().optional(),
     // Pin to specific version number
-    versions: import_v45.z.array(SkillVersionWeightSchema).optional(),
+    versions: import_v47.z.array(SkillVersionWeightSchema).optional(),
     // A/B testing weights
     // Legacy support:
-    instructions: import_v45.z.string().optional(),
+    instructions: import_v47.z.string().optional(),
     // Inline instructions (deprecated)
-    enabled: import_v45.z.boolean().optional()
+    enabled: import_v47.z.boolean().optional()
   })
 ]);
-var SkillMetadataSchema = import_v45.z.object({
-  id: import_v45.z.string(),
-  handle: import_v45.z.string(),
-  name: import_v45.z.string(),
-  version: import_v45.z.string().optional(),
-  description: import_v45.z.string().optional(),
+var SkillMetadataSchema = import_v47.z.object({
+  id: import_v47.z.string(),
+  handle: import_v47.z.string(),
+  name: import_v47.z.string(),
+  version: import_v47.z.string().optional(),
+  description: import_v47.z.string().optional(),
   source: SkillSourceSchema,
-  s3Key: import_v45.z.string().optional(),
-  appVersionId: import_v45.z.string().optional(),
-  workplaceId: import_v45.z.string().optional(),
-  createdAt: import_v45.z.string().datetime().optional(),
-  updatedAt: import_v45.z.string().datetime().optional()
+  s3Key: import_v47.z.string().optional(),
+  appVersionId: import_v47.z.string().optional(),
+  workplaceId: import_v47.z.string().optional(),
+  createdAt: import_v47.z.string().datetime().optional(),
+  updatedAt: import_v47.z.string().datetime().optional()
 });
-var ResolvedSkillSchema = import_v45.z.object({
-  handle: import_v45.z.string(),
-  name: import_v45.z.string(),
-  instructions: import_v45.z.string().optional(),
-  description: import_v45.z.string().optional(),
-  tools: import_v45.z.array(import_v45.z.string()).optional(),
-  examples: import_v45.z.array(SkillExampleSchema).optional()
+var ResolvedSkillSchema = import_v47.z.object({
+  handle: import_v47.z.string(),
+  name: import_v47.z.string(),
+  instructions: import_v47.z.string().optional(),
+  description: import_v47.z.string().optional(),
+  tools: import_v47.z.array(import_v47.z.string()).optional(),
+  examples: import_v47.z.array(SkillExampleSchema).optional()
 });
-var LoadedSkillSchema = import_v45.z.object({
-  handle: import_v45.z.string(),
-  name: import_v45.z.string(),
-  instructions: import_v45.z.string().optional(),
-  description: import_v45.z.string().optional(),
-  tools: import_v45.z.array(SkillToolDefinitionSchema).optional(),
-  examples: import_v45.z.array(SkillExampleSchema).optional()
+var LoadedSkillSchema = import_v47.z.object({
+  handle: import_v47.z.string(),
+  name: import_v47.z.string(),
+  instructions: import_v47.z.string().optional(),
+  description: import_v47.z.string().optional(),
+  tools: import_v47.z.array(SkillToolDefinitionSchema).optional(),
+  examples: import_v47.z.array(SkillExampleSchema).optional()
 });
 function validateSkillYAML(skill) {
   const result = SkillYAMLSchema.safeParse(skill);
@@ -10455,179 +10615,179 @@ function validateSkillYAML(skill) {
 }
 
 // src/context/types.ts
-var import_v46 = require("zod/v4");
-var CRMContextSchema2 = import_v46.z.object({
-  model: import_v46.z.string(),
-  instanceId: import_v46.z.string(),
-  data: import_v46.z.record(import_v46.z.string(), import_v46.z.unknown())
+var import_v48 = require("zod/v4");
+var CRMContextSchema2 = import_v48.z.object({
+  model: import_v48.z.string(),
+  instanceId: import_v48.z.string(),
+  data: import_v48.z.record(import_v48.z.string(), import_v48.z.unknown())
 });
-var SenderContextSchema = import_v46.z.object({
+var SenderContextSchema2 = import_v48.z.object({
   kind: ParticipantKindSchema,
-  displayName: import_v46.z.string().optional(),
-  email: import_v46.z.string().optional(),
-  role: import_v46.z.string().optional(),
-  permissions: import_v46.z.array(import_v46.z.string()).optional(),
+  displayName: import_v48.z.string().optional(),
+  email: import_v48.z.string().optional(),
+  role: import_v48.z.string().optional(),
+  permissions: import_v48.z.array(import_v48.z.string()).optional(),
   crm: CRMContextSchema2.optional()
 });
-var ThreadContextItemSchema = import_v46.z.object({
-  handle: import_v46.z.string(),
-  model: import_v46.z.string(),
-  instanceId: import_v46.z.string(),
-  data: import_v46.z.record(import_v46.z.string(), import_v46.z.unknown()).optional()
+var ThreadContextItemSchema2 = import_v48.z.object({
+  handle: import_v48.z.string(),
+  model: import_v48.z.string(),
+  instanceId: import_v48.z.string(),
+  data: import_v48.z.record(import_v48.z.string(), import_v48.z.unknown()).optional()
 });
-var ThreadInfoSchema = import_v46.z.object({
-  id: import_v46.z.string(),
-  title: import_v46.z.string().optional(),
-  status: import_v46.z.string().optional(),
-  kind: import_v46.z.string().optional()
+var ThreadInfoSchema = import_v48.z.object({
+  id: import_v48.z.string(),
+  title: import_v48.z.string().optional(),
+  status: import_v48.z.string().optional(),
+  kind: import_v48.z.string().optional()
 });
-var SubscriptionSchema = import_v46.z.object({
-  identifierValue: import_v46.z.string(),
-  channelHandle: import_v46.z.string().optional()
+var SubscriptionSchema = import_v48.z.object({
+  identifierValue: import_v48.z.string(),
+  channelHandle: import_v48.z.string().optional()
 });
-var AssociationSchema = import_v46.z.object({
-  id: import_v46.z.string().optional(),
-  data: import_v46.z.record(import_v46.z.string(), import_v46.z.unknown())
+var AssociationSchema = import_v48.z.object({
+  id: import_v48.z.string().optional(),
+  data: import_v48.z.record(import_v48.z.string(), import_v48.z.unknown())
 });
-var ContactSchema = import_v46.z.object({
-  id: import_v46.z.string().optional(),
-  name: import_v46.z.string().optional(),
+var ContactSchema = import_v48.z.object({
+  id: import_v48.z.string().optional(),
+  name: import_v48.z.string().optional(),
   subscription: SubscriptionSchema.optional(),
-  associations: import_v46.z.record(import_v46.z.string(), AssociationSchema).optional()
+  associations: import_v48.z.record(import_v48.z.string(), AssociationSchema).optional()
 });
-var AgentSenderContextSchema = import_v46.z.object({
-  kind: import_v46.z.enum(["contact", "member"]),
-  displayName: import_v46.z.string().optional(),
-  role: import_v46.z.string().optional(),
-  permissions: import_v46.z.array(import_v46.z.string()).optional(),
+var AgentSenderContextSchema = import_v48.z.object({
+  kind: import_v48.z.enum(["contact", "member"]),
+  displayName: import_v48.z.string().optional(),
+  role: import_v48.z.string().optional(),
+  permissions: import_v48.z.array(import_v48.z.string()).optional(),
   contact: ContactSchema.optional()
 });
-var AgentThreadContextSchema = import_v46.z.object({
-  handle: import_v46.z.string(),
-  model: import_v46.z.string(),
-  data: import_v46.z.record(import_v46.z.string(), import_v46.z.unknown())
+var AgentThreadContextSchema = import_v48.z.object({
+  handle: import_v48.z.string(),
+  model: import_v48.z.string(),
+  data: import_v48.z.record(import_v48.z.string(), import_v48.z.unknown())
 });
-var AgentContextSchema = import_v46.z.object({
+var AgentContextSchema = import_v48.z.object({
   sender: AgentSenderContextSchema,
-  contexts: import_v46.z.array(AgentThreadContextSchema).optional()
+  contexts: import_v48.z.array(AgentThreadContextSchema).optional()
 });
-var ContextIssueSeveritySchema = import_v46.z.enum(["ERROR", "WARNING"]);
-var ContextIssueTypeSchema = import_v46.z.enum([
+var ContextIssueSeveritySchema = import_v48.z.enum(["ERROR", "WARNING"]);
+var ContextIssueTypeSchema = import_v48.z.enum([
   "MISSING_ROUTING_PARTICIPANT",
   "MISSING_ASSOCIATION",
   "MISSING_REQUIRED_FIELD",
   "MISSING_RECOMMENDED_FIELD"
 ]);
-var ContextIssueSchema = import_v46.z.object({
+var ContextIssueSchema = import_v48.z.object({
   type: ContextIssueTypeSchema,
   severity: ContextIssueSeveritySchema,
-  model: import_v46.z.string().optional(),
-  field: import_v46.z.string().optional(),
-  message: import_v46.z.string(),
-  suggestion: import_v46.z.string().optional()
+  model: import_v48.z.string().optional(),
+  field: import_v48.z.string().optional(),
+  message: import_v48.z.string(),
+  suggestion: import_v48.z.string().optional()
 });
-var ContextValidationResultSchema = import_v46.z.object({
-  valid: import_v46.z.boolean(),
-  degraded: import_v46.z.boolean(),
-  issues: import_v46.z.array(ContextIssueSchema)
+var ContextValidationResultSchema = import_v48.z.object({
+  valid: import_v48.z.boolean(),
+  degraded: import_v48.z.boolean(),
+  issues: import_v48.z.array(ContextIssueSchema)
 });
-var SandboxConfigSchema = import_v46.z.object({
-  enabled: import_v46.z.boolean().optional(),
+var SandboxConfigSchema = import_v48.z.object({
+  enabled: import_v48.z.boolean().optional(),
   /** @deprecated Use 'context' instead of 'mockContext' */
   mockContext: AgentContextSchema.optional(),
   context: AgentContextSchema.optional()
 });
 
 // src/schemas/agent-schema-v3.ts
-var PersonaVoiceFormatV3Schema = import_v47.z.object({
-  maxChars: import_v47.z.number().optional(),
-  noEmojis: import_v47.z.boolean().optional(),
-  noHyphens: import_v47.z.boolean().optional(),
-  noBulletPoints: import_v47.z.boolean().optional(),
-  maxQuestionsPerMessage: import_v47.z.number().optional(),
-  noSignOffs: import_v47.z.boolean().optional()
+var PersonaVoiceFormatV3Schema = import_v49.z.object({
+  maxChars: import_v49.z.number().optional(),
+  noEmojis: import_v49.z.boolean().optional(),
+  noHyphens: import_v49.z.boolean().optional(),
+  noBulletPoints: import_v49.z.boolean().optional(),
+  maxQuestionsPerMessage: import_v49.z.number().optional(),
+  noSignOffs: import_v49.z.boolean().optional()
 });
-var PersonaVoiceV3Schema = import_v47.z.object({
-  style: import_v47.z.string(),
+var PersonaVoiceV3Schema = import_v49.z.object({
+  style: import_v49.z.string(),
   format: PersonaVoiceFormatV3Schema.optional()
 });
-var PersonaV3Schema = import_v47.z.object({
-  name: import_v47.z.string(),
+var PersonaV3Schema = import_v49.z.object({
+  name: import_v49.z.string(),
   voice: PersonaVoiceV3Schema
 });
-var ToolApprovalConfigSchema = import_v47.z.object({
-  required: import_v47.z.boolean().optional(),
-  requiredIf: import_v47.z.array(import_v47.z.string()).optional()
+var ToolApprovalConfigSchema = import_v49.z.object({
+  required: import_v49.z.boolean().optional(),
+  requiredIf: import_v49.z.array(import_v49.z.string()).optional()
 });
-var ToolSandboxConfigSchema = import_v47.z.object({
-  mock: import_v47.z.unknown().optional()
+var ToolSandboxConfigSchema = import_v49.z.object({
+  mock: import_v49.z.unknown().optional()
 });
-var ToolRefV3Schema = import_v47.z.union([
-  import_v47.z.string(),
-  import_v47.z.object({
-    tool: import_v47.z.string(),
-    description: import_v47.z.string().optional(),
+var ToolRefV3Schema = import_v49.z.union([
+  import_v49.z.string(),
+  import_v49.z.object({
+    tool: import_v49.z.string(),
+    description: import_v49.z.string().optional(),
     approval: ToolApprovalConfigSchema.optional(),
     sandbox: ToolSandboxConfigSchema.optional(),
-    overrides: import_v47.z.record(import_v47.z.string(), import_v47.z.unknown()).optional()
+    overrides: import_v49.z.record(import_v49.z.string(), import_v49.z.unknown()).optional()
   })
 ]);
-var AgentToolRefSchema = import_v47.z.union([
-  import_v47.z.string(),
-  import_v47.z.object({
-    tool: import_v47.z.string(),
-    description: import_v47.z.string().optional()
+var AgentToolRefSchema = import_v49.z.union([
+  import_v49.z.string(),
+  import_v49.z.object({
+    tool: import_v49.z.string(),
+    description: import_v49.z.string().optional()
   })
 ]);
-var WorkingMemoryConfigSchema = import_v47.z.object({
-  strategy: import_v47.z.enum(["full", "rolling_summary", "sliding_window"]).optional(),
-  maxTokens: import_v47.z.number().optional(),
-  summarizeAt: import_v47.z.number().optional()
+var WorkingMemoryConfigSchema = import_v49.z.object({
+  strategy: import_v49.z.enum(["full", "rolling_summary", "sliding_window"]).optional(),
+  maxTokens: import_v49.z.number().optional(),
+  summarizeAt: import_v49.z.number().optional()
 });
-var ExternalMemoryConfigSchema = import_v47.z.object({
-  enabled: import_v47.z.boolean().optional(),
-  ttl: import_v47.z.string().optional()
+var ExternalMemoryConfigSchema = import_v49.z.object({
+  enabled: import_v49.z.boolean().optional(),
+  ttl: import_v49.z.string().optional()
 });
-var SemanticMemoryConfigSchema = import_v47.z.object({
-  enabled: import_v47.z.boolean().optional(),
-  topK: import_v47.z.number().optional(),
-  scope: import_v47.z.enum(["thread", "instance", "workspace"]).optional()
+var SemanticMemoryConfigSchema = import_v49.z.object({
+  enabled: import_v49.z.boolean().optional(),
+  topK: import_v49.z.number().optional(),
+  scope: import_v49.z.enum(["thread", "instance", "workspace"]).optional()
 });
-var MemoryConfigV3Schema = import_v47.z.object({
+var MemoryConfigV3Schema = import_v49.z.object({
   working: WorkingMemoryConfigSchema.optional(),
-  persistent: import_v47.z.object({
-    namespace: import_v47.z.string().optional()
+  persistent: import_v49.z.object({
+    namespace: import_v49.z.string().optional()
   }).optional(),
   external: ExternalMemoryConfigSchema.optional(),
   semantic: SemanticMemoryConfigSchema.optional()
 });
-var RequiresApprovalPolicySchema = import_v47.z.object({
-  requiresApproval: import_v47.z.boolean().optional()
+var RequiresApprovalPolicySchema = import_v49.z.object({
+  requiresApproval: import_v49.z.boolean().optional()
 });
-var PoliciesConfigV3Schema = import_v47.z.object({
-  messages: import_v47.z.object({
+var PoliciesConfigV3Schema = import_v49.z.object({
+  messages: import_v49.z.object({
     send: RequiresApprovalPolicySchema.optional(),
     schedule: RequiresApprovalPolicySchema.optional()
   }).optional(),
-  tools: import_v47.z.object({
-    externalRequiresApproval: import_v47.z.boolean().optional(),
-    systemRequiresApproval: import_v47.z.boolean().optional()
+  tools: import_v49.z.object({
+    externalRequiresApproval: import_v49.z.boolean().optional(),
+    systemRequiresApproval: import_v49.z.boolean().optional()
   }).optional()
 });
-var RuntimeConfigV3Schema = import_v47.z.object({
+var RuntimeConfigV3Schema = import_v49.z.object({
   /** LLM model identifier for reasoning (e.g., "google/gemini-3.1-flash-lite") */
-  model: import_v47.z.string().optional(),
+  model: import_v49.z.string().optional(),
   /** LLM model for persona transformation (e.g., "openai/gpt-5-nano") */
-  personaModel: import_v47.z.string().optional()
+  personaModel: import_v49.z.string().optional()
 });
-var TimeWindowTimeStampSchema = import_v47.z.union([
-  import_v47.z.number().describe("Hour of day (0-23)"),
-  import_v47.z.object({
-    hour: import_v47.z.number(),
-    minute: import_v47.z.number().optional().default(0)
+var TimeWindowTimeStampSchema = import_v49.z.union([
+  import_v49.z.number().describe("Hour of day (0-23)"),
+  import_v49.z.object({
+    hour: import_v49.z.number(),
+    minute: import_v49.z.number().optional().default(0)
   })
 ]);
-var TimeWindowDayOfWeekSchema = import_v47.z.enum([
+var TimeWindowDayOfWeekSchema = import_v49.z.enum([
   "monday",
   "tuesday",
   "wednesday",
@@ -10636,47 +10796,47 @@ var TimeWindowDayOfWeekSchema = import_v47.z.enum([
   "saturday",
   "sunday"
 ]);
-var TimeWindowSlotAgentSchema = import_v47.z.object({
+var TimeWindowSlotAgentSchema = import_v49.z.object({
   startTime: TimeWindowTimeStampSchema,
   endTime: TimeWindowTimeStampSchema,
-  days: import_v47.z.array(TimeWindowDayOfWeekSchema)
+  days: import_v49.z.array(TimeWindowDayOfWeekSchema)
 });
-var ResponseModeSchema = import_v47.z.enum([
+var ResponseModeSchema = import_v49.z.enum([
   "immediate",
   "ack_and_schedule",
   "schedule_only"
 ]);
-var TimeWindowBehaviorSchema = import_v47.z.object({
+var TimeWindowBehaviorSchema = import_v49.z.object({
   /** How to handle responses in this window */
   responseMode: ResponseModeSchema,
   /** Prompt injection for this time context */
-  prompt: import_v47.z.string().optional().describe("Prompt injection for this time context"),
+  prompt: import_v49.z.string().optional().describe("Prompt injection for this time context"),
   /** Window to schedule responses for (when responseMode is ack_and_schedule or schedule_only) */
-  scheduleFor: import_v47.z.string().optional().describe("Window name to schedule responses for")
+  scheduleFor: import_v49.z.string().optional().describe("Window name to schedule responses for")
 });
-var TimeWindowPolicySchema = import_v47.z.object({
+var TimeWindowPolicySchema = import_v49.z.object({
   /** IANA timezone for the window (e.g., "Australia/Sydney") */
-  timezone: import_v47.z.string().describe('IANA timezone, e.g., "Australia/Sydney"'),
+  timezone: import_v49.z.string().describe('IANA timezone, e.g., "Australia/Sydney"'),
   /** Time slots when this window is active */
-  windows: import_v47.z.array(TimeWindowSlotAgentSchema),
+  windows: import_v49.z.array(TimeWindowSlotAgentSchema),
   /** Behavior for this window (optional - defaults to immediate response) */
   behavior: TimeWindowBehaviorSchema.optional()
 });
-var TimeWindowPoliciesSchema = import_v47.z.record(import_v47.z.string(), TimeWindowPolicySchema);
+var TimeWindowPoliciesSchema = import_v49.z.record(import_v49.z.string(), TimeWindowPolicySchema);
 var TimeWindowDefaultSchema = TimeWindowBehaviorSchema.describe(
   "Fallback behavior when no time window matches"
 );
-var ResponsesBehaviorConfigSchema = import_v47.z.object({
+var ResponsesBehaviorConfigSchema = import_v49.z.object({
   /**
    * Maximum immediate messages per agent run (acks, progress updates).
    * @default 1
    */
-  maxImmediate: import_v47.z.number().optional(),
+  maxImmediate: import_v49.z.number().optional(),
   /**
    * Maximum scheduled messages per agent run (follow-ups via sendAt).
    * @default 2
    */
-  maxScheduled: import_v47.z.number().optional(),
+  maxScheduled: import_v49.z.number().optional(),
   /**
    * Maximum intermediate messages per agent run.
    * Intermediate = progress updates, acknowledgments before task completion.
@@ -10684,74 +10844,74 @@ var ResponsesBehaviorConfigSchema = import_v47.z.object({
    * @deprecated Use maxImmediate instead
    * @default 2
    */
-  maxIntermediate: import_v47.z.number().optional(),
+  maxIntermediate: import_v49.z.number().optional(),
   /**
    * Whether a final message is required before the run completes.
    * If true and no final message is sent, the run fails.
    * @default true
    */
-  requireFinal: import_v47.z.boolean().optional(),
+  requireFinal: import_v49.z.boolean().optional(),
   /**
    * Whether the agent can schedule messages for future delivery.
    * Scheduled messages typically require approval.
    * @default false
    */
-  allowSchedule: import_v47.z.boolean().optional(),
+  allowSchedule: import_v49.z.boolean().optional(),
   /**
    * Message splitting configuration.
    * Controls whether and how the agent splits responses into multiple messages.
    */
-  messageSplitting: import_v47.z.object({
+  messageSplitting: import_v49.z.object({
     /**
      * Whether to allow natural message splitting.
      * When true, the agent may split responses into multiple messages
      * when it improves conversational flow.
      */
-    enabled: import_v47.z.boolean(),
+    enabled: import_v49.z.boolean(),
     /**
      * Custom prompt to override the default message splitting guidance.
      * If not provided, uses sensible defaults for when to split vs. keep together.
      */
-    prompt: import_v47.z.string().optional()
+    prompt: import_v49.z.string().optional()
   }).optional()
 });
-var SchedulingDelaySchema = import_v47.z.object({
+var SchedulingDelaySchema = import_v49.z.object({
   /** Time unit amount */
-  amount: import_v47.z.number(),
+  amount: import_v49.z.number(),
   /** Time unit (e.g., "week", "weeks", "day", "days", "month", "months") */
-  unit: import_v47.z.string(),
+  unit: import_v49.z.string(),
   /** Optional time window to constrain the delay */
-  timeWindow: import_v47.z.string().optional()
+  timeWindow: import_v49.z.string().optional()
 });
-var SchedulingPatternSchema = import_v47.z.object({
+var SchedulingPatternSchema = import_v49.z.object({
   /** Trigger name for this pattern */
-  trigger: import_v47.z.string(),
+  trigger: import_v49.z.string(),
   /** Human-readable description of when this pattern applies */
-  description: import_v47.z.string().optional(),
+  description: import_v49.z.string().optional(),
   /** Example user phrases that match this pattern */
-  examples: import_v47.z.array(import_v47.z.string()).optional(),
+  examples: import_v49.z.array(import_v49.z.string()).optional(),
   /** Default delay for this pattern */
   defaultDelay: SchedulingDelaySchema.optional()
 });
-var SchedulingBehaviorConfigSchema = import_v47.z.object({
+var SchedulingBehaviorConfigSchema = import_v49.z.object({
   /**
    * Patterns that trigger scheduling suggestions.
    * The agent uses these to know when to add sendAt to messages.
    */
-  patterns: import_v47.z.array(SchedulingPatternSchema).optional(),
+  patterns: import_v49.z.array(SchedulingPatternSchema).optional(),
   /**
    * Default settings for scheduled messages.
    */
-  defaults: import_v47.z.object({
+  defaults: import_v49.z.object({
     /** Cancel scheduled message if user replies before send time (default: true) */
-    cancelOnActivity: import_v47.z.boolean().optional(),
+    cancelOnActivity: import_v49.z.boolean().optional(),
     /** Whether scheduled messages require approval (default: true) */
-    requiresApproval: import_v47.z.boolean().optional(),
+    requiresApproval: import_v49.z.boolean().optional(),
     /** Default time window policy to constrain all scheduled messages */
-    timeWindow: import_v47.z.string().optional().describe("Time window policy name for scheduled messages")
+    timeWindow: import_v49.z.string().optional().describe("Time window policy name for scheduled messages")
   }).optional()
 });
-var BehaviorConfigV3Schema = import_v47.z.object({
+var BehaviorConfigV3Schema = import_v49.z.object({
   /**
    * Response behavior - controls message sending via tool calls.
    * When configured, agents must explicitly call system:message:send
@@ -10764,32 +10924,32 @@ var BehaviorConfigV3Schema = import_v47.z.object({
    */
   scheduling: SchedulingBehaviorConfigSchema.optional()
 });
-var PromptsConfigV3Schema = import_v47.z.object({
+var PromptsConfigV3Schema = import_v49.z.object({
   /** Main system prompt with workflow instructions */
-  system: import_v47.z.string().optional(),
+  system: import_v49.z.string().optional(),
   /** Injected during second pass when skills were loaded but tools not used */
-  recovery: import_v47.z.string().optional(),
+  recovery: import_v49.z.string().optional(),
   /** Injected during follow-up passes when context needs updating */
-  followUp: import_v47.z.string().optional(),
+  followUp: import_v49.z.string().optional(),
   /** Thread list title generation (system + user template with {{var}} placeholders) */
-  titleEnrichment: import_v47.z.object({
-    system: import_v47.z.string().optional(),
-    user: import_v47.z.string().optional()
+  titleEnrichment: import_v49.z.object({
+    system: import_v49.z.string().optional(),
+    user: import_v49.z.string().optional()
   }).optional()
 });
-var AgentYAMLV3Schema = import_v47.z.object({
-  $schema: import_v47.z.string().optional(),
-  handle: import_v47.z.string(),
-  name: import_v47.z.string(),
-  version: import_v47.z.string().optional(),
-  description: import_v47.z.string().optional(),
+var AgentYAMLV3Schema = import_v49.z.object({
+  $schema: import_v49.z.string().optional(),
+  handle: import_v49.z.string(),
+  name: import_v49.z.string(),
+  version: import_v49.z.string().optional(),
+  description: import_v49.z.string().optional(),
   // Persona - Who the agent is
   persona: PersonaV3Schema.optional(),
   // Skills - What the agent knows how to do (skills own their tools)
-  skills: import_v47.z.array(SkillRefSchema).optional(),
+  skills: import_v49.z.array(SkillRefSchema).optional(),
   // Tools - Always-available tools before any skill loads
   // Examples: system:settings:business_information:get
-  tools: import_v47.z.array(AgentToolRefSchema).optional(),
+  tools: import_v49.z.array(AgentToolRefSchema).optional(),
   /**
    * Events - When the agent activates
    * @deprecated Not yet implemented - this is a planned feature for event-driven agents.
@@ -10944,7 +11104,7 @@ async function loadAgentFile(filePath) {
   if (isJson) {
     rawAgent = JSON.parse(content);
   } else if (isYaml) {
-    rawAgent = (0, import_yaml.parse)(content);
+    rawAgent = (0, import_yaml2.parse)(content);
   } else {
     throw new Error(
       `Unsupported agent file format: ${path22.extname(absolutePath)}. Use .agent.yml or .agent.json`
@@ -12762,7 +12922,7 @@ Error: ${input.name} is required`);
 // src/cli/commands/skills.ts
 var fs24 = __toESM(require("fs"));
 var path24 = __toESM(require("path"));
-var import_yaml2 = require("yaml");
+var import_yaml3 = require("yaml");
 init_utils();
 function printHelp21() {
   console.log(`
@@ -12844,7 +13004,7 @@ async function loadSkillFile(filePath) {
   }
   let rawSkill;
   try {
-    rawSkill = (0, import_yaml2.parse)(content);
+    rawSkill = (0, import_yaml3.parse)(content);
   } catch (err) {
     throw new Error(`Failed to parse YAML: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -13286,188 +13446,7 @@ async function skillsCommand(args2) {
 var fs25 = __toESM(require("fs"));
 var path25 = __toESM(require("path"));
 var readline7 = __toESM(require("readline"));
-var import_yaml3 = require("yaml");
 init_utils();
-
-// src/workflows/types.ts
-var import_v49 = require("zod/v4");
-
-// src/triggers/types.ts
-var import_v48 = require("zod/v4");
-var CRMDataSchema = import_v48.z.object({
-  model: import_v48.z.string(),
-  instanceId: import_v48.z.string(),
-  data: import_v48.z.record(import_v48.z.string(), import_v48.z.unknown())
-});
-var SenderContextSchema2 = import_v48.z.object({
-  kind: ParticipantKindSchema,
-  displayName: import_v48.z.string().optional(),
-  crm: CRMDataSchema.optional()
-});
-var ThreadContextItemSchema2 = import_v48.z.object({
-  handle: import_v48.z.string(),
-  model: import_v48.z.string(),
-  instanceId: import_v48.z.string(),
-  data: import_v48.z.record(import_v48.z.string(), import_v48.z.unknown()).optional()
-});
-var ParticipantContextSchema = import_v48.z.object({
-  id: import_v48.z.string(),
-  kind: ParticipantKindSchema,
-  displayName: import_v48.z.string().optional(),
-  contactId: import_v48.z.string().optional(),
-  memberId: import_v48.z.string().optional(),
-  agentId: import_v48.z.string().optional(),
-  workflowId: import_v48.z.string().optional()
-});
-var TriggerContextSchema = import_v48.z.object({
-  // The event that triggered this
-  event: import_v48.z.object({
-    type: EventTypeSchema,
-    payload: import_v48.z.record(import_v48.z.string(), import_v48.z.unknown()),
-    participant: ParticipantContextSchema.optional()
-  }),
-  // Thread information
-  thread: import_v48.z.object({
-    id: import_v48.z.string(),
-    title: import_v48.z.string().optional(),
-    status: import_v48.z.string().optional(),
-    sender: SenderContextSchema2.optional(),
-    context: import_v48.z.record(import_v48.z.string(), CRMDataSchema).optional(),
-    participants: import_v48.z.array(ParticipantContextSchema).optional()
-  }),
-  // Workplace info
-  workplace: import_v48.z.object({
-    id: import_v48.z.string(),
-    name: import_v48.z.string().optional(),
-    settings: import_v48.z.record(import_v48.z.string(), import_v48.z.unknown()).optional()
-  })
-});
-var InputMappingSchema = import_v48.z.record(import_v48.z.string(), import_v48.z.string());
-var EventConditionsSchema = import_v48.z.record(import_v48.z.string(), import_v48.z.string());
-var TriggerConfigSchema = import_v48.z.object({
-  id: import_v48.z.string(),
-  workflowId: import_v48.z.string(),
-  workflowVersionId: import_v48.z.string().optional(),
-  workplaceId: import_v48.z.string(),
-  handle: import_v48.z.string(),
-  // Input mappings: how to resolve workflow inputs from thread context
-  inputMappings: InputMappingSchema.optional(),
-  // Event conditions: additional workplace-specific conditions
-  eventConditions: EventConditionsSchema.optional(),
-  // Workplace-specific config overrides
-  config: import_v48.z.record(import_v48.z.string(), import_v48.z.unknown()).optional(),
-  // Trigger type and status
-  type: import_v48.z.string().optional(),
-  isEnabled: import_v48.z.boolean().optional()
-});
-var ResolvedTriggerSchema = import_v48.z.object({
-  trigger: TriggerConfigSchema,
-  workflow: import_v48.z.object({
-    id: import_v48.z.string(),
-    handle: import_v48.z.string(),
-    name: import_v48.z.string().optional(),
-    inputs: import_v48.z.record(import_v48.z.string(), import_v48.z.unknown()).optional(),
-    events: import_v48.z.object({
-      subscribes: import_v48.z.array(EventTypeSchema).optional(),
-      condition: import_v48.z.string().optional()
-    }).optional()
-  }),
-  inputs: import_v48.z.record(import_v48.z.string(), import_v48.z.unknown()),
-  context: TriggerContextSchema
-});
-var WorkflowInputDefinitionSchema = import_v48.z.object({
-  type: import_v48.z.string(),
-  required: import_v48.z.boolean().optional(),
-  description: import_v48.z.string().optional(),
-  default: import_v48.z.unknown().optional()
-});
-var WorkflowInputSchemaSchema = import_v48.z.record(import_v48.z.string(), WorkflowInputDefinitionSchema);
-
-// src/workflows/types.ts
-var WorkflowInputSchema = import_v49.z.object({
-  type: import_v49.z.string(),
-  required: import_v49.z.boolean().optional().default(false),
-  description: import_v49.z.string().optional(),
-  default: import_v49.z.unknown().optional()
-});
-var WorkflowStepInputSchema = import_v49.z.union([import_v49.z.string(), import_v49.z.number(), import_v49.z.boolean(), import_v49.z.record(import_v49.z.string(), import_v49.z.unknown())]);
-var WorkflowStepSchema = import_v49.z.object({
-  // Service and command
-  service: import_v49.z.string(),
-  cmd: import_v49.z.string(),
-  // Dependencies
-  needs: import_v49.z.array(import_v49.z.string()).optional(),
-  // Inputs (Liquid templates supported)
-  inputs: import_v49.z.record(import_v49.z.string(), WorkflowStepInputSchema).optional(),
-  // Conditional execution
-  condition: import_v49.z.string().optional(),
-  // Retry configuration
-  retry: import_v49.z.object({
-    attempts: import_v49.z.number().optional(),
-    backoff: import_v49.z.enum(["linear", "exponential"]).optional()
-  }).optional(),
-  // Timeout
-  timeout: import_v49.z.string().optional()
-});
-var WorkflowRuntimeSchema = import_v49.z.object({
-  durable: import_v49.z.boolean().optional().default(true),
-  timeout: import_v49.z.string().optional(),
-  retry: import_v49.z.object({
-    attempts: import_v49.z.number().optional(),
-    backoff: import_v49.z.enum(["linear", "exponential"]).optional()
-  }).optional()
-});
-var WorkflowYAMLSchema = import_v49.z.object({
-  // Schema version
-  $schema: import_v49.z.string().optional(),
-  // Identity
-  handle: import_v49.z.string(),
-  name: import_v49.z.string(),
-  version: import_v49.z.string().optional(),
-  description: import_v49.z.string().optional(),
-  // Inputs this workflow needs (portable, declared in YAML)
-  inputs: import_v49.z.record(import_v49.z.string(), WorkflowInputSchema).optional(),
-  // Event subscriptions and conditions
-  events: EventsConfigSchema.optional(),
-  // Deterministic steps
-  steps: import_v49.z.record(import_v49.z.string(), WorkflowStepSchema),
-  // Runtime configuration
-  runtime: WorkflowRuntimeSchema.optional()
-});
-var WorkflowMetadataSchema = import_v49.z.object({
-  handle: import_v49.z.string(),
-  name: import_v49.z.string(),
-  version: import_v49.z.string().optional(),
-  description: import_v49.z.string().optional(),
-  inputs: import_v49.z.record(import_v49.z.string(), WorkflowInputDefinitionSchema).optional(),
-  events: EventsConfigSchema.optional()
-});
-var WorkflowExecutionStatusSchema = import_v49.z.enum([
-  "PENDING",
-  "RUNNING",
-  "COMPLETED",
-  "FAILED",
-  "CANCELLED",
-  "WAITING"
-]);
-var WorkflowExecutionResultSchema = import_v49.z.object({
-  status: WorkflowExecutionStatusSchema,
-  outputs: import_v49.z.record(import_v49.z.string(), import_v49.z.unknown()).optional(),
-  error: import_v49.z.string().optional(),
-  startedAt: import_v49.z.string().datetime().optional(),
-  completedAt: import_v49.z.string().datetime().optional(),
-  cancelledAt: import_v49.z.string().datetime().optional(),
-  cancelReason: import_v49.z.string().optional()
-});
-function validateWorkflowYAML(workflow) {
-  const result = WorkflowYAMLSchema.safeParse(workflow);
-  if (result.success) {
-    return { success: true, data: result.data };
-  }
-  return { success: false, error: result.error };
-}
-
-// src/cli/commands/workflows.ts
 function printHelp22() {
   console.log(`
 skedyul workflows - Manage workplace workflows
@@ -13541,13 +13520,6 @@ function ensureAuth5() {
   }
   return { token: credentials.token, serverUrl: getServerUrl() };
 }
-async function getWorkplaceToken7(workplaceSubdomain, serverUrl, cliToken) {
-  return callCliApi(
-    { serverUrl, token: cliToken },
-    "/workplace-token",
-    { workplaceSubdomain }
-  );
-}
 async function loadWorkflowFile(filePath) {
   const absolutePath = path25.resolve(filePath);
   if (!fs25.existsSync(absolutePath)) {
@@ -13558,19 +13530,7 @@ async function loadWorkflowFile(filePath) {
   if (ext !== ".yml" && ext !== ".yaml") {
     throw new Error("Workflow file must be a .yml or .yaml file");
   }
-  let rawWorkflow;
-  try {
-    rawWorkflow = (0, import_yaml3.parse)(content);
-  } catch (err) {
-    throw new Error(`Failed to parse YAML: ${err instanceof Error ? err.message : String(err)}`);
-  }
-  const validation = validateWorkflowYAML(rawWorkflow);
-  if (!validation.success) {
-    const errorMessages = validation.error.issues.map((e) => `  - ${String(e.path.join(".")) || "(root)"}: ${e.message}`).join("\n");
-    throw new Error(`Workflow validation failed:
-${errorMessages}`);
-  }
-  return { content };
+  return validateWorkflowContent(content);
 }
 function parseInputFlags(flags) {
   const inputs = {};
@@ -13606,30 +13566,21 @@ async function handleList5(args2) {
     console.error("Error: --workplace (-w) is required");
     process.exit(1);
   }
-  const { token, serverUrl } = ensureAuth5();
-  const workplaceToken = await getWorkplaceToken7(workplace, serverUrl, token);
-  const result = await callCliApi(
-    { serverUrl, token },
-    "/workflows",
-    void 0,
-    { method: "GET", query: { workplaceId: workplaceToken.workplaceId } }
-  );
-  if (!result.success) {
-    throw new Error(result.error || "Failed to list workflows");
-  }
+  const ctx = ensureAuth5();
+  const listed = await listWorkflows(ctx, workplace);
   if (jsonOutput) {
-    console.log(JSON.stringify(result.workflows, null, 2));
+    console.log(JSON.stringify(listed, null, 2));
     return;
   }
   console.log("");
   console.log(`Workflows in ${workplace}`);
   console.log("");
-  if (result.workflows.length === 0) {
+  if (listed.length === 0) {
     console.log("  No workflows found.");
   } else {
     console.log("  Handle                      Name                          Active");
     console.log("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500  \u2500\u2500\u2500\u2500\u2500\u2500\u2500");
-    for (const workflow of result.workflows) {
+    for (const workflow of listed) {
       const handle = workflow.handle.slice(0, 26).padEnd(26);
       const name = workflow.name.slice(0, 28).padEnd(28);
       const active = workflow.triggerVersion !== null ? `v${workflow.triggerVersion}` : "-";
@@ -13647,25 +13598,12 @@ async function handleGet4(args2) {
     console.error("Error: handle and --workplace are required");
     process.exit(1);
   }
-  const { token, serverUrl } = ensureAuth5();
-  const workplaceToken = await getWorkplaceToken7(workplace, serverUrl, token);
-  const result = await callCliApi(
-    { serverUrl, token },
-    "/workflows",
-    void 0,
-    {
-      method: "GET",
-      query: { workplaceId: workplaceToken.workplaceId, handle }
-    }
-  );
-  if (!result.success) {
-    throw new Error(result.error || "Failed to get workflow");
-  }
+  const ctx = ensureAuth5();
+  const workflow = await getWorkflow(ctx, workplace, handle);
   if (jsonOutput) {
-    console.log(JSON.stringify(result.workflow, null, 2));
+    console.log(JSON.stringify(workflow, null, 2));
     return;
   }
-  const workflow = result.workflow;
   console.log("");
   console.log(`Workflow: ${workflow.name}`);
   console.log("");
@@ -13699,29 +13637,12 @@ async function handleVersions3(args2) {
     console.error("Error: handle and --workplace are required");
     process.exit(1);
   }
-  const { token, serverUrl } = ensureAuth5();
-  const workplaceToken = await getWorkplaceToken7(workplace, serverUrl, token);
-  const result = await callCliApi(
-    { serverUrl, token },
-    "/workflows",
-    void 0,
-    {
-      method: "GET",
-      query: {
-        workplaceId: workplaceToken.workplaceId,
-        handle,
-        action: "versions"
-      }
-    }
-  );
-  if (!result.success) {
-    throw new Error(result.error || "Failed to list versions");
-  }
+  const ctx = ensureAuth5();
+  const versions = await listWorkflowVersions(ctx, workplace, handle);
   if (jsonOutput) {
-    console.log(JSON.stringify(result.workflow.versions ?? [], null, 2));
+    console.log(JSON.stringify(versions, null, 2));
     return;
   }
-  const versions = result.workflow.versions ?? [];
   console.log("");
   console.log(`Versions for ${handle}`);
   console.log("");
@@ -13765,19 +13686,11 @@ async function handleDeploy3(args2) {
     }
     process.exit(1);
   }
-  const { token, serverUrl } = ensureAuth5();
-  const workplaceToken = await getWorkplaceToken7(workplace, serverUrl, token);
-  const result = await callCliApi(
-    { serverUrl, token },
-    "/workflows",
-    {
-      action: "deploy",
-      workplaceId: workplaceToken.workplaceId,
-      yamlContent: content,
-      publish: !draft,
-      versionLabel
-    }
-  );
+  const ctx = ensureAuth5();
+  const result = await deployWorkflow(ctx, workplace, content, {
+    publish: !draft,
+    versionLabel
+  });
   if (!result.success) {
     const message = result.error || "Deploy failed";
     if (jsonOutput) {
@@ -13850,17 +13763,8 @@ async function handleValidate(args2) {
     }
     return;
   }
-  const { token, serverUrl } = ensureAuth5();
-  const workplaceToken = await getWorkplaceToken7(workplace, serverUrl, token);
-  const result = await callCliApi(
-    { serverUrl, token },
-    "/workflows",
-    {
-      action: "validate",
-      workplaceId: workplaceToken.workplaceId,
-      yamlContent: content
-    }
-  );
+  const ctx = ensureAuth5();
+  const result = await validateWorkflow(ctx, workplace, content);
   if (!result.valid) {
     if (jsonOutput) {
       console.log(JSON.stringify(result, null, 2));
@@ -13893,21 +13797,12 @@ async function handlePull2(args2) {
     console.error("Error: handle and --workplace are required");
     process.exit(1);
   }
-  const { token, serverUrl } = ensureAuth5();
-  const workplaceToken = await getWorkplaceToken7(workplace, serverUrl, token);
-  const result = await callCliApi(
-    { serverUrl, token },
-    "/workflows",
-    void 0,
-    {
-      method: "GET",
-      query: {
-        workplaceId: workplaceToken.workplaceId,
-        handle,
-        action: "pull",
-        version: version !== void 0 ? String(version) : void 0
-      }
-    }
+  const ctx = ensureAuth5();
+  const result = await pullWorkflow(
+    ctx,
+    workplace,
+    handle,
+    version !== void 0 ? Number(version) : void 0
   );
   if (jsonOutput) {
     console.log(JSON.stringify(result, null, 2));
@@ -13932,18 +13827,8 @@ async function handlePublish3(args2) {
     console.error("Error: --version must be a number");
     process.exit(1);
   }
-  const { token, serverUrl } = ensureAuth5();
-  const workplaceToken = await getWorkplaceToken7(workplace, serverUrl, token);
-  const result = await callCliApi(
-    { serverUrl, token },
-    "/workflows",
-    {
-      action: "publish",
-      workplaceId: workplaceToken.workplaceId,
-      handle,
-      version: versionNumber
-    }
-  );
+  const ctx = ensureAuth5();
+  const result = await publishWorkflow(ctx, workplace, handle, versionNumber);
   if (jsonOutput) {
     console.log(JSON.stringify(result, null, 2));
     return;
@@ -13983,17 +13868,9 @@ async function promptForMissingInputs(schema, inputs) {
   }
   return resolved;
 }
-async function waitForWorkflowRun(serverUrl, token, workplaceId, workflowRunId) {
+async function waitForWorkflowRun(ctx, workplace, workflowRunId) {
   while (true) {
-    const status = await callCliApi(
-      { serverUrl, token },
-      "/workflows/run",
-      void 0,
-      {
-        method: "GET",
-        query: { workplaceId, workflowRunId }
-      }
-    );
+    const status = await getWorkflowRun(ctx, workplace, workflowRunId);
     if (!status.success) {
       throw new Error(status.error || "Failed to fetch workflow run status");
     }
@@ -14036,8 +13913,7 @@ async function handleRun(args2) {
     console.error("Error: handle and --workplace are required");
     process.exit(1);
   }
-  const { token, serverUrl } = ensureAuth5();
-  const workplaceToken = await getWorkplaceToken7(workplace, serverUrl, token);
+  const ctx = ensureAuth5();
   let inputs;
   try {
     inputs = parseInputFlags(flags);
@@ -14046,18 +13922,11 @@ async function handleRun(args2) {
     console.error(`Error: ${message}`);
     process.exit(1);
   }
-  const schema = await callCliApi(
-    { serverUrl, token },
-    "/workflow-schema",
-    void 0,
-    {
-      method: "GET",
-      query: {
-        workplaceId: workplaceToken.workplaceId,
-        handle,
-        version: version !== void 0 ? String(version) : void 0
-      }
-    }
+  const schema = await getWorkflowSchema(
+    ctx,
+    workplace,
+    handle,
+    version !== void 0 ? Number(version) : void 0
   );
   if (schema.error) {
     throw new Error(schema.error);
@@ -14069,16 +13938,10 @@ async function handleRun(args2) {
     console.error(`Error: ${message}`);
     process.exit(1);
   }
-  const runResult = await callCliApi(
-    { serverUrl, token },
-    "/workflows/run",
-    {
-      workplaceId: workplaceToken.workplaceId,
-      handle,
-      version: version !== void 0 ? Number(version) : void 0,
-      inputs
-    }
-  );
+  const runResult = await runWorkflow(ctx, workplace, handle, {
+    version: version !== void 0 ? Number(version) : void 0,
+    inputs
+  });
   if (!runResult.success) {
     throw new Error(runResult.error || "Failed to start workflow run");
   }
@@ -14094,9 +13957,8 @@ async function handleRun(args2) {
   }
   if (wait) {
     const finalStatus = await waitForWorkflowRun(
-      serverUrl,
-      token,
-      workplaceToken.workplaceId,
+      ctx,
+      workplace,
       runResult.workflowRunId
     );
     if (jsonOutput) {
@@ -14197,7 +14059,7 @@ Notes:
   - Create EventSubscription rows in the UI to test workflow dispatch
 `);
 }
-async function getWorkplaceToken8(workplaceSubdomain, serverUrl, cliToken) {
+async function getWorkplaceToken7(workplaceSubdomain, serverUrl, cliToken) {
   return callCliApi(
     { serverUrl, token: cliToken },
     "/workplace-token",
@@ -14257,7 +14119,7 @@ async function eventCommand(args2) {
   const serverUrl = getServerUrl();
   let workplaceToken;
   try {
-    workplaceToken = await getWorkplaceToken8(
+    workplaceToken = await getWorkplaceToken7(
       workplaceSubdomain,
       serverUrl,
       credentials.token