@rudderhq/cli 0.4.6-canary.10 → 0.4.6-canary.12

package/dist/index.js

@@ -9,6 +9,20 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// ../packages/shared/dist/browser-shortcuts.js
+var init_browser_shortcuts = __esm({
+  "../packages/shared/dist/browser-shortcuts.js"() {
+    "use strict";
+  }
+});
+
+// ../packages/shared/dist/chat-inline-visuals.js
+var init_chat_inline_visuals = __esm({
+  "../packages/shared/dist/chat-inline-visuals.js"() {
+    "use strict";
+  }
+});
+
 // ../packages/shared/dist/project-mentions.js
 var init_project_mentions = __esm({
   "../packages/shared/dist/project-mentions.js"() {
@@ -614,8 +628,413 @@ var init_custom_integration = __esm({
   }
 });
 
-// ../packages/shared/dist/validators/instance.js
+// ../packages/shared/dist/validators/chat.js
 import { z as z2 } from "zod";
+var chatConversationStatusSchema, chatIssueCreationModeSchema, chatMessageRoleSchema, chatMessageKindSchema, chatMessageStatusSchema, chatContextEntityTypeSchema, chatGenerationStatusSchema, chatGenerationControlStateSchema, chatQueueDeliveryIntentSchema, chatControlDispositionSchema, chatProviderControlDispositionSchema, chatControlActionKindSchema, chatGenerationEventKindSchema, chatTerminalOutboxStatusSchema, chatQueuedMessageStatusSchema, chatControlActionIdSchema, chatBodyHashSchema, createChatContextLinkSchema, createChatConversationSchema, setChatProjectContextSchema, updateChatConversationSchema, forkChatConversationSchema, addChatMessageSchema, chatQueuedMessagePayloadSchema, createChatQueuedMessageSchema, updateChatQueuedMessageSchema, cancelChatQueuedMessageSchema, steerChatQueuedMessageSchema, stopChatGenerationSchema, chatClientCheckpointSchema, appendChatGenerationEventSchema, chatRichReferenceDisplaySchema, chatIssueIdentifierSchema, chatAskUserIdentifierSchema, chatAskUserOptionSchema, chatAskUserQuestionSchema, chatAskUserRequestSchema, chatIssueRichReferenceSchema, chatIssueCommentRichReferenceSchema, chatRichReferenceSchema, chatRichReferencesSchema, chatAutomationCreateSchema, createChatAttachmentMetadataSchema, chatIssueProposalSchema, convertChatToIssueSchema, chatOperationProposalSchema, resolveChatOperationProposalSchema, updateChatConversationUserStateSchema, updateMessengerThreadUserStateSchema, createMessengerCustomGroupSchema, createMessengerCustomGroupWithEntriesSchema, updateMessengerCustomGroupSchema, reorderMessengerCustomGroupsSchema, assignMessengerCustomGroupEntrySchema, reorderMessengerCustomGroupEntriesSchema;
+var init_chat = __esm({
+  "../packages/shared/dist/validators/chat.js"() {
+    "use strict";
+    init_constants();
+    chatConversationStatusSchema = z2.enum(CHAT_CONVERSATION_STATUSES);
+    chatIssueCreationModeSchema = z2.enum(CHAT_ISSUE_CREATION_MODES);
+    chatMessageRoleSchema = z2.enum(CHAT_MESSAGE_ROLES);
+    chatMessageKindSchema = z2.enum(CHAT_MESSAGE_KINDS);
+    chatMessageStatusSchema = z2.enum(CHAT_MESSAGE_STATUSES);
+    chatContextEntityTypeSchema = z2.enum(CHAT_CONTEXT_ENTITY_TYPES);
+    chatGenerationStatusSchema = z2.enum([
+      "starting",
+      "active",
+      "running",
+      "tool_busy",
+      "closing",
+      "stop_requested",
+      "stopping",
+      "completed",
+      "failed",
+      "stopped",
+      "aborted",
+      "interrupted_unverified",
+      "control_lost"
+    ]);
+    chatGenerationControlStateSchema = z2.enum([
+      "unregistered",
+      "ready",
+      "stopping",
+      "terminal",
+      "control_lost"
+    ]);
+    chatQueueDeliveryIntentSchema = z2.enum(["queue", "steer"]);
+    chatControlDispositionSchema = z2.enum([
+      "pending",
+      "accepted_current",
+      "acceptance_unknown",
+      "reconciled_current",
+      "continuation_pending",
+      "waiting_safe_boundary",
+      "running_next",
+      "delivered",
+      "stop_requested",
+      "stopping",
+      "stopped",
+      "interrupted_unverified",
+      "cancellation_unverified",
+      "control_lost",
+      "failed_actionable",
+      "cancelled"
+    ]);
+    chatProviderControlDispositionSchema = z2.enum([
+      "not_sent",
+      "sent",
+      "acknowledged",
+      "rejected",
+      "timed_out",
+      "connection_lost",
+      "waiting_safe_boundary",
+      "unverified"
+    ]);
+    chatControlActionKindSchema = z2.enum(["stop", "steer"]);
+    chatGenerationEventKindSchema = z2.enum([
+      "generation_started",
+      "runtime_output",
+      "assistant_delta",
+      "transcript",
+      "client_checkpoint",
+      "steer_requested",
+      "steer_provider_sent",
+      "steer_acknowledged",
+      "continuation_scheduled",
+      "stop_requested",
+      "output_cutoff",
+      "runtime_terminal",
+      "late_output_dropped",
+      "terminal_projection_requested",
+      "terminal_projected"
+    ]);
+    chatTerminalOutboxStatusSchema = z2.enum([
+      "pending",
+      "claimed",
+      "retry_wait",
+      "projected",
+      "failed_actionable"
+    ]);
+    chatQueuedMessageStatusSchema = z2.enum([
+      "queued",
+      "steer_pending",
+      "accepted_current",
+      "acceptance_unknown",
+      "reconciled_current",
+      "continuation_pending",
+      "running_next",
+      "delivered",
+      "failed_actionable",
+      "steered",
+      "dequeue_claimed",
+      "running",
+      "completed",
+      "cancelled",
+      "failed"
+    ]);
+    chatControlActionIdSchema = z2.string().uuid();
+    chatBodyHashSchema = z2.string().regex(/^[a-f0-9]{64}$/i, "Expected a SHA-256 body hash");
+    createChatContextLinkSchema = z2.object({
+      entityType: chatContextEntityTypeSchema,
+      entityId: z2.string().min(1),
+      metadata: z2.record(z2.unknown()).optional().nullable()
+    });
+    createChatConversationSchema = z2.object({
+      title: z2.string().trim().min(1).max(200).optional(),
+      summary: z2.string().trim().max(5e3).optional().nullable(),
+      preferredAgentId: z2.string().uuid().optional().nullable(),
+      issueCreationMode: chatIssueCreationModeSchema.optional(),
+      planMode: z2.boolean().optional(),
+      contextLinks: z2.array(createChatContextLinkSchema).optional().default([])
+    });
+    setChatProjectContextSchema = z2.object({
+      projectId: z2.string().uuid().optional().nullable()
+    });
+    updateChatConversationSchema = createChatConversationSchema.partial().extend({
+      status: chatConversationStatusSchema.optional(),
+      routedAgentId: z2.string().uuid().optional().nullable(),
+      primaryIssueId: z2.string().uuid().optional().nullable(),
+      resolvedAt: z2.string().datetime().optional().nullable()
+    });
+    forkChatConversationSchema = z2.object({
+      sourceMessageId: z2.string().uuid().optional().nullable(),
+      title: z2.string().trim().min(1).max(200).optional()
+    });
+    addChatMessageSchema = z2.object({
+      body: z2.string().trim().min(1).max(2e4),
+      editUserMessageId: z2.string().uuid().optional().nullable(),
+      queuedMessageId: z2.string().uuid().optional().nullable()
+    });
+    chatQueuedMessagePayloadSchema = z2.object({
+      body: z2.string().trim().min(1).max(2e4),
+      attachmentIds: z2.array(z2.string().uuid()).optional().default([]),
+      projectId: z2.string().uuid().optional().nullable(),
+      skillRefs: z2.array(z2.string().trim().min(1).max(240)).optional().default([]),
+      accessMode: z2.string().trim().min(1).max(120).optional().nullable(),
+      model: z2.string().trim().min(1).max(120).optional().nullable(),
+      effort: z2.string().trim().min(1).max(120).optional().nullable(),
+      metadata: z2.record(z2.unknown()).optional().nullable()
+    });
+    createChatQueuedMessageSchema = z2.object({
+      clientMutationId: z2.string().trim().min(1).max(120),
+      expectedGenerationId: z2.string().uuid().optional().nullable(),
+      payload: chatQueuedMessagePayloadSchema
+    });
+    updateChatQueuedMessageSchema = z2.object({
+      version: z2.number().int().positive(),
+      payload: chatQueuedMessagePayloadSchema
+    });
+    cancelChatQueuedMessageSchema = z2.object({
+      version: z2.number().int().positive().optional()
+    });
+    steerChatQueuedMessageSchema = z2.object({
+      expectedActiveGenerationId: z2.string().uuid().optional().nullable(),
+      controlActionId: chatControlActionIdSchema.optional(),
+      expectedAttemptEpoch: z2.number().int().nonnegative().optional(),
+      expectedControlVersion: z2.number().int().nonnegative().optional(),
+      lastCommittedRenderSeq: z2.number().int().nonnegative().optional(),
+      renderedBodyHash: chatBodyHashSchema.optional()
+    }).superRefine((value, ctx) => {
+      const hasGenerationTarget = Boolean(value.expectedActiveGenerationId);
+      const hasFenceVersion = value.expectedAttemptEpoch !== void 0 || value.expectedControlVersion !== void 0;
+      if (value.lastCommittedRenderSeq === void 0 !== (value.renderedBodyHash === void 0)) {
+        ctx.addIssue({ code: z2.ZodIssueCode.custom, path: ["renderedBodyHash"], message: "Steer render sequence and body hash must be supplied together" });
+      }
+      if (!hasFenceVersion && (!value.controlActionId || !hasGenerationTarget))
+        return;
+      if (!value.controlActionId) {
+        ctx.addIssue({ code: z2.ZodIssueCode.custom, path: ["controlActionId"], message: "Required for durable Steer control" });
+      }
+      if (!value.expectedActiveGenerationId) {
+        ctx.addIssue({ code: z2.ZodIssueCode.custom, path: ["expectedActiveGenerationId"], message: "Required for durable Steer control" });
+      }
+      if (value.expectedAttemptEpoch === void 0) {
+        ctx.addIssue({ code: z2.ZodIssueCode.custom, path: ["expectedAttemptEpoch"], message: "Required for durable Steer control" });
+      }
+      if (value.expectedControlVersion === void 0) {
+        ctx.addIssue({ code: z2.ZodIssueCode.custom, path: ["expectedControlVersion"], message: "Required for durable Steer control" });
+      }
+    });
+    stopChatGenerationSchema = z2.object({
+      controlActionId: chatControlActionIdSchema.optional(),
+      expectedGenerationId: z2.string().uuid().optional(),
+      expectedAttemptEpoch: z2.number().int().nonnegative().optional(),
+      expectedControlVersion: z2.number().int().nonnegative().optional(),
+      lastCommittedRenderSeq: z2.number().int().nonnegative().optional(),
+      renderedBodyHash: chatBodyHashSchema.optional()
+    }).superRefine((value, ctx) => {
+      const generationFenceStarted = value.expectedGenerationId !== void 0 || value.expectedAttemptEpoch !== void 0 || value.expectedControlVersion !== void 0;
+      if (generationFenceStarted) {
+        if (!value.expectedGenerationId) {
+          ctx.addIssue({ code: z2.ZodIssueCode.custom, path: ["expectedGenerationId"], message: "Required for fenced Stop control" });
+        }
+        if (value.expectedAttemptEpoch === void 0) {
+          ctx.addIssue({ code: z2.ZodIssueCode.custom, path: ["expectedAttemptEpoch"], message: "Required for fenced Stop control" });
+        }
+        if (value.expectedControlVersion === void 0) {
+          ctx.addIssue({ code: z2.ZodIssueCode.custom, path: ["expectedControlVersion"], message: "Required for fenced Stop control" });
+        }
+      }
+      if (value.lastCommittedRenderSeq === void 0 !== (value.renderedBodyHash === void 0)) {
+        ctx.addIssue({ code: z2.ZodIssueCode.custom, path: ["renderedBodyHash"], message: "Stop render sequence and body hash must be supplied together" });
+      }
+    });
+    chatClientCheckpointSchema = z2.object({
+      generationId: z2.string().uuid(),
+      attemptEpoch: z2.number().int().positive(),
+      generationSeq: z2.number().int().nonnegative(),
+      renderedBodyHash: chatBodyHashSchema
+    });
+    appendChatGenerationEventSchema = z2.object({
+      generationId: z2.string().uuid(),
+      generationSeq: z2.number().int().nonnegative(),
+      attemptEpoch: z2.number().int().positive(),
+      eventKind: chatGenerationEventKindSchema,
+      payload: z2.record(z2.unknown()).default({}),
+      bodyOffset: z2.number().int().nonnegative().optional().nullable(),
+      bodyLength: z2.number().int().nonnegative().optional().nullable(),
+      assistantMessageId: z2.string().uuid().optional().nullable(),
+      runId: z2.string().uuid().optional().nullable(),
+      controlActionId: chatControlActionIdSchema.optional().nullable(),
+      queueItemId: z2.string().uuid().optional().nullable()
+    });
+    chatRichReferenceDisplaySchema = z2.enum(["card", "inline"]);
+    chatIssueIdentifierSchema = z2.string().trim().min(1).max(64).regex(/^[A-Z0-9][A-Z0-9-]*$/i);
+    chatAskUserIdentifierSchema = z2.string().trim().min(1).max(64).regex(/^[a-zA-Z0-9_-]+$/);
+    chatAskUserOptionSchema = z2.object({
+      id: chatAskUserIdentifierSchema,
+      label: z2.string().trim().min(1).max(80),
+      description: z2.string().trim().min(1).max(220).optional(),
+      recommended: z2.boolean().optional()
+    });
+    chatAskUserQuestionSchema = z2.object({
+      id: chatAskUserIdentifierSchema,
+      header: z2.string().trim().min(1).max(32).optional(),
+      question: z2.string().trim().min(1).max(240),
+      options: z2.array(chatAskUserOptionSchema).min(2).max(3),
+      selectionMode: z2.enum(["single", "multiple"]).optional(),
+      allowFreeform: z2.boolean().optional()
+    }).superRefine((question, ctx) => {
+      const optionIds = /* @__PURE__ */ new Set();
+      question.options.forEach((option, index) => {
+        if (optionIds.has(option.id)) {
+          ctx.addIssue({
+            code: z2.ZodIssueCode.custom,
+            message: "Option ids must be unique within each question",
+            path: ["options", index, "id"]
+          });
+          return;
+        }
+        optionIds.add(option.id);
+      });
+    });
+    chatAskUserRequestSchema = z2.object({
+      questions: z2.array(chatAskUserQuestionSchema).min(1).max(3)
+    }).superRefine((request, ctx) => {
+      const questionIds = /* @__PURE__ */ new Set();
+      request.questions.forEach((question, index) => {
+        if (questionIds.has(question.id)) {
+          ctx.addIssue({
+            code: z2.ZodIssueCode.custom,
+            message: "Question ids must be unique within requestUserInput",
+            path: ["questions", index, "id"]
+          });
+          return;
+        }
+        questionIds.add(question.id);
+      });
+    });
+    chatIssueRichReferenceSchema = z2.object({
+      type: z2.literal("issue"),
+      issueId: z2.string().uuid().optional(),
+      identifier: chatIssueIdentifierSchema.optional(),
+      display: chatRichReferenceDisplaySchema.optional()
+    }).refine((value) => Boolean(value.issueId || value.identifier), {
+      message: "issueId or identifier is required"
+    });
+    chatIssueCommentRichReferenceSchema = z2.object({
+      type: z2.literal("issue_comment"),
+      issueId: z2.string().uuid().optional(),
+      identifier: chatIssueIdentifierSchema.optional(),
+      commentId: z2.string().uuid(),
+      display: chatRichReferenceDisplaySchema.optional()
+    }).refine((value) => Boolean(value.issueId || value.identifier), {
+      message: "issueId or identifier is required"
+    });
+    chatRichReferenceSchema = z2.union([
+      chatIssueRichReferenceSchema,
+      chatIssueCommentRichReferenceSchema
+    ]);
+    chatRichReferencesSchema = z2.array(chatRichReferenceSchema).max(5);
+    chatAutomationCreateSchema = z2.object({
+      title: z2.string().trim().min(1).max(200),
+      instructions: z2.string().trim().max(2e4).optional().nullable(),
+      description: z2.string().trim().max(2e4).optional().nullable(),
+      projectId: z2.string().uuid().optional().nullable(),
+      goalId: z2.string().uuid().optional().nullable(),
+      parentIssueId: z2.string().uuid().optional().nullable(),
+      priority: z2.enum(["critical", "high", "medium", "low"]).optional().default("medium"),
+      status: z2.enum(AUTOMATION_STATUSES).optional().default("active"),
+      concurrencyPolicy: z2.enum(AUTOMATION_CONCURRENCY_POLICIES).optional().default("coalesce_if_active"),
+      catchUpPolicy: z2.enum(AUTOMATION_CATCH_UP_POLICIES).optional().default("skip_missed"),
+      outputMode: z2.enum(AUTOMATION_OUTPUT_MODES).optional().default("track_issue"),
+      schedule: z2.object({
+        cronExpression: z2.string().trim().min(1),
+        timezone: z2.string().trim().min(1),
+        label: z2.string().trim().max(120).optional().nullable(),
+        enabled: z2.boolean().optional().default(true)
+      })
+    }).transform(({ description, instructions, ...value }) => ({
+      ...value,
+      instructions: instructions === void 0 ? description : instructions
+    }));
+    createChatAttachmentMetadataSchema = z2.object({
+      messageId: z2.string().uuid()
+    });
+    chatIssueProposalSchema = z2.object({
+      title: z2.string().trim().min(1).max(200),
+      description: z2.string().trim().min(1).max(2e4),
+      status: z2.enum(ISSUE_STATUSES).optional().default("todo"),
+      priority: z2.enum(["critical", "high", "medium", "low"]).optional().default("medium"),
+      projectId: z2.string().uuid().optional().nullable(),
+      goalId: z2.string().uuid().optional().nullable(),
+      parentId: z2.string().uuid().optional().nullable(),
+      assigneeAgentId: z2.string().uuid().optional().nullable(),
+      assigneeUserId: z2.string().trim().optional().nullable(),
+      assigneeUnassignedReason: z2.string().trim().min(1).max(500).optional().nullable(),
+      reviewerAgentId: z2.string().uuid().optional().nullable(),
+      reviewerUserId: z2.string().trim().optional().nullable(),
+      labelIds: z2.array(z2.string().uuid()).optional()
+    }).superRefine((proposal, ctx) => {
+      const hasAssignee = Boolean(proposal.assigneeAgentId || proposal.assigneeUserId);
+      const hasUnassignedReason = Boolean(proposal.assigneeUnassignedReason?.trim());
+      if (hasAssignee && hasUnassignedReason) {
+        ctx.addIssue({
+          code: z2.ZodIssueCode.custom,
+          message: "Issue proposals with an assignee must not also declare an unassigned reason",
+          path: ["assigneeUnassignedReason"]
+        });
+      }
+      if (!hasAssignee && !hasUnassignedReason) {
+        ctx.addIssue({
+          code: z2.ZodIssueCode.custom,
+          message: "Issue proposals without an owner must include assigneeUnassignedReason",
+          path: ["assigneeUnassignedReason"]
+        });
+      }
+    });
+    convertChatToIssueSchema = z2.object({
+      messageId: z2.string().uuid().optional().nullable(),
+      proposal: chatIssueProposalSchema.optional()
+    });
+    chatOperationProposalSchema = z2.object({
+      targetType: z2.enum(["organization", "agent"]),
+      targetId: z2.string().min(1),
+      summary: z2.string().trim().min(1).max(500),
+      patch: z2.record(z2.unknown())
+    });
+    resolveChatOperationProposalSchema = z2.object({
+      action: z2.enum(["approve", "reject", "requestRevision"]),
+      decisionNote: z2.string().trim().max(5e3).optional().nullable()
+    });
+    updateChatConversationUserStateSchema = z2.object({
+      pinned: z2.boolean().optional(),
+      unread: z2.boolean().optional()
+    });
+    updateMessengerThreadUserStateSchema = z2.object({
+      pinned: z2.boolean().optional()
+    });
+    createMessengerCustomGroupSchema = z2.object({
+      name: z2.string().trim().min(1).max(80),
+      icon: z2.string().trim().min(1).max(24).optional().nullable()
+    });
+    createMessengerCustomGroupWithEntriesSchema = createMessengerCustomGroupSchema.extend({
+      threadKeys: z2.array(z2.string().trim().min(1).max(240)).min(1).max(50),
+      autoGenerateName: z2.boolean().optional()
+    });
+    updateMessengerCustomGroupSchema = z2.object({
+      name: z2.string().trim().min(1).max(80).optional(),
+      icon: z2.string().trim().min(1).max(24).optional().nullable(),
+      collapsed: z2.boolean().optional(),
+      pinned: z2.boolean().optional(),
+      sortOrder: z2.number().int().min(0).optional()
+    });
+    reorderMessengerCustomGroupsSchema = z2.object({
+      groupIds: z2.array(z2.string().uuid()).max(200)
+    });
+    assignMessengerCustomGroupEntrySchema = z2.object({
+      threadKey: z2.string().trim().min(1).max(240)
+    });
+    reorderMessengerCustomGroupEntriesSchema = z2.object({
+      threadKeys: z2.array(z2.string().trim().min(1).max(240)).max(500)
+    });
+  }
+});
+
+// ../packages/shared/dist/validators/instance.js
+import { z as z3 } from "zod";
 var DEFAULT_INSTANCE_BROWSER_SETTINGS, instanceBrowserSettingsSchema, patchInstanceBrowserSettingsSchema, instanceLocaleSchema, instanceGeneralSettingsSchema, patchInstanceGeneralSettingsSchema, instanceNotificationSettingsSchema, patchInstanceNotificationSettingsSchema, OPERATOR_PROFILE_MORE_ABOUT_YOU_MAX_LENGTH, operatorProfileSettingsSchema, patchOperatorProfileSettingsSchema, KEYBOARD_SHORTCUT_ACTION_IDS, keyboardShortcutActionIdSchema, keyboardShortcutBindingSchema, keyboardShortcutPreferenceSchema, keyboardShortcutSettingsSchema, instancePathPickerSelectionTypeSchema, instancePathPickerRequestSchema, instancePathPickerResultSchema;
 var init_instance = __esm({
   "../packages/shared/dist/validators/instance.js"() {
@@ -624,32 +1043,32 @@ var init_instance = __esm({
       enabled: true,
       openLinksIn: "built_in"
     };
-    instanceBrowserSettingsSchema = z2.object({
-      enabled: z2.boolean().default(DEFAULT_INSTANCE_BROWSER_SETTINGS.enabled),
-      openLinksIn: z2.enum(["built_in", "default_browser"]).default(DEFAULT_INSTANCE_BROWSER_SETTINGS.openLinksIn)
+    instanceBrowserSettingsSchema = z3.object({
+      enabled: z3.boolean().default(DEFAULT_INSTANCE_BROWSER_SETTINGS.enabled),
+      openLinksIn: z3.enum(["built_in", "default_browser"]).default(DEFAULT_INSTANCE_BROWSER_SETTINGS.openLinksIn)
     }).strict();
-    patchInstanceBrowserSettingsSchema = z2.object({
-      enabled: z2.boolean().optional(),
-      openLinksIn: z2.enum(["built_in", "default_browser"]).optional()
+    patchInstanceBrowserSettingsSchema = z3.object({
+      enabled: z3.boolean().optional(),
+      openLinksIn: z3.enum(["built_in", "default_browser"]).optional()
     }).strict();
-    instanceLocaleSchema = z2.enum(["en", "zh-CN"]);
-    instanceGeneralSettingsSchema = z2.object({
-      censorUsernameInLogs: z2.boolean().default(false),
-      showDeveloperDiagnostics: z2.boolean().default(false),
+    instanceLocaleSchema = z3.enum(["en", "zh-CN"]);
+    instanceGeneralSettingsSchema = z3.object({
+      censorUsernameInLogs: z3.boolean().default(false),
+      showDeveloperDiagnostics: z3.boolean().default(false),
       locale: instanceLocaleSchema.default("en")
     }).strict();
     patchInstanceGeneralSettingsSchema = instanceGeneralSettingsSchema.partial();
-    instanceNotificationSettingsSchema = z2.object({
-      desktopInboxNotifications: z2.boolean().default(true),
-      desktopDockBadge: z2.boolean().default(true),
-      desktopIssueNotifications: z2.boolean().default(true),
-      desktopChatNotifications: z2.boolean().default(true)
+    instanceNotificationSettingsSchema = z3.object({
+      desktopInboxNotifications: z3.boolean().default(true),
+      desktopDockBadge: z3.boolean().default(true),
+      desktopIssueNotifications: z3.boolean().default(true),
+      desktopChatNotifications: z3.boolean().default(true)
     }).strict();
     patchInstanceNotificationSettingsSchema = instanceNotificationSettingsSchema.partial();
     OPERATOR_PROFILE_MORE_ABOUT_YOU_MAX_LENGTH = 8e3;
-    operatorProfileSettingsSchema = z2.object({
-      nickname: z2.string().max(80).default(""),
-      moreAboutYou: z2.string().max(OPERATOR_PROFILE_MORE_ABOUT_YOU_MAX_LENGTH).default("")
+    operatorProfileSettingsSchema = z3.object({
+      nickname: z3.string().max(80).default(""),
+      moreAboutYou: z3.string().max(OPERATOR_PROFILE_MORE_ABOUT_YOU_MAX_LENGTH).default("")
     }).strict();
     patchOperatorProfileSettingsSchema = operatorProfileSettingsSchema.partial();
     KEYBOARD_SHORTCUT_ACTION_IDS = [
@@ -660,28 +1079,28 @@ var init_instance = __esm({
       "sidebar.toggle",
       "panel.toggle"
     ];
-    keyboardShortcutActionIdSchema = z2.enum(KEYBOARD_SHORTCUT_ACTION_IDS);
-    keyboardShortcutBindingSchema = z2.object({
-      key: z2.string().trim().min(1).max(64),
-      code: z2.string().trim().min(1).max(80).optional(),
-      metaKey: z2.boolean().optional(),
-      ctrlKey: z2.boolean().optional(),
-      altKey: z2.boolean().optional(),
-      shiftKey: z2.boolean().optional()
+    keyboardShortcutActionIdSchema = z3.enum(KEYBOARD_SHORTCUT_ACTION_IDS);
+    keyboardShortcutBindingSchema = z3.object({
+      key: z3.string().trim().min(1).max(64),
+      code: z3.string().trim().min(1).max(80).optional(),
+      metaKey: z3.boolean().optional(),
+      ctrlKey: z3.boolean().optional(),
+      altKey: z3.boolean().optional(),
+      shiftKey: z3.boolean().optional()
     }).strict();
-    keyboardShortcutPreferenceSchema = z2.object({
+    keyboardShortcutPreferenceSchema = z3.object({
       actionId: keyboardShortcutActionIdSchema,
-      bindings: z2.array(keyboardShortcutBindingSchema).max(4).optional(),
-      disabled: z2.boolean().optional()
+      bindings: z3.array(keyboardShortcutBindingSchema).max(4).optional(),
+      disabled: z3.boolean().optional()
     }).strict();
-    keyboardShortcutSettingsSchema = z2.object({
-      shortcuts: z2.array(keyboardShortcutPreferenceSchema).max(KEYBOARD_SHORTCUT_ACTION_IDS.length).default([])
+    keyboardShortcutSettingsSchema = z3.object({
+      shortcuts: z3.array(keyboardShortcutPreferenceSchema).max(KEYBOARD_SHORTCUT_ACTION_IDS.length).default([])
     }).strict().superRefine((value, ctx) => {
       const seen = /* @__PURE__ */ new Set();
       value.shortcuts.forEach((shortcut, index) => {
         if (seen.has(shortcut.actionId)) {
           ctx.addIssue({
-            code: z2.ZodIssueCode.custom,
+            code: z3.ZodIssueCode.custom,
             message: `Duplicate shortcut action id: ${shortcut.actionId}`,
             path: ["shortcuts", index, "actionId"]
           });
@@ -690,43 +1109,43 @@ var init_instance = __esm({
         seen.add(shortcut.actionId);
       });
     });
-    instancePathPickerSelectionTypeSchema = z2.enum(["file", "directory"]);
-    instancePathPickerRequestSchema = z2.object({
+    instancePathPickerSelectionTypeSchema = z3.enum(["file", "directory"]);
+    instancePathPickerRequestSchema = z3.object({
       selectionType: instancePathPickerSelectionTypeSchema
     }).strict();
-    instancePathPickerResultSchema = z2.object({
-      path: z2.string().nullable(),
-      cancelled: z2.boolean()
+    instancePathPickerResultSchema = z3.object({
+      path: z3.string().nullable(),
+      cancelled: z3.boolean()
     }).strict();
   }
 });
 
 // ../packages/shared/dist/validators/budget.js
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 var upsertBudgetPolicySchema, resolveBudgetIncidentSchema;
 var init_budget = __esm({
   "../packages/shared/dist/validators/budget.js"() {
     "use strict";
     init_constants();
-    upsertBudgetPolicySchema = z3.object({
-      scopeType: z3.enum(BUDGET_SCOPE_TYPES),
-      scopeId: z3.string().uuid(),
-      metric: z3.enum(BUDGET_METRICS).optional().default("billed_cents"),
-      windowKind: z3.enum(BUDGET_WINDOW_KINDS).optional().default("calendar_month_utc"),
-      amount: z3.number().int().nonnegative(),
-      warnPercent: z3.number().int().min(1).max(99).optional().default(80),
-      hardStopEnabled: z3.boolean().optional().default(true),
-      notifyEnabled: z3.boolean().optional().default(true),
-      isActive: z3.boolean().optional().default(true)
+    upsertBudgetPolicySchema = z4.object({
+      scopeType: z4.enum(BUDGET_SCOPE_TYPES),
+      scopeId: z4.string().uuid(),
+      metric: z4.enum(BUDGET_METRICS).optional().default("billed_cents"),
+      windowKind: z4.enum(BUDGET_WINDOW_KINDS).optional().default("calendar_month_utc"),
+      amount: z4.number().int().nonnegative(),
+      warnPercent: z4.number().int().min(1).max(99).optional().default(80),
+      hardStopEnabled: z4.boolean().optional().default(true),
+      notifyEnabled: z4.boolean().optional().default(true),
+      isActive: z4.boolean().optional().default(true)
     });
-    resolveBudgetIncidentSchema = z3.object({
-      action: z3.enum(BUDGET_INCIDENT_RESOLUTION_ACTIONS),
-      amount: z3.number().int().nonnegative().optional(),
-      decisionNote: z3.string().optional().nullable()
+    resolveBudgetIncidentSchema = z4.object({
+      action: z4.enum(BUDGET_INCIDENT_RESOLUTION_ACTIONS),
+      amount: z4.number().int().nonnegative().optional(),
+      decisionNote: z4.string().optional().nullable()
     }).superRefine((value, ctx) => {
       if (value.action === "raise_budget_and_resume" && typeof value.amount !== "number") {
         ctx.addIssue({
-          code: z3.ZodIssueCode.custom,
+          code: z4.ZodIssueCode.custom,
           message: "amount is required when raising a budget",
           path: ["amount"]
         });
@@ -736,12 +1155,12 @@ var init_budget = __esm({
 });
 
 // ../packages/shared/dist/validators/adapter-skills.js
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 var agentSkillStateSchema, agentSkillOriginSchema, agentSkillSourceClassSchema, agentSkillSyncModeSchema, agentSkillEntrySchema, agentSkillSnapshotSchema, agentSkillSyncSchema, agentSkillEnableSchema;
 var init_adapter_skills = __esm({
   "../packages/shared/dist/validators/adapter-skills.js"() {
     "use strict";
-    agentSkillStateSchema = z4.enum([
+    agentSkillStateSchema = z5.enum([
       "available",
       "configured",
       "installed",
@@ -749,302 +1168,60 @@ var init_adapter_skills = __esm({
       "stale",
       "external"
     ]);
-    agentSkillOriginSchema = z4.preprocess((value) => {
+    agentSkillOriginSchema = z5.preprocess((value) => {
       if (value === "company_managed")
         return "organization_managed";
       return value;
-    }, z4.enum([
+    }, z5.enum([
       "organization_managed",
       "user_installed",
       "external_unknown"
     ]));
-    agentSkillSourceClassSchema = z4.enum([
+    agentSkillSourceClassSchema = z5.enum([
       "bundled",
       "organization",
       "agent_home",
       "global",
       "adapter_home"
     ]);
-    agentSkillSyncModeSchema = z4.enum([
+    agentSkillSyncModeSchema = z5.enum([
       "unsupported",
       "persistent",
       "ephemeral"
     ]);
-    agentSkillEntrySchema = z4.object({
-      key: z4.string().min(1),
-      selectionKey: z4.string().min(1),
-      runtimeName: z4.string().min(1).nullable(),
-      description: z4.string().nullable().optional(),
-      desired: z4.boolean(),
-      configurable: z4.boolean(),
-      alwaysEnabled: z4.boolean(),
-      managed: z4.boolean(),
+    agentSkillEntrySchema = z5.object({
+      key: z5.string().min(1),
+      selectionKey: z5.string().min(1),
+      runtimeName: z5.string().min(1).nullable(),
+      description: z5.string().nullable().optional(),
+      desired: z5.boolean(),
+      configurable: z5.boolean(),
+      alwaysEnabled: z5.boolean(),
+      managed: z5.boolean(),
       state: agentSkillStateSchema,
       sourceClass: agentSkillSourceClassSchema,
       origin: agentSkillOriginSchema.optional(),
-      originLabel: z4.string().nullable().optional(),
-      locationLabel: z4.string().nullable().optional(),
-      readOnly: z4.boolean().optional(),
-      sourcePath: z4.string().nullable().optional(),
-      targetPath: z4.string().nullable().optional(),
-      workspaceEditPath: z4.string().nullable().optional(),
-      detail: z4.string().nullable().optional()
+      originLabel: z5.string().nullable().optional(),
+      locationLabel: z5.string().nullable().optional(),
+      readOnly: z5.boolean().optional(),
+      sourcePath: z5.string().nullable().optional(),
+      targetPath: z5.string().nullable().optional(),
+      workspaceEditPath: z5.string().nullable().optional(),
+      detail: z5.string().nullable().optional()
     });
-    agentSkillSnapshotSchema = z4.object({
-      agentRuntimeType: z4.string().min(1),
-      supported: z4.boolean(),
+    agentSkillSnapshotSchema = z5.object({
+      agentRuntimeType: z5.string().min(1),
+      supported: z5.boolean(),
       mode: agentSkillSyncModeSchema,
-      desiredSkills: z4.array(z4.string().min(1)),
-      entries: z4.array(agentSkillEntrySchema),
-      warnings: z4.array(z4.string())
-    });
-    agentSkillSyncSchema = z4.object({
-      desiredSkills: z4.array(z4.string().min(1))
-    });
-    agentSkillEnableSchema = z4.object({
-      skills: z4.array(z4.string().min(1)).min(1)
-    });
-  }
-});
-
-// ../packages/shared/dist/validators/chat.js
-import { z as z5 } from "zod";
-var chatConversationStatusSchema, chatIssueCreationModeSchema, chatMessageRoleSchema, chatMessageKindSchema, chatMessageStatusSchema, chatContextEntityTypeSchema, createChatContextLinkSchema, createChatConversationSchema, setChatProjectContextSchema, updateChatConversationSchema, forkChatConversationSchema, addChatMessageSchema, chatQueuedMessagePayloadSchema, createChatQueuedMessageSchema, updateChatQueuedMessageSchema, cancelChatQueuedMessageSchema, steerChatQueuedMessageSchema, chatRichReferenceDisplaySchema, chatIssueIdentifierSchema, chatAskUserIdentifierSchema, chatAskUserOptionSchema, chatAskUserQuestionSchema, chatAskUserRequestSchema, chatIssueRichReferenceSchema, chatIssueCommentRichReferenceSchema, chatRichReferenceSchema, chatRichReferencesSchema, chatAutomationCreateSchema, createChatAttachmentMetadataSchema, chatIssueProposalSchema, convertChatToIssueSchema, chatOperationProposalSchema, resolveChatOperationProposalSchema, updateChatConversationUserStateSchema, updateMessengerThreadUserStateSchema, createMessengerCustomGroupSchema, createMessengerCustomGroupWithEntriesSchema, updateMessengerCustomGroupSchema, reorderMessengerCustomGroupsSchema, assignMessengerCustomGroupEntrySchema, reorderMessengerCustomGroupEntriesSchema;
-var init_chat = __esm({
-  "../packages/shared/dist/validators/chat.js"() {
-    "use strict";
-    init_constants();
-    chatConversationStatusSchema = z5.enum(CHAT_CONVERSATION_STATUSES);
-    chatIssueCreationModeSchema = z5.enum(CHAT_ISSUE_CREATION_MODES);
-    chatMessageRoleSchema = z5.enum(CHAT_MESSAGE_ROLES);
-    chatMessageKindSchema = z5.enum(CHAT_MESSAGE_KINDS);
-    chatMessageStatusSchema = z5.enum(CHAT_MESSAGE_STATUSES);
-    chatContextEntityTypeSchema = z5.enum(CHAT_CONTEXT_ENTITY_TYPES);
-    createChatContextLinkSchema = z5.object({
-      entityType: chatContextEntityTypeSchema,
-      entityId: z5.string().min(1),
-      metadata: z5.record(z5.unknown()).optional().nullable()
-    });
-    createChatConversationSchema = z5.object({
-      title: z5.string().trim().min(1).max(200).optional(),
-      summary: z5.string().trim().max(5e3).optional().nullable(),
-      preferredAgentId: z5.string().uuid().optional().nullable(),
-      issueCreationMode: chatIssueCreationModeSchema.optional(),
-      planMode: z5.boolean().optional(),
-      contextLinks: z5.array(createChatContextLinkSchema).optional().default([])
-    });
-    setChatProjectContextSchema = z5.object({
-      projectId: z5.string().uuid().optional().nullable()
-    });
-    updateChatConversationSchema = createChatConversationSchema.partial().extend({
-      status: chatConversationStatusSchema.optional(),
-      routedAgentId: z5.string().uuid().optional().nullable(),
-      primaryIssueId: z5.string().uuid().optional().nullable(),
-      resolvedAt: z5.string().datetime().optional().nullable()
-    });
-    forkChatConversationSchema = z5.object({
-      sourceMessageId: z5.string().uuid().optional().nullable(),
-      title: z5.string().trim().min(1).max(200).optional()
-    });
-    addChatMessageSchema = z5.object({
-      body: z5.string().trim().min(1).max(2e4),
-      editUserMessageId: z5.string().uuid().optional().nullable(),
-      queuedMessageId: z5.string().uuid().optional().nullable()
-    });
-    chatQueuedMessagePayloadSchema = z5.object({
-      body: z5.string().trim().min(1).max(2e4),
-      attachmentIds: z5.array(z5.string().uuid()).optional().default([]),
-      projectId: z5.string().uuid().optional().nullable(),
-      skillRefs: z5.array(z5.string().trim().min(1).max(240)).optional().default([]),
-      accessMode: z5.string().trim().min(1).max(120).optional().nullable(),
-      model: z5.string().trim().min(1).max(120).optional().nullable(),
-      effort: z5.string().trim().min(1).max(120).optional().nullable(),
-      metadata: z5.record(z5.unknown()).optional().nullable()
-    });
-    createChatQueuedMessageSchema = z5.object({
-      clientMutationId: z5.string().trim().min(1).max(120),
-      expectedGenerationId: z5.string().uuid().optional().nullable(),
-      payload: chatQueuedMessagePayloadSchema
-    });
-    updateChatQueuedMessageSchema = z5.object({
-      version: z5.number().int().positive(),
-      payload: chatQueuedMessagePayloadSchema
-    });
-    cancelChatQueuedMessageSchema = z5.object({
-      version: z5.number().int().positive().optional()
-    });
-    steerChatQueuedMessageSchema = z5.object({
-      expectedActiveGenerationId: z5.string().uuid().optional().nullable()
-    });
-    chatRichReferenceDisplaySchema = z5.enum(["card", "inline"]);
-    chatIssueIdentifierSchema = z5.string().trim().min(1).max(64).regex(/^[A-Z0-9][A-Z0-9-]*$/i);
-    chatAskUserIdentifierSchema = z5.string().trim().min(1).max(64).regex(/^[a-zA-Z0-9_-]+$/);
-    chatAskUserOptionSchema = z5.object({
-      id: chatAskUserIdentifierSchema,
-      label: z5.string().trim().min(1).max(80),
-      description: z5.string().trim().min(1).max(220).optional(),
-      recommended: z5.boolean().optional()
-    });
-    chatAskUserQuestionSchema = z5.object({
-      id: chatAskUserIdentifierSchema,
-      header: z5.string().trim().min(1).max(32).optional(),
-      question: z5.string().trim().min(1).max(240),
-      options: z5.array(chatAskUserOptionSchema).min(2).max(3),
-      selectionMode: z5.enum(["single", "multiple"]).optional(),
-      allowFreeform: z5.boolean().optional()
-    }).superRefine((question, ctx) => {
-      const optionIds = /* @__PURE__ */ new Set();
-      question.options.forEach((option, index) => {
-        if (optionIds.has(option.id)) {
-          ctx.addIssue({
-            code: z5.ZodIssueCode.custom,
-            message: "Option ids must be unique within each question",
-            path: ["options", index, "id"]
-          });
-          return;
-        }
-        optionIds.add(option.id);
-      });
-    });
-    chatAskUserRequestSchema = z5.object({
-      questions: z5.array(chatAskUserQuestionSchema).min(1).max(3)
-    }).superRefine((request, ctx) => {
-      const questionIds = /* @__PURE__ */ new Set();
-      request.questions.forEach((question, index) => {
-        if (questionIds.has(question.id)) {
-          ctx.addIssue({
-            code: z5.ZodIssueCode.custom,
-            message: "Question ids must be unique within requestUserInput",
-            path: ["questions", index, "id"]
-          });
-          return;
-        }
-        questionIds.add(question.id);
-      });
-    });
-    chatIssueRichReferenceSchema = z5.object({
-      type: z5.literal("issue"),
-      issueId: z5.string().uuid().optional(),
-      identifier: chatIssueIdentifierSchema.optional(),
-      display: chatRichReferenceDisplaySchema.optional()
-    }).refine((value) => Boolean(value.issueId || value.identifier), {
-      message: "issueId or identifier is required"
-    });
-    chatIssueCommentRichReferenceSchema = z5.object({
-      type: z5.literal("issue_comment"),
-      issueId: z5.string().uuid().optional(),
-      identifier: chatIssueIdentifierSchema.optional(),
-      commentId: z5.string().uuid(),
-      display: chatRichReferenceDisplaySchema.optional()
-    }).refine((value) => Boolean(value.issueId || value.identifier), {
-      message: "issueId or identifier is required"
-    });
-    chatRichReferenceSchema = z5.union([
-      chatIssueRichReferenceSchema,
-      chatIssueCommentRichReferenceSchema
-    ]);
-    chatRichReferencesSchema = z5.array(chatRichReferenceSchema).max(5);
-    chatAutomationCreateSchema = z5.object({
-      title: z5.string().trim().min(1).max(200),
-      instructions: z5.string().trim().max(2e4).optional().nullable(),
-      description: z5.string().trim().max(2e4).optional().nullable(),
-      projectId: z5.string().uuid().optional().nullable(),
-      goalId: z5.string().uuid().optional().nullable(),
-      parentIssueId: z5.string().uuid().optional().nullable(),
-      priority: z5.enum(["critical", "high", "medium", "low"]).optional().default("medium"),
-      status: z5.enum(AUTOMATION_STATUSES).optional().default("active"),
-      concurrencyPolicy: z5.enum(AUTOMATION_CONCURRENCY_POLICIES).optional().default("coalesce_if_active"),
-      catchUpPolicy: z5.enum(AUTOMATION_CATCH_UP_POLICIES).optional().default("skip_missed"),
-      outputMode: z5.enum(AUTOMATION_OUTPUT_MODES).optional().default("track_issue"),
-      schedule: z5.object({
-        cronExpression: z5.string().trim().min(1),
-        timezone: z5.string().trim().min(1),
-        label: z5.string().trim().max(120).optional().nullable(),
-        enabled: z5.boolean().optional().default(true)
-      })
-    }).transform(({ description, instructions, ...value }) => ({
-      ...value,
-      instructions: instructions === void 0 ? description : instructions
-    }));
-    createChatAttachmentMetadataSchema = z5.object({
-      messageId: z5.string().uuid()
-    });
-    chatIssueProposalSchema = z5.object({
-      title: z5.string().trim().min(1).max(200),
-      description: z5.string().trim().min(1).max(2e4),
-      status: z5.enum(ISSUE_STATUSES).optional().default("todo"),
-      priority: z5.enum(["critical", "high", "medium", "low"]).optional().default("medium"),
-      projectId: z5.string().uuid().optional().nullable(),
-      goalId: z5.string().uuid().optional().nullable(),
-      parentId: z5.string().uuid().optional().nullable(),
-      assigneeAgentId: z5.string().uuid().optional().nullable(),
-      assigneeUserId: z5.string().trim().optional().nullable(),
-      assigneeUnassignedReason: z5.string().trim().min(1).max(500).optional().nullable(),
-      reviewerAgentId: z5.string().uuid().optional().nullable(),
-      reviewerUserId: z5.string().trim().optional().nullable(),
-      labelIds: z5.array(z5.string().uuid()).optional()
-    }).superRefine((proposal, ctx) => {
-      const hasAssignee = Boolean(proposal.assigneeAgentId || proposal.assigneeUserId);
-      const hasUnassignedReason = Boolean(proposal.assigneeUnassignedReason?.trim());
-      if (hasAssignee && hasUnassignedReason) {
-        ctx.addIssue({
-          code: z5.ZodIssueCode.custom,
-          message: "Issue proposals with an assignee must not also declare an unassigned reason",
-          path: ["assigneeUnassignedReason"]
-        });
-      }
-      if (!hasAssignee && !hasUnassignedReason) {
-        ctx.addIssue({
-          code: z5.ZodIssueCode.custom,
-          message: "Issue proposals without an owner must include assigneeUnassignedReason",
-          path: ["assigneeUnassignedReason"]
-        });
-      }
-    });
-    convertChatToIssueSchema = z5.object({
-      messageId: z5.string().uuid().optional().nullable(),
-      proposal: chatIssueProposalSchema.optional()
-    });
-    chatOperationProposalSchema = z5.object({
-      targetType: z5.enum(["organization", "agent"]),
-      targetId: z5.string().min(1),
-      summary: z5.string().trim().min(1).max(500),
-      patch: z5.record(z5.unknown())
-    });
-    resolveChatOperationProposalSchema = z5.object({
-      action: z5.enum(["approve", "reject", "requestRevision"]),
-      decisionNote: z5.string().trim().max(5e3).optional().nullable()
+      desiredSkills: z5.array(z5.string().min(1)),
+      entries: z5.array(agentSkillEntrySchema),
+      warnings: z5.array(z5.string())
     });
-    updateChatConversationUserStateSchema = z5.object({
-      pinned: z5.boolean().optional(),
-      unread: z5.boolean().optional()
+    agentSkillSyncSchema = z5.object({
+      desiredSkills: z5.array(z5.string().min(1))
     });
-    updateMessengerThreadUserStateSchema = z5.object({
-      pinned: z5.boolean().optional()
-    });
-    createMessengerCustomGroupSchema = z5.object({
-      name: z5.string().trim().min(1).max(80),
-      icon: z5.string().trim().min(1).max(24).optional().nullable()
-    });
-    createMessengerCustomGroupWithEntriesSchema = createMessengerCustomGroupSchema.extend({
-      threadKeys: z5.array(z5.string().trim().min(1).max(240)).min(1).max(50),
-      autoGenerateName: z5.boolean().optional()
-    });
-    updateMessengerCustomGroupSchema = z5.object({
-      name: z5.string().trim().min(1).max(80).optional(),
-      icon: z5.string().trim().min(1).max(24).optional().nullable(),
-      collapsed: z5.boolean().optional(),
-      pinned: z5.boolean().optional(),
-      sortOrder: z5.number().int().min(0).optional()
-    });
-    reorderMessengerCustomGroupsSchema = z5.object({
-      groupIds: z5.array(z5.string().uuid()).max(200)
-    });
-    assignMessengerCustomGroupEntrySchema = z5.object({
-      threadKey: z5.string().trim().min(1).max(240)
-    });
-    reorderMessengerCustomGroupEntriesSchema = z5.object({
-      threadKeys: z5.array(z5.string().trim().min(1).max(240)).max(500)
+    agentSkillEnableSchema = z5.object({
+      skills: z5.array(z5.string().min(1)).min(1)
     });
   }
 });
@@ -1219,7 +1396,7 @@ var init_organization_issue_key = __esm({
 
 // ../packages/shared/dist/validators/organization.js
 import { z as z9 } from "zod";
-var logoAssetIdSchema, brandColorSchema, organizationIssueKeySchema, createOrganizationSchema, updateOrganizationSchema, updateOrganizationBrandingSchema, updateOrganizationWorkspaceFileSchema, createOrganizationWorkspaceFileSchema, createOrganizationWorkspaceDirectorySchema, renameOrganizationWorkspaceEntrySchema, moveOrganizationWorkspaceEntrySchema, copyOrganizationWorkspaceEntrySchema;
+var logoAssetIdSchema, brandColorSchema, organizationIssueKeySchema, createOrganizationSchema, updateOrganizationSchema, updateOrganizationBrandingSchema, updateOrganizationWorkspaceFileSchema, workspaceWebPreviewNetworkModeSchema, createOrganizationWorkspaceWebPreviewSessionSchema, createOrganizationWorkspaceFileSchema, createOrganizationWorkspaceDirectorySchema, renameOrganizationWorkspaceEntrySchema, moveOrganizationWorkspaceEntrySchema, copyOrganizationWorkspaceEntrySchema;
 var init_organization = __esm({
   "../packages/shared/dist/validators/organization.js"() {
     "use strict";
@@ -1257,6 +1434,12 @@ var init_organization = __esm({
       content: z9.string(),
       expectedContent: z9.string().optional()
     });
+    workspaceWebPreviewNetworkModeSchema = z9.enum(["offline", "connected"]);
+    createOrganizationWorkspaceWebPreviewSessionSchema = z9.object({
+      entryPath: z9.string().trim().min(1).max(1e3),
+      networkMode: workspaceWebPreviewNetworkModeSchema,
+      htmlContent: z9.string().optional()
+    });
     createOrganizationWorkspaceFileSchema = z9.object({
       filePath: z9.string().trim().min(1).max(1e3),
       content: z9.string().optional().default("")
@@ -3114,6 +3297,7 @@ var init_organization_skill_reference = __esm({
       "rudder-create-agent",
       "rudder-create-plugin",
       "skill-creator",
+      "visualize",
       "browser"
     ];
     RUDDER_BUNDLED_SKILL_KEYS = new Set(RUDDER_BUNDLED_SKILL_SLUGS.map((slug) => `rudder/${slug}`));
@@ -3335,12 +3519,15 @@ var init_config_schema = __esm({
 var init_dist = __esm({
   "../packages/shared/dist/index.js"() {
     "use strict";
+    init_browser_shortcuts();
+    init_chat_inline_visuals();
     init_chat_work_manifest();
     init_constants();
     init_agent_run();
     init_workspace_backup();
     init_website_icons();
     init_custom_integration();
+    init_chat();
     init_validators();
     init_validators();
     init_agent_url_key();
@@ -3358,6 +3545,46 @@ var init_dist = __esm({
   }
 });
 
+// src/version.ts
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+function readPackageVersion(packagePath, expectedName) {
+  if (!existsSync(packagePath)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync(packagePath, "utf8"));
+    if (parsed.name === expectedName && parsed.version) return parsed.version;
+  } catch {
+    return null;
+  }
+  return null;
+}
+function resolveCliVersion(moduleUrl = import.meta.url, env = process.env) {
+  if (env.npm_package_name === CLI_PACKAGE_NAME && env.npm_package_version) {
+    return env.npm_package_version;
+  }
+  const moduleDir = path.dirname(fileURLToPath(moduleUrl));
+  const candidates = [
+    path.resolve(moduleDir, CLI_VERSION_MANIFEST),
+    path.resolve(moduleDir, "package.json"),
+    path.resolve(moduleDir, "../package.json"),
+    path.resolve(moduleDir, "../../package.json")
+  ];
+  for (const candidate of candidates) {
+    const version = readPackageVersion(candidate, CLI_PACKAGE_NAME);
+    if (version) return version;
+  }
+  return "0.0.0";
+}
+var CLI_PACKAGE_NAME, CLI_VERSION_MANIFEST;
+var init_version = __esm({
+  "src/version.ts"() {
+    "use strict";
+    CLI_PACKAGE_NAME = "@rudderhq/cli";
+    CLI_VERSION_MANIFEST = "rudder-cli-package.json";
+  }
+});
+
 // src/config/hostnames.ts
 function normalizeHostnameInput(raw) {
   const input = raw.trim();
@@ -3390,11 +3617,11 @@ var init_hostnames = __esm({
 
 // src/config/home.ts
 import os2 from "node:os";
-import path2 from "node:path";
+import path3 from "node:path";
 function resolveRudderHomeDir() {
   const envHome = process.env.RUDDER_HOME?.trim();
-  if (envHome) return path2.resolve(expandHomePrefix(envHome));
-  return path2.resolve(os2.homedir(), ".rudder");
+  if (envHome) return path3.resolve(expandHomePrefix(envHome));
+  return path3.resolve(os2.homedir(), ".rudder");
 }
 function resolveRudderInstanceId(override) {
   const raw = override?.trim() || process.env.RUDDER_INSTANCE_ID?.trim() || DEFAULT_INSTANCE_ID;
@@ -3407,35 +3634,35 @@ function resolveRudderInstanceId(override) {
 }
 function resolveRudderInstanceRoot(instanceId) {
   const id = resolveRudderInstanceId(instanceId);
-  return path2.resolve(resolveRudderHomeDir(), "instances", id);
+  return path3.resolve(resolveRudderHomeDir(), "instances", id);
 }
 function resolveDefaultConfigPath(instanceId) {
-  return path2.resolve(resolveRudderInstanceRoot(instanceId), "config.json");
+  return path3.resolve(resolveRudderInstanceRoot(instanceId), "config.json");
 }
 function resolveDefaultContextPath() {
-  return path2.resolve(resolveRudderHomeDir(), "context.json");
+  return path3.resolve(resolveRudderHomeDir(), "context.json");
 }
 function resolveDefaultCliAuthPath() {
-  return path2.resolve(resolveRudderHomeDir(), "auth.json");
+  return path3.resolve(resolveRudderHomeDir(), "auth.json");
 }
 function resolveDefaultEmbeddedPostgresDir(instanceId) {
-  return path2.resolve(resolveRudderInstanceRoot(instanceId), "db");
+  return path3.resolve(resolveRudderInstanceRoot(instanceId), "db");
 }
 function resolveDefaultLogsDir(instanceId) {
-  return path2.resolve(resolveRudderInstanceRoot(instanceId), "logs");
+  return path3.resolve(resolveRudderInstanceRoot(instanceId), "logs");
 }
 function resolveDefaultSecretsKeyFilePath(instanceId) {
-  return path2.resolve(resolveRudderInstanceRoot(instanceId), "secrets", "master.key");
+  return path3.resolve(resolveRudderInstanceRoot(instanceId), "secrets", "master.key");
 }
 function resolveDefaultStorageDir(instanceId) {
-  return path2.resolve(resolveRudderInstanceRoot(instanceId), "data", "storage");
+  return path3.resolve(resolveRudderInstanceRoot(instanceId), "data", "storage");
 }
 function resolveDefaultBackupDir(instanceId) {
-  return path2.resolve(resolveRudderInstanceRoot(instanceId), "data", "backups");
+  return path3.resolve(resolveRudderInstanceRoot(instanceId), "data", "backups");
 }
 function expandHomePrefix(value) {
   if (value === "~") return os2.homedir();
-  if (value.startsWith("~/")) return path2.resolve(os2.homedir(), value.slice(2));
+  if (value.startsWith("~/")) return path3.resolve(os2.homedir(), value.slice(2));
   return value;
 }
 function describeLocalInstancePaths(instanceId) {
@@ -3472,24 +3699,24 @@ var init_schema = __esm({
 
 // src/config/store.ts
 import fs2 from "node:fs";
-import path3 from "node:path";
+import path4 from "node:path";
 function findConfigFileFromAncestors(startDir) {
-  const absoluteStartDir = path3.resolve(startDir);
+  const absoluteStartDir = path4.resolve(startDir);
   let currentDir = absoluteStartDir;
   while (true) {
-    const candidate = path3.resolve(currentDir, ".rudder", DEFAULT_CONFIG_BASENAME);
+    const candidate = path4.resolve(currentDir, ".rudder", DEFAULT_CONFIG_BASENAME);
     if (fs2.existsSync(candidate)) {
       return candidate;
     }
-    const nextDir = path3.resolve(currentDir, "..");
+    const nextDir = path4.resolve(currentDir, "..");
     if (nextDir === currentDir) break;
     currentDir = nextDir;
   }
   return null;
 }
 function resolveConfigPath(overridePath) {
-  if (overridePath) return path3.resolve(overridePath);
-  if (process.env.RUDDER_CONFIG) return path3.resolve(process.env.RUDDER_CONFIG);
+  if (overridePath) return path4.resolve(overridePath);
+  if (process.env.RUDDER_CONFIG) return path4.resolve(process.env.RUDDER_CONFIG);
   return findConfigFileFromAncestors(process.cwd()) ?? resolveDefaultConfigPath(resolveRudderInstanceId());
 }
 function parseJson(filePath) {
@@ -3544,7 +3771,7 @@ function readConfig(configPath) {
 }
 function writeConfig(config, configPath) {
   const filePath = resolveConfigPath(configPath);
-  const dir = path3.dirname(filePath);
+  const dir = path4.dirname(filePath);
   fs2.mkdirSync(dir, { recursive: true });
   if (fs2.existsSync(filePath)) {
     const backupPath = filePath + ".backup";
@@ -3572,9 +3799,9 @@ var init_store = __esm({
 import { config as loadDotenv, parse as parseEnvFileContents } from "dotenv";
 import { randomBytes } from "node:crypto";
 import fs3 from "node:fs";
-import path4 from "node:path";
+import path5 from "node:path";
 function resolveEnvFilePath(configPath) {
-  return path4.resolve(path4.dirname(resolveConfigPath(configPath)), ".env");
+  return path5.resolve(path5.dirname(resolveConfigPath(configPath)), ".env");
 }
 function isNonEmpty(value) {
   return typeof value === "string" && value.trim().length > 0;
@@ -3647,7 +3874,7 @@ function readPaperclipEnvEntries(filePath = resolveEnvFilePath()) {
   return parseEnvFile(fs3.readFileSync(filePath, "utf-8"));
 }
 function writePaperclipEnvEntries(entries, filePath = resolveEnvFilePath()) {
-  const dir = path4.dirname(filePath);
+  const dir = path5.dirname(filePath);
   fs3.mkdirSync(dir, { recursive: true });
   fs3.writeFileSync(filePath, renderEnvFile(entries), {
     mode: 384
@@ -3678,7 +3905,7 @@ var init_env = __esm({
 import { execFileSync, spawnSync as spawnSync2 } from "node:child_process";
 import { cp, mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
 import { createRequire } from "node:module";
-import path5 from "node:path";
+import path6 from "node:path";
 import { pathToFileURL } from "node:url";
 function sanitizeRuntimeCacheSegment(value) {
   return encodeURIComponent(value.trim() || "latest").replaceAll("%", "_");
@@ -3688,7 +3915,7 @@ function resolveRuntimePackageVersion(version) {
   return normalized.length > 0 ? normalized : "latest";
 }
 function resolveRuntimeCacheDir(version, homeDir = resolveRudderHomeDir()) {
-  return path5.join(homeDir, "runtimes", sanitizeRuntimeCacheSegment(resolveRuntimePackageVersion(version)));
+  return path6.join(homeDir, "runtimes", sanitizeRuntimeCacheSegment(resolveRuntimePackageVersion(version)));
 }
 function resolveRuntimePackageSpec(version, packageName = RUNTIME_NPM_PACKAGE_NAME) {
   const packageVersion = resolveRuntimePackageVersion(version);
@@ -3696,7 +3923,7 @@ function resolveRuntimePackageSpec(version, packageName = RUNTIME_NPM_PACKAGE_NA
 }
 async function readRuntimeInstallMetadata(cacheDir) {
   try {
-    const raw = await readFile(path5.join(cacheDir, RUNTIME_METADATA_FILE), "utf8");
+    const raw = await readFile(path6.join(cacheDir, RUNTIME_METADATA_FILE), "utf8");
     const parsed = JSON.parse(raw);
     if (parsed.version !== 1) return null;
     if (typeof parsed.packageName !== "string" || typeof parsed.packageVersion !== "string") return null;
@@ -3706,7 +3933,7 @@ async function readRuntimeInstallMetadata(cacheDir) {
   }
 }
 async function writeRuntimeInstallMetadata(cacheDir, metadata) {
-  await writeFile(path5.join(cacheDir, RUNTIME_METADATA_FILE), `${JSON.stringify(metadata, null, 2)}
+  await writeFile(path6.join(cacheDir, RUNTIME_METADATA_FILE), `${JSON.stringify(metadata, null, 2)}
 `, "utf8");
 }
 async function touchRuntimeInstallMetadata(cacheDir) {
@@ -3733,7 +3960,7 @@ function resolveEmbeddedPostgresPlatformPackage(platform = process.platform, arc
 }
 async function canResolveRuntimePackage(cacheDir, packageName) {
   try {
-    await readFile(path5.join(cacheDir, "node_modules", ...packageName.split("/"), "package.json"), "utf8");
+    await readFile(path6.join(cacheDir, "node_modules", ...packageName.split("/"), "package.json"), "utf8");
     return true;
   } catch {
     return false;
@@ -3753,7 +3980,7 @@ async function isRuntimeCacheHit(options) {
     return false;
   }
   try {
-    const packageJsonPath = path5.join(options.cacheDir, "node_modules", ...packageName.split("/"), "package.json");
+    const packageJsonPath = path6.join(options.cacheDir, "node_modules", ...packageName.split("/"), "package.json");
     const packageJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
     const packageVersionMatches = packageVersion === "latest" || packageJson.version === packageVersion;
     return packageVersionMatches && await hasRequiredRuntimePlatformDependencies(options.cacheDir);
@@ -3764,13 +3991,14 @@ async function isRuntimeCacheHit(options) {
 async function ensureRuntimeInstalled(options) {
   const packageName = options.packageName ?? RUNTIME_NPM_PACKAGE_NAME;
   const packageVersion = resolveRuntimePackageVersion(options.version);
-  const cacheDir = resolveRuntimeCacheDir(packageVersion, options.homeDir);
+  const homeDir = options.homeDir ?? resolveRudderHomeDir();
+  const cacheDir = resolveRuntimeCacheDir(packageVersion, homeDir);
   const packageSpec = resolveRuntimePackageSpec(packageVersion, packageName);
   const command = formatRuntimeInstallCommand(cacheDir, packageSpec);
   const preparePostgresPayload = options.preparePostgresPayload === true;
   const postgresVersionProbe = options.postgresVersionProbe ?? readPostgresVersion;
   if (await isRuntimeCacheHit({ cacheDir, version: packageVersion, packageName })) {
-    const postgresPayload2 = await stageRuntimePostgresPayload(cacheDir, preparePostgresPayload, postgresVersionProbe);
+    const postgresPayload2 = await stageRuntimePostgresPayload(cacheDir, homeDir, preparePostgresPayload, postgresVersionProbe);
     await touchRuntimeInstallMetadata(cacheDir);
     const prune2 = await maybePruneRuntimeCache({
       homeDir: options.homeDir,
@@ -3791,7 +4019,7 @@ async function ensureRuntimeInstalled(options) {
     packageVersion
   });
   if (existingRuntimeOutput !== null) {
-    const postgresPayload2 = await stageRuntimePostgresPayload(cacheDir, preparePostgresPayload, postgresVersionProbe);
+    const postgresPayload2 = await stageRuntimePostgresPayload(cacheDir, homeDir, preparePostgresPayload, postgresVersionProbe);
     const metadata2 = {
       version: 1,
       packageName,
@@ -3813,7 +4041,7 @@ async function ensureRuntimeInstalled(options) {
   }
   await rm(cacheDir, { recursive: true, force: true });
   await mkdir(cacheDir, { recursive: true });
-  await writeFile(path5.join(cacheDir, "package.json"), `${JSON.stringify(RUNTIME_CACHE_PACKAGE_JSON, null, 2)}
+  await writeFile(path6.join(cacheDir, "package.json"), `${JSON.stringify(RUNTIME_CACHE_PACKAGE_JSON, null, 2)}
 `, "utf8");
   const result = runNpmRuntimeInstall(spawnSyncImpl, cacheDir, packageSpec);
   let output = collectSpawnOutput(result);
@@ -3824,6 +4052,7 @@ async function ensureRuntimeInstalled(options) {
     if (await isRuntimeCacheHit({ cacheDir: fallbackCacheDir, version: fallbackVersion, packageName })) {
       const fallbackPostgresPayload = await stageRuntimePostgresPayload(
         fallbackCacheDir,
+        homeDir,
         preparePostgresPayload,
         postgresVersionProbe
       );
@@ -3841,7 +4070,7 @@ async function ensureRuntimeInstalled(options) {
     }
     await rm(fallbackCacheDir, { recursive: true, force: true });
     await mkdir(fallbackCacheDir, { recursive: true });
-    await writeFile(path5.join(fallbackCacheDir, "package.json"), `${JSON.stringify(RUNTIME_CACHE_PACKAGE_JSON, null, 2)}
+    await writeFile(path6.join(fallbackCacheDir, "package.json"), `${JSON.stringify(RUNTIME_CACHE_PACKAGE_JSON, null, 2)}
 `, "utf8");
     const fallbackResult = runNpmRuntimeInstall(spawnSyncImpl, fallbackCacheDir, fallbackSpec);
     let fallbackOutput = collectSpawnOutput(fallbackResult);
@@ -3852,6 +4081,7 @@ async function ensureRuntimeInstalled(options) {
       );
       const postgresPayload2 = await stageRuntimePostgresPayload(
         fallbackCacheDir,
+        homeDir,
         preparePostgresPayload,
         postgresVersionProbe
       );
@@ -3885,7 +4115,7 @@ async function ensureRuntimeInstalled(options) {
     output,
     await ensureRequiredEmbeddedPostgresPlatformPackage(spawnSyncImpl, cacheDir)
   );
-  const postgresPayload = await stageRuntimePostgresPayload(cacheDir, preparePostgresPayload, postgresVersionProbe);
+  const postgresPayload = await stageRuntimePostgresPayload(cacheDir, homeDir, preparePostgresPayload, postgresVersionProbe);
   const metadata = {
     version: 1,
     packageName,
@@ -3906,10 +4136,19 @@ async function ensureRuntimeInstalled(options) {
   );
 }
 function resolveRuntimePostgresPayloadBinDir(cacheDir, platform = process.platform, arch = process.arch) {
-  return path5.join(cacheDir, RUNTIME_POSTGRES_PAYLOAD_DIR, runtimePostgresPlatformSegment(platform, arch), "bin");
+  return path6.join(cacheDir, RUNTIME_POSTGRES_PAYLOAD_DIR, runtimePostgresPlatformSegment(platform, arch), "bin");
+}
+function resolveSharedRuntimePostgresPayloadBinDir(homeDir = resolveRudderHomeDir(), platform = process.platform, arch = process.arch) {
+  return path6.join(
+    homeDir,
+    "runtime-payloads",
+    RUNTIME_POSTGRES_PAYLOAD_DIR,
+    runtimePostgresPlatformSegment(platform, arch),
+    "bin"
+  );
 }
 function resolveRuntimeServerEntrypoint(cacheDir, packageName = RUNTIME_NPM_PACKAGE_NAME) {
-  return createRequire(path5.join(cacheDir, "package.json")).resolve(packageName);
+  return createRequire(path6.join(cacheDir, "package.json")).resolve(packageName);
 }
 async function importRuntimeServerModule(cacheDir, packageName = RUNTIME_NPM_PACKAGE_NAME) {
   const entrypoint = resolveRuntimeServerEntrypoint(cacheDir, packageName);
@@ -3930,7 +4169,7 @@ function formatRuntimeInstallCommand(cacheDir, packageSpec) {
   return `npm install --prefix ${cacheDir} ${RUNTIME_NPM_INSTALL_FLAGS.join(" ")} ${packageSpec}`;
 }
 function formatRuntimePlatformRepairCommand(cacheDir, packageSpec) {
-  return `npm pack ${packageSpec} --registry=${NPM_PUBLIC_REGISTRY_URL} --silent, then extract it into ${path5.join(cacheDir, "node_modules")}`;
+  return `npm pack ${packageSpec} --registry=${NPM_PUBLIC_REGISTRY_URL} --silent, then extract it into ${path6.join(cacheDir, "node_modules")}`;
 }
 function collectSpawnOutput(result) {
   return [result.stdout, result.stderr, result.error instanceof Error ? result.error.message : null].filter((value) => typeof value === "string" && value.trim().length > 0).join("\n").trim();
@@ -3946,7 +4185,7 @@ function withPostgresPayload(result, postgresPayload) {
   };
 }
 function runtimePackageJsonPath(cacheDir, packageName) {
-  return path5.join(cacheDir, "node_modules", ...packageName.split("/"), "package.json");
+  return path6.join(cacheDir, "node_modules", ...packageName.split("/"), "package.json");
 }
 async function readRuntimePackageJson(cacheDir, packageName) {
   try {
@@ -3989,7 +4228,7 @@ async function ensureRequiredEmbeddedPostgresPlatformPackage(spawnSyncImpl, cach
   );
 }
 async function installRuntimePackageInStaging(spawnSyncImpl, cacheDir, packageSpec, packageName) {
-  const stagingDir = path5.join(cacheDir, `.platform-repair-${process.pid}-${Date.now()}`);
+  const stagingDir = path6.join(cacheDir, `.platform-repair-${process.pid}-${Date.now()}`);
   await mkdir(stagingDir, { recursive: true });
   try {
     const packResult = runNpmPack(spawnSyncImpl, packageSpec, stagingDir);
@@ -3998,9 +4237,9 @@ async function installRuntimePackageInStaging(spawnSyncImpl, cacheDir, packageSp
     if (!packFilename) {
       return createSyntheticSpawnResult(1, "", `Unable to parse npm pack output for ${packageSpec}.`);
     }
-    const archivePath = path5.join(stagingDir, packFilename);
-    const targetDir = path5.dirname(runtimePackageJsonPath(cacheDir, packageName));
-    await mkdir(path5.dirname(targetDir), { recursive: true });
+    const archivePath = path6.join(stagingDir, packFilename);
+    const targetDir = path6.dirname(runtimePackageJsonPath(cacheDir, packageName));
+    await mkdir(path6.dirname(targetDir), { recursive: true });
     await rm(targetDir, { recursive: true, force: true });
     await mkdir(targetDir, { recursive: true });
     const extractResult = runTarExtract(spawnSyncImpl, archivePath, targetDir);
@@ -4051,8 +4290,8 @@ function combineSpawnResults(...results) {
 }
 async function removeRuntimeInstallLocks(cacheDir) {
   await Promise.all([
-    rm(path5.join(cacheDir, "package-lock.json"), { force: true }),
-    rm(path5.join(cacheDir, "node_modules", ".package-lock.json"), { force: true })
+    rm(path6.join(cacheDir, "package-lock.json"), { force: true }),
+    rm(path6.join(cacheDir, "node_modules", ".package-lock.json"), { force: true })
   ]);
 }
 function packageNameFromSpec(packageSpec) {
@@ -4076,41 +4315,41 @@ function runtimePostgresExecutableName(baseName) {
   return process.platform === "win32" ? `${baseName}.exe` : baseName;
 }
 function debianSharedirCandidate(binDir) {
-  const normalized = path5.resolve(binDir);
-  const parts = normalized.split(path5.sep);
+  const normalized = path6.resolve(binDir);
+  const parts = normalized.split(path6.sep);
   const libIndex = parts.lastIndexOf("lib");
   if (libIndex < 0) return null;
   if (parts[libIndex + 1] !== "postgresql") return null;
   const version = parts[libIndex + 2];
   if (!version || parts[libIndex + 3] !== "bin") return null;
-  const prefix = parts.slice(0, libIndex).join(path5.sep) || path5.sep;
-  return path5.join(prefix, "share", "postgresql", version);
+  const prefix = parts.slice(0, libIndex).join(path6.sep) || path6.sep;
+  return path6.join(prefix, "share", "postgresql", version);
 }
 async function resolveRuntimePostgresTemplateDir(binDir) {
   for (const candidatePath of [
-    path5.join(binDir, "..", "share", "postgresql", "postgres.bki"),
-    path5.join(binDir, "..", "share", "postgres.bki")
+    path6.join(binDir, "..", "share", "postgresql", "postgres.bki"),
+    path6.join(binDir, "..", "share", "postgres.bki")
   ]) {
     try {
       await stat(candidatePath);
-      return path5.dirname(candidatePath);
+      return path6.dirname(candidatePath);
     } catch {
     }
   }
   const debianSharedir = debianSharedirCandidate(binDir);
   if (debianSharedir) {
     try {
-      await stat(path5.join(debianSharedir, "postgres.bki"));
+      await stat(path6.join(debianSharedir, "postgres.bki"));
       return debianSharedir;
     } catch {
     }
   }
-  const pgConfigPath = path5.join(binDir, process.platform === "win32" ? "pg_config.exe" : "pg_config");
+  const pgConfigPath = path6.join(binDir, process.platform === "win32" ? "pg_config.exe" : "pg_config");
   try {
     await stat(pgConfigPath);
     const sharedir = execFileSync(pgConfigPath, ["--sharedir"], { encoding: "utf8" }).trim();
     if (!sharedir) return null;
-    const candidatePath = path5.join(sharedir, "postgres.bki");
+    const candidatePath = path6.join(sharedir, "postgres.bki");
     await stat(candidatePath);
     return sharedir;
   } catch {
@@ -4121,14 +4360,14 @@ async function assertRuntimePostgresBinDirComplete(cacheDir, binDir) {
   const requiredBinaries = ["initdb", "pg_ctl", "postgres"];
   const missing = [];
   for (const binary of requiredBinaries) {
-    const binaryPath = path5.join(binDir, runtimePostgresExecutableName(binary));
+    const binaryPath = path6.join(binDir, runtimePostgresExecutableName(binary));
     try {
       await stat(binaryPath);
     } catch {
       missing.push(binaryPath);
     }
   }
-  const expectedTemplatePath = path5.join(binDir, "..", "share", "postgresql", "postgres.bki");
+  const expectedTemplatePath = path6.join(binDir, "..", "share", "postgresql", "postgres.bki");
   const templateDir = await resolveRuntimePostgresTemplateDir(binDir);
   if (!templateDir) missing.push(expectedTemplatePath);
   if (missing.length > 0) {
@@ -4144,25 +4383,28 @@ function readPostgresVersion(postgresBinary) {
 async function isRuntimePostgresPayloadUsable(cacheDir, binDir, postgresVersionProbe) {
   try {
     await assertRuntimePostgresBinDirComplete(cacheDir, binDir);
-    const postgresBinary = path5.join(binDir, runtimePostgresExecutableName("postgres"));
+    const postgresBinary = path6.join(binDir, runtimePostgresExecutableName("postgres"));
     const result = postgresVersionProbe(postgresBinary);
     return /\bPostgreSQL\)?\s+18\.4\b/i.test(result);
   } catch {
     return false;
   }
 }
-async function stageRuntimePostgresPayload(cacheDir, enabled, postgresVersionProbe) {
-  const targetPayloadRoot = path5.join(cacheDir, RUNTIME_POSTGRES_PAYLOAD_DIR);
+async function stageRuntimePostgresPayload(cacheDir, homeDir, enabled, postgresVersionProbe) {
+  const targetPayloadRoot = path6.join(cacheDir, RUNTIME_POSTGRES_PAYLOAD_DIR);
   const targetBinDir = resolveRuntimePostgresPayloadBinDir(cacheDir);
-  const targetRuntimeDir = path5.dirname(targetBinDir);
+  const targetRuntimeDir = path6.dirname(targetBinDir);
   if (await isRuntimePostgresPayloadUsable(cacheDir, targetBinDir, postgresVersionProbe)) {
     return { output: "", binDir: targetBinDir };
   }
   if (!enabled) return { output: "" };
-  const sourceBinDir = process.env[RUDDER_POSTGRES_BIN_DIR_ENV]?.trim();
-  if (!sourceBinDir) return { output: "" };
-  const resolvedSourceBinDir = path5.resolve(sourceBinDir);
-  await assertRuntimePostgresBinDirComplete(cacheDir, resolvedSourceBinDir);
+  const explicitSourceBinDir = process.env[RUDDER_POSTGRES_BIN_DIR_ENV]?.trim();
+  const resolvedSourceBinDir = explicitSourceBinDir ? path6.resolve(explicitSourceBinDir) : resolveSharedRuntimePostgresPayloadBinDir(homeDir);
+  if (explicitSourceBinDir) {
+    await assertRuntimePostgresBinDirComplete(cacheDir, resolvedSourceBinDir);
+  } else if (!await isRuntimePostgresPayloadUsable(cacheDir, resolvedSourceBinDir, postgresVersionProbe)) {
+    return { output: "" };
+  }
   const sourceTemplateDir = await resolveRuntimePostgresTemplateDir(resolvedSourceBinDir);
   if (!sourceTemplateDir) {
     throw new RuntimeInstallError(
@@ -4170,7 +4412,7 @@ async function stageRuntimePostgresPayload(cacheDir, enabled, postgresVersionPro
       { cacheDir, command: "validate PostgreSQL 18.4 runtime payload", output: "" }
     );
   }
-  const postgresBinary = path5.join(resolvedSourceBinDir, runtimePostgresExecutableName("postgres"));
+  const postgresBinary = path6.join(resolvedSourceBinDir, runtimePostgresExecutableName("postgres"));
   const result = postgresVersionProbe(postgresBinary);
   if (!/\bPostgreSQL\)?\s+18\.4\b/i.test(result)) {
     throw new RuntimeInstallError(
@@ -4179,12 +4421,12 @@ async function stageRuntimePostgresPayload(cacheDir, enabled, postgresVersionPro
     );
   }
   await rm(targetPayloadRoot, { recursive: true, force: true });
-  await mkdir(path5.dirname(targetBinDir), { recursive: true });
-  await cp(path5.resolve(resolvedSourceBinDir, ".."), targetRuntimeDir, { recursive: true });
-  const targetShareDir = path5.join(targetRuntimeDir, "share");
-  const targetTemplateDir = path5.join(targetShareDir, "postgresql");
+  await mkdir(path6.dirname(targetBinDir), { recursive: true });
+  await cp(path6.resolve(resolvedSourceBinDir, ".."), targetRuntimeDir, { recursive: true });
+  const targetShareDir = path6.join(targetRuntimeDir, "share");
+  const targetTemplateDir = path6.join(targetShareDir, "postgresql");
   await rm(targetShareDir, { recursive: true, force: true });
-  await mkdir(path5.dirname(targetTemplateDir), { recursive: true });
+  await mkdir(path6.dirname(targetTemplateDir), { recursive: true });
   await cp(sourceTemplateDir, targetTemplateDir, { recursive: true });
   return { output: `staged PostgreSQL 18.4 runtime payload at ${targetBinDir}`, binDir: targetBinDir };
 }
@@ -4246,13 +4488,13 @@ async function pruneRuntimeCache(options = {}) {
   };
 }
 async function scanRuntimeCacheEntries(homeDir) {
-  const runtimesDir = path5.join(homeDir, "runtimes");
+  const runtimesDir = path6.join(homeDir, "runtimes");
   const dirents = await readdir(runtimesDir, { withFileTypes: true }).catch(() => null);
   if (!dirents) return [];
   const entries = [];
   for (const dirent of dirents) {
     if (!dirent.isDirectory()) continue;
-    const cacheDir = path5.join(runtimesDir, dirent.name);
+    const cacheDir = path6.join(runtimesDir, dirent.name);
     const metadata = await readRuntimeInstallMetadata(cacheDir);
     if (!metadata) continue;
     const fallbackStat = await safeStat(cacheDir);
@@ -4285,7 +4527,7 @@ async function directorySizeBytes(targetPath) {
   if (!dirents) return 0;
   let total = 0;
   for (const dirent of dirents) {
-    const entryPath = path5.join(targetPath, dirent.name);
+    const entryPath = path6.join(targetPath, dirent.name);
     if (dirent.isSymbolicLink()) continue;
     if (dirent.isDirectory()) {
       total += await directorySizeBytes(entryPath);
@@ -4297,14 +4539,14 @@ async function directorySizeBytes(targetPath) {
   return total;
 }
 async function readActiveRuntimeVersions(homeDir) {
-  const instancesDir = path5.join(homeDir, "instances");
+  const instancesDir = path6.join(homeDir, "instances");
   const dirents = await readdir(instancesDir, { withFileTypes: true }).catch(() => null);
   if (!dirents) return [];
   const versions = /* @__PURE__ */ new Set();
   for (const dirent of dirents) {
     if (!dirent.isDirectory()) continue;
     try {
-      const descriptorPath = path5.join(instancesDir, dirent.name, "runtime", "server.json");
+      const descriptorPath = path6.join(instancesDir, dirent.name, "runtime", "server.json");
       const parsed = JSON.parse(await readFile(descriptorPath, "utf8"));
       if (typeof parsed.version !== "string") continue;
       if (typeof parsed.pid === "number" && Number.isInteger(parsed.pid) && parsed.pid > 0 && isPidRunning(parsed.pid)) {
@@ -4458,8 +4700,8 @@ var init_install = __esm({
 
 // src/runtime/server-entry.ts
 import fs4 from "node:fs";
-import path6 from "node:path";
-import { fileURLToPath as fileURLToPath2, pathToFileURL as pathToFileURL2 } from "node:url";
+import path7 from "node:path";
+import { fileURLToPath as fileURLToPath3, pathToFileURL as pathToFileURL2 } from "node:url";
 function formatError(err) {
   if (err instanceof Error) {
     if (err.message && err.message.trim().length > 0) return err.message;
@@ -4480,8 +4722,8 @@ function maybeEnableUiDevMiddleware(entrypoint) {
   }
 }
 function resolveDevServerEntry() {
-  const projectRoot = path6.resolve(path6.dirname(fileURLToPath2(import.meta.url)), "../../..");
-  return path6.resolve(projectRoot, "server/src/index.ts");
+  const projectRoot = path7.resolve(path7.dirname(fileURLToPath3(import.meta.url)), "../../..");
+  return path7.resolve(projectRoot, "server/src/index.ts");
 }
 async function loadServerRuntimeModule(options) {
   const devEntry = resolveDevServerEntry();
@@ -4531,46 +4773,6 @@ var init_server_entry = __esm({
   }
 });
 
-// src/version.ts
-import { existsSync as existsSync2, readFileSync } from "node:fs";
-import path7 from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
-function readPackageVersion(packagePath, expectedName) {
-  if (!existsSync2(packagePath)) return null;
-  try {
-    const parsed = JSON.parse(readFileSync(packagePath, "utf8"));
-    if (parsed.name === expectedName && parsed.version) return parsed.version;
-  } catch {
-    return null;
-  }
-  return null;
-}
-function resolveCliVersion(moduleUrl = import.meta.url, env = process.env) {
-  if (env.npm_package_name === CLI_PACKAGE_NAME && env.npm_package_version) {
-    return env.npm_package_version;
-  }
-  const moduleDir = path7.dirname(fileURLToPath3(moduleUrl));
-  const candidates = [
-    path7.resolve(moduleDir, CLI_VERSION_MANIFEST),
-    path7.resolve(moduleDir, "package.json"),
-    path7.resolve(moduleDir, "../package.json"),
-    path7.resolve(moduleDir, "../../package.json")
-  ];
-  for (const candidate of candidates) {
-    const version = readPackageVersion(candidate, CLI_PACKAGE_NAME);
-    if (version) return version;
-  }
-  return "0.0.0";
-}
-var CLI_PACKAGE_NAME, CLI_VERSION_MANIFEST;
-var init_version = __esm({
-  "src/version.ts"() {
-    "use strict";
-    CLI_PACKAGE_NAME = "@rudderhq/cli";
-    CLI_VERSION_MANIFEST = "rudder-cli-package.json";
-  }
-});
-
 // src/commands/auth-bootstrap-ceo.ts
 import * as p2 from "@clack/prompts";
 import pc2 from "picocolors";
@@ -6897,17 +7099,991 @@ var init_onboard = __esm({
   }
 });
 
-// src/program.ts
-import { Command, CommanderError } from "commander";
+// src/program.ts
+import { Command, CommanderError } from "commander";
+
+// ../packages/agent-runtime-utils/dist/rudder-mcp-tool-descriptors.generated.js
+var RUDDER_MCP_TOOL_DESCRIPTORS = [
+  {
+    "capabilityId": "agent.me",
+    "name": "rudder_agent_me",
+    "description": "Show the authenticated agent identity, budget, and chain of command.",
+    "mutating": false,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": false
+  },
+  {
+    "capabilityId": "agent.inbox",
+    "name": "rudder_agent_inbox",
+    "description": "List the compact assignee and reviewer work inbox for the authenticated agent.",
+    "mutating": false,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": false
+  },
+  {
+    "capabilityId": "agent.capabilities",
+    "name": "rudder_agent_capabilities",
+    "description": "List the stable Rudder agent command contract.",
+    "mutating": false,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": false
+  },
+  {
+    "capabilityId": "agent.update",
+    "name": "rudder_agent_update",
+    "description": "Update an agent's control-plane identity fields; defaults to the authenticated agent.",
+    "mutating": true,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": true
+  },
+  {
+    "capabilityId": "agent.skills.create",
+    "name": "rudder_agent_skills_create",
+    "description": "Create an agent-private skill package under AGENT_HOME/skills.",
+    "mutating": true,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": true
+  },
+  {
+    "capabilityId": "agent.skills.enable",
+    "name": "rudder_agent_skills_enable",
+    "description": "Add skill selections to an agent without replacing existing enabled skills.",
+    "mutating": true,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": true
+  },
+  {
+    "capabilityId": "agent.skills.sync",
+    "name": "rudder_agent_skills_sync",
+    "description": "Sync the desired enabled skill set for an agent.",
+    "mutating": true,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": true
+  },
+  {
+    "capabilityId": "issue.get",
+    "name": "rudder_issue_get",
+    "description": "Read a full issue by UUID or identifier.",
+    "mutating": false,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": false
+  },
+  {
+    "capabilityId": "issue.search",
+    "name": "rudder_issue_search",
+    "description": "Search issues with the server-side issue index across title, identifier, description, and comments.",
+    "mutating": false,
+    "requiresOrgId": true,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": false
+  },
+  {
+    "capabilityId": "issue.context",
+    "name": "rudder_issue_context",
+    "description": "Read the compact heartbeat context for an issue; wake comments may be addressed by full id or cmt_<uuid-prefix>.",
+    "mutating": false,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": false
+  },
+  {
+    "capabilityId": "issue.checkout",
+    "name": "rudder_issue_checkout",
+    "description": "Atomically checkout an issue for the current or specified agent.",
+    "mutating": true,
+    "requiresOrgId": false,
+    "requiresAgentId": true,
+    "attachesRunIdWhenAvailable": true
+  },
+  {
+    "capabilityId": "issue.comment",
+    "name": "rudder_issue_comment",
+    "description": "Add a comment to an issue, optionally uploading images and appending Markdown image links.",
+    "mutating": true,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": true
+  },
+  {
+    "capabilityId": "issue.comments.list",
+    "name": "rudder_issue_comments_list",
+    "description": "List issue comments, optionally only newer comments after a full comment id or cmt_<uuid-prefix> with --after.",
+    "mutating": false,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": false
+  },
+  {
+    "capabilityId": "issue.comments.get",
+    "name": "rudder_issue_comments_get",
+    "description": "Read one issue comment by full id or cmt_<uuid-prefix> scoped to the issue.",
+    "mutating": false,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": false
+  },
+  {
+    "capabilityId": "issue.update",
+    "name": "rudder_issue_update",
+    "description": "Apply generic issue updates when workflow commands are not enough, optionally uploading images for the update comment.",
+    "mutating": true,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": true
+  },
+  {
+    "capabilityId": "issue.review",
+    "name": "rudder_issue_review",
+    "description": "Record a structured reviewer decision with a required comment.",
+    "mutating": true,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": true
+  },
+  {
+    "capabilityId": "issue.commit",
+    "name": "rudder_issue_commit",
+    "description": "Report a code commit created during issue work as structured issue activity.",
+    "mutating": true,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": true
+  },
+  {
+    "capabilityId": "issue.done",
+    "name": "rudder_issue_done",
+    "description": "Mark an issue done with a required completion comment, optionally uploading images.",
+    "mutating": true,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": true
+  },
+  {
+    "capabilityId": "issue.block",
+    "name": "rudder_issue_block",
+    "description": "Mark an issue blocked with a required blocker comment, optionally uploading images.",
+    "mutating": true,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": true
+  },
+  {
+    "capabilityId": "project.list",
+    "name": "rudder_project_list",
+    "description": "List projects in an organization.",
+    "mutating": false,
+    "requiresOrgId": true,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": false
+  },
+  {
+    "capabilityId": "project.get",
+    "name": "rudder_project_get",
+    "description": "Read one project by ID or shortname.",
+    "mutating": false,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": false
+  },
+  {
+    "capabilityId": "project.create",
+    "name": "rudder_project_create",
+    "description": "Create a project in the organization.",
+    "mutating": true,
+    "requiresOrgId": true,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": true
+  },
+  {
+    "capabilityId": "project.update",
+    "name": "rudder_project_update",
+    "description": "Update mutable project fields such as name, description, status, goals, lead agent, target date, color, or archivedAt.",
+    "mutating": true,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": true
+  },
+  {
+    "capabilityId": "user.activity",
+    "name": "rudder_user_activity",
+    "description": "Read a user-centered activity ledger with safe excerpts and provenance across chats, issue comments, approval comments, and user actor activity.",
+    "mutating": false,
+    "requiresOrgId": true,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": false
+  },
+  {
+    "capabilityId": "library.file.list",
+    "name": "rudder_library_file_list",
+    "description": "List Library files and folders; file rows include `libraryEntryId` when a strong reference can be generated.",
+    "mutating": false,
+    "requiresOrgId": true,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": false
+  },
+  {
+    "capabilityId": "library.file.get",
+    "name": "rudder_library_file_get",
+    "description": "Fallback read when local filesystem access is unavailable; JSON includes `mentionHref` and `markdownLink`.",
+    "mutating": false,
+    "requiresOrgId": true,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": false
+  },
+  {
+    "capabilityId": "library.file.ref",
+    "name": "rudder_library_file_ref",
+    "description": "Return the stable Markdown reference for one Library file without printing file content.",
+    "mutating": false,
+    "requiresOrgId": true,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": false
+  },
+  {
+    "capabilityId": "library.file.link",
+    "name": "rudder_library_file_link",
+    "description": "Compatibility alias for `rudder library file ref <path>`.",
+    "mutating": false,
+    "requiresOrgId": true,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": false
+  },
+  {
+    "capabilityId": "library.file.put",
+    "name": "rudder_library_file_put",
+    "description": "Fallback create/update when local filesystem access is unavailable; JSON includes `mentionHref` and `markdownLink`.",
+    "mutating": true,
+    "requiresOrgId": true,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": true
+  },
+  {
+    "capabilityId": "approval.get",
+    "name": "rudder_approval_get",
+    "description": "Read one approval request.",
+    "mutating": false,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": false
+  },
+  {
+    "capabilityId": "approval.issues",
+    "name": "rudder_approval_issues",
+    "description": "List the issues linked to an approval.",
+    "mutating": false,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": false
+  },
+  {
+    "capabilityId": "approval.comment",
+    "name": "rudder_approval_comment",
+    "description": "Add a comment to an approval.",
+    "mutating": true,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": true
+  },
+  {
+    "capabilityId": "skill.list",
+    "name": "rudder_skill_list",
+    "description": "List organization-visible skills.",
+    "mutating": false,
+    "requiresOrgId": true,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": false
+  },
+  {
+    "capabilityId": "skill.get",
+    "name": "rudder_skill_get",
+    "description": "Read one organization skill detail.",
+    "mutating": false,
+    "requiresOrgId": true,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": false
+  },
+  {
+    "capabilityId": "skill.file",
+    "name": "rudder_skill_file",
+    "description": "Read one file from an organization skill package.",
+    "mutating": false,
+    "requiresOrgId": true,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": false
+  },
+  {
+    "capabilityId": "skill.import",
+    "name": "rudder_skill_import",
+    "description": "Import a skill package into the organization skill library.",
+    "mutating": true,
+    "requiresOrgId": true,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": true
+  },
+  {
+    "capabilityId": "skill.scan-local",
+    "name": "rudder_skill_scan_local",
+    "description": "Scan local roots for skill packages and import new ones.",
+    "mutating": true,
+    "requiresOrgId": true,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": true
+  },
+  {
+    "capabilityId": "skill.scan-projects",
+    "name": "rudder_skill_scan_projects",
+    "description": "Scan the org workspace and any legacy project workspace records for skill packages and import new ones.",
+    "mutating": true,
+    "requiresOrgId": true,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": true
+  },
+  {
+    "capabilityId": "browser.tabs",
+    "name": "rudder_browser_tabs",
+    "description": "List Browser tabs owned by the current Rudder agent run.",
+    "mutating": false,
+    "requiresOrgId": true,
+    "requiresAgentId": true,
+    "attachesRunIdWhenAvailable": false
+  },
+  {
+    "capabilityId": "browser.open",
+    "name": "rudder_browser_open",
+    "description": "Open a run-owned tab in the Rudder Browser.",
+    "mutating": true,
+    "requiresOrgId": true,
+    "requiresAgentId": true,
+    "attachesRunIdWhenAvailable": true
+  },
+  {
+    "capabilityId": "browser.navigate",
+    "name": "rudder_browser_navigate",
+    "description": "Navigate a run-owned Rudder Browser tab.",
+    "mutating": true,
+    "requiresOrgId": true,
+    "requiresAgentId": true,
+    "attachesRunIdWhenAvailable": true
+  },
+  {
+    "capabilityId": "browser.read",
+    "name": "rudder_browser_read",
+    "description": "Read a structured snapshot from a run-owned Rudder Browser tab.",
+    "mutating": false,
+    "requiresOrgId": true,
+    "requiresAgentId": true,
+    "attachesRunIdWhenAvailable": false
+  },
+  {
+    "capabilityId": "browser.click",
+    "name": "rudder_browser_click",
+    "description": "Click an element reference returned by Rudder Browser read.",
+    "mutating": true,
+    "requiresOrgId": true,
+    "requiresAgentId": true,
+    "attachesRunIdWhenAvailable": true
+  },
+  {
+    "capabilityId": "browser.type",
+    "name": "rudder_browser_type",
+    "description": "Type into an element reference in a run-owned Rudder Browser tab.",
+    "mutating": true,
+    "requiresOrgId": true,
+    "requiresAgentId": true,
+    "attachesRunIdWhenAvailable": true
+  },
+  {
+    "capabilityId": "browser.screenshot",
+    "name": "rudder_browser_screenshot",
+    "description": "Capture a screenshot of a run-owned Rudder Browser tab.",
+    "mutating": false,
+    "requiresOrgId": true,
+    "requiresAgentId": true,
+    "attachesRunIdWhenAvailable": false
+  },
+  {
+    "capabilityId": "browser.close",
+    "name": "rudder_browser_close",
+    "description": "Close a run-owned Rudder Browser tab.",
+    "mutating": true,
+    "requiresOrgId": true,
+    "requiresAgentId": true,
+    "attachesRunIdWhenAvailable": true
+  },
+  {
+    "capabilityId": "automation.list",
+    "name": "rudder_automation_list",
+    "description": "List automations for an organization with compact local filters.",
+    "mutating": false,
+    "requiresOrgId": true,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": false
+  },
+  {
+    "capabilityId": "automation.get",
+    "name": "rudder_automation_get",
+    "description": "Read one automation detail including triggers and recent runs.",
+    "mutating": false,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": false
+  },
+  {
+    "capabilityId": "automation.runs",
+    "name": "rudder_automation_runs",
+    "description": "List recent runs for one automation.",
+    "mutating": false,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": false
+  },
+  {
+    "capabilityId": "automation.triggers.list",
+    "name": "rudder_automation_triggers_list",
+    "description": "List triggers configured for one automation.",
+    "mutating": false,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": false
+  },
+  {
+    "capabilityId": "automation.triggers.create",
+    "name": "rudder_automation_triggers_create",
+    "description": "Create a schedule, webhook, or API trigger through the governed automation API.",
+    "mutating": true,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": true
+  },
+  {
+    "capabilityId": "automation.triggers.update",
+    "name": "rudder_automation_triggers_update",
+    "description": "Update an automation trigger through the governed automation API.",
+    "mutating": true,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": true
+  },
+  {
+    "capabilityId": "automation.triggers.delete",
+    "name": "rudder_automation_triggers_delete",
+    "description": "Delete an automation trigger through the governed automation API.",
+    "mutating": true,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": true
+  },
+  {
+    "capabilityId": "automation.triggers.rotate-secret",
+    "name": "rudder_automation_triggers_rotate_secret",
+    "description": "Rotate an automation webhook trigger secret through the governed automation API.",
+    "mutating": true,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": true
+  },
+  {
+    "capabilityId": "automation.create",
+    "name": "rudder_automation_create",
+    "description": "Create an automation through the governed automation API.",
+    "mutating": true,
+    "requiresOrgId": true,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": true
+  },
+  {
+    "capabilityId": "automation.update",
+    "name": "rudder_automation_update",
+    "description": "Update automation fields through the governed automation API.",
+    "mutating": true,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": true
+  },
+  {
+    "capabilityId": "automation.enable",
+    "name": "rudder_automation_enable",
+    "description": "Enable an automation by setting status to active.",
+    "mutating": true,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": true
+  },
+  {
+    "capabilityId": "automation.disable",
+    "name": "rudder_automation_disable",
+    "description": "Disable an automation by setting status to paused.",
+    "mutating": true,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": true
+  },
+  {
+    "capabilityId": "automation.run",
+    "name": "rudder_automation_run",
+    "description": "Trigger a manual automation run.",
+    "mutating": true,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": true
+  },
+  {
+    "capabilityId": "chat.list",
+    "name": "rudder_chat_list",
+    "description": "List chat conversations without dumping full message history.",
+    "mutating": false,
+    "requiresOrgId": true,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": false
+  },
+  {
+    "capabilityId": "chat.search",
+    "name": "rudder_chat_search",
+    "description": "Search chats with bounded snippets and optional scope filtering.",
+    "mutating": false,
+    "requiresOrgId": true,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": false
+  },
+  {
+    "capabilityId": "chat.get",
+    "name": "rudder_chat_get",
+    "description": "Read one chat conversation record.",
+    "mutating": false,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": false
+  },
+  {
+    "capabilityId": "chat.messages",
+    "name": "rudder_chat_messages",
+    "description": "Read bounded chat messages with page cursors; transcript output is omitted unless requested.",
+    "mutating": false,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": false
+  },
+  {
+    "capabilityId": "chat.transcript",
+    "name": "rudder_chat_transcript",
+    "description": "Read paginated chat messages with assistant transcript entries clipped in human output.",
+    "mutating": false,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": false
+  },
+  {
+    "capabilityId": "chat.read",
+    "name": "rudder_chat_read",
+    "description": "Read a bounded recent-message snapshot for one chat with page cursors.",
+    "mutating": false,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": false
+  },
+  {
+    "capabilityId": "chat.create",
+    "name": "rudder_chat_create",
+    "description": "Create a chat conversation.",
+    "mutating": true,
+    "requiresOrgId": true,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": true
+  },
+  {
+    "capabilityId": "chat.send",
+    "name": "rudder_chat_send",
+    "description": "Send an agent-authored message directly to the operator in a chat.",
+    "mutating": true,
+    "requiresOrgId": false,
+    "requiresAgentId": true,
+    "attachesRunIdWhenAvailable": true
+  },
+  {
+    "capabilityId": "chat.archive",
+    "name": "rudder_chat_archive",
+    "description": "Archive a chat conversation without deleting it.",
+    "mutating": true,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": true
+  },
+  {
+    "capabilityId": "runs.list",
+    "name": "rudder_runs_list",
+    "description": "List lightweight run summaries with stable pagination and filters; use --full only for legacy full-row compatibility.",
+    "mutating": false,
+    "requiresOrgId": true,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": false
+  },
+  {
+    "capabilityId": "runs.by-skill",
+    "name": "rudder_runs_by_skill",
+    "description": "Build a paginated skill evidence packet from lightweight run summaries; use --full only for legacy full-row compatibility.",
+    "mutating": false,
+    "requiresOrgId": true,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": false
+  },
+  {
+    "capabilityId": "runs.get",
+    "name": "rudder_runs_get",
+    "description": "Read one bounded run summary; use --full only from a direct trusted CLI for raw detail.",
+    "mutating": false,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": false
+  },
+  {
+    "capabilityId": "runs.events",
+    "name": "rudder_runs_events",
+    "description": "List a bounded page of persisted run events with a lossless opaque cursor and clipped payload previews.",
+    "mutating": false,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": false
+  },
+  {
+    "capabilityId": "runs.log",
+    "name": "rudder_runs_log",
+    "description": "Read a bounded byte range of stored run log content.",
+    "mutating": false,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": false
+  },
+  {
+    "capabilityId": "runs.transcript",
+    "name": "rudder_runs_transcript",
+    "description": "Read a compact server-normalized transcript; --json changes encoding only and --full is direct-CLI-only raw access.",
+    "mutating": false,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": false
+  },
+  {
+    "capabilityId": "runs.errors",
+    "name": "rudder_runs_errors",
+    "description": "List failed tool calls, stderr, runtime failures, and jump-to-context commands.",
+    "mutating": false,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": false
+  },
+  {
+    "capabilityId": "runs.cancel",
+    "name": "rudder_runs_cancel",
+    "description": "Cancel a heartbeat run through the governed server route.",
+    "mutating": true,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": true
+  },
+  {
+    "capabilityId": "runs.retry",
+    "name": "rudder_runs_retry",
+    "description": "Retry a failed, timed out, or cancelled run through the governed server route.",
+    "mutating": true,
+    "requiresOrgId": false,
+    "requiresAgentId": false,
+    "attachesRunIdWhenAvailable": true
+  }
+];
+
+// ../packages/agent-runtime-utils/dist/rudder-mcp-contract.js
+var RUDDER_MCP_CONTRACT_VERSION = "rudder.agent-mcp-tools/v1";
+function mcpString(description) {
+  return { type: "string", description };
+}
+function mcpBoolean(description) {
+  return { type: "boolean", description };
+}
+function mcpNumber(description) {
+  return { type: "number", description };
+}
+function mcpStringArray(description) {
+  return { type: "array", items: { type: "string" }, description };
+}
+function rudderMcpInputSchemaForCapability(id) {
+  const properties = {};
+  const add = (key, value) => {
+    properties[key] = value;
+  };
+  if (id.startsWith("runs.")) {
+    const addString = (key, description) => add(key, mcpString(description));
+    const addNumber = (key, description) => add(key, mcpNumber(description));
+    const addBoolean = (key, description) => add(key, mcpBoolean(description));
+    switch (id) {
+      case "runs.list":
+        addString("updatedAfter", "Only runs updated after this timestamp.");
+        addString("runIdPrefix", "Run id prefix filter.");
+        addString("relatedAgentId", "Agent id filter.");
+        addString("status", "Run status filter.");
+        addString("runtime", "Runtime type filter.");
+        addString("issueId", "Linked issue id filter.");
+        addString("usedSkill", "Used skill filter.");
+        addString("loadedSkill", "Loaded skill filter.");
+        addString("createdBefore", "Only runs created before this timestamp.");
+        addString("cursor", "Stable summary cursor.");
+        addNumber("limit", "Summary page size, capped by the server.");
+        break;
+      case "runs.by-skill":
+        addString("skill", "Skill key or display name.");
+        addString("evidence", "Evidence type: used or loaded.");
+        addString("relatedAgentId", "Agent id filter.");
+        addString("status", "Run status filter.");
+        addString("runtime", "Runtime type filter.");
+        addString("issueId", "Linked issue id filter.");
+        addString("createdBefore", "Only runs created before this timestamp.");
+        addString("cursor", "Stable summary cursor.");
+        addNumber("limit", "Summary page size, capped by the server.");
+        break;
+      case "runs.events":
+        addString("run", "Run id or short run id.");
+        addString("cursor", "Opaque total-order event cursor.");
+        addNumber("afterSeq", "Legacy sequence-only cursor.");
+        addNumber("limit", "Event page size, capped by the server.");
+        addNumber("maxChars", "Maximum payload preview characters per event.");
+        break;
+      case "runs.log":
+        addString("run", "Run id or short run id.");
+        addNumber("maxChars", "Maximum log characters for display.");
+        addNumber("offset", "Byte offset for the ranged read.");
+        addNumber("limitBytes", "Maximum bytes for the ranged read.");
+        break;
+      case "runs.transcript":
+        addString("run", "Run id or short run id.");
+        addBoolean("errorsOnly", "Return only error rows.");
+        addString("aroundError", "Transcript error step id.");
+        addNumber("contextTurns", "Turns around the selected error.");
+        addString("cursor", "Stable transcript cursor.");
+        addNumber("turnLimit", "Maximum turns to return.");
+        addBoolean("chronological", "Return oldest-first rows.");
+        addBoolean("narrative", "Use narrative row formatting.");
+        addNumber("maxChars", "Maximum output characters per row.");
+        addBoolean("includeOutput", "Include clipped row output.");
+        break;
+      case "runs.errors":
+        addString("run", "Run id or short run id.");
+        addString("cursor", "Error page cursor.");
+        addNumber("maxChars", "Maximum output characters per error.");
+        break;
+      default:
+        addString("run", "Run id or short run id.");
+        break;
+    }
+    return { type: "object", additionalProperties: false, properties };
+  }
+  if (id.startsWith("issue.")) {
+    add("issue", mcpString("Issue UUID, identifier, or short reference."));
+    add("body", mcpString("Direct Markdown body for issue comments or close-out notes."));
+    add("comment", mcpString("Direct Markdown review, blocker, or completion comment."));
+    add("images", { type: "array", items: { type: "string" }, description: "Local image paths to attach when supported." });
+  }
+  if (id.startsWith("project."))
+    add("project", mcpString("Project UUID or shortname."));
+  if (id.startsWith("library.file.")) {
+    add("path", mcpString("Library-relative file or directory path."));
+    if (id === "library.file.list") {
+      add("directory", mcpString("Library-relative directory path. Defaults to the run's project Library path when available."));
+    }
+    add("body", mcpString("Direct file content for put operations."));
+  }
+  if (id.startsWith("approval.")) {
+    add("approval", mcpString("Approval UUID or short reference."));
+    add("body", mcpString("Direct Markdown approval comment body."));
+  }
+  if (id.startsWith("skill.")) {
+    add("skill", mcpString("Organization skill id."));
+    add("path", mcpString("Skill package file path, such as SKILL.md."));
+  }
+  if (id.startsWith("browser.")) {
+    add("url", mcpString("HTTP or HTTPS URL."));
+    add("tabId", mcpString("Run-owned Rudder Browser tab id."));
+    add("ref", mcpString("Element reference returned by rudder_browser_read."));
+    add("text", mcpString("Text to enter into the referenced element."));
+  }
+  if (id.startsWith("automation.")) {
+    add("automation", mcpString("Automation id."));
+    add("trigger", mcpString("Automation trigger id."));
+    add("payload", { type: ["object", "string"], description: "JSON payload object or JSON string." });
+  }
+  if (id.startsWith("chat.")) {
+    add("chat", mcpString("Chat conversation id."));
+    add("body", mcpString("Agent-authored chat message body."));
+  }
+  if (id.startsWith("agent.skills.")) {
+    add("selectionRefs", { type: "array", items: { type: "string" }, description: "Skill selection refs." });
+    add("skills", { type: "array", items: { type: "string" }, description: "Skill selection refs alias." });
+    add("desiredSkills", mcpString("Comma-separated desired skill refs for sync."));
+  }
+  for (const [key, description] of Object.entries({
+    query: "Search query.",
+    decision: "Structured review decision.",
+    title: "Title.",
+    name: "Name.",
+    description: "Description or summary text.",
+    status: "Status filter or new status.",
+    cursor: "Pagination cursor.",
+    source: "Source path or source label.",
+    kind: "Trigger kind.",
+    label: "Trigger label.",
+    skill: "Skill key, id, or display name.",
+    slug: "Slug.",
+    markdown: "Direct Markdown content.",
+    role: "Agent role.",
+    reportsTo: "Manager or reporting agent reference.",
+    capabilities: "Agent capability summary.",
+    wakeCommentId: "Issue comment id that triggered the wake.",
+    expectedStatuses: "Comma-separated checkout precondition statuses.",
+    after: "Pagination anchor or lower bound.",
+    order: "Sort order.",
+    priority: "Issue or automation priority.",
+    assigneeAgentId: "Target assignee agent id or reference.",
+    projectId: "Project id or reference.",
+    goalId: "Goal id or reference.",
+    parentId: "Parent issue id or reference.",
+    parentIssueId: "Parent issue id or reference.",
+    requestDepth: "Requested issue depth.",
+    billingCode: "Billing code.",
+    hiddenAt: "Hidden timestamp.",
+    archivedAt: "Archived timestamp.",
+    targetDate: "Target date.",
+    color: "Display color.",
+    scope: "Search or visibility scope.",
+    sha: "Git commit SHA.",
+    message: "Commit or status message.",
+    branch: "Git branch name.",
+    repoPath: "Repository path.",
+    workspacePath: "Workspace path.",
+    relatedAgentId: "Agent id used as a filter or related principal.",
+    leadAgentId: "Lead agent id or reference.",
+    approvalId: "Approval id or short approval id alias.",
+    automationId: "Automation id alias.",
+    chatId: "Chat conversation id alias.",
+    commentId: "Issue comment id alias.",
+    skillId: "Skill id alias.",
+    user: "User id, reference, or self.",
+    since: "Activity start timestamp.",
+    until: "Activity end timestamp.",
+    include: "Comma-separated optional data sections.",
+    content: "Direct content alias for body.",
+    roots: "Comma-separated local roots.",
+    projectIds: "Comma-separated project ids.",
+    workspaceIds: "Comma-separated workspace ids.",
+    cronExpression: "Cron expression.",
+    timezone: "Timezone.",
+    signingMode: "Webhook signing mode.",
+    replayWindowSec: "Webhook replay window in seconds.",
+    instructions: "Automation instructions.",
+    outputMode: "Automation output mode.",
+    concurrencyPolicy: "Automation concurrency policy.",
+    catchUpPolicy: "Automation catch-up policy.",
+    triggerId: "Automation trigger id.",
+    idempotencyKey: "Idempotency key.",
+    summary: "Chat summary.",
+    preferredAgentId: "Preferred responding agent id or reference.",
+    issueCreationMode: "Chat issue creation mode.",
+    editUserMessageId: "User message id to edit.",
+    updatedAfter: "Run updated-after timestamp.",
+    runIdPrefix: "Run id prefix filter.",
+    runtime: "Runtime type filter.",
+    issueId: "Issue id filter.",
+    usedSkill: "Used skill filter.",
+    loadedSkill: "Loaded skill filter.",
+    createdBefore: "Created-before timestamp.",
+    evidence: "Skill evidence type.",
+    aroundError: "Transcript error step id.",
+    maxOutputChars: "Maximum output characters."
+  })) {
+    add(key, mcpString(description));
+  }
+  for (const [key, description] of Object.entries({
+    limit: "Page size or result limit.",
+    count: "Count represented by a report.",
+    turnLimit: "Maximum turns to return.",
+    contextTurns: "Number of context turns.",
+    maxChars: "Maximum characters.",
+    snippetChars: "Maximum snippet characters.",
+    afterSeq: "Return events after this sequence number.",
+    offset: "Byte offset for ranged reads.",
+    limitBytes: "Maximum bytes for ranged reads."
+  })) {
+    add(key, mcpNumber(description));
+  }
+  for (const [key, description] of Object.entries({
+    selectionRefs: "Skill selection refs.",
+    selections: "Skill selection refs alias.",
+    skills: "Skill selection refs alias.",
+    images: "Local image paths to attach when supported.",
+    goalIds: "Goal ids."
+  })) {
+    add(key, mcpStringArray(description));
+  }
+  for (const key of ["clearTitle", "clearCapabilities", "clearDescription", "clearReportsTo", "enable", "enabled", "disabled", "reopen", "planMode", "includeTranscript", "includeOutput", "includeOutputs", "notifyOnIssueCreated", "errorsOnly", "chronological", "narrative", "submit", "full"]) {
+    add(key, mcpBoolean(`Boolean option ${key}.`));
+  }
+  return { type: "object", additionalProperties: false, properties };
+}
+var RUDDER_MCP_CANONICAL_TOOL_DEFINITIONS = RUDDER_MCP_TOOL_DESCRIPTORS.map((tool) => ({
+  ...tool,
+  inputSchema: rudderMcpInputSchemaForCapability(tool.capabilityId)
+}));
+function rudderMcpSemanticToolContract(tool) {
+  return {
+    name: tool.name,
+    description: `${tool.description} Mutating: ${tool.mutating ? "yes" : "no"}. Runtime identity and authorization are injected by the Rudder-managed MCP server and are not accepted as tool input. Org context: ${tool.requiresOrgId ? "required from runtime env" : "not required by this tool"}. Agent context: ${tool.requiresAgentId ? "required from runtime env" : "runtime env when available"}. Run attribution: ${tool.attachesRunIdWhenAvailable ? "attached from runtime env when available" : "not attached"}.`,
+    inputSchema: tool.inputSchema
+  };
+}
+var RUDDER_MCP_CANONICAL_TOOL_CONTRACTS = RUDDER_MCP_CANONICAL_TOOL_DEFINITIONS.map(rudderMcpSemanticToolContract);
+var RUDDER_CORE_MCP_TOOL_CONTRACTS = RUDDER_MCP_CANONICAL_TOOL_CONTRACTS.filter((tool) => !tool.name.startsWith("rudder_browser_"));
+var RUDDER_BROWSER_MCP_TOOL_CONTRACTS = RUDDER_MCP_CANONICAL_TOOL_CONTRACTS.filter((tool) => tool.name.startsWith("rudder_browser_"));
+var RUDDER_CORE_MCP_TOOL_NAMES = RUDDER_CORE_MCP_TOOL_CONTRACTS.map((tool) => tool.name);
+var RUDDER_BROWSER_MCP_TOOL_NAMES = RUDDER_BROWSER_MCP_TOOL_CONTRACTS.map((tool) => tool.name);
+
+// ../packages/agent-runtime-utils/dist/rudder-mcp.js
+var RUDDER_MCP_SERVER_NAME = "rudder-control-plane";
+var RUDDER_MCP_TOOL_COUNT = RUDDER_CORE_MCP_TOOL_NAMES.length;
+var RUDDER_BROWSER_MCP_TOOL_COUNT = RUDDER_BROWSER_MCP_TOOL_NAMES.length;
+
+// ../packages/agent-runtime-utils/dist/rudder-mcp-fingerprint.js
+import { createHash } from "node:crypto";
+function stableJsonValue(value) {
+  if (Array.isArray(value))
+    return value.map(stableJsonValue);
+  if (typeof value !== "object" || value === null)
+    return value;
+  return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([key, entry]) => [key, stableJsonValue(entry)]));
+}
+function stableRudderMcpContractJson(value) {
+  return JSON.stringify(stableJsonValue(value));
+}
+function fingerprintRudderMcpToolManifest(tools) {
+  return createHash("sha256").update(stableRudderMcpContractJson(tools.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    inputSchema: tool.inputSchema
+  })))).digest("hex");
+}
 
 // src/agent-v1-mcp-server.ts
 init_dist();
 import { spawn, spawnSync } from "node:child_process";
-import { existsSync } from "node:fs";
+import { existsSync as existsSync2 } from "node:fs";
 import fs from "node:fs/promises";
 import os from "node:os";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
+import path2 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/agent-v1-registry.ts
 var AGENT_CLI_CAPABILITIES = [
@@ -7897,9 +9073,9 @@ var AGENT_CLI_CAPABILITIES = [
   },
   {
     id: "runs.get",
-    command: "rudder runs get <run-id>",
+    command: "rudder runs get <run-id> [--full]",
     category: "runs",
-    description: "Read one observed run detail.",
+    description: "Read one bounded run summary; use --full only from a direct trusted CLI for raw detail.",
     mutating: false,
     contract: "agent-v1",
     requiresOrgId: false,
@@ -7909,9 +9085,9 @@ var AGENT_CLI_CAPABILITIES = [
   },
   {
     id: "runs.events",
-    command: "rudder runs events <run-id> [--after-seq <n>] [--limit <n>]",
+    command: "rudder runs events <run-id> [--cursor <cursor>] [--after-seq <n>] [--limit <n>] [--full]",
     category: "runs",
-    description: "List a bounded page of persisted run events with a sequence cursor.",
+    description: "List a bounded page of persisted run events with a lossless opaque cursor and clipped payload previews.",
     mutating: false,
     contract: "agent-v1",
     requiresOrgId: false,
@@ -7933,9 +9109,9 @@ var AGENT_CLI_CAPABILITIES = [
   },
   {
     id: "runs.transcript",
-    command: "rudder runs transcript <run-id> [--turn-limit <n>] [--cursor <cursor>] [--include-output]",
+    command: "rudder runs transcript <run-id> [--turn-limit <n>] [--cursor <cursor>] [--include-output] [--full]",
     category: "runs",
-    description: "Read the server-normalized run transcript; human output is compact and JSON includes full entries.",
+    description: "Read a compact server-normalized transcript; --json changes encoding only and --full is direct-CLI-only raw access.",
     mutating: false,
     contract: "agent-v1",
     requiresOrgId: false,
@@ -8020,194 +9196,29 @@ function buildAgentCliCapabilitiesManifest(contract = "agent-v1") {
     capabilities
   };
 }
-function agentCliCapabilityIdToMcpToolName(id) {
-  return `rudder_${id.replace(/[^a-zA-Z0-9]+/g, "_").replace(/^_+|_+$/g, "")}`;
-}
-function mcpString(description) {
-  return { type: "string", description };
-}
-function mcpBoolean(description) {
-  return { type: "boolean", description };
-}
-function mcpNumber(description) {
-  return { type: "number", description };
-}
-function mcpStringArray(description) {
-  return { type: "array", items: { type: "string" }, description };
-}
-function mcpInputSchemaForCapability(id) {
-  const properties = {};
-  const add = (key, value) => {
-    properties[key] = value;
-  };
-  if (id.startsWith("issue.")) {
-    add("issue", mcpString("Issue UUID, identifier, or short reference."));
-    add("body", mcpString("Direct Markdown body for issue comments or close-out notes."));
-    add("comment", mcpString("Direct Markdown review, blocker, or completion comment."));
-    add("images", { type: "array", items: { type: "string" }, description: "Local image paths to attach when supported." });
-  }
-  if (id.startsWith("project.")) add("project", mcpString("Project UUID or shortname."));
-  if (id.startsWith("library.file.")) {
-    add("path", mcpString("Library-relative file or directory path."));
-    if (id === "library.file.list") {
-      add("directory", mcpString("Library-relative directory path. Defaults to the run's project Library path when available."));
-    }
-    add("body", mcpString("Direct file content for put operations."));
-  }
-  if (id.startsWith("approval.")) {
-    add("approval", mcpString("Approval UUID or short reference."));
-    add("body", mcpString("Direct Markdown approval comment body."));
-  }
-  if (id.startsWith("skill.")) {
-    add("skill", mcpString("Organization skill id."));
-    add("path", mcpString("Skill package file path, such as SKILL.md."));
-  }
-  if (id.startsWith("browser.")) {
-    add("url", mcpString("HTTP or HTTPS URL."));
-    add("tabId", mcpString("Run-owned Rudder Browser tab id."));
-    add("ref", mcpString("Element reference returned by rudder_browser_read."));
-    add("text", mcpString("Text to enter into the referenced element."));
-  }
-  if (id.startsWith("automation.")) {
-    add("automation", mcpString("Automation id."));
-    add("trigger", mcpString("Automation trigger id."));
-    add("payload", { type: ["object", "string"], description: "JSON payload object or JSON string." });
-  }
-  if (id.startsWith("chat.")) {
-    add("chat", mcpString("Chat conversation id."));
-    add("body", mcpString("Agent-authored chat message body."));
-  }
-  if (id.startsWith("runs.")) add("run", mcpString("Run id or short run id."));
-  if (id.startsWith("agent.skills.")) {
-    add("selectionRefs", { type: "array", items: { type: "string" }, description: "Skill selection refs." });
-    add("skills", { type: "array", items: { type: "string" }, description: "Skill selection refs alias." });
-    add("desiredSkills", mcpString("Comma-separated desired skill refs for sync."));
-  }
-  for (const [key, description] of Object.entries({
-    query: "Search query.",
-    decision: "Structured review decision.",
-    title: "Title.",
-    name: "Name.",
-    description: "Description or summary text.",
-    status: "Status filter or new status.",
-    cursor: "Pagination cursor.",
-    source: "Source path or source label.",
-    kind: "Trigger kind.",
-    label: "Trigger label.",
-    skill: "Skill key, id, or display name.",
-    slug: "Slug.",
-    markdown: "Direct Markdown content.",
-    role: "Agent role.",
-    reportsTo: "Manager or reporting agent reference.",
-    capabilities: "Agent capability summary.",
-    wakeCommentId: "Issue comment id that triggered the wake.",
-    expectedStatuses: "Comma-separated checkout precondition statuses.",
-    after: "Pagination anchor or lower bound.",
-    order: "Sort order.",
-    priority: "Issue or automation priority.",
-    assigneeAgentId: "Target assignee agent id or reference.",
-    projectId: "Project id or reference.",
-    goalId: "Goal id or reference.",
-    parentId: "Parent issue id or reference.",
-    parentIssueId: "Parent issue id or reference.",
-    requestDepth: "Requested issue depth.",
-    billingCode: "Billing code.",
-    hiddenAt: "Hidden timestamp.",
-    archivedAt: "Archived timestamp.",
-    targetDate: "Target date.",
-    color: "Display color.",
-    scope: "Search or visibility scope.",
-    sha: "Git commit SHA.",
-    message: "Commit or status message.",
-    branch: "Git branch name.",
-    repoPath: "Repository path.",
-    workspacePath: "Workspace path.",
-    relatedAgentId: "Agent id used as a filter or related principal.",
-    leadAgentId: "Lead agent id or reference.",
-    approvalId: "Approval id or short approval id alias.",
-    automationId: "Automation id alias.",
-    chatId: "Chat conversation id alias.",
-    commentId: "Issue comment id alias.",
-    skillId: "Skill id alias.",
-    user: "User id, reference, or self.",
-    since: "Activity start timestamp.",
-    until: "Activity end timestamp.",
-    include: "Comma-separated optional data sections.",
-    content: "Direct content alias for body.",
-    roots: "Comma-separated local roots.",
-    projectIds: "Comma-separated project ids.",
-    workspaceIds: "Comma-separated workspace ids.",
-    cronExpression: "Cron expression.",
-    timezone: "Timezone.",
-    signingMode: "Webhook signing mode.",
-    replayWindowSec: "Webhook replay window in seconds.",
-    instructions: "Automation instructions.",
-    outputMode: "Automation output mode.",
-    concurrencyPolicy: "Automation concurrency policy.",
-    catchUpPolicy: "Automation catch-up policy.",
-    triggerId: "Automation trigger id.",
-    idempotencyKey: "Idempotency key.",
-    summary: "Chat summary.",
-    preferredAgentId: "Preferred responding agent id or reference.",
-    issueCreationMode: "Chat issue creation mode.",
-    editUserMessageId: "User message id to edit.",
-    updatedAfter: "Run updated-after timestamp.",
-    runIdPrefix: "Run id prefix filter.",
-    runtime: "Runtime type filter.",
-    issueId: "Issue id filter.",
-    usedSkill: "Used skill filter.",
-    loadedSkill: "Loaded skill filter.",
-    createdBefore: "Created-before timestamp.",
-    evidence: "Skill evidence type.",
-    aroundError: "Transcript error step id.",
-    maxOutputChars: "Maximum output characters."
-  })) {
-    add(key, mcpString(description));
-  }
-  for (const [key, description] of Object.entries({
-    limit: "Page size or result limit.",
-    count: "Count represented by a report.",
-    turnLimit: "Maximum turns to return.",
-    contextTurns: "Number of context turns.",
-    maxChars: "Maximum characters.",
-    snippetChars: "Maximum snippet characters.",
-    afterSeq: "Return events after this sequence number.",
-    offset: "Byte offset for ranged reads.",
-    limitBytes: "Maximum bytes for ranged reads."
-  })) {
-    add(key, mcpNumber(description));
-  }
-  for (const [key, description] of Object.entries({
-    selectionRefs: "Skill selection refs.",
-    selections: "Skill selection refs alias.",
-    skills: "Skill selection refs alias.",
-    images: "Local image paths to attach when supported.",
-    goalIds: "Goal ids."
-  })) {
-    add(key, mcpStringArray(description));
-  }
-  for (const key of ["clearTitle", "clearCapabilities", "clearDescription", "clearReportsTo", "enable", "enabled", "disabled", "reopen", "planMode", "includeTranscript", "includeOutput", "includeOutputs", "notifyOnIssueCreated", "errorsOnly", "chronological", "narrative", "submit", "full"]) {
-    add(key, mcpBoolean(`Boolean option ${key}.`));
-  }
-  return {
-    type: "object",
-    additionalProperties: false,
-    properties
-  };
-}
 function buildAgentV1McpToolsManifest(contract = "agent-v1", options = {}) {
   const capabilities = buildAgentCliCapabilitiesManifest(contract).capabilities.filter((entry) => options.browserEnabled !== false || entry.category !== "browser");
+  const semanticContractByCapability = new Map(
+    RUDDER_MCP_CANONICAL_TOOL_DEFINITIONS.map((tool) => [tool.capabilityId, tool])
+  );
   return {
     schema: "rudder.agent-mcp-tools/v1",
     contract,
     serverName: "rudder-control-plane",
-    tools: capabilities.map((entry) => ({
-      ...entry,
-      capabilityId: entry.id,
-      name: agentCliCapabilityIdToMcpToolName(entry.id),
-      inputSchema: mcpInputSchemaForCapability(entry.id),
-      outputMode: "json"
-    }))
+    tools: capabilities.map((entry) => {
+      const semanticContract = semanticContractByCapability.get(entry.id);
+      if (!semanticContract) {
+        throw new Error(`Missing canonical Rudder MCP contract for capability: ${entry.id}`);
+      }
+      return {
+        ...entry,
+        description: semanticContract.description,
+        capabilityId: entry.id,
+        name: semanticContract.name,
+        inputSchema: semanticContract.inputSchema,
+        outputMode: "json"
+      };
+    })
   };
 }
 function formatAgentCliCapabilitiesHumanReadable(capabilities = getAgentCliCapabilities()) {
@@ -8394,7 +9405,9 @@ function toStringRecord(headers) {
 }
 
 // src/agent-v1-mcp-server.ts
-var RUDDER_MCP_SERVER_NAME = "rudder-control-plane";
+init_version();
+var RUDDER_MCP_MAX_TOOL_RESULT_BYTES = 1e6;
+var RUDDER_MCP_MAX_INLINE_TEXT_BYTES = 32e3;
 var RESERVED_MODEL_ARGUMENTS = /* @__PURE__ */ new Set([
   "orgId",
   "org_id",
@@ -8441,6 +9454,7 @@ function buildAgentV1ToolCallPlan(toolName, rawArgs, env = buildMcpServerEnv())
   }
   const capability = getAgentCliCapabilityById(capabilityId);
   rejectModelProvidedRuntimeIdentity(input);
+  rejectUnsupportedToolArguments(toolName, input);
   assertBrowserCapabilityEnabled(capabilityId, env);
   assertRuntimeMcpContext(capability, env);
   const tempFiles = [];
@@ -8470,10 +9484,26 @@ async function runAgentV1McpJsonRpcMessage(message, env = buildMcpServerEnv()) {
       case "notifications/initialized":
         return isNotification ? null : rpcResult(id, {});
       case "initialize":
+        const contractManifest = buildAgentV1McpToolsManifest("agent-v1").tools.map(rudderMcpSemanticToolContract);
+        const coreContractHash = fingerprintRudderMcpToolManifest(
+          contractManifest.filter((tool) => !tool.name.startsWith("rudder_browser_"))
+        );
+        const browserContractHash = fingerprintRudderMcpToolManifest(
+          contractManifest.filter((tool) => tool.name.startsWith("rudder_browser_"))
+        );
         return rpcResult(id, {
           protocolVersion: requestedProtocolVersion(message.params) ?? "2024-11-05",
-          capabilities: { tools: {} },
-          serverInfo: { name: RUDDER_MCP_SERVER_NAME, version: "1.0.0" }
+          capabilities: {
+            tools: {},
+            experimental: {
+              rudder: {
+                contractVersion: RUDDER_MCP_CONTRACT_VERSION,
+                coreContractHash,
+                browserContractHash
+              }
+            }
+          },
+          serverInfo: { name: RUDDER_MCP_SERVER_NAME, version: resolveCliVersion() }
         });
       case "tools/list":
         return rpcResult(id, {
@@ -8482,7 +9512,7 @@ async function runAgentV1McpJsonRpcMessage(message, env = buildMcpServerEnv()) {
           }).tools.map(toMcpToolListEntry)
         });
       case "tools/call":
-        return rpcResult(id, await callToolSafely(message.params, env));
+        return boundedToolCallRpcResponse(id, await callToolSafely(message.params, env));
       default:
         if (isNotification) return null;
         return rpcError(id, -32601, `Unsupported JSON-RPC method: ${String(message.method ?? "")}`);
@@ -8581,12 +9611,12 @@ async function callTool(params, env) {
   const plan = buildAgentV1ToolCallPlan(toolName, args, env);
   const directResult = await callToolDirectlyIfSupported(toolName, args, env);
   if (directResult) return directResult;
-  const tempDir = plan.tempFiles.length > 0 ? await fs.mkdtemp(path.join(os.tmpdir(), "rudder-mcp-")) : null;
+  const tempDir = plan.tempFiles.length > 0 ? await fs.mkdtemp(path2.join(os.tmpdir(), "rudder-mcp-")) : null;
   const materializedArgs = [...plan.args];
   try {
     if (tempDir) {
       for (const tempFile of plan.tempFiles) {
-        const tempPath = path.join(tempDir, `${tempFile.flag.replace(/^-+/, "")}.md`);
+        const tempPath = path2.join(tempDir, `${tempFile.flag.replace(/^-+/, "")}.md`);
         await fs.writeFile(tempPath, tempFile.contents, "utf8");
         const index = materializedArgs.indexOf(tempFile.flag);
         if (index >= 0) materializedArgs[index + 1] = tempPath;
@@ -8595,11 +9625,7 @@ async function callTool(params, env) {
     const result = await runRudderCli(materializedArgs, plan.env);
     if (result.exitCode === 0) {
       const text6 = result.stdout.trim() || "{}";
-      return {
-        content: [{ type: "text", text: text6 }],
-        ...structuredContentFromJsonText(text6),
-        isError: false
-      };
+      return mcpSuccessFromJsonText(text6);
     }
     const payload = {
       status: "error",
@@ -8722,12 +9748,47 @@ function mcpApiClient(env) {
   });
 }
 function mcpSuccess(data) {
-  const text6 = JSON.stringify(data ?? {});
-  return {
-    content: [{ type: "text", text: text6 }],
-    ...structuredContentFromJsonText(text6),
+  return mcpSuccessFromJsonText(JSON.stringify(data ?? {}));
+}
+function mcpSuccessFromJsonText(text6) {
+  const structured = structuredContentFromJsonText(text6);
+  const textBytes = Buffer.byteLength(text6, "utf8");
+  const inlineText = textBytes <= RUDDER_MCP_MAX_INLINE_TEXT_BYTES ? text6 : JSON.stringify({
+    status: "ok",
+    output: "structuredContent",
+    originalLength: text6.length,
+    originalBytes: textBytes
+  });
+  const result = {
+    content: [{ type: "text", text: inlineText }],
+    ...structured,
     isError: false
   };
+  const resultBytes = Buffer.byteLength(JSON.stringify(result), "utf8");
+  if (resultBytes <= RUDDER_MCP_MAX_TOOL_RESULT_BYTES) return result;
+  return mcpResponseTooLarge(resultBytes);
+}
+function boundedToolCallRpcResponse(id, result) {
+  const response = rpcResult(id, result);
+  const responseBytes = Buffer.byteLength(JSON.stringify(response), "utf8");
+  if (responseBytes <= RUDDER_MCP_MAX_TOOL_RESULT_BYTES) return response;
+  return rpcResult(id, mcpResponseTooLarge(responseBytes));
+}
+function mcpResponseTooLarge(responseBytes) {
+  const payload = {
+    status: "error",
+    code: "rudder_mcp_response_too_large",
+    message: "Rudder MCP response exceeded the bounded tool-result budget. Use pagination or a ranged log read.",
+    details: {
+      maxBytes: RUDDER_MCP_MAX_TOOL_RESULT_BYTES,
+      responseBytes
+    }
+  };
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload) }],
+    structuredContent: payload,
+    isError: true
+  };
 }
 function parseCsvInput(value, fallback) {
   const source = Array.isArray(value) ? value.map((entry) => optionalString(entry)).filter(Boolean).join(",") : optionalString(value) || fallback;
@@ -9124,7 +10185,6 @@ function cliArgsForCapability(capabilityId, input, tempFiles, env) {
       pushOptional(args, "--created-before", input.createdBefore);
       pushOptional(args, "--cursor", input.cursor);
       pushOptional(args, "--limit", input.limit);
-      pushBoolean(args, "--full", input.full);
       return args;
     }
     case "runs.by-skill": {
@@ -9137,15 +10197,16 @@ function cliArgsForCapability(capabilityId, input, tempFiles, env) {
       pushOptional(args, "--created-before", input.createdBefore);
       pushOptional(args, "--cursor", input.cursor);
       pushOptional(args, "--limit", input.limit);
-      pushBoolean(args, "--full", input.full);
       return args;
     }
     case "runs.get":
       return ["runs", "get", requiredString(input, "run")];
     case "runs.events": {
       const args = ["runs", "events", requiredString(input, "run")];
+      pushOptional(args, "--cursor", input.cursor);
       pushOptional(args, "--after-seq", input.afterSeq);
       pushOptional(args, "--limit", input.limit);
+      pushOptional(args, "--max-chars", input.maxChars);
       return args;
     }
     case "runs.log": {
@@ -9171,6 +10232,7 @@ function cliArgsForCapability(capabilityId, input, tempFiles, env) {
     case "runs.errors": {
       const args = ["runs", "errors", requiredString(input, "run")];
       pushOptional(args, "--max-chars", input.maxChars);
+      pushOptional(args, "--cursor", input.cursor);
       return args;
     }
     case "runs.cancel":
@@ -9182,11 +10244,7 @@ function cliArgsForCapability(capabilityId, input, tempFiles, env) {
   }
 }
 function toMcpToolListEntry(tool) {
-  return {
-    name: tool.name,
-    description: `${tool.description} Mutating: ${tool.mutating ? "yes" : "no"}. Runtime identity and authorization are injected by the Rudder-managed MCP server and are not accepted as tool input. Org context: ${tool.requiresOrgId ? "required from runtime env" : "not required by this tool"}. Agent context: ${tool.requiresAgentId ? "required from runtime env" : "runtime env when available"}. Run attribution: ${tool.attachesRunIdWhenAvailable ? "attached from runtime env when available" : "not attached"}.`,
-    inputSchema: tool.inputSchema
-  };
+  return rudderMcpSemanticToolContract(tool);
 }
 function requestedProtocolVersion(params) {
   if (!isRecord2(params)) return null;
@@ -9270,6 +10328,16 @@ function rejectModelProvidedRuntimeIdentity(input) {
   err.code = "rudder_mcp_reserved_identity_argument";
   throw err;
 }
+function rejectUnsupportedToolArguments(toolName, input) {
+  const tool = buildAgentV1McpToolsManifest("agent-v1").tools.find((entry) => entry.name === toolName);
+  if (!tool) return;
+  const supported = new Set(Object.keys(tool.inputSchema.properties));
+  const unsupported = Object.keys(input).filter((key) => !supported.has(key)).sort();
+  if (unsupported.length === 0) return;
+  const err = new Error(`Unsupported argument${unsupported.length === 1 ? "" : "s"} for ${toolName}: ${unsupported.join(", ")}`);
+  err.code = "rudder_mcp_invalid_arguments";
+  throw err;
+}
 function normalizeRuntimeIdentityKey(key) {
   return key.replace(/[^a-z0-9]/giu, "").toLowerCase();
 }
@@ -9327,8 +10395,8 @@ function resolveRudderCliInvocation(args, env) {
   if (env.RUDDER_MCP_RUDDER_BIN) {
     return { command: env.RUDDER_MCP_RUDDER_BIN, args };
   }
-  const modulePath = fileURLToPath(new URL("./index.js", import.meta.url));
-  if (existsSync(modulePath)) {
+  const modulePath = fileURLToPath2(new URL("./index.js", import.meta.url));
+  if (existsSync2(modulePath)) {
     return { command: process.execPath, args: [modulePath, ...args] };
   }
   if (hasRunnableRudderOnPath(env)) {
@@ -14208,10 +15276,13 @@ function registerRunsCommands(program) {
     { includeCompany: false }
   );
   addCommonClientOptions(
-    runs.command("get").description(getAgentCliCapabilityById("runs.get").description).argument("<runId>", "Run ID or short run ID").action(async (runId, opts) => {
+    runs.command("get").description(getAgentCliCapabilityById("runs.get").description).argument("<runId>", "Run ID or short run ID").option("--full", "Include raw run result, context, excerpts, and session fields").action(async (runId, opts) => {
       try {
         const ctx = resolveCommandContext(opts);
-        const row = await ctx.api.get(`/api/run-intelligence/runs/${encodeURIComponent(runId)}`);
+        const projection = opts.full ? "full" : "summary";
+        const row = await ctx.api.get(
+          `/api/run-intelligence/runs/${encodeURIComponent(runId)}?projection=${projection}`
+        );
         printOutput(row, { json: ctx.json });
       } catch (err) {
         handleCommandError(err);
@@ -14219,13 +15290,16 @@ function registerRunsCommands(program) {
     })
   );
   addCommonClientOptions(
-    runs.command("events").description(getAgentCliCapabilityById("runs.events").description).argument("<runId>", "Run ID or short run ID").option("--after-seq <n>", "Return events after this sequence number", "0").option("--limit <n>", "Maximum events to return", "200").action(async (runId, opts) => {
+    runs.command("events").description(getAgentCliCapabilityById("runs.events").description).argument("<runId>", "Run ID or short run ID").option("--cursor <cursor>", "Opaque total-order cursor returned in page.nextCursor").option("--after-seq <n>", "Legacy sequence-only cursor; prefer --cursor", "0").option("--limit <n>", "Maximum events to return", "200").option("--max-chars <n>", "Maximum payload preview characters per event", "1200").option("--full", "Include raw event payloads; unavailable through MCP").action(async (runId, opts) => {
       try {
         const ctx = resolveCommandContext(opts);
         const params = new URLSearchParams({
           afterSeq: String(parseNonNegativeInteger(opts.afterSeq, 0)),
-          limit: String(parseLimit2(opts.limit, 200))
+          limit: String(parseLimit2(opts.limit, 200)),
+          maxChars: String(parseLimit2(opts.maxChars, 1200)),
+          projection: opts.full ? "full" : "compact"
         });
+        if (opts.cursor) params.set("cursor", opts.cursor);
         const page = await ctx.api.get(
           `/api/run-intelligence/runs/${encodeURIComponent(runId)}/events?${params}`
         );
@@ -14257,7 +15331,7 @@ function registerRunsCommands(program) {
     })
   );
   addCommonClientOptions(
-    runs.command("transcript").description(getAgentCliCapabilityById("runs.transcript").description).argument("<runId>", "Run ID or short run ID").option("--errors-only", "Show only error transcript rows").option("--around-error <id>", "Show context around a run error id such as step-12").option("--context-turns <n>", "Turns around --around-error", "1").option("--cursor <cursor>", "Stable transcript cursor returned in page.nextCursor").option("--turn-limit <n>", "Maximum turns to return", "20").option("--chronological", "Show oldest-first instead of default newest-first").option("--narrative", "Use a narrative human layout").option("--max-chars <n>", "Maximum output characters per row", "1200").option("--max-output-chars <n>", "Alias for --max-chars").option("--include-output", "Include row output in compact human transcript rows").option("--include-outputs", "Alias for --include-output").addHelpText("after", formatExamplesAndCautions({
+    runs.command("transcript").description(getAgentCliCapabilityById("runs.transcript").description).argument("<runId>", "Run ID or short run ID").option("--errors-only", "Show only error transcript rows").option("--around-error <id>", "Show context around a run error id such as step-12").option("--context-turns <n>", "Turns around --around-error", "1").option("--cursor <cursor>", "Stable transcript cursor returned in page.nextCursor").option("--turn-limit <n>", "Maximum turns to return", "20").option("--chronological", "Show oldest-first instead of default newest-first").option("--narrative", "Use a narrative human layout").option("--max-chars <n>", "Maximum output characters per row", "1200").option("--max-output-chars <n>", "Alias for --max-chars").option("--include-output", "Include row output in compact human transcript rows").option("--include-outputs", "Alias for --include-output").option("--full", "Return raw lossless transcript entries; unavailable through MCP").addHelpText("after", formatExamplesAndCautions({
       examples: [
         {
           description: "Inspect the neighborhood around a failing step:",
@@ -14269,14 +15343,15 @@ function registerRunsCommands(program) {
         }
       ],
       cautions: [
-        "Human output is compact and clipped by default; use --json only when a script needs the full payload.",
+        "Human and JSON output use the same compact projection; --json changes encoding only.",
+        "Use --full only from a direct trusted CLI when lossless provider entries are required.",
         "Use --around-error from runs errors when investigating a failure instead of reading the entire run first."
       ]
     })).action(async (runId, opts) => {
       try {
         const ctx = resolveCommandContext(opts);
         const payload = await ctx.api.get(
-          `/api/run-intelligence/runs/${encodeURIComponent(runId)}/transcript?${buildTranscriptQuery(opts, { json: ctx.json })}`
+          `/api/run-intelligence/runs/${encodeURIComponent(runId)}/transcript?${buildTranscriptQuery(opts)}`
         );
         if (ctx.json) {
           printOutput(payload, { json: true });
@@ -14291,7 +15366,7 @@ function registerRunsCommands(program) {
     })
   );
   addCommonClientOptions(
-    runs.command("errors").description(getAgentCliCapabilityById("runs.errors").description).argument("<runId>", "Run ID or short run ID").option("--max-chars <n>", "Maximum output characters per error", "1200").addHelpText("after", formatExamplesAndCautions({
+    runs.command("errors").description(getAgentCliCapabilityById("runs.errors").description).argument("<runId>", "Run ID or short run ID").option("--max-chars <n>", "Maximum output characters per error", "1200").option("--cursor <cursor>", "Cursor returned in page.nextCursor").addHelpText("after", formatExamplesAndCautions({
       examples: [
         {
           description: "Start failed-run investigation with error summaries:",
@@ -14311,6 +15386,7 @@ function registerRunsCommands(program) {
         const ctx = resolveCommandContext(opts);
         const params = new URLSearchParams();
         params.set("maxChars", String(parseLimit2(opts.maxChars, 1200)));
+        if (opts.cursor) params.set("cursor", opts.cursor);
         const payload = await ctx.api.get(
           `/api/run-intelligence/runs/${encodeURIComponent(runId)}/errors?${params.toString()}`
         );
@@ -14382,7 +15458,7 @@ function parseSkillEvidenceType(value) {
   if (normalized === "used" || normalized === "loaded") return normalized;
   throw new Error("--evidence must be either 'used' or 'loaded'.");
 }
-function buildTranscriptQuery(opts, output) {
+function buildTranscriptQuery(opts) {
   const params = new URLSearchParams();
   if (opts.errorsOnly) params.set("errorsOnly", "true");
   if (opts.aroundError) params.set("aroundError", opts.aroundError);
@@ -14390,8 +15466,8 @@ function buildTranscriptQuery(opts, output) {
   if (opts.turnLimit) params.set("turnLimit", String(parseLimit2(opts.turnLimit, 20)));
   params.set("contextTurns", String(parseLimit2(opts.contextTurns, 1)));
   params.set("order", opts.chronological || opts.narrative ? "oldest" : "newest");
-  params.set("output", output.json ? "full" : "compact");
-  const includeOutputs = output.json || Boolean(opts.includeOutput || opts.includeOutputs || opts.narrative);
+  params.set("output", opts.full ? "full" : "compact");
+  const includeOutputs = Boolean(opts.full || opts.includeOutput || opts.includeOutputs || opts.narrative);
   params.set("includeOutputs", includeOutputs ? "true" : "false");
   params.set("maxChars", String(parseLimit2(opts.maxOutputChars ?? opts.maxChars, 1200)));
   return params.toString();
@@ -15586,7 +16662,7 @@ init_install2();
 init_install();
 import * as p15 from "@clack/prompts";
 import { spawn as spawn3, spawnSync as spawnSync4 } from "node:child_process";
-import { createHash, randomUUID } from "node:crypto";
+import { createHash as createHash2, randomUUID } from "node:crypto";
 import { createWriteStream, constants as fsConstants, mkdirSync, readFileSync as readFileSync2 } from "node:fs";
 import { access, chmod, copyFile, cp as cp2, mkdir as mkdir3, mkdtemp, readdir as readdir3, readFile as readFile6, rm as rm2, stat as stat4, utimes, writeFile as writeFile3 } from "node:fs/promises";
 import { homedir, tmpdir } from "node:os";
@@ -15789,43 +16865,88 @@ function createDesktopProgressFactory() {
     };
   };
 }
-async function waitForDesktopApplySignal() {
+function createDesktopApplySignalController() {
   process.stdin.setEncoding("utf8");
   process.stdin.resume();
-  return await new Promise((resolve, reject) => {
-    let buffer = "";
-    const cleanup = () => {
-      process.stdin.off("data", onData);
-      process.stdin.off("end", onEnd);
-      process.stdin.off("error", onError);
-    };
-    const onData = (chunk) => {
-      buffer += chunk;
-      const lines = buffer.split(/\r?\n/);
-      buffer = lines.pop() ?? "";
-      const commands = lines.map((line) => line.trim());
-      if (commands.includes("force-apply")) {
-        cleanup();
-        resolve({ force: true });
-        return;
-      }
-      if (commands.includes("apply")) {
-        cleanup();
-        resolve({ force: false });
-      }
-    };
-    const onEnd = () => {
-      cleanup();
-      reject(new Error("Desktop update apply signal ended before confirmation."));
-    };
-    const onError = (error) => {
-      cleanup();
-      reject(error);
-    };
-    process.stdin.on("data", onData);
-    process.stdin.on("end", onEnd);
-    process.stdin.on("error", onError);
+  let buffer = "";
+  let closed = false;
+  let initialSettled = false;
+  let forceRequested = false;
+  let resolveInitial;
+  let rejectInitial;
+  const forceWaiters = /* @__PURE__ */ new Set();
+  const initialSignal = new Promise((resolve, reject) => {
+    resolveInitial = resolve;
+    rejectInitial = reject;
   });
+  const settleForceWaiters = (force) => {
+    for (const resolve of forceWaiters) resolve(force);
+    forceWaiters.clear();
+  };
+  const cleanup = () => {
+    if (closed) return;
+    closed = true;
+    process.stdin.off("data", onData);
+    process.stdin.off("end", onEnd);
+    process.stdin.off("error", onError);
+    settleForceWaiters(false);
+  };
+  const onData = (chunk) => {
+    buffer += chunk;
+    const lines = buffer.split(/\r?\n/);
+    buffer = lines.pop() ?? "";
+    for (const command of lines.map((line) => line.trim())) {
+      if (command === "force-apply") {
+        forceRequested = true;
+        if (!initialSettled) {
+          initialSettled = true;
+          resolveInitial({ force: true });
+        }
+        settleForceWaiters(true);
+      } else if (command === "apply" && !initialSettled) {
+        initialSettled = true;
+        resolveInitial({ force: false });
+      }
+    }
+  };
+  const onEnd = () => {
+    if (!initialSettled) {
+      initialSettled = true;
+      rejectInitial(new Error("Desktop update apply signal ended before confirmation."));
+    }
+    cleanup();
+  };
+  const onError = (error) => {
+    if (!initialSettled) {
+      initialSettled = true;
+      rejectInitial(error);
+    }
+    cleanup();
+  };
+  process.stdin.on("data", onData);
+  process.stdin.on("end", onEnd);
+  process.stdin.on("error", onError);
+  return {
+    waitForInitialSignal: () => initialSignal,
+    waitForForceRequest: async (timeoutMs) => {
+      if (forceRequested) return true;
+      if (closed) return false;
+      return await new Promise((resolve) => {
+        let settled = false;
+        const finish = (force) => {
+          if (settled) return;
+          settled = true;
+          forceWaiters.delete(finish);
+          clearTimeout2(timer);
+          resolve(force);
+        };
+        const timer = setTimeout2(() => finish(false), timeoutMs);
+        timer.unref?.();
+        forceWaiters.add(finish);
+      });
+    },
+    close: cleanup
+  };
 }
 function resolveCurrentCliVersion(env = process.env) {
   const version = resolveCliVersion(import.meta.url, env);
@@ -15884,7 +17005,7 @@ function isExactRuntimePackageSpec(version, packageSpec) {
   return version !== "latest" && packageSpec === resolveRuntimePackageSpec(version);
 }
 function runtimeSupportsDesktopShellAssets(version, runtime) {
-  return isExactRuntimePackageSpec(version, runtime.packageSpec);
+  return isExactRuntimePackageSpec(version, runtime.packageSpec) && Boolean(runtime.postgresPayloadBinDir);
 }
 function resolveDesktopAssetTarget(platform = process.platform, arch = process.arch) {
   if (platform === "darwin") {
@@ -16151,7 +17272,7 @@ async function downloadAsset(asset, outputDir, progressFactory = createByteProgr
   return outputPath;
 }
 function checksumForFile(filePath) {
-  const hash = createHash("sha256");
+  const hash = createHash2("sha256");
   hash.update(readFileSync2(filePath));
   return hash.digest("hex");
 }
@@ -16378,7 +17499,7 @@ async function pathExists2(targetPath) {
   }
 }
 function resolveDesktopInstallLockPath(paths) {
-  const installRootHash = createHash("sha256").update(path22.resolve(paths.installRoot)).digest("hex").slice(0, 16);
+  const installRootHash = createHash2("sha256").update(path22.resolve(paths.installRoot)).digest("hex").slice(0, 16);
   return path22.join(path22.dirname(paths.appPath), `.rudder-desktop-install-${installRootHash}.lock`);
 }
 async function readDesktopInstallLock(lockPath) {
@@ -16663,20 +17784,23 @@ async function prepareForDesktopReplace(paths, target, options = {}) {
   const hasManagedExecutable = await pathExists2(paths.executablePath);
   if (hasManagedExecutable) {
     managedExecutablePids = findPids(paths.executablePath, target);
+    let forceUpdate = options.forceUpdate === true;
     const requestQuit = () => requestDesktopQuit(paths.executablePath, target, {
-      forceUpdate: options.forceUpdate,
+      forceUpdate,
       responseTimeoutMs: options.updateQuitResponseTimeoutMs
     });
     let quitResponse = await requestQuit();
-    while (quitResponse && !quitResponse.ok && quitResponse.status === "active_runs" && options.waitForActiveRuns && !options.forceUpdate) {
+    while (quitResponse && !quitResponse.ok && quitResponse.status === "active_runs" && options.waitForActiveRuns && !forceUpdate) {
       p15.log.warn(
         `Rudder Desktop has ${quitResponse.totalRuns} active run${quitResponse.totalRuns === 1 ? "" : "s"}; waiting before replacing Desktop.`
       );
-      await delay2(options.activeRunPollIntervalMs ?? 15e3);
+      options.onActiveRunsWaiting?.(quitResponse.totalRuns);
+      const pollIntervalMs = options.activeRunPollIntervalMs ?? 15e3;
+      forceUpdate = options.waitForForceUpdate ? await options.waitForForceUpdate(pollIntervalMs) : (await delay2(pollIntervalMs), false);
       quitResponse = await requestQuit();
     }
     if (quitResponse && !quitResponse.ok && quitResponse.status === "active_runs") {
-      if (!options.forceUpdate) {
+      if (!forceUpdate) {
         throw new Error(
           `Rudder Desktop has ${quitResponse.totalRuns} active run${quitResponse.totalRuns === 1 ? "" : "s"}. Stop active work, then rerun start.`
         );
@@ -17067,27 +18191,39 @@ async function startCommand(opts) {
           desktopProgressJson ? "verifying_checksum" : null
         );
         let applySignal = null;
+        let applySignalController = null;
         if (desktopProgressJson && opts.desktopWaitForApply === true) {
           writeDesktopProgress({
             phase: "ready_to_install",
             message: "Desktop update is downloaded and verified.",
             percent: 100
           });
-          applySignal = await waitForDesktopApplySignal();
+          applySignalController = createDesktopApplySignalController();
+          applySignal = await applySignalController.waitForInitialSignal();
           writeDesktopProgress({
             phase: "preparing_restart",
             message: applySignal.force ? "Applying Desktop update and quitting active runs..." : "Applying Desktop update..."
           });
         }
-        await runStartPhase(
-          "Replacing existing Rudder Desktop if needed...",
-          "Existing Desktop install is ready for replacement.",
-          () => prepareForDesktopReplace(installPaths, target, {
-            waitForActiveRuns: opts.waitForActiveRuns === true,
-            forceUpdate: applySignal?.force === true
-          }),
-          desktopProgressJson ? opts.waitForActiveRuns === true ? "waiting_for_active_runs" : "preparing_restart" : null
-        );
+        try {
+          await runStartPhase(
+            "Replacing existing Rudder Desktop if needed...",
+            "Existing Desktop install is ready for replacement.",
+            () => prepareForDesktopReplace(installPaths, target, {
+              waitForActiveRuns: opts.waitForActiveRuns === true,
+              forceUpdate: applySignal?.force === true,
+              waitForForceUpdate: applySignalController?.waitForForceRequest,
+              onActiveRunsWaiting: desktopProgressJson ? (totalRuns) => writeDesktopProgress({
+                phase: "waiting_for_active_runs",
+                message: `Waiting for ${totalRuns} running agent run${totalRuns === 1 ? "" : "s"} before replacing Desktop.`,
+                totalRuns
+              }) : void 0
+            }),
+            desktopProgressJson ? opts.waitForActiveRuns === true ? "waiting_for_active_runs" : "preparing_restart" : null
+          );
+        } finally {
+          applySignalController?.close();
+        }
         await runStartPhase(
           "Installing portable Desktop app...",
           `Installed Rudder Desktop to ${pc15.cyan(installPaths.appPath)}.`,